mirror of
https://github.com/ZHANGTIANYAO1/teamspeak-music-bot.git
synced 2026-10-02 04:52:50 +08:00
fix: harden bot lifecycle, validate HTTP inputs, make YouTube truly optional
Major bug fixes and corner-case hardening across the backend, plus a
comprehensive feature test suite. All 94 unit tests + 51 integration
tests pass against a local TS3 server.
Lifecycle & state consistency
-----------------------------
- Bug A: startBot() now wraps connect() in a 15s deadline. A hung TS
handshake no longer blocks the /start HTTP call forever; the failing
instance is torn down and the caller gets a clean 500.
- Bug B: executeCommand rejects audio-dispatching commands (play, add,
next, skip, prev, playlist, album, fm) when the bot is disconnected.
Config-only commands (vol, mode, clear, stop, queue, now, lyrics)
still work so the UI stays usable while offline.
- Bug C: the tsClient 'disconnected' handler always clears player state
now, even when connect() never completed. A separate disconnectEmitted
flag guards duplicate external event emission. Previously an orphaned
connect attempt that idle-timed-out would leave playing=true forever.
- resolveAndPlay re-checks this.connected AFTER the URL-resolve await so
a stop() during the network call can't spawn ffmpeg on a disconnected
bot.
- connect() throws if disconnect() fired during the handshake await,
preventing a concurrent stop from being overwritten by a late connected
flag flip.
- startBot always disconnects the outgoing BotInstance before creating
a replacement, covering the mid-handshake case where isConnected()
still returned false but the library client was live.
- startBot now reuses the stored identity so server groups granted to
the bot survive restarts (was regenerating a fresh UID each time).
WebSocket reliability
---------------------
- BotManager extends EventEmitter and emits 'botInstance' whenever a
new instance is created. websocket.ts listens and re-attaches its
stateChange / connected / disconnected listeners immediately, fixing
the bug where player-bar UI never updated until manual refresh.
- attachedBots map now stores the BotInstance reference and detaches
stale listeners when the instance is replaced. Safety-net interval
(5s) also reconciles to catch anything missed.
- removeBot emits 'botInstanceRemoved' -> WS broadcasts a new
{type:"botRemoved", botId} message. Client drops the bot from its
local store instead of showing it as permanently offline.
HTTP input validation
---------------------
- /volume rejects non-number, NaN, Infinity, and out-of-range values
with a proper 400 instead of a 200 OK wrapping a usage-text string.
- /mode rejects anything not in {seq, loop, random, rloop} with 400.
- /seek rejects NaN / Infinity / negative (previously NaN slipped
through typeof==="number" and poisoned seekOffset).
- /play-at validates index < queue.size() BEFORE stopping current
playback (was silently killing the current song on invalid input).
- /play, /add, /playlist, /play-by-id, /add-by-id, /play-playlist
all honour platform=youtube now (previously fell through to netease
and silently played the wrong platform).
YouTube made truly optional
---------------------------
- Lazy checkYtDlpAvailable() runs `yt-dlp --version` once, caches only
positive results so users can install yt-dlp mid-run and have it
picked up without a restart.
- getAuthStatus() returns loggedIn=false with nickname
"YouTube (yt-dlp not installed)" when the binary is missing. UI can
grey out YouTube instead of silently returning empty searches.
- findYtDlp() picks .exe on win32 and bare binary elsewhere.
- /auth/status?platform=youtube now routes to the YouTube provider
instead of falling through to NetEase and leaking the NetEase
user's nickname + avatar.
- /auth/cookie rejects platform=youtube with 400 instead of clobbering
the NetEase cookie entry.
- README documents yt-dlp install paths (bin/ local vs PATH) and adds
a dedicated "Optional: YouTube source" section.
Bot Selector UI
---------------
- New power button in each row of the dropdown with play-state-aware
styling: disabled + wait-cursor during API call, green highlight when
connected, greys out when the bot is offline.
- Dropdown always visible when >=1 bot exists, bigger font + padding.
Queue correctness
-----------------
- PlayQueue.remove(current) now decrements currentIndex so next() in
sequential mode advances to the shifted song. Previously removing
the currently-playing track silently skipped the next track because
current() falsely reported it as active and next() then incremented
past it.
Vote-skip hardening
-------------------
- cmdVote: needed threshold is Math.max(1, ceil(users/2)) so a single
voter in an empty channel can't unanimously pass a vote with
needed=0.
- resolveAndPlay clears voteSkipUsers on every new track load so votes
can't leak across songs via cmdPlay/cmdPlaylist/cmdAlbum/cmdFm paths.
cmdAdd parity
-------------
- cmdAdd auto-plays the newly-added song if the player was idle,
matching /api/player/:id/add-by-id behaviour. Previously add'ing to
an empty queue on a connected+idle bot silently enqueued without
starting playback.
Test suite
----------
- scripts/test_full_feature.py — 51 tests across 10 groups exercising
every HTTP endpoint, WebSocket broadcasts, all music providers, bot
lifecycle, disconnected-state corners, seek validation, input
validation, and the main race conditions. Captures and restores the
target bot's initial state. Resilient to TS3 anti-flood via retry
with exponential backoff. Runs against a real local TS3 server.
- scripts/test_rapid_cycle.py — Bugs A/B/C regressions
- scripts/test_corner_cases.py — disconnect-during-connect race, config
commands while disconnected, etc.
- scripts/test_more_corners.py — resolveAndPlay race, seek NaN
- scripts/test_power_button.py — E2E for the new power button
- scripts/test_bot_remove.py — E2E for WS botRemoved broadcast
- scripts/test_playbar.py — player bar auto-show regression (updated
to restore bot state on exit)
- scripts/test_multibot.py — two-bot concurrent playback monitor
- src/audio/queue.test.ts — 4 new vitest cases for remove() edge cases
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
saopig1andClaude Opus 4.6 committed
1 parent
6e828b9c2d
commit
4643f70f4a
21 files changed
+2281
-110
No files matched your search
@@ -5,7 +5,7 @@
|
||||
<h1 align="center">TSMusicBot</h1>
|
||||
|
||||
<p align="center">
|
||||
<strong>TeamSpeak 音乐机器人</strong> — 网易云音乐 + QQ 音乐 + 哔哩哔哩 三平台，YesPlayMusic 风格 WebUI 控制面板
|
||||
<strong>TeamSpeak 音乐机器人</strong> — 网易云音乐 + QQ 音乐 + 哔哩哔哩 + YouTube（可选），YesPlayMusic 风格 WebUI 控制面板
|
||||
</p>
|
||||
|
||||
<p align="center">
|
||||
@@ -16,6 +16,7 @@
|
||||
<img src="https://img.shields.io/badge/FFmpeg-已内置-orange?logo=ffmpeg" />
|
||||
<img src="https://img.shields.io/badge/Docker-支持-2496ED?logo=docker&logoColor=white" />
|
||||
<img src="https://img.shields.io/badge/BiliBili-支持-00a1d6?logo=bilibili&logoColor=white" />
|
||||
<img src="https://img.shields.io/badge/YouTube-可选-FF0000?logo=youtube&logoColor=white" />
|
||||
<img src="https://img.shields.io/badge/TS3-支持-2580C3?logo=teamspeak&logoColor=white" />
|
||||
<img src="https://img.shields.io/badge/TS6-支持-2580C3?logo=teamspeak&logoColor=white" />
|
||||
</p>
|
||||
@@ -55,11 +56,19 @@
|
||||
- 修复 `TS6HttpQuery.request()` 双重 reject 问题
|
||||
- 添加重复 `connect()` 调用的保护（先断开旧连接）
|
||||
|
||||
### YouTube 音源（可选）
|
||||
|
||||
新增基于 `yt-dlp` 的 YouTube 音源，**默认未启用**。安装 `yt-dlp` 后可通过 `!play -y <关键词>` 或 WebUI 平台选项使用。详见 [可选：YouTube 音源](#可选youtube-音源) 章节的安装步骤。
|
||||
|
||||
- `src/music/youtube.ts` — YouTubeProvider（通过 `yt-dlp --dump-json` 搜索、`--get-url` 取直链）
|
||||
- 未安装 `yt-dlp` 时搜索静默返回空结果，不影响其他音源
|
||||
- 服务器密码登录（`serverPassword` 字段）、Bot 选择器 UI 改进等特性见 git log
|
||||
|
||||
---
|
||||
|
||||
## 功能特性
|
||||
|
||||
- **三平台音源** — 网易云音乐 + QQ 音乐 + 哔哩哔哩，统一搜索，结果标注来源
|
||||
- **多平台音源** — 网易云音乐 + QQ 音乐 + 哔哩哔哩（默认内置），YouTube 可选启用（通过 yt-dlp），统一搜索，结果标注来源
|
||||
- **真实客户端协议 (TS3/TS6 双协议)** — 机器人在 TeamSpeak 中可见（非 ServerQuery 隐身模式），自动检测并适配 TS3 和 TS6 服务器，支持 TS6 HTTP Query API
|
||||
- **YesPlayMusic 风格 WebUI** — 精美界面，支持深色/浅色主题切换
|
||||
- **完整播放控制** — 播放/暂停/上一首/下一首/进度跳转/音量调节
|
||||
@@ -254,6 +263,7 @@ sudo systemctl start tsmusicbot
|
||||
| `!play <歌名>` | 搜索并播放 |
|
||||
| `!play -q <歌名>` | 从 QQ 音乐搜索 |
|
||||
| `!play -b <关键词>` | 从哔哩哔哩搜索视频并播放音频 |
|
||||
| `!play -y <关键词>` | 从 YouTube 搜索并播放（需要安装 [yt-dlp](#可选youtube-音源)）|
|
||||
| `!add <歌名>` | 添加到播放队列 |
|
||||
| `!pause` / `!resume` | 暂停 / 恢复播放 |
|
||||
| `!next` / `!prev` | 下一首 / 上一首 |
|
||||
@@ -306,6 +316,7 @@ tsmusicbot/
|
||||
│ │ ├── netease.ts # 网易云音乐适配器
|
||||
│ │ ├── qq.ts # QQ 音乐适配器
|
||||
│ │ ├── bilibili.ts # 哔哩哔哩适配器（视频音频提取）
|
||||
│ │ ├── youtube.ts # YouTube 适配器（可选，依赖 yt-dlp）
|
||||
│ │ ├── auth.ts # Cookie 持久化存储
|
||||
│ │ └── api-server.ts # 嵌入式 API 服务（自动启动）
|
||||
│ ├── ts-protocol/ # TeamSpeak 客户端协议（TS3/TS6 双协议）
|
||||
@@ -359,6 +370,55 @@ tsmusicbot/
|
||||
| **图标** | @iconify/vue |
|
||||
| **日志** | pino |
|
||||
|
||||
## 可选：YouTube 音源
|
||||
|
||||
YouTube 是**可选**的音源，默认**未启用**，需要安装 [yt-dlp](https://github.com/yt-dlp/yt-dlp) 才能使用。启用后可通过聊天命令 `!play -y <关键词>` 或 WebUI 的 YouTube 平台选项搜索/播放 YouTube 视频的音频流。
|
||||
|
||||
### 启用方式（任选其一）
|
||||
|
||||
**方式一：项目本地 `bin/` 目录（推荐）**
|
||||
|
||||
将 `yt-dlp` 可执行文件放到项目根目录下的 `bin/` 文件夹，程序会优先使用此路径。该目录已被 `.gitignore` 忽略，不会影响代码更新。
|
||||
|
||||
```bash
|
||||
# Windows（PowerShell 或 Git Bash）
|
||||
mkdir bin
|
||||
curl -L -o bin/yt-dlp.exe https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe
|
||||
|
||||
# Linux / macOS
|
||||
mkdir -p bin
|
||||
curl -L -o bin/yt-dlp https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp
|
||||
chmod +x bin/yt-dlp
|
||||
```
|
||||
|
||||
**方式二：系统级安装（让 `yt-dlp` 在 `PATH` 中可用）**
|
||||
|
||||
```bash
|
||||
# Windows
|
||||
winget install yt-dlp
|
||||
|
||||
# macOS
|
||||
brew install yt-dlp
|
||||
|
||||
# Debian/Ubuntu
|
||||
sudo apt install yt-dlp
|
||||
|
||||
# 通用（Python 环境下）
|
||||
pip install -U yt-dlp
|
||||
```
|
||||
|
||||
### 验证是否可用
|
||||
|
||||
重启机器人程序，在 WebUI 或 `!play -y lofi` 测试搜索。若 `bin/` 和 `PATH` 中都找不到 `yt-dlp`，YouTube 搜索会静默返回空结果（不会影响其他音源），其余功能正常。
|
||||
|
||||
### 注意事项
|
||||
|
||||
- YouTube 音源通过 `yt-dlp` 本地调用实现，不依赖 API Key，也无需登录
|
||||
- 播放的是视频的最佳音频流（`bestaudio[ext=webm]/bestaudio[ext=m4a]/bestaudio`），由 FFmpeg 解码
|
||||
- 音质由源视频决定，不受音质设置影响
|
||||
- 受 YouTube 风控/地域限制，部分视频可能无法播放
|
||||
- `yt-dlp` 更新较频繁，如果播放失败，先尝试升级 `yt-dlp` 到最新版本
|
||||
|
||||
## 配置文件
|
||||
|
||||
`config.json` 在首次运行时自动生成，可手动编辑：
|
||||
@@ -412,6 +472,9 @@ A：原生模块（opus、sqlite3）需要编译工具，Dockerfile 已包含。
|
||||
**Q：B站视频搜索不到结果？**
|
||||
A：B站搜索需要 buvid3 匿名 Cookie（程序启动时自动获取）。如果失败，重启程序即可。登录B站账号后搜索效果更好。
|
||||
|
||||
**Q：YouTube 平台搜索返回空结果？**
|
||||
A：YouTube 是可选音源，需要手动安装 `yt-dlp`。详见 [可选：YouTube 音源](#可选youtube-音源) 章节。快速验证：在项目根目录执行 `bin/yt-dlp --version`（或系统 `yt-dlp --version`），能打印版本号即可。若 yt-dlp 已安装但仍搜索失败，通常是网络/地域问题或 yt-dlp 版本过旧（执行 `yt-dlp -U` 升级）。
|
||||
|
||||
**Q：如何更新到新版本？**
|
||||
A：`git pull` 拉取最新代码，然后 `npm install && npm run build && npm start` 重新构建启动。Docker 用户执行 `docker-compose up -d --build`。
|
||||
|
||||
|
||||
@@ -0,0 +1,99 @@
|
||||
"""Regression: DELETE /api/bot/:id must broadcast botRemoved so the UI drops the row.
|
||||
|
||||
Creates an ephemeral bot, opens the dropdown, deletes the bot via API, and
|
||||
asserts the row disappears without any page reload. Does not touch any
|
||||
existing user bot.
|
||||
"""
|
||||
import time
|
||||
import requests
|
||||
from playwright.sync_api import sync_playwright
|
||||
|
||||
BASE = "http://localhost:3000"
|
||||
EPHEMERAL_NAME = "rmbot_test"
|
||||
EPHEMERAL_NICK = "RmBotTest"
|
||||
|
||||
|
||||
def api(path, method="GET", **kw):
|
||||
r = getattr(requests, method.lower())(f"{BASE}{path}", timeout=10, **kw)
|
||||
r.raise_for_status()
|
||||
return r.json() if r.text else None
|
||||
|
||||
|
||||
def cleanup():
|
||||
for b in api("/api/bot/")["bots"]:
|
||||
if b["name"] == EPHEMERAL_NAME:
|
||||
try:
|
||||
api(f"/api/bot/{b['id']}", method="DELETE")
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
def main():
|
||||
cleanup()
|
||||
new = api(
|
||||
"/api/bot/",
|
||||
method="POST",
|
||||
json={
|
||||
"name": EPHEMERAL_NAME,
|
||||
"serverAddress": "127.0.0.1",
|
||||
"serverPort": 9987,
|
||||
"nickname": EPHEMERAL_NICK,
|
||||
"autoStart": False,
|
||||
},
|
||||
)
|
||||
bot_id = new["id"]
|
||||
print(f"[setup] created ephemeral bot {bot_id[:8]}")
|
||||
|
||||
try:
|
||||
with sync_playwright() as p:
|
||||
browser = p.chromium.launch(headless=True)
|
||||
try:
|
||||
page = browser.new_page(viewport={"width": 1440, "height": 900})
|
||||
page.goto(BASE)
|
||||
page.wait_for_load_state("networkidle")
|
||||
time.sleep(0.8)
|
||||
|
||||
# Open dropdown and confirm the new bot row is present
|
||||
page.locator(".bot-selector-btn").click()
|
||||
page.wait_for_selector(".bot-dropdown")
|
||||
rows_before = page.locator(".bot-dropdown-row").count()
|
||||
print(f"[ui] dropdown rows before remove: {rows_before}")
|
||||
|
||||
# Match the ephemeral row by its name text
|
||||
present = (
|
||||
page.locator(".bot-dropdown-row", has_text=EPHEMERAL_NAME).count()
|
||||
)
|
||||
assert present == 1, f"ephemeral row not found (got {present})"
|
||||
|
||||
# Delete via API
|
||||
api(f"/api/bot/{bot_id}", method="DELETE")
|
||||
print("[api] deleted bot")
|
||||
|
||||
# Wait up to 4s for UI to drop the row
|
||||
removed = False
|
||||
for _ in range(40):
|
||||
if (
|
||||
page.locator(
|
||||
".bot-dropdown-row", has_text=EPHEMERAL_NAME
|
||||
).count()
|
||||
== 0
|
||||
):
|
||||
removed = True
|
||||
break
|
||||
time.sleep(0.1)
|
||||
|
||||
rows_after = page.locator(".bot-dropdown-row").count()
|
||||
print(f"[ui] dropdown rows after remove: {rows_after}")
|
||||
assert removed, "ephemeral row did not disappear from UI after DELETE"
|
||||
assert rows_after == rows_before - 1, (
|
||||
f"row count mismatch: before={rows_before} after={rows_after}"
|
||||
)
|
||||
print("[PASS] bot removal propagates to UI via WS")
|
||||
finally:
|
||||
browser.close()
|
||||
finally:
|
||||
cleanup()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,171 @@
|
||||
"""Corner case regressions that go beyond Bugs A/B/C.
|
||||
|
||||
A. Race — disconnect() called during connect()'s awaited handshake must
|
||||
NOT leave the bot reporting connected=true afterwards.
|
||||
|
||||
B. Config-only commands (vol, mode, clear) must work even when the bot is
|
||||
disconnected (UI should stay usable while the bot is offline).
|
||||
|
||||
C. After a disconnect mid-playback, the player must not be able to
|
||||
auto-advance to the next queued song (trackEnd → resolveAndPlay).
|
||||
"""
|
||||
import time
|
||||
import threading
|
||||
import requests
|
||||
|
||||
BASE = "http://localhost:3000"
|
||||
|
||||
|
||||
def api(path, method="GET", **kw):
|
||||
return getattr(requests, method.lower())(f"{BASE}{path}", timeout=30, **kw)
|
||||
|
||||
|
||||
def get_bot(bot_id):
|
||||
return next(b for b in api("/api/bot/").json()["bots"] if b["id"] == bot_id)
|
||||
|
||||
|
||||
def wait_connected(bot_id, want, timeout=15):
|
||||
end = time.time() + timeout
|
||||
while time.time() < end:
|
||||
if get_bot(bot_id)["connected"] is want:
|
||||
return True
|
||||
time.sleep(0.1)
|
||||
return False
|
||||
|
||||
|
||||
def test_config_commands_when_disconnected(bot_id):
|
||||
"""B. vol/mode/clear should succeed while bot is disconnected."""
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False)
|
||||
|
||||
# volume is the simplest config-only command
|
||||
r = api(
|
||||
f"/api/player/{bot_id}/volume",
|
||||
method="POST",
|
||||
json={"volume": 60},
|
||||
)
|
||||
assert r.status_code == 200, f"volume failed while disconnected: {r.status_code} {r.text[:100]}"
|
||||
|
||||
r = api(
|
||||
f"/api/player/{bot_id}/mode",
|
||||
method="POST",
|
||||
json={"mode": "seq"},
|
||||
)
|
||||
assert r.status_code == 200, f"mode failed while disconnected: {r.status_code} {r.text[:100]}"
|
||||
|
||||
r = api(f"/api/player/{bot_id}/clear", method="POST")
|
||||
assert r.status_code == 200, f"clear failed while disconnected: {r.status_code} {r.text[:100]}"
|
||||
|
||||
print("[PASS] config commands (vol/mode/clear) work when disconnected")
|
||||
|
||||
|
||||
def test_play_rejected_when_disconnected(bot_id):
|
||||
"""B (negative). play/add/next/prev should still be rejected."""
|
||||
r = api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json={"query": "test", "platform": "netease"},
|
||||
)
|
||||
assert r.status_code >= 400, f"play should fail while disconnected"
|
||||
|
||||
r = api(
|
||||
f"/api/player/{bot_id}/add",
|
||||
method="POST",
|
||||
json={"query": "test", "platform": "netease"},
|
||||
)
|
||||
assert r.status_code >= 400, f"add should fail while disconnected"
|
||||
|
||||
r = api(f"/api/player/{bot_id}/next", method="POST")
|
||||
assert r.status_code >= 400, f"next should fail while disconnected"
|
||||
|
||||
print("[PASS] audio commands (play/add/next) rejected when disconnected")
|
||||
|
||||
|
||||
def test_disconnect_during_connect_race(bot_id):
|
||||
"""A. disconnect() called while connect() is awaiting must win the race.
|
||||
|
||||
Fires a stop 200ms into a start call; after things settle the bot's
|
||||
connected state must be stable (either cleanly disconnected, or cleanly
|
||||
connected if the stop happened after connect completed). It must NOT
|
||||
end up in a weird state where connected=true but a subsequent query
|
||||
shows inconsistent data.
|
||||
"""
|
||||
# Ensure disconnected first
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False)
|
||||
time.sleep(1) # give TS server a moment to forget us
|
||||
|
||||
def delayed_stop():
|
||||
time.sleep(0.2)
|
||||
try:
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
threading.Thread(target=delayed_stop, daemon=True).start()
|
||||
try:
|
||||
r = api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
except Exception as e:
|
||||
r = None
|
||||
print(f"[info] start threw: {e}")
|
||||
|
||||
# Wait for all state transitions to settle
|
||||
time.sleep(2)
|
||||
|
||||
b = get_bot(bot_id)
|
||||
# The key invariant: if connected is false, playing must also be false;
|
||||
# if connected is true, the transport is actually up (we can issue
|
||||
# another command without error).
|
||||
assert not (b["connected"] is False and b["playing"] is True), (
|
||||
f"inconsistent state: connected={b['connected']} playing={b['playing']}"
|
||||
)
|
||||
print(
|
||||
f"[PASS] disconnect-during-connect race — final state consistent "
|
||||
f"(connected={b['connected']} playing={b['playing']})"
|
||||
)
|
||||
|
||||
|
||||
def test_resolve_guard(bot_id):
|
||||
"""C. resolveAndPlay on a disconnected bot is a no-op.
|
||||
|
||||
We can't directly invoke resolveAndPlay from the API, but we can
|
||||
verify by checking that after a stop, the bot stays idle even if we
|
||||
wait for a trackEnd-like event to fire.
|
||||
"""
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False)
|
||||
time.sleep(1.5) # more than a frame cycle
|
||||
b = get_bot(bot_id)
|
||||
assert not b["playing"], (
|
||||
f"player should stay stopped after disconnect: {b}"
|
||||
)
|
||||
print("[PASS] player stays idle after disconnect (no ghost autoplay)")
|
||||
|
||||
|
||||
def main():
|
||||
bots = api("/api/bot/").json()["bots"]
|
||||
if not bots:
|
||||
print("[skip] no bots")
|
||||
return
|
||||
bot_id = bots[0]["id"]
|
||||
initial = bots[0]["connected"]
|
||||
print(f"[init] bot={bot_id[:8]} initial connected={initial}")
|
||||
|
||||
try:
|
||||
test_config_commands_when_disconnected(bot_id)
|
||||
test_play_rejected_when_disconnected(bot_id)
|
||||
test_resolve_guard(bot_id)
|
||||
test_disconnect_during_connect_race(bot_id)
|
||||
print("ALL GREEN")
|
||||
finally:
|
||||
if initial:
|
||||
api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
wait_connected(bot_id, True)
|
||||
else:
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False)
|
||||
print(f"[restore] connected={get_bot(bot_id)['connected']}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,852 @@
|
||||
"""Comprehensive feature + corner-case test for TSMusicBot against a
|
||||
local TeamSpeak 3 server.
|
||||
|
||||
Exercises every major HTTP endpoint, the WebSocket state-broadcast path,
|
||||
all music providers, bot lifecycle transitions, and a handful of races
|
||||
that have burned us in the past. Designed to be safe to run against a
|
||||
real installation: captures the target bot's initial connected/volume/
|
||||
mode settings and restores them in `finally`.
|
||||
|
||||
Usage:
|
||||
"C:/Users/saopig1/miniforge3/python.exe" scripts/test_full_feature.py
|
||||
|
||||
Exit code: 0 if every non-skipped test passed, 1 otherwise.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import threading
|
||||
import time
|
||||
from dataclasses import dataclass
|
||||
from typing import Any
|
||||
|
||||
import requests
|
||||
|
||||
BASE = "http://localhost:3000"
|
||||
POLL_INTERVAL = 0.15
|
||||
CONNECT_TIMEOUT = 20 # tolerate occasional TS3 anti-flood grace
|
||||
ANTIFLOOD_BREATHER = 1.5 # gap between rapid cycles so TS3 stays happy
|
||||
|
||||
|
||||
# ----------------------------- HTTP helpers ---------------------------------
|
||||
|
||||
|
||||
def api(path: str, method: str = "GET", json_body: Any = None):
|
||||
"""Return (status_code, body). Never raises."""
|
||||
try:
|
||||
fn = getattr(requests, method.lower())
|
||||
r = fn(f"{BASE}{path}", json=json_body, timeout=30)
|
||||
try:
|
||||
return r.status_code, r.json()
|
||||
except Exception:
|
||||
return r.status_code, r.text
|
||||
except Exception as e:
|
||||
return None, f"<{type(e).__name__}: {e}>"
|
||||
|
||||
|
||||
def get_bot(bot_id: str) -> dict | None:
|
||||
_, data = api("/api/bot/")
|
||||
if not isinstance(data, dict):
|
||||
return None
|
||||
return next((b for b in data.get("bots", []) if b["id"] == bot_id), None)
|
||||
|
||||
|
||||
def wait_connected(bot_id: str, want: bool, timeout: float = CONNECT_TIMEOUT) -> bool:
|
||||
end = time.time() + timeout
|
||||
while time.time() < end:
|
||||
b = get_bot(bot_id)
|
||||
if b is not None and b["connected"] is want:
|
||||
return True
|
||||
time.sleep(POLL_INTERVAL)
|
||||
return False
|
||||
|
||||
|
||||
def start_and_wait(bot_id: str, retries: int = 2) -> bool:
|
||||
"""Start the bot, tolerating transient TS3 anti-flood by retrying with
|
||||
exponential backoff. Returns True only when the bot reports connected."""
|
||||
for attempt in range(retries + 1):
|
||||
s, _ = api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
if s == 200 and wait_connected(bot_id, True):
|
||||
return True
|
||||
# If /start returned an error (e.g. connect timeout from our 15s
|
||||
# deadline), back off and retry — TS3 server-side anti-flood
|
||||
# usually clears in a few seconds.
|
||||
if attempt < retries:
|
||||
time.sleep(3.0 * (attempt + 1))
|
||||
# Make sure we're fully stopped before the next attempt so
|
||||
# oldBot.disconnect() doesn't double-fire
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False, timeout=5)
|
||||
return False
|
||||
|
||||
|
||||
def stop_and_wait(bot_id: str) -> bool:
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
return wait_connected(bot_id, False)
|
||||
|
||||
|
||||
def assert_started(bot_id: str):
|
||||
"""Helper that raises with a clear message when start fails so test
|
||||
output points at 'could not connect' rather than an empty assertion."""
|
||||
if not start_and_wait(bot_id):
|
||||
raise AssertionError(
|
||||
"could not bring bot online (TS3 server may be anti-flooding "
|
||||
"or unreachable)"
|
||||
)
|
||||
|
||||
|
||||
# ----------------------------- test runner ----------------------------------
|
||||
|
||||
|
||||
@dataclass
|
||||
class TestResult:
|
||||
name: str
|
||||
status: str # PASS / FAIL / ERROR / SKIP
|
||||
detail: str = ""
|
||||
|
||||
|
||||
passed = 0
|
||||
failed = 0
|
||||
skipped = 0
|
||||
results: list[TestResult] = []
|
||||
|
||||
|
||||
def run(name: str, fn):
|
||||
global passed, failed
|
||||
try:
|
||||
fn()
|
||||
print(f" [PASS] {name}")
|
||||
passed += 1
|
||||
results.append(TestResult(name, "PASS"))
|
||||
except AssertionError as e:
|
||||
print(f" [FAIL] {name}: {e}")
|
||||
failed += 1
|
||||
results.append(TestResult(name, "FAIL", str(e)))
|
||||
except Exception as e:
|
||||
print(f" [ERROR] {name}: {type(e).__name__}: {e}")
|
||||
failed += 1
|
||||
results.append(TestResult(name, "ERROR", f"{type(e).__name__}: {e}"))
|
||||
|
||||
|
||||
def skip(name: str, reason: str):
|
||||
global skipped
|
||||
print(f" [SKIP] {name} ({reason})")
|
||||
skipped += 1
|
||||
results.append(TestResult(name, "SKIP", reason))
|
||||
|
||||
|
||||
# ----------------------------- test groups ----------------------------------
|
||||
|
||||
|
||||
def group_infrastructure(bot_id: str):
|
||||
print("\n== infrastructure ==")
|
||||
|
||||
def t_health():
|
||||
s, d = api("/api/health")
|
||||
assert s == 200, f"health returned {s}"
|
||||
assert d.get("status") == "ok"
|
||||
run("GET /api/health", t_health)
|
||||
|
||||
def t_list_bots():
|
||||
s, d = api("/api/bot/")
|
||||
assert s == 200
|
||||
assert isinstance(d.get("bots"), list)
|
||||
assert any(b["id"] == bot_id for b in d["bots"])
|
||||
run("GET /api/bot/ lists target bot", t_list_bots)
|
||||
|
||||
def t_bot_config():
|
||||
s, d = api(f"/api/bot/{bot_id}/config")
|
||||
assert s == 200
|
||||
assert d["id"] == bot_id
|
||||
assert "identity" in d
|
||||
assert "serverAddress" in d and "nickname" in d
|
||||
assert "serverPassword" in d, "serverPassword field missing"
|
||||
run("GET /api/bot/:id/config returns all fields", t_bot_config)
|
||||
|
||||
def t_404_on_unknown_bot():
|
||||
s, _ = api("/api/bot/does-not-exist/config")
|
||||
assert s == 404
|
||||
run("404 on unknown bot id", t_404_on_unknown_bot)
|
||||
|
||||
def t_quality_shape():
|
||||
s, d = api("/api/music/quality")
|
||||
assert s == 200
|
||||
for p in ("netease", "qq", "bilibili"):
|
||||
assert p in d, f"{p} missing from quality response"
|
||||
run("GET /api/music/quality shape", t_quality_shape)
|
||||
|
||||
|
||||
def group_auth_status():
|
||||
print("\n== auth status per platform ==")
|
||||
|
||||
def t_netease_ok():
|
||||
s, d = api("/api/auth/status?platform=netease")
|
||||
assert s == 200
|
||||
assert d.get("platform") == "netease"
|
||||
assert "loggedIn" in d
|
||||
run("auth status netease", t_netease_ok)
|
||||
|
||||
def t_qq_ok():
|
||||
s, d = api("/api/auth/status?platform=qq")
|
||||
assert s == 200
|
||||
assert d.get("platform") == "qq"
|
||||
run("auth status qq", t_qq_ok)
|
||||
|
||||
def t_bilibili_ok():
|
||||
s, d = api("/api/auth/status?platform=bilibili")
|
||||
assert s == 200
|
||||
assert d.get("platform") == "bilibili"
|
||||
run("auth status bilibili", t_bilibili_ok)
|
||||
|
||||
def t_youtube_routed():
|
||||
# Regression: /auth/status?platform=youtube used to fall through
|
||||
# to NetEase and leak the NetEase user's nickname/avatar.
|
||||
s, d = api("/api/auth/status?platform=youtube")
|
||||
assert s == 200
|
||||
assert d.get("platform") == "youtube", (
|
||||
f"youtube auth status leaked to {d.get('platform')}"
|
||||
)
|
||||
run("auth status youtube routes correctly", t_youtube_routed)
|
||||
|
||||
def t_youtube_cookie_rejected():
|
||||
s, d = api(
|
||||
"/api/auth/cookie",
|
||||
method="POST",
|
||||
json_body={"platform": "youtube", "cookie": "fake"},
|
||||
)
|
||||
assert s == 400, f"youtube cookie should be rejected, got {s}: {d}"
|
||||
run("POST /auth/cookie rejects youtube", t_youtube_cookie_rejected)
|
||||
|
||||
|
||||
def group_search():
|
||||
print("\n== multi-platform search ==")
|
||||
|
||||
def search(platform: str, query: str = "test"):
|
||||
return api(f"/api/music/search?q={query}&platform={platform}&limit=1")
|
||||
|
||||
def t_netease():
|
||||
s, d = search("netease")
|
||||
assert s == 200
|
||||
assert isinstance(d.get("songs"), list)
|
||||
run("netease search", t_netease)
|
||||
|
||||
def t_qq():
|
||||
s, d = search("qq")
|
||||
assert s == 200
|
||||
# QQ may return 0 results if no cookie, but shouldn't error
|
||||
assert isinstance(d.get("songs"), list)
|
||||
run("qq search (empty ok)", t_qq)
|
||||
|
||||
def t_bilibili():
|
||||
s, d = search("bilibili")
|
||||
assert s == 200
|
||||
assert isinstance(d.get("songs"), list)
|
||||
run("bilibili search", t_bilibili)
|
||||
|
||||
def t_missing_query():
|
||||
s, _ = api("/api/music/search?platform=netease")
|
||||
assert s == 400, "missing q should 400"
|
||||
run("400 on missing query", t_missing_query)
|
||||
|
||||
_, auth = api("/api/auth/status?platform=youtube")
|
||||
youtube_available = isinstance(auth, dict) and auth.get("loggedIn") is True
|
||||
|
||||
if youtube_available:
|
||||
def t_youtube():
|
||||
s, d = search("youtube", "lofi")
|
||||
assert s == 200
|
||||
songs = d.get("songs", [])
|
||||
assert len(songs) >= 1, "expected at least 1 YouTube result"
|
||||
assert songs[0]["platform"] == "youtube"
|
||||
run("youtube search (yt-dlp installed)", t_youtube)
|
||||
else:
|
||||
skip("youtube search", "yt-dlp not installed")
|
||||
|
||||
|
||||
def group_lifecycle(bot_id: str):
|
||||
print("\n== connection lifecycle ==")
|
||||
|
||||
def t_stop_from_any_state():
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
assert wait_connected(bot_id, False), "bot did not stop"
|
||||
b = get_bot(bot_id)
|
||||
assert not b["playing"], "playing should be false after stop"
|
||||
run("stop from any state \u2192 disconnected+idle", t_stop_from_any_state)
|
||||
|
||||
def t_start_completes_quickly():
|
||||
t0 = time.time()
|
||||
s, d = api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
elapsed = time.time() - t0
|
||||
assert s == 200, f"start failed: {d}"
|
||||
assert elapsed < 10, f"start took {elapsed:.1f}s (expected <10s)"
|
||||
assert wait_connected(bot_id, True)
|
||||
run("start completes well under 15s deadline", t_start_completes_quickly)
|
||||
|
||||
def t_identity_persists():
|
||||
assert_started(bot_id)
|
||||
_, cfg1 = api(f"/api/bot/{bot_id}/config")
|
||||
id1 = cfg1["identity"]
|
||||
assert id1, "identity empty after first start"
|
||||
assert stop_and_wait(bot_id)
|
||||
time.sleep(ANTIFLOOD_BREATHER)
|
||||
assert_started(bot_id)
|
||||
_, cfg2 = api(f"/api/bot/{bot_id}/config")
|
||||
assert cfg2["identity"] == id1, (
|
||||
f"identity changed across restart: {id1} \u2192 {cfg2['identity']}"
|
||||
)
|
||||
run("identity preserved across stop/start", t_identity_persists)
|
||||
|
||||
|
||||
def group_playback(bot_id: str):
|
||||
print("\n== playback ==")
|
||||
|
||||
# Bring the bot online ONCE for the whole playback group, then only
|
||||
# toggle player state (play/pause/stop) between tests. This keeps the
|
||||
# TS3 reconnect count for this group at exactly 1.
|
||||
assert_started(bot_id)
|
||||
|
||||
def t_play_song():
|
||||
s, d = api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json_body={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
assert s == 200, f"play failed: {d}"
|
||||
time.sleep(1.2)
|
||||
b = get_bot(bot_id)
|
||||
assert b["playing"] is True, f"not playing after /play: {b}"
|
||||
assert b["currentSong"] is not None
|
||||
run("play netease song \u2192 playing=true", t_play_song)
|
||||
|
||||
def t_pause_resume():
|
||||
# Previous test left a song playing
|
||||
api(f"/api/player/{bot_id}/pause", method="POST")
|
||||
time.sleep(0.4)
|
||||
b = get_bot(bot_id)
|
||||
assert b["paused"] is True, f"pause failed: {b}"
|
||||
api(f"/api/player/{bot_id}/resume", method="POST")
|
||||
time.sleep(0.4)
|
||||
b = get_bot(bot_id)
|
||||
assert b["paused"] is False and b["playing"] is True, f"resume failed: {b}"
|
||||
run("pause \u2192 paused, resume \u2192 playing", t_pause_resume)
|
||||
|
||||
def t_volume_change():
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/volume",
|
||||
method="POST",
|
||||
json_body={"volume": 42},
|
||||
)
|
||||
assert s == 200
|
||||
time.sleep(0.2)
|
||||
b = get_bot(bot_id)
|
||||
assert b["volume"] == 42, f"volume not applied: {b['volume']}"
|
||||
run("volume change", t_volume_change)
|
||||
|
||||
def t_mode_cycle():
|
||||
for m in ("seq", "loop", "random", "rloop"):
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/mode", method="POST", json_body={"mode": m}
|
||||
)
|
||||
assert s == 200
|
||||
b = get_bot(bot_id)
|
||||
assert b["playMode"] == m, f"mode {m} not applied: {b['playMode']}"
|
||||
run("all four play modes apply", t_mode_cycle)
|
||||
|
||||
def t_queue_endpoint():
|
||||
s, d = api(f"/api/player/{bot_id}/queue")
|
||||
assert s == 200
|
||||
assert isinstance(d.get("queue"), list)
|
||||
assert "status" in d
|
||||
run("GET /player/:id/queue returns queue+status", t_queue_endpoint)
|
||||
|
||||
def t_elapsed_endpoint():
|
||||
s, d = api(f"/api/player/{bot_id}/elapsed")
|
||||
assert s == 200
|
||||
elapsed = d.get("elapsed")
|
||||
assert isinstance(elapsed, (int, float)) and elapsed >= 0, (
|
||||
f"elapsed should be non-negative number: {elapsed}"
|
||||
)
|
||||
run("GET /player/:id/elapsed returns finite number", t_elapsed_endpoint)
|
||||
|
||||
def t_add_autoplay_on_idle():
|
||||
# This specific test needs an IDLE bot — stop first (but keep
|
||||
# connected), then add and confirm auto-play.
|
||||
api(f"/api/player/{bot_id}/stop", method="POST")
|
||||
time.sleep(0.4)
|
||||
b = get_bot(bot_id)
|
||||
assert not b["playing"] and b["queueSize"] == 0, f"setup failed: {b}"
|
||||
s, d = api(
|
||||
f"/api/player/{bot_id}/add",
|
||||
method="POST",
|
||||
json_body={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
assert s == 200
|
||||
msg = d.get("message", "") if isinstance(d, dict) else ""
|
||||
assert "Now playing" in msg, (
|
||||
f"add on idle bot should auto-play, got: {msg!r}"
|
||||
)
|
||||
time.sleep(0.8)
|
||||
b = get_bot(bot_id)
|
||||
assert b["playing"] is True, f"not playing after add: {b}"
|
||||
run("add on idle bot auto-plays", t_add_autoplay_on_idle)
|
||||
|
||||
# Leave the bot in a clean state for the next group
|
||||
api(f"/api/player/{bot_id}/stop", method="POST")
|
||||
|
||||
|
||||
def group_queue_ops(bot_id: str):
|
||||
print("\n== queue operations ==")
|
||||
assert_started(bot_id)
|
||||
|
||||
def t_clear():
|
||||
api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json_body={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
time.sleep(0.8)
|
||||
api(
|
||||
f"/api/player/{bot_id}/add",
|
||||
method="POST",
|
||||
json_body={"query": "lemon tree", "platform": "netease"},
|
||||
)
|
||||
time.sleep(0.6)
|
||||
b_before = get_bot(bot_id)
|
||||
assert b_before["queueSize"] >= 2, f"expected \u22652 songs: {b_before}"
|
||||
api(f"/api/player/{bot_id}/clear", method="POST")
|
||||
time.sleep(0.4)
|
||||
b_after = get_bot(bot_id)
|
||||
assert b_after["queueSize"] == 0
|
||||
run("clear queue empties it", t_clear)
|
||||
|
||||
def t_play_at_invalid_preserves_playback():
|
||||
api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json_body={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
time.sleep(1.2)
|
||||
assert get_bot(bot_id)["playing"]
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/play-at",
|
||||
method="POST",
|
||||
json_body={"index": 9999},
|
||||
)
|
||||
assert s == 400, f"invalid index should 400, got {s}"
|
||||
time.sleep(0.4)
|
||||
b = get_bot(bot_id)
|
||||
assert b["playing"], "invalid play-at killed the current song"
|
||||
run("invalid play-at preserves current playback", t_play_at_invalid_preserves_playback)
|
||||
|
||||
def t_play_at_negative_rejected():
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/play-at",
|
||||
method="POST",
|
||||
json_body={"index": -1},
|
||||
)
|
||||
assert s == 400
|
||||
run("play-at with negative index rejected", t_play_at_negative_rejected)
|
||||
|
||||
api(f"/api/player/{bot_id}/stop", method="POST")
|
||||
|
||||
|
||||
def group_input_validation(bot_id: str):
|
||||
print("\n== HTTP input validation ==")
|
||||
|
||||
def t_volume_out_of_range():
|
||||
for bad in (150, -10, 1000, -1):
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/volume",
|
||||
method="POST",
|
||||
json_body={"volume": bad},
|
||||
)
|
||||
assert s == 400, f"volume={bad} should 400, got {s}"
|
||||
run("volume out-of-range rejected (400)", t_volume_out_of_range)
|
||||
|
||||
def t_volume_wrong_type():
|
||||
for bad in ("50", None, [50], {"v": 50}):
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/volume",
|
||||
method="POST",
|
||||
json_body={"volume": bad},
|
||||
)
|
||||
assert s == 400, f"volume={bad!r} should 400, got {s}"
|
||||
run("volume wrong-type rejected (400)", t_volume_wrong_type)
|
||||
|
||||
def t_volume_missing():
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/volume", method="POST", json_body={}
|
||||
)
|
||||
assert s == 400
|
||||
run("volume missing rejected (400)", t_volume_missing)
|
||||
|
||||
def t_volume_valid():
|
||||
for good in (0, 1, 50, 100):
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/volume",
|
||||
method="POST",
|
||||
json_body={"volume": good},
|
||||
)
|
||||
assert s == 200, f"volume={good} should succeed, got {s}"
|
||||
b = get_bot(bot_id)
|
||||
assert b["volume"] == good, f"volume not applied: {b['volume']}"
|
||||
run("valid volumes apply", t_volume_valid)
|
||||
|
||||
def t_mode_invalid():
|
||||
for bad in ("bogus", "", None, 1, "SEQ"):
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/mode",
|
||||
method="POST",
|
||||
json_body={"mode": bad},
|
||||
)
|
||||
assert s == 400, f"mode={bad!r} should 400, got {s}"
|
||||
run("mode invalid rejected (400)", t_mode_invalid)
|
||||
|
||||
def t_mode_missing():
|
||||
s, _ = api(f"/api/player/{bot_id}/mode", method="POST", json_body={})
|
||||
assert s == 400
|
||||
run("mode missing rejected (400)", t_mode_missing)
|
||||
|
||||
|
||||
def group_disconnect_corners(bot_id: str):
|
||||
print("\n== disconnected-bot corners ==")
|
||||
|
||||
def t_play_rejected():
|
||||
assert stop_and_wait(bot_id)
|
||||
s, d = api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json_body={"query": "x", "platform": "netease"},
|
||||
)
|
||||
assert s >= 400
|
||||
err = (d.get("error") or "") if isinstance(d, dict) else ""
|
||||
assert "not connected" in err.lower(), f"expected 'not connected' error: {d}"
|
||||
run("play rejected while disconnected", t_play_rejected)
|
||||
|
||||
def t_add_rejected():
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/add",
|
||||
method="POST",
|
||||
json_body={"query": "x", "platform": "netease"},
|
||||
)
|
||||
assert s >= 400
|
||||
run("add rejected while disconnected", t_add_rejected)
|
||||
|
||||
def t_next_rejected():
|
||||
s, _ = api(f"/api/player/{bot_id}/next", method="POST")
|
||||
assert s >= 400
|
||||
run("next rejected while disconnected", t_next_rejected)
|
||||
|
||||
def t_volume_allowed():
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/volume",
|
||||
method="POST",
|
||||
json_body={"volume": 60},
|
||||
)
|
||||
assert s == 200, "volume should work while disconnected"
|
||||
run("volume allowed while disconnected", t_volume_allowed)
|
||||
|
||||
def t_mode_allowed():
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/mode", method="POST", json_body={"mode": "random"}
|
||||
)
|
||||
assert s == 200, "mode should work while disconnected"
|
||||
run("mode allowed while disconnected", t_mode_allowed)
|
||||
|
||||
def t_clear_allowed():
|
||||
s, _ = api(f"/api/player/{bot_id}/clear", method="POST")
|
||||
assert s == 200, "clear should work while disconnected"
|
||||
run("clear allowed while disconnected", t_clear_allowed)
|
||||
|
||||
def t_player_state_clean():
|
||||
b = get_bot(bot_id)
|
||||
assert not b["playing"] and not b["paused"], f"state leak: {b}"
|
||||
run("no player state leak while disconnected", t_player_state_clean)
|
||||
|
||||
|
||||
def group_seek(bot_id: str):
|
||||
print("\n== seek validation ==")
|
||||
|
||||
def t_negative():
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/seek", method="POST", json_body={"position": -5}
|
||||
)
|
||||
assert s == 400
|
||||
run("negative seek rejected", t_negative)
|
||||
|
||||
def t_string():
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/seek",
|
||||
method="POST",
|
||||
json_body={"position": "abc"},
|
||||
)
|
||||
assert s == 400
|
||||
run("string seek rejected", t_string)
|
||||
|
||||
def t_nan_literal():
|
||||
r = requests.post(
|
||||
f"{BASE}/api/player/{bot_id}/seek",
|
||||
data='{"position": NaN}',
|
||||
headers={"Content-Type": "application/json"},
|
||||
timeout=10,
|
||||
)
|
||||
assert r.status_code >= 400, f"NaN literal accepted: {r.status_code}"
|
||||
run("NaN literal seek rejected", t_nan_literal)
|
||||
|
||||
def t_valid_seek():
|
||||
# Seek needs a live connection + playing song. The disconnect-
|
||||
# corners group right before this one left the bot disconnected.
|
||||
assert_started(bot_id)
|
||||
api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json_body={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
time.sleep(1.5)
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/seek",
|
||||
method="POST",
|
||||
json_body={"position": 25},
|
||||
)
|
||||
assert s == 200
|
||||
time.sleep(0.5)
|
||||
_, d = api(f"/api/player/{bot_id}/elapsed")
|
||||
elapsed = d.get("elapsed")
|
||||
assert isinstance(elapsed, (int, float)) and 24 <= elapsed < 40, (
|
||||
f"elapsed after seek(25) wrong: {elapsed}"
|
||||
)
|
||||
api(f"/api/player/{bot_id}/stop", method="POST")
|
||||
run("valid seek produces finite elapsed", t_valid_seek)
|
||||
|
||||
|
||||
def group_races(bot_id: str):
|
||||
print("\n== race conditions ==")
|
||||
|
||||
def t_disconnect_during_connect():
|
||||
assert stop_and_wait(bot_id)
|
||||
time.sleep(ANTIFLOOD_BREATHER)
|
||||
|
||||
def delayed_stop():
|
||||
time.sleep(0.2)
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
|
||||
threading.Thread(target=delayed_stop, daemon=True).start()
|
||||
api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
time.sleep(2)
|
||||
b = get_bot(bot_id)
|
||||
assert not (b["connected"] is False and b["playing"] is True), (
|
||||
f"inconsistent state: {b}"
|
||||
)
|
||||
run("disconnect during connect", t_disconnect_during_connect)
|
||||
|
||||
def t_stop_during_url_resolve():
|
||||
assert stop_and_wait(bot_id)
|
||||
time.sleep(ANTIFLOOD_BREATHER)
|
||||
assert_started(bot_id)
|
||||
|
||||
def delayed_stop():
|
||||
time.sleep(0.15)
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
|
||||
threading.Thread(target=delayed_stop, daemon=True).start()
|
||||
api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json_body={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
time.sleep(3)
|
||||
b = get_bot(bot_id)
|
||||
assert not (b["connected"] is False and b["playing"] is True), (
|
||||
f"inconsistent state: {b}"
|
||||
)
|
||||
run("stop during URL resolve", t_stop_during_url_resolve)
|
||||
|
||||
def t_rapid_volume_change():
|
||||
# Volume is a config-only command and works while disconnected,
|
||||
# so this test deliberately doesn't call assert_started — we're
|
||||
# validating the API's last-write-wins behavior, not the TS
|
||||
# transport. That also spares the TS3 anti-flood budget.
|
||||
for v in (10, 25, 50, 75, 100, 1):
|
||||
s, _ = api(
|
||||
f"/api/player/{bot_id}/volume",
|
||||
method="POST",
|
||||
json_body={"volume": v},
|
||||
)
|
||||
assert s == 200, f"volume POST failed: {s}"
|
||||
time.sleep(0.3)
|
||||
b = get_bot(bot_id)
|
||||
assert b["volume"] == 1, f"final volume wrong: {b['volume']}"
|
||||
run("rapid volume changes converge", t_rapid_volume_change)
|
||||
|
||||
|
||||
def group_websocket(bot_id: str):
|
||||
print("\n== websocket broadcasts ==")
|
||||
try:
|
||||
from websocket import create_connection
|
||||
except Exception as e:
|
||||
skip("websocket state broadcasts", f"websocket lib unavailable: {e}")
|
||||
return
|
||||
|
||||
try:
|
||||
ws = create_connection("ws://localhost:3000/ws", timeout=5)
|
||||
except Exception as e:
|
||||
skip("websocket state broadcasts", f"connect failed: {e}")
|
||||
return
|
||||
|
||||
ws.settimeout(0.3)
|
||||
messages: list[dict] = []
|
||||
stop_reader = threading.Event()
|
||||
|
||||
def reader():
|
||||
while not stop_reader.is_set():
|
||||
try:
|
||||
raw = ws.recv()
|
||||
if not raw:
|
||||
break
|
||||
try:
|
||||
messages.append(json.loads(raw))
|
||||
except Exception:
|
||||
pass
|
||||
except Exception:
|
||||
# recv() timeout or closed — keep trying until stop_reader
|
||||
if stop_reader.is_set():
|
||||
break
|
||||
continue
|
||||
|
||||
reader_thread = threading.Thread(target=reader, daemon=True)
|
||||
reader_thread.start()
|
||||
|
||||
try:
|
||||
def t_init():
|
||||
time.sleep(0.6)
|
||||
types = [m.get("type") for m in messages]
|
||||
assert "init" in types, f"no init message; got: {types}"
|
||||
run("init message on connect", t_init)
|
||||
|
||||
def t_state_change_on_play():
|
||||
assert_started(bot_id)
|
||||
messages.clear()
|
||||
api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json_body={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
time.sleep(1.5)
|
||||
types = [m.get("type") for m in messages]
|
||||
assert "stateChange" in types, (
|
||||
f"no stateChange after play; got types: {types}"
|
||||
)
|
||||
api(f"/api/player/{bot_id}/stop", method="POST")
|
||||
run("stateChange broadcast on play", t_state_change_on_play)
|
||||
|
||||
def t_bot_disconnected_event():
|
||||
assert_started(bot_id)
|
||||
messages.clear()
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
time.sleep(1.5)
|
||||
types = [m.get("type") for m in messages]
|
||||
assert "botDisconnected" in types or "stateChange" in types, (
|
||||
f"no disconnect event; got: {types}"
|
||||
)
|
||||
run("botDisconnected event on stop", t_bot_disconnected_event)
|
||||
finally:
|
||||
stop_reader.set()
|
||||
try:
|
||||
ws.close()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
# ----------------------------- main ----------------------------------------
|
||||
|
||||
|
||||
def main() -> int:
|
||||
_, data = api("/api/bot/")
|
||||
if not isinstance(data, dict) or not data.get("bots"):
|
||||
print("[fatal] no bots registered — create one via the WebUI first")
|
||||
return 2
|
||||
|
||||
target = data["bots"][0]
|
||||
bot_id = target["id"]
|
||||
initial_connected = target["connected"]
|
||||
initial_volume = target["volume"]
|
||||
initial_mode = target["playMode"]
|
||||
|
||||
print(f"[init] target bot = {bot_id[:8]} ({target['name']})")
|
||||
print(
|
||||
f"[init] initial state: connected={initial_connected} "
|
||||
f"volume={initial_volume} mode={initial_mode}"
|
||||
)
|
||||
|
||||
try:
|
||||
# Read-only / no-lifecycle groups first — they don't consume TS3
|
||||
# anti-flood budget.
|
||||
group_infrastructure(bot_id)
|
||||
group_auth_status()
|
||||
group_search()
|
||||
|
||||
# Lifecycle-heavy groups — interleave with small breathers so the
|
||||
# TS3 server's per-IP reconnect limit doesn't start throttling us.
|
||||
group_lifecycle(bot_id)
|
||||
time.sleep(ANTIFLOOD_BREATHER)
|
||||
|
||||
group_playback(bot_id)
|
||||
time.sleep(ANTIFLOOD_BREATHER)
|
||||
|
||||
group_queue_ops(bot_id)
|
||||
time.sleep(ANTIFLOOD_BREATHER)
|
||||
|
||||
group_input_validation(bot_id)
|
||||
group_disconnect_corners(bot_id)
|
||||
group_seek(bot_id)
|
||||
time.sleep(ANTIFLOOD_BREATHER)
|
||||
|
||||
group_races(bot_id)
|
||||
# Extra breather before websocket group — races is the heaviest
|
||||
# consumer of TS3 reconnect budget (disconnect-during-connect and
|
||||
# stop-during-url-resolve each burn one cycle), and the websocket
|
||||
# group needs a clean reconnect to observe live state broadcasts.
|
||||
time.sleep(ANTIFLOOD_BREATHER * 3)
|
||||
|
||||
group_websocket(bot_id)
|
||||
finally:
|
||||
# Restore initial state — this runs even if a test raised
|
||||
try:
|
||||
api(
|
||||
f"/api/player/{bot_id}/volume",
|
||||
method="POST",
|
||||
json_body={"volume": initial_volume},
|
||||
)
|
||||
api(
|
||||
f"/api/player/{bot_id}/mode",
|
||||
method="POST",
|
||||
json_body={"mode": initial_mode},
|
||||
)
|
||||
api(f"/api/player/{bot_id}/stop", method="POST")
|
||||
if initial_connected:
|
||||
start_and_wait(bot_id)
|
||||
else:
|
||||
stop_and_wait(bot_id)
|
||||
except Exception as e:
|
||||
print(f"[warn] restore failed: {e}")
|
||||
|
||||
print()
|
||||
print("=" * 60)
|
||||
print(f" PASSED: {passed}")
|
||||
print(f" FAILED: {failed}")
|
||||
print(f" SKIPPED: {skipped}")
|
||||
print("=" * 60)
|
||||
|
||||
if failed > 0:
|
||||
print("\nFailed tests:")
|
||||
for r in results:
|
||||
if r.status in ("FAIL", "ERROR"):
|
||||
print(f" [{r.status}] {r.name}: {r.detail}")
|
||||
|
||||
return 0 if failed == 0 else 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
import sys
|
||||
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,166 @@
|
||||
"""More corner-case regressions.
|
||||
|
||||
A. resolveAndPlay disconnect-during-URL-resolve race
|
||||
The bot checks !this.connected at the top of resolveAndPlay, but the
|
||||
URL-resolve await can take several seconds. If stop is called during
|
||||
that window, playback would previously start on a disconnected bot.
|
||||
|
||||
B. /seek NaN/Infinity rejection
|
||||
typeof NaN === "number" and NaN < 0 is false, so a plain range check
|
||||
leaks NaN through and corrupts seekOffset / getElapsed.
|
||||
"""
|
||||
import threading
|
||||
import time
|
||||
import requests
|
||||
|
||||
BASE = "http://localhost:3000"
|
||||
|
||||
|
||||
def api(path, method="GET", **kw):
|
||||
return getattr(requests, method.lower())(f"{BASE}{path}", timeout=30, **kw)
|
||||
|
||||
|
||||
def get_bot(bot_id):
|
||||
return next(b for b in api("/api/bot/").json()["bots"] if b["id"] == bot_id)
|
||||
|
||||
|
||||
def wait_connected(bot_id, want, timeout=15):
|
||||
end = time.time() + timeout
|
||||
while time.time() < end:
|
||||
if get_bot(bot_id)["connected"] is want:
|
||||
return True
|
||||
time.sleep(0.15)
|
||||
return False
|
||||
|
||||
|
||||
def test_resolve_play_stop_race(bot_id):
|
||||
"""Fire stopBot during the /play call's URL resolve window."""
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False)
|
||||
time.sleep(1)
|
||||
api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
wait_connected(bot_id, True)
|
||||
|
||||
# Schedule a stop 150ms into the play call — that lands inside the
|
||||
# provider.getSongUrl await, which is where the race lives.
|
||||
def delayed_stop():
|
||||
time.sleep(0.15)
|
||||
try:
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
threading.Thread(target=delayed_stop, daemon=True).start()
|
||||
|
||||
try:
|
||||
api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# Give both calls time to settle fully
|
||||
time.sleep(3)
|
||||
b = get_bot(bot_id)
|
||||
# Key invariant: we never want connected=false AND playing=true. That
|
||||
# pair is the exact Bug C symptom and would indicate the resolveAndPlay
|
||||
# post-await check didn't fire.
|
||||
assert not (b["connected"] is False and b["playing"] is True), (
|
||||
f"inconsistent state after race: {b}"
|
||||
)
|
||||
print(
|
||||
f"[PASS] resolveAndPlay stop-race — final state consistent "
|
||||
f"(connected={b['connected']} playing={b['playing']})"
|
||||
)
|
||||
|
||||
|
||||
def test_seek_nan_rejected(bot_id):
|
||||
"""Verify that NaN and Infinity seek positions are rejected at the API
|
||||
layer (instead of poisoning seekOffset)."""
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False)
|
||||
api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
wait_connected(bot_id, True)
|
||||
|
||||
# Start a real song so there is an active playback to seek against
|
||||
api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
time.sleep(1.2)
|
||||
|
||||
# JSON spec doesn't allow NaN/Infinity literals, but Python's json
|
||||
# encoder emits them as bare tokens when allow_nan=True (the default).
|
||||
# Express's body-parser rejects them as invalid JSON, which itself is
|
||||
# a form of rejection. We additionally verify that sending a string
|
||||
# "NaN" or a negative value is also rejected with a clean 400.
|
||||
r = api(
|
||||
f"/api/player/{bot_id}/seek",
|
||||
method="POST",
|
||||
json={"position": -5},
|
||||
)
|
||||
assert r.status_code == 400, f"negative seek should be rejected, got {r.status_code}"
|
||||
|
||||
r = api(
|
||||
f"/api/player/{bot_id}/seek",
|
||||
method="POST",
|
||||
json={"position": "fifty"},
|
||||
)
|
||||
assert r.status_code == 400, f"string seek should be rejected, got {r.status_code}"
|
||||
|
||||
# Directly send NaN in raw body (body-parser will likely 400 it)
|
||||
r = requests.post(
|
||||
f"{BASE}/api/player/{bot_id}/seek",
|
||||
data='{"position": NaN}',
|
||||
headers={"Content-Type": "application/json"},
|
||||
timeout=10,
|
||||
)
|
||||
assert r.status_code >= 400, f"NaN seek should be rejected, got {r.status_code}"
|
||||
|
||||
# After the junk attempts, a valid seek still works and the elapsed
|
||||
# time is a finite number (not NaN).
|
||||
r = api(
|
||||
f"/api/player/{bot_id}/seek",
|
||||
method="POST",
|
||||
json={"position": 30},
|
||||
)
|
||||
assert r.status_code == 200, f"valid seek failed: {r.text[:120]}"
|
||||
|
||||
elapsed_resp = api(f"/api/player/{bot_id}/elapsed")
|
||||
elapsed = elapsed_resp.json().get("elapsed")
|
||||
assert elapsed is not None and isinstance(elapsed, (int, float)), (
|
||||
f"elapsed should be a number, got {elapsed}"
|
||||
)
|
||||
# Could be exactly 30 or a tiny bit more if a frame has advanced
|
||||
assert 29 <= elapsed < 40, f"elapsed after seek(30) out of range: {elapsed}"
|
||||
print(f"[PASS] seek NaN/Infinity rejected; valid seek produces finite elapsed={elapsed:.2f}")
|
||||
|
||||
|
||||
def main():
|
||||
bots = api("/api/bot/").json()["bots"]
|
||||
if not bots:
|
||||
print("[skip] no bots")
|
||||
return
|
||||
bot_id = bots[0]["id"]
|
||||
initial = bots[0]["connected"]
|
||||
print(f"[init] bot={bot_id[:8]} initial connected={initial}")
|
||||
|
||||
try:
|
||||
test_resolve_play_stop_race(bot_id)
|
||||
test_seek_nan_rejected(bot_id)
|
||||
print("ALL GREEN")
|
||||
finally:
|
||||
if initial:
|
||||
api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
wait_connected(bot_id, True)
|
||||
else:
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False)
|
||||
print(f"[restore] connected={get_bot(bot_id)['connected']}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,212 @@
|
||||
"""Stress-test two bots playing music concurrently on the same TS server.
|
||||
|
||||
Creates two temporary bots (or reuses existing named ones), starts them,
|
||||
plays music on both, and polls /api/bot/ every 2 seconds to detect when
|
||||
(if) either bot disconnects or stops playing. Cleans up on exit.
|
||||
|
||||
Usage:
|
||||
python scripts/test_multibot.py --minutes 3
|
||||
python scripts/test_multibot.py --minutes 10 --host 127.0.0.1 --port 9987
|
||||
"""
|
||||
import argparse
|
||||
import sys
|
||||
import time
|
||||
from dataclasses import dataclass
|
||||
|
||||
import requests
|
||||
|
||||
API = "http://localhost:3000"
|
||||
POLL_INTERVAL = 2.0
|
||||
TEST_BOT_NAMES = ("mbtest1", "mbtest2")
|
||||
TEST_BOT_NICKS = ("MBTest1", "MBTest2")
|
||||
QUERIES = ("the mass", "lofi") # one different song per bot
|
||||
|
||||
|
||||
@dataclass
|
||||
class BotSnapshot:
|
||||
t: float
|
||||
connected: bool
|
||||
playing: bool
|
||||
song: str | None
|
||||
|
||||
|
||||
def api_get(path: str):
|
||||
r = requests.get(f"{API}{path}", timeout=5)
|
||||
r.raise_for_status()
|
||||
return r.json()
|
||||
|
||||
|
||||
def api_post(path: str, json=None):
|
||||
r = requests.post(f"{API}{path}", json=json, timeout=15)
|
||||
r.raise_for_status()
|
||||
return r.json()
|
||||
|
||||
|
||||
def api_delete(path: str):
|
||||
r = requests.delete(f"{API}{path}", timeout=10)
|
||||
r.raise_for_status()
|
||||
return r.json()
|
||||
|
||||
|
||||
def cleanup_existing(names: tuple[str, ...]) -> None:
|
||||
bots = api_get("/api/bot/")["bots"]
|
||||
for b in bots:
|
||||
if b["name"] in names:
|
||||
try:
|
||||
api_post(f"/api/player/{b['id']}/stop")
|
||||
except Exception:
|
||||
pass
|
||||
try:
|
||||
api_delete(f"/api/bot/{b['id']}")
|
||||
print(f"[cleanup] removed existing bot {b['name']} ({b['id']})")
|
||||
except Exception as e:
|
||||
print(f"[cleanup] failed to remove {b['name']}: {e}")
|
||||
|
||||
|
||||
def create_bot(name: str, nickname: str, host: str, port: int) -> str:
|
||||
res = api_post(
|
||||
"/api/bot/",
|
||||
json={
|
||||
"name": name,
|
||||
"serverAddress": host,
|
||||
"serverPort": port,
|
||||
"nickname": nickname,
|
||||
"autoStart": False,
|
||||
},
|
||||
)
|
||||
bot_id = res["id"]
|
||||
print(f"[create] {name} -> {bot_id}")
|
||||
return bot_id
|
||||
|
||||
|
||||
def start_bot(bot_id: str) -> None:
|
||||
api_post(f"/api/bot/{bot_id}/start")
|
||||
|
||||
|
||||
def play(bot_id: str, query: str) -> None:
|
||||
api_post(f"/api/player/{bot_id}/play", json={"query": query, "platform": "netease"})
|
||||
|
||||
|
||||
def snapshot(bot_id: str, t0: float) -> BotSnapshot:
|
||||
bots = api_get("/api/bot/")["bots"]
|
||||
b = next((x for x in bots if x["id"] == bot_id), None)
|
||||
if not b:
|
||||
return BotSnapshot(time.time() - t0, False, False, None)
|
||||
song = b["currentSong"]["name"] if b.get("currentSong") else None
|
||||
return BotSnapshot(time.time() - t0, b["connected"], b["playing"], song)
|
||||
|
||||
|
||||
def run(minutes: float, host: str, port: int) -> int:
|
||||
print(f"[setup] duration={minutes}min host={host}:{port}")
|
||||
|
||||
cleanup_existing(TEST_BOT_NAMES)
|
||||
|
||||
bot_ids = [
|
||||
create_bot(TEST_BOT_NAMES[0], TEST_BOT_NICKS[0], host, port),
|
||||
create_bot(TEST_BOT_NAMES[1], TEST_BOT_NICKS[1], host, port),
|
||||
]
|
||||
|
||||
# Start both, allowing a small stagger to avoid handshake collision
|
||||
for i, bid in enumerate(bot_ids):
|
||||
start_bot(bid)
|
||||
print(f"[start] bot{i+1} started")
|
||||
time.sleep(1.5)
|
||||
|
||||
# Wait until both are connected (or bail after 15s)
|
||||
deadline = time.time() + 15
|
||||
while time.time() < deadline:
|
||||
bots = {b["id"]: b for b in api_get("/api/bot/")["bots"]}
|
||||
if all(bots[b]["connected"] for b in bot_ids):
|
||||
print("[start] both bots connected")
|
||||
break
|
||||
time.sleep(0.5)
|
||||
else:
|
||||
print("[fatal] bots did not both come online in 15s")
|
||||
cleanup_existing(TEST_BOT_NAMES)
|
||||
return 2
|
||||
|
||||
# Kick off playback on both
|
||||
for i, bid in enumerate(bot_ids):
|
||||
play(bid, QUERIES[i])
|
||||
print(f"[play] bot{i+1} -> {QUERIES[i]!r}")
|
||||
|
||||
t0 = time.time()
|
||||
end = t0 + minutes * 60
|
||||
first_drop: dict[str, float] = {}
|
||||
last_state: dict[str, BotSnapshot] = {}
|
||||
|
||||
print(f"[monitor] polling every {POLL_INTERVAL}s for {minutes} min...")
|
||||
print(f"{'time':>7} {'bot1':<40} {'bot2':<40}")
|
||||
|
||||
def fmt(snap: BotSnapshot) -> str:
|
||||
flag = ("C" if snap.connected else "-") + ("P" if snap.playing else "-")
|
||||
song = (snap.song or "").replace("\n", " ")[:30]
|
||||
return f"{flag} {song}"
|
||||
|
||||
try:
|
||||
while time.time() < end:
|
||||
snaps = [snapshot(bid, t0) for bid in bot_ids]
|
||||
elapsed = int(time.time() - t0)
|
||||
row = f"{elapsed:>6}s {fmt(snaps[0]):<40} {fmt(snaps[1]):<40}"
|
||||
# Only print when state changes or every 10s
|
||||
changed = False
|
||||
for bid, s in zip(bot_ids, snaps):
|
||||
prev = last_state.get(bid)
|
||||
if (prev is None
|
||||
or prev.connected != s.connected
|
||||
or prev.playing != s.playing
|
||||
or prev.song != s.song):
|
||||
changed = True
|
||||
last_state[bid] = s
|
||||
if not s.connected and bid not in first_drop:
|
||||
first_drop[bid] = s.t
|
||||
if changed or elapsed % 10 == 0:
|
||||
print(row)
|
||||
|
||||
# If both stopped playing but are still connected, re-queue the same song
|
||||
for i, (bid, s) in enumerate(zip(bot_ids, snaps)):
|
||||
if s.connected and not s.playing:
|
||||
try:
|
||||
play(bid, QUERIES[i])
|
||||
except Exception as e:
|
||||
print(f"[warn] re-play bot{i+1} failed: {e}")
|
||||
|
||||
time.sleep(POLL_INTERVAL)
|
||||
except KeyboardInterrupt:
|
||||
print("\n[abort] interrupted")
|
||||
|
||||
# Summary
|
||||
total = time.time() - t0
|
||||
print()
|
||||
print("=" * 60)
|
||||
print(f"Total observed time: {total:.1f}s")
|
||||
for i, bid in enumerate(bot_ids):
|
||||
drop = first_drop.get(bid)
|
||||
if drop is None:
|
||||
print(f" bot{i+1} ({TEST_BOT_NICKS[i]}): stayed connected the whole run")
|
||||
else:
|
||||
print(f" bot{i+1} ({TEST_BOT_NICKS[i]}): FIRST DISCONNECT at t+{drop:.1f}s")
|
||||
print("=" * 60)
|
||||
|
||||
# Cleanup
|
||||
cleanup_existing(TEST_BOT_NAMES)
|
||||
print("[cleanup] done")
|
||||
|
||||
return 0 if not first_drop else 1
|
||||
|
||||
|
||||
def main() -> int:
|
||||
p = argparse.ArgumentParser()
|
||||
p.add_argument("--minutes", type=float, default=3.0)
|
||||
p.add_argument("--host", default="127.0.0.1")
|
||||
p.add_argument("--port", type=int, default=9987)
|
||||
args = p.parse_args()
|
||||
try:
|
||||
return run(args.minutes, args.host, args.port)
|
||||
except requests.HTTPError as e:
|
||||
print(f"[http-error] {e} body={e.response.text[:200] if e.response else ''}")
|
||||
return 3
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
+76
-62
@@ -1,25 +1,55 @@
|
||||
"""Reproduce the player-bar-not-appearing bug."""
|
||||
"""Reproduce / regression-check the player-bar-not-appearing bug.
|
||||
|
||||
Captures the bot's initial playback state and restores it on exit so the
|
||||
test never leaves the user with surprise music or a cleared queue.
|
||||
"""
|
||||
import time
|
||||
import requests
|
||||
from playwright.sync_api import sync_playwright
|
||||
|
||||
BASE = "http://localhost:3000"
|
||||
|
||||
def get_bot_id():
|
||||
r = requests.get(f"{BASE}/api/bot/")
|
||||
return r.json()["bots"][0]["id"]
|
||||
|
||||
def stop(bot_id):
|
||||
requests.post(f"{BASE}/api/player/{bot_id}/stop")
|
||||
requests.post(f"{BASE}/api/player/{bot_id}/clear")
|
||||
def api(path, method="GET", **kw):
|
||||
fn = getattr(requests, method.lower())
|
||||
r = fn(f"{BASE}{path}", timeout=10, **kw)
|
||||
r.raise_for_status()
|
||||
return r.json() if r.text else None
|
||||
|
||||
def play(bot_id, query="test"):
|
||||
requests.post(f"{BASE}/api/player/{bot_id}/play", json={"query": query, "platform": "netease"})
|
||||
|
||||
with sync_playwright() as p:
|
||||
def get_bot(bot_id):
|
||||
return next(b for b in api("/api/bot/")["bots"] if b["id"] == bot_id)
|
||||
|
||||
|
||||
def capture_state(bot_id):
|
||||
b = get_bot(bot_id)
|
||||
return {
|
||||
"playing": b["playing"],
|
||||
"paused": b["paused"],
|
||||
"song": (b["currentSong"] or {}).get("name"),
|
||||
}
|
||||
|
||||
|
||||
def main():
|
||||
bots = api("/api/bot/")["bots"]
|
||||
if not bots:
|
||||
print("[skip] no bots")
|
||||
return
|
||||
bot_id = bots[0]["id"]
|
||||
initial = capture_state(bot_id)
|
||||
print(f"[init] initial state: {initial}")
|
||||
|
||||
try:
|
||||
# Clear slate
|
||||
api(f"/api/player/{bot_id}/stop", method="POST")
|
||||
time.sleep(0.6)
|
||||
|
||||
with sync_playwright() as p:
|
||||
browser = p.chromium.launch(headless=True)
|
||||
try:
|
||||
ctx = browser.new_context()
|
||||
ctx.add_init_script("""
|
||||
ctx.add_init_script(
|
||||
"""
|
||||
(() => {
|
||||
const OrigWS = window.WebSocket;
|
||||
window.__wsMessages = [];
|
||||
@@ -28,55 +58,30 @@ with sync_playwright() as p:
|
||||
ws.addEventListener('message', (ev) => {
|
||||
try {
|
||||
const d = JSON.parse(ev.data);
|
||||
const summary = {type: d.type, botId: d.botId};
|
||||
if (d.status) summary.playing = d.status.playing;
|
||||
if (d.status?.currentSong) summary.song = d.status.currentSong.name;
|
||||
window.__wsMessages.push(summary);
|
||||
console.log('WS_MSG ' + JSON.stringify(summary));
|
||||
window.__wsMessages.push({type: d.type, botId: d.botId});
|
||||
} catch(e) {}
|
||||
});
|
||||
return ws;
|
||||
};
|
||||
Object.assign(window.WebSocket, OrigWS);
|
||||
})();
|
||||
""")
|
||||
"""
|
||||
)
|
||||
page = ctx.new_page()
|
||||
logs = []
|
||||
page.on("console", lambda msg: logs.append(f"[{msg.type}] {msg.text}"))
|
||||
|
||||
bot_id = get_bot_id()
|
||||
stop(bot_id)
|
||||
time.sleep(0.6)
|
||||
|
||||
page.goto(BASE)
|
||||
page.wait_for_load_state("networkidle")
|
||||
time.sleep(0.8)
|
||||
|
||||
# Hook into WebSocket messages from the page to confirm they arrive
|
||||
page.evaluate("""
|
||||
() => {
|
||||
const origWS = window.WebSocket;
|
||||
// Already connected via useWebSocket — tap Pinia store directly
|
||||
// Expose store state via window
|
||||
const store = window.__pinia?._s?.get('player');
|
||||
window.__getStore = () => ({
|
||||
bots: JSON.parse(JSON.stringify(store?.bots || [])),
|
||||
activeBotId: store?.activeBotId,
|
||||
currentSong: store?.currentSong ? JSON.parse(JSON.stringify(store.currentSong)) : null,
|
||||
isPlaying: store?.isPlaying,
|
||||
});
|
||||
}
|
||||
""")
|
||||
|
||||
snap_before = page.evaluate("() => window.__getStore?.()")
|
||||
print("store before:", snap_before)
|
||||
|
||||
# Player bar should be absent right now (nothing playing)
|
||||
initial = page.locator(".player-wrapper").count()
|
||||
print(f"initial .player-wrapper count: {initial}")
|
||||
assert page.locator(".player-wrapper").count() == 0, (
|
||||
"player bar should be hidden before playback"
|
||||
)
|
||||
|
||||
# Trigger play via API (simulates any play trigger)
|
||||
play(bot_id, "test")
|
||||
api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
|
||||
# Poll for up to 6s to see if player bar appears automatically
|
||||
appeared_at = None
|
||||
@@ -86,20 +91,29 @@ with sync_playwright() as p:
|
||||
break
|
||||
page.wait_for_timeout(100)
|
||||
|
||||
print(f"player bar appeared after: {appeared_at}")
|
||||
snap_after = page.evaluate("() => window.__getStore?.()")
|
||||
print("store after:", snap_after)
|
||||
|
||||
# After force reload, does it appear?
|
||||
if appeared_at is None:
|
||||
page.reload()
|
||||
page.wait_for_load_state("networkidle")
|
||||
time.sleep(0.8)
|
||||
after_reload = page.locator(".player-wrapper").count()
|
||||
print(f"after reload .player-wrapper count: {after_reload}")
|
||||
|
||||
print("--- console logs ---")
|
||||
for line in logs[-20:]:
|
||||
print(line)
|
||||
|
||||
msgs = page.evaluate("() => window.__wsMessages")
|
||||
print(f"[FAIL] player bar never appeared; WS msgs: {msgs}")
|
||||
raise AssertionError("player bar did not auto-show on stateChange")
|
||||
print(f"[PASS] player bar appeared after {appeared_at:.1f}s")
|
||||
finally:
|
||||
browser.close()
|
||||
finally:
|
||||
# Restore: stop the "test" song we triggered, then re-apply initial
|
||||
# state as best we can. We can't re-queue the user's previous song,
|
||||
# but we can at least stop ours and leave the bot idle if it was idle.
|
||||
try:
|
||||
api(f"/api/player/{bot_id}/stop", method="POST")
|
||||
except Exception as e:
|
||||
print(f"[warn] failed to stop test song on cleanup: {e}")
|
||||
post = capture_state(bot_id)
|
||||
print(f"[restore] bot now idle (was playing={initial['playing']} song={initial['song']!r})")
|
||||
if initial["playing"] and initial["song"]:
|
||||
print(
|
||||
f"[note] initial bot was playing {initial['song']!r}; "
|
||||
"this test cannot resume arbitrary tracks — you may need to restart playback"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,100 @@
|
||||
"""E2E: the new power button in the Bot Selector dropdown toggles bot connected state.
|
||||
|
||||
Captures the target bot's initial connected state and restores it on exit
|
||||
(including on assertion failure), so running this test never pollutes the
|
||||
user's current bot setup.
|
||||
"""
|
||||
import time
|
||||
import requests
|
||||
from playwright.sync_api import sync_playwright
|
||||
|
||||
BASE = "http://localhost:3000"
|
||||
|
||||
|
||||
def get_bot(bot_id):
|
||||
return next(b for b in requests.get(f"{BASE}/api/bot/").json()["bots"] if b["id"] == bot_id)
|
||||
|
||||
|
||||
def wait_for_connected(bot_id, want: bool, timeout_s: float = 12.0) -> bool:
|
||||
deadline = time.time() + timeout_s
|
||||
while time.time() < deadline:
|
||||
if get_bot(bot_id)["connected"] is want:
|
||||
return True
|
||||
time.sleep(0.2)
|
||||
return False
|
||||
|
||||
|
||||
def set_connected(bot_id, want: bool) -> None:
|
||||
"""Force the bot into the given connected state via API."""
|
||||
current = get_bot(bot_id)["connected"]
|
||||
if current == want:
|
||||
return
|
||||
endpoint = "start" if want else "stop"
|
||||
requests.post(f"{BASE}/api/bot/{bot_id}/{endpoint}")
|
||||
wait_for_connected(bot_id, want)
|
||||
|
||||
|
||||
def main():
|
||||
bots = requests.get(f"{BASE}/api/bot/").json()["bots"]
|
||||
if not bots:
|
||||
print("[skip] no bots registered, nothing to test")
|
||||
return
|
||||
target = bots[0]
|
||||
bot_id = target["id"]
|
||||
initial_connected = target["connected"]
|
||||
print(f"[init] target bot {target['name']} ({bot_id[:8]}), initial connected={initial_connected}")
|
||||
|
||||
try:
|
||||
# Force bot disconnected before the test
|
||||
set_connected(bot_id, False)
|
||||
assert not get_bot(bot_id)["connected"], "bot should be disconnected at start"
|
||||
|
||||
with sync_playwright() as p:
|
||||
browser = p.chromium.launch(headless=True)
|
||||
try:
|
||||
page = browser.new_page(viewport={"width": 1440, "height": 900})
|
||||
page.goto(BASE)
|
||||
page.wait_for_load_state("networkidle")
|
||||
time.sleep(0.6)
|
||||
|
||||
# Open dropdown
|
||||
page.locator(".bot-selector-btn").click()
|
||||
page.wait_for_selector(".bot-power-btn")
|
||||
|
||||
# Click the power button to start
|
||||
page.locator(".bot-power-btn").first.click()
|
||||
print("[ui] clicked power (start)")
|
||||
|
||||
assert wait_for_connected(bot_id, True), "bot should be connected after clicking start"
|
||||
print("[api] bot connected = True")
|
||||
|
||||
# Let UI catch up via WS then re-open the dropdown to re-check class
|
||||
time.sleep(1.0)
|
||||
page.locator(".bot-selector-btn").click() # close
|
||||
time.sleep(0.2)
|
||||
page.locator(".bot-selector-btn").click() # reopen
|
||||
page.wait_for_selector(".bot-power-btn.online", timeout=3000)
|
||||
print("[ui] power button now shows .online class")
|
||||
|
||||
# Click again to stop
|
||||
page.locator(".bot-power-btn.online").first.click()
|
||||
print("[ui] clicked power (stop)")
|
||||
|
||||
assert wait_for_connected(bot_id, False), "bot should be disconnected after clicking stop"
|
||||
print("[api] bot connected = False")
|
||||
|
||||
print("[PASS] power button toggles bot connection")
|
||||
finally:
|
||||
browser.close()
|
||||
finally:
|
||||
# Always restore the initial state so the test never leaves the bot
|
||||
# in an unexpected place
|
||||
set_connected(bot_id, initial_connected)
|
||||
final = get_bot(bot_id)["connected"]
|
||||
print(f"[restore] bot connected={final} (initial was {initial_connected})")
|
||||
if final != initial_connected:
|
||||
print("[warn] failed to restore initial connected state")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,130 @@
|
||||
"""Regression for the 'connected=False but playing=True' stuck-state bug.
|
||||
|
||||
After rapid disconnect/reconnect, the library could drop the connection
|
||||
(TS3 server anti-flood or a hung handshake). The bot then ended up in an
|
||||
inconsistent state: player.state='playing' but tsClient disconnected.
|
||||
|
||||
This test verifies three fixes:
|
||||
Bug A — startBot() has a 15s timeout instead of hanging forever on a
|
||||
stalled handshake. /start returns a clean 500 instead of blocking.
|
||||
Bug B — play/add/etc commands are rejected when the bot is not connected.
|
||||
Bug C — the tsClient 'disconnected' handler always clears player state,
|
||||
even when connect() never completed (so !this.connected).
|
||||
|
||||
We also sanity-check that the bot recovers (can start a fresh cycle) after
|
||||
a transient failure.
|
||||
"""
|
||||
import time
|
||||
import requests
|
||||
|
||||
BASE = "http://localhost:3000"
|
||||
|
||||
|
||||
def api(path, method="GET", **kw):
|
||||
return getattr(requests, method.lower())(f"{BASE}{path}", timeout=30, **kw)
|
||||
|
||||
|
||||
def get_bot(bot_id):
|
||||
return next(b for b in api("/api/bot/").json()["bots"] if b["id"] == bot_id)
|
||||
|
||||
|
||||
def wait_connected(bot_id, want, timeout=15):
|
||||
end = time.time() + timeout
|
||||
while time.time() < end:
|
||||
if get_bot(bot_id)["connected"] is want:
|
||||
return True
|
||||
time.sleep(0.15)
|
||||
return False
|
||||
|
||||
|
||||
def main():
|
||||
bots = api("/api/bot/").json()["bots"]
|
||||
if not bots:
|
||||
print("[skip] no bots")
|
||||
return
|
||||
bot_id = bots[0]["id"]
|
||||
initial_connected = bots[0]["connected"]
|
||||
print(f"[init] bot={bot_id[:8]} initial connected={initial_connected}")
|
||||
|
||||
try:
|
||||
# Start from a clean slate
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False)
|
||||
|
||||
# --- Bug B: play while disconnected must be rejected ---
|
||||
r = api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json={"query": "rejection test", "platform": "netease"},
|
||||
)
|
||||
assert r.status_code >= 400, (
|
||||
f"play while disconnected should fail, got {r.status_code} {r.text[:120]}"
|
||||
)
|
||||
assert "not connected" in r.text.lower(), (
|
||||
f"expected 'not connected' error, got: {r.text[:200]}"
|
||||
)
|
||||
b = get_bot(bot_id)
|
||||
assert not b["playing"], f"player shouldn't be playing after rejected /play: {b}"
|
||||
print("[PASS] Bug B — /play rejected while bot disconnected; state untouched")
|
||||
|
||||
# --- Bug C: normal start→play→stop leaves player state clean ---
|
||||
r = api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
assert r.status_code == 200, f"start failed {r.text[:120]}"
|
||||
assert wait_connected(bot_id, True), "bot did not connect within 15s"
|
||||
|
||||
r = api(
|
||||
f"/api/player/{bot_id}/play",
|
||||
method="POST",
|
||||
json={"query": "the mass", "platform": "netease"},
|
||||
)
|
||||
assert r.status_code == 200, f"play failed {r.text[:120]}"
|
||||
time.sleep(1.2)
|
||||
b = get_bot(bot_id)
|
||||
assert b["connected"] and b["playing"], f"should be connected+playing: {b}"
|
||||
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
assert wait_connected(bot_id, False, timeout=5), "bot did not disconnect"
|
||||
b = get_bot(bot_id)
|
||||
assert not b["playing"], (
|
||||
f"player should have stopped after bot disconnect (Bug C): {b}"
|
||||
)
|
||||
print("[PASS] Bug C — stop clears both connected and playing state")
|
||||
|
||||
# --- Bug A: startBot has a deadline and returns a clean error if connect hangs ---
|
||||
# We can't easily force a hang in-process, but we can sanity-check that
|
||||
# startBot returns promptly (well under the 15s cap) on a normal run.
|
||||
t0 = time.time()
|
||||
r = api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
elapsed = time.time() - t0
|
||||
assert r.status_code == 200, f"start failed {r.text[:120]}"
|
||||
assert elapsed < 10, f"start should be prompt, took {elapsed:.1f}s"
|
||||
assert wait_connected(bot_id, True), "bot did not connect"
|
||||
print(
|
||||
f"[PASS] Bug A — startBot completed in {elapsed:.2f}s "
|
||||
"(deadline is 15s, would throw on hang)"
|
||||
)
|
||||
|
||||
# --- Recovery: after any failure, another start should work ---
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False)
|
||||
# Give TS3 server a moment to forget us (anti-flood grace)
|
||||
time.sleep(2)
|
||||
r = api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
assert r.status_code == 200, f"recovery start failed {r.text[:120]}"
|
||||
assert wait_connected(bot_id, True), "bot did not recover"
|
||||
print("[PASS] recovery — bot reconnects cleanly after a cycle")
|
||||
|
||||
print("ALL GREEN")
|
||||
|
||||
finally:
|
||||
if initial_connected:
|
||||
api(f"/api/bot/{bot_id}/start", method="POST")
|
||||
wait_connected(bot_id, True)
|
||||
else:
|
||||
api(f"/api/bot/{bot_id}/stop", method="POST")
|
||||
wait_connected(bot_id, False)
|
||||
print(f"[restore] bot connected={get_bot(bot_id)['connected']} (was {initial_connected})")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -302,6 +302,13 @@ export class AudioPlayer extends EventEmitter {
|
||||
|
||||
seek(seconds: number): void {
|
||||
if (!this.currentUrl) return;
|
||||
// Reject NaN/Infinity/negative — the HTTP layer validates too, but a
|
||||
// bad value here would poison seekOffset and leave getElapsed()
|
||||
// returning NaN until the track ends.
|
||||
if (!Number.isFinite(seconds) || seconds < 0) {
|
||||
this.logger.warn({ seek: seconds }, "Ignoring invalid seek position");
|
||||
return;
|
||||
}
|
||||
this.logger.info({ seek: seconds }, "Seeking");
|
||||
this.play(this.currentUrl, seconds);
|
||||
}
|
||||
|
||||
@@ -89,6 +89,49 @@ describe("PlayQueue", () => {
|
||||
expect(queue.list()[1].id).toBe("3");
|
||||
});
|
||||
|
||||
it("removing a song before current shifts current index", () => {
|
||||
queue.setMode(PlayMode.Sequential);
|
||||
queue.add(makeSong("A"));
|
||||
queue.add(makeSong("B"));
|
||||
queue.add(makeSong("C"));
|
||||
queue.playAt(2); // playing C at index 2
|
||||
queue.remove(0); // remove A (before current)
|
||||
expect(queue.current()?.id).toBe("C"); // still on C
|
||||
expect(queue.getCurrentIndex()).toBe(1);
|
||||
});
|
||||
|
||||
it("removing the currently-playing song lets next() advance to the shifted song", () => {
|
||||
queue.setMode(PlayMode.Sequential);
|
||||
queue.add(makeSong("A"));
|
||||
queue.add(makeSong("B"));
|
||||
queue.add(makeSong("C"));
|
||||
queue.add(makeSong("D"));
|
||||
queue.playAt(2); // playing C
|
||||
queue.remove(2); // remove C — D shifts into slot 2
|
||||
// Before the fix this returned null (D was silently skipped)
|
||||
expect(queue.next()?.id).toBe("D");
|
||||
});
|
||||
|
||||
it("removing the only song clears the queue", () => {
|
||||
queue.add(makeSong("only"));
|
||||
queue.playAt(0);
|
||||
queue.remove(0);
|
||||
expect(queue.size()).toBe(0);
|
||||
expect(queue.current()).toBeNull();
|
||||
expect(queue.next()).toBeNull();
|
||||
});
|
||||
|
||||
it("removing the last song while playing it advances to null in sequential mode", () => {
|
||||
queue.setMode(PlayMode.Sequential);
|
||||
queue.add(makeSong("A"));
|
||||
queue.add(makeSong("B"));
|
||||
queue.playAt(1); // playing B (last)
|
||||
queue.remove(1);
|
||||
expect(queue.size()).toBe(1);
|
||||
// currentIndex moved to 0, so next() should try to advance past the end
|
||||
expect(queue.next()).toBeNull();
|
||||
});
|
||||
|
||||
it("clears all songs", () => {
|
||||
queue.add(makeSong("1"));
|
||||
queue.add(makeSong("2"));
|
||||
|
||||
+8
-3
@@ -36,9 +36,14 @@ export class PlayQueue {
|
||||
if (index < this.currentIndex) {
|
||||
this.currentIndex--;
|
||||
} else if (index === this.currentIndex) {
|
||||
if (this.currentIndex >= this.songs.length) {
|
||||
this.currentIndex = this.songs.length - 1;
|
||||
}
|
||||
// Move the pointer back by one so next() in sequential mode advances
|
||||
// to the song that shifted into the removed slot. Without this, the
|
||||
// shifted song is silently skipped because current() incorrectly
|
||||
// returns it (even though the player is still on the removed song)
|
||||
// and next() then increments past it. currentIndex may become -1,
|
||||
// which is fine — it represents "no current song" and next() will
|
||||
// pick index 0.
|
||||
this.currentIndex--;
|
||||
}
|
||||
|
||||
return removed;
|
||||
|
||||
+77
-8
@@ -57,6 +57,7 @@ export class BotInstance extends EventEmitter {
|
||||
private config: BotConfig;
|
||||
private logger: Logger;
|
||||
private connected = false;
|
||||
private disconnectEmitted = false;
|
||||
private voteSkipUsers = new Set<string>();
|
||||
private isAdvancing = false;
|
||||
|
||||
@@ -108,29 +109,43 @@ export class BotInstance extends EventEmitter {
|
||||
});
|
||||
|
||||
this.tsClient.on("disconnected", () => {
|
||||
// Avoid duplicate event if disconnect() was called explicitly
|
||||
// (it already set connected = false and emitted "disconnected").
|
||||
if (!this.connected) return;
|
||||
// Always reset local state — covers the case where connect() never
|
||||
// completed (hanging handshake → 60s library idle timeout) and
|
||||
// this.connected was never flipped to true. Previously this handler
|
||||
// short-circuited on !this.connected, leaving player stuck as "playing".
|
||||
this.connected = false;
|
||||
this.player.stop();
|
||||
// Only emit externally once per lifecycle so clients don't see a
|
||||
// duplicate "disconnected" after an explicit disconnect() call.
|
||||
if (this.disconnectEmitted) return;
|
||||
this.disconnectEmitted = true;
|
||||
this.emit("disconnected");
|
||||
});
|
||||
}
|
||||
|
||||
async connect(): Promise<void> {
|
||||
this.disconnectEmitted = false;
|
||||
await this.tsClient.connect();
|
||||
// Race guard: if disconnect() was called while the handshake was
|
||||
// awaiting, don't flip connected back to true — that would leave the
|
||||
// bot in an inconsistent state (externally "connected" but the tsClient
|
||||
// has already been torn down).
|
||||
if (this.disconnectEmitted) {
|
||||
throw new Error("Connect aborted by concurrent disconnect");
|
||||
}
|
||||
this.connected = true;
|
||||
this.emit("connected");
|
||||
}
|
||||
|
||||
disconnect(): void {
|
||||
this.player.stop();
|
||||
// Set connected = false BEFORE tsClient.disconnect() so that the
|
||||
// "disconnected" event handler (setupTsEvents) won't emit a duplicate.
|
||||
this.connected = false;
|
||||
this.tsClient.disconnect();
|
||||
if (!this.disconnectEmitted) {
|
||||
this.disconnectEmitted = true;
|
||||
this.emit("disconnected");
|
||||
}
|
||||
this.tsClient.disconnect();
|
||||
}
|
||||
|
||||
private async handleTextMessage(msg: TS3TextMessage): Promise<void> {
|
||||
const parsed = parseCommand(
|
||||
@@ -170,6 +185,24 @@ export class BotInstance extends EventEmitter {
|
||||
cmd: ParsedCommand,
|
||||
msg?: TS3TextMessage
|
||||
): Promise<string | null> {
|
||||
// Reject commands that would push audio when the bot isn't connected:
|
||||
// otherwise ffmpeg spawns and voice goes to a half-initialized or
|
||||
// torn-down TS client, leaving player.state="playing" on a disconnected
|
||||
// bot. Config-only commands (vol, mode, clear, stop, queue, now) are
|
||||
// still allowed so the UI stays usable while the bot is offline.
|
||||
const AUDIO_COMMANDS = new Set([
|
||||
"play",
|
||||
"add",
|
||||
"next",
|
||||
"skip",
|
||||
"prev",
|
||||
"playlist",
|
||||
"album",
|
||||
"fm",
|
||||
]);
|
||||
if (!this.connected && AUDIO_COMMANDS.has(cmd.name)) {
|
||||
throw new Error("Bot is not connected to TeamSpeak");
|
||||
}
|
||||
switch (cmd.name) {
|
||||
case "play":
|
||||
return this.cmdPlay(cmd);
|
||||
@@ -235,6 +268,14 @@ export class BotInstance extends EventEmitter {
|
||||
|
||||
/** Resolve URL for a song and start playing it. Skips to next if URL fails. */
|
||||
async resolveAndPlay(song: QueuedSong): Promise<boolean> {
|
||||
if (!this.connected) {
|
||||
this.logger.warn({ songId: song.id, name: song.name }, "resolveAndPlay called on disconnected bot — skipping");
|
||||
return false;
|
||||
}
|
||||
// Clear any accumulated skip votes — every fresh track starts with a
|
||||
// clean slate, regardless of which code path loaded it (cmdPlay,
|
||||
// cmdPlaylist, cmdAlbum, cmdFm, trackEnd auto-advance, etc.).
|
||||
this.voteSkipUsers.clear();
|
||||
const provider = this.getProviderFor(song.platform);
|
||||
try {
|
||||
const url = await provider.getSongUrl(song.id);
|
||||
@@ -242,6 +283,18 @@ export class BotInstance extends EventEmitter {
|
||||
this.logger.warn({ songId: song.id, name: song.name }, "No URL available, skipping");
|
||||
return false;
|
||||
}
|
||||
// Re-check connection state AFTER the network round-trip — the URL
|
||||
// resolve can take multiple seconds and the user may have called stop
|
||||
// during that window. Without this, we'd spawn ffmpeg on a
|
||||
// disconnected bot and land back in the same "connected=false but
|
||||
// playing=true" inconsistency that Bug C was about.
|
||||
if (!this.connected) {
|
||||
this.logger.warn(
|
||||
{ songId: song.id, name: song.name },
|
||||
"bot disconnected during URL resolve — aborting playback",
|
||||
);
|
||||
return false;
|
||||
}
|
||||
song.url = url;
|
||||
this.player.play(url);
|
||||
this.database.addPlayHistory({
|
||||
@@ -288,7 +341,20 @@ export class BotInstance extends EventEmitter {
|
||||
return `No results found for: ${cmd.args}`;
|
||||
|
||||
const song = result.songs[0];
|
||||
const wasIdle = this.player.getState() === "idle";
|
||||
this.queue.add({ ...song, platform: provider.platform });
|
||||
|
||||
// If nothing was playing, start this newly-added song immediately.
|
||||
// Matches /api/player/:id/add-by-id behavior so both add paths feel
|
||||
// the same to the user (add to idle bot → plays now).
|
||||
if (wasIdle) {
|
||||
this.queue.playAt(this.queue.size() - 1);
|
||||
this.player.resetFailures();
|
||||
await this.resolveAndPlay(this.queue.current()!);
|
||||
this.emit("stateChange");
|
||||
return `Now playing: ${song.name} - ${song.artist}`;
|
||||
}
|
||||
|
||||
this.emit("stateChange");
|
||||
return `Added to queue: ${song.name} - ${song.artist} (position ${this.queue.size()})`;
|
||||
}
|
||||
@@ -440,8 +506,11 @@ export class BotInstance extends EventEmitter {
|
||||
if (!msg) return "Vote can only be used in TeamSpeak";
|
||||
this.voteSkipUsers.add(msg.invokerUid);
|
||||
const clients = await this.tsClient.getClientsInChannel();
|
||||
const totalUsers = clients.length - 1;
|
||||
const needed = Math.ceil(totalUsers / 2);
|
||||
const totalUsers = clients.length - 1; // exclude the bot itself
|
||||
// At least 1 vote is always required — otherwise a single voter in an
|
||||
// otherwise empty channel (or a transient clients.length=1 race) could
|
||||
// unanimously "win" with needed=0.
|
||||
const needed = Math.max(1, Math.ceil(totalUsers / 2));
|
||||
const votes = this.voteSkipUsers.size;
|
||||
|
||||
if (votes >= needed) {
|
||||
|
||||
+55
-2
@@ -12,6 +12,42 @@ import type { Logger } from "../logger.js";
|
||||
|
||||
import type { ServerProtocol } from "../ts-protocol/client.js";
|
||||
|
||||
/**
|
||||
* Run bot.connect() with a hard deadline. If the handshake hangs (e.g. the
|
||||
* server silently drops the connection after initivexpand2), we tear the
|
||||
* instance down instead of waiting for the library's 60s idle timeout, so
|
||||
* the HTTP /start call returns promptly and the UI doesn't lock up.
|
||||
*/
|
||||
async function connectWithTimeout(
|
||||
bot: BotInstance,
|
||||
ms: number,
|
||||
logger: Logger
|
||||
): Promise<void> {
|
||||
let timer: ReturnType<typeof setTimeout> | undefined;
|
||||
const timeout = new Promise<never>((_, reject) => {
|
||||
timer = setTimeout(
|
||||
() => reject(new Error(`connect timeout after ${ms}ms`)),
|
||||
ms
|
||||
);
|
||||
});
|
||||
try {
|
||||
await Promise.race([bot.connect(), timeout]);
|
||||
} catch (err) {
|
||||
logger.warn(
|
||||
{ err, botId: bot.id },
|
||||
"Connect failed or timed out — tearing down instance"
|
||||
);
|
||||
try {
|
||||
bot.disconnect();
|
||||
} catch {
|
||||
// ignore teardown errors
|
||||
}
|
||||
throw err;
|
||||
} finally {
|
||||
if (timer) clearTimeout(timer);
|
||||
}
|
||||
}
|
||||
|
||||
export interface CreateBotParams {
|
||||
name: string;
|
||||
serverAddress: string;
|
||||
@@ -111,6 +147,7 @@ export class BotManager extends EventEmitter {
|
||||
this.bots.delete(id);
|
||||
}
|
||||
this.database.deleteBotInstance(id);
|
||||
this.emit("botInstanceRemoved", id);
|
||||
this.logger.info({ botId: id }, "Bot instance removed");
|
||||
}
|
||||
|
||||
@@ -155,6 +192,18 @@ export class BotManager extends EventEmitter {
|
||||
const oldBot = this.bots.get(id);
|
||||
if (!oldBot) throw new Error(`Bot ${id} not found`);
|
||||
|
||||
// Always tear down the outgoing instance before creating a replacement.
|
||||
// Covers three cases:
|
||||
// 1. oldBot is fully connected (manual restart)
|
||||
// 2. oldBot is mid-handshake from a prior rapid start (isConnected()
|
||||
// still returns false but the library client is live and will leak
|
||||
// a TS session if we abandon it)
|
||||
// 3. oldBot was just created by createBot but never connected — the
|
||||
// disconnect call is a cheap no-op here.
|
||||
// Calling disconnect() is idempotent (disconnectEmitted guards event
|
||||
// emission), so this is safe in all states.
|
||||
oldBot.disconnect();
|
||||
|
||||
// Reload config from database so updated settings (channel, nickname, etc.) take effect
|
||||
const saved = this.database.getBotInstances().find((i) => i.id === id);
|
||||
if (saved) {
|
||||
@@ -167,6 +216,10 @@ export class BotManager extends EventEmitter {
|
||||
port: saved.serverPort,
|
||||
queryPort: proto === "ts6" ? 10080 : 10011,
|
||||
nickname: saved.nickname,
|
||||
// Reuse the stored identity so server groups assigned to this bot
|
||||
// survive restarts — without this the TS server sees a new UID
|
||||
// each connect and strips all previously granted groups.
|
||||
identity: saved.identity || undefined,
|
||||
defaultChannel: saved.defaultChannel || undefined,
|
||||
channelPassword: saved.channelPassword || undefined,
|
||||
serverPassword: saved.serverPassword || undefined,
|
||||
@@ -183,12 +236,12 @@ export class BotManager extends EventEmitter {
|
||||
});
|
||||
this.bots.set(id, bot);
|
||||
this.emit("botInstance", bot);
|
||||
await bot.connect();
|
||||
await connectWithTimeout(bot, 15_000, this.logger);
|
||||
// Mark as autoStart so it reconnects on Docker restart, and persist identity
|
||||
this.database.saveBotInstance({ ...saved, autoStart: true });
|
||||
this.persistBotIdentity(saved, bot);
|
||||
} else {
|
||||
await oldBot.connect();
|
||||
await connectWithTimeout(oldBot, 15_000, this.logger);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+54
-6
@@ -21,17 +21,54 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
|
||||
|
||||
/** Resolve the yt-dlp binary path. Checks the project bin/ dir first, then PATH. */
|
||||
function findYtDlp(): string {
|
||||
const exe = process.platform === "win32" ? "yt-dlp.exe" : "yt-dlp";
|
||||
const candidates = [
|
||||
join(__dirname, "..", "..", "bin", "yt-dlp.exe"),
|
||||
join(__dirname, "..", "..", "bin", exe),
|
||||
join(__dirname, "..", "..", "bin", "yt-dlp"),
|
||||
"yt-dlp",
|
||||
"yt-dlp.exe",
|
||||
exe,
|
||||
];
|
||||
for (const c of candidates) {
|
||||
if (!c.includes(join("bin", "yt-dlp")) || existsSync(c)) return c;
|
||||
// For PATH entries (no directory prefix), fall through to let execFile try
|
||||
// Absolute/relative paths: only return if the file exists.
|
||||
// Bare names: return and let execFile resolve via PATH.
|
||||
const isBinPath = c.includes(join("bin", "yt-dlp"));
|
||||
if (!isBinPath || existsSync(c)) return c;
|
||||
}
|
||||
return "yt-dlp";
|
||||
return exe;
|
||||
}
|
||||
|
||||
/**
|
||||
* Availability check for yt-dlp. Runs `yt-dlp --version` and caches only
|
||||
* the positive result — if the binary is missing, subsequent calls retry
|
||||
* so the user can install yt-dlp while the server is running and pick it
|
||||
* up without a restart. Used by getAuthStatus() so the UI can reflect
|
||||
* whether YouTube is actually usable.
|
||||
*/
|
||||
let cachedAvailable = false;
|
||||
let pendingCheck: Promise<boolean> | null = null;
|
||||
async function checkYtDlpAvailable(): Promise<boolean> {
|
||||
if (cachedAvailable) return true;
|
||||
if (pendingCheck) return pendingCheck;
|
||||
pendingCheck = (async () => {
|
||||
try {
|
||||
await execFileAsync(findYtDlp(), ["--version"], {
|
||||
timeout: 5_000,
|
||||
maxBuffer: 1024,
|
||||
});
|
||||
cachedAvailable = true;
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
} finally {
|
||||
pendingCheck = null;
|
||||
}
|
||||
})();
|
||||
return pendingCheck;
|
||||
}
|
||||
|
||||
/** Force re-detection on the next call (for tests). */
|
||||
export function resetYtDlpAvailabilityCache(): void {
|
||||
cachedAvailable = false;
|
||||
pendingCheck = null;
|
||||
}
|
||||
|
||||
async function runYtDlp(args: string[], timeoutMs = 30_000): Promise<string> {
|
||||
@@ -179,6 +216,17 @@ export class YouTubeProvider implements MusicProvider {
|
||||
getCookie(): string { return ""; }
|
||||
|
||||
async getAuthStatus(): Promise<AuthStatus> {
|
||||
// YouTube has no login concept via yt-dlp, so "loggedIn" here means
|
||||
// "yt-dlp binary is reachable and responds to --version". The UI can
|
||||
// use this flag to grey out YouTube when the optional dependency is
|
||||
// missing, instead of silently returning empty search results.
|
||||
const available = await checkYtDlpAvailable();
|
||||
if (available) {
|
||||
return { loggedIn: true, nickname: "YouTube (yt-dlp)" };
|
||||
}
|
||||
return {
|
||||
loggedIn: false,
|
||||
nickname: "YouTube (yt-dlp not installed)",
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
import { Router } from "express";
|
||||
import type { MusicProvider } from "../../music/provider.js";
|
||||
import { YouTubeProvider } from "../../music/youtube.js";
|
||||
import type { CookieStore } from "../../music/auth.js";
|
||||
import type { Logger } from "../../logger.js";
|
||||
|
||||
@@ -11,9 +12,13 @@ export function createAuthRouter(
|
||||
cookieStore?: CookieStore
|
||||
): Router {
|
||||
const router = Router();
|
||||
// YouTube is auth-less; we only use this instance so /auth/status can
|
||||
// report whether yt-dlp is actually installed (loggedIn=false otherwise).
|
||||
const youtubeProvider: MusicProvider = new YouTubeProvider();
|
||||
|
||||
function getProvider(platform?: string): MusicProvider {
|
||||
if (platform === "bilibili") return bilibiliProvider;
|
||||
if (platform === "youtube") return youtubeProvider;
|
||||
return platform === "qq" ? qqProvider : neteaseProvider;
|
||||
}
|
||||
|
||||
@@ -119,6 +124,14 @@ export function createAuthRouter(
|
||||
res.status(400).json({ error: "cookie is required" });
|
||||
return;
|
||||
}
|
||||
// YouTube has no cookie concept — reject instead of falling through and
|
||||
// clobbering the NetEase cookie entry.
|
||||
if (platform === "youtube") {
|
||||
res
|
||||
.status(400)
|
||||
.json({ error: "YouTube does not use cookies (uses yt-dlp binary)" });
|
||||
return;
|
||||
}
|
||||
const provider = getProvider(platform);
|
||||
provider.setCookie(cookie);
|
||||
const plat = platform === "bilibili" ? "bilibili" as const
|
||||
|
||||
+66
-26
@@ -25,6 +25,14 @@ export function createPlayerRouter(
|
||||
next();
|
||||
});
|
||||
|
||||
/** Map API platform string to the corresponding command flag. */
|
||||
const platformFlag = (platform: unknown): string => {
|
||||
if (platform === "bilibili") return "-b";
|
||||
if (platform === "qq") return "-q";
|
||||
if (platform === "youtube") return "-y";
|
||||
return "";
|
||||
};
|
||||
|
||||
router.post("/:botId/play", async (req, res) => {
|
||||
try {
|
||||
const bot = (req as any).bot;
|
||||
@@ -33,8 +41,7 @@ export function createPlayerRouter(
|
||||
res.status(400).json({ error: "query is required" });
|
||||
return;
|
||||
}
|
||||
const flags = platform === "bilibili" ? "-b" : platform === "qq" ? "-q" : "";
|
||||
const cmd = parseCommand(`!play ${flags} ${query}`.trim(), "!");
|
||||
const cmd = parseCommand(`!play ${platformFlag(platform)} ${query}`.trim(), "!");
|
||||
if (!cmd) {
|
||||
res.status(400).json({ error: "Invalid command" });
|
||||
return;
|
||||
@@ -50,8 +57,7 @@ export function createPlayerRouter(
|
||||
try {
|
||||
const bot = (req as any).bot;
|
||||
const { query, platform } = req.body;
|
||||
const flags = platform === "bilibili" ? "-b" : platform === "qq" ? "-q" : "";
|
||||
const cmd = parseCommand(`!add ${flags} ${query}`.trim(), "!");
|
||||
const cmd = parseCommand(`!add ${platformFlag(platform)} ${query}`.trim(), "!");
|
||||
if (!cmd) {
|
||||
res.status(400).json({ error: "Invalid command" });
|
||||
return;
|
||||
@@ -85,7 +91,21 @@ export function createPlayerRouter(
|
||||
try {
|
||||
const bot = (req as any).bot;
|
||||
const { volume } = req.body;
|
||||
const cmd = parseCommand(`!vol ${volume}`, "!")!;
|
||||
// Reject bad input with a proper 4xx instead of letting cmdVol
|
||||
// return a "Usage:" string inside a 200 body — API clients can't
|
||||
// detect that failure mode, and the UI would silently swallow it.
|
||||
if (
|
||||
typeof volume !== "number" ||
|
||||
!Number.isFinite(volume) ||
|
||||
volume < 0 ||
|
||||
volume > 100
|
||||
) {
|
||||
res
|
||||
.status(400)
|
||||
.json({ error: "volume must be a number between 0 and 100" });
|
||||
return;
|
||||
}
|
||||
const cmd = parseCommand(`!vol ${Math.round(volume)}`, "!")!;
|
||||
const response = await bot.executeCommand(cmd);
|
||||
res.json({ message: response });
|
||||
} catch (err) {
|
||||
@@ -93,10 +113,18 @@ export function createPlayerRouter(
|
||||
}
|
||||
});
|
||||
|
||||
const VALID_MODES = new Set(["seq", "loop", "random", "rloop"]);
|
||||
|
||||
router.post("/:botId/mode", async (req, res) => {
|
||||
try {
|
||||
const bot = (req as any).bot;
|
||||
const { mode } = req.body;
|
||||
if (typeof mode !== "string" || !VALID_MODES.has(mode)) {
|
||||
res
|
||||
.status(400)
|
||||
.json({ error: "mode must be one of: seq, loop, random, rloop" });
|
||||
return;
|
||||
}
|
||||
const cmd = parseCommand(`!mode ${mode}`, "!")!;
|
||||
const response = await bot.executeCommand(cmd);
|
||||
res.json({ message: response });
|
||||
@@ -116,8 +144,12 @@ export function createPlayerRouter(
|
||||
try {
|
||||
const bot = (req as any).bot;
|
||||
const { position } = req.body; // seconds
|
||||
if (typeof position !== "number" || position < 0) {
|
||||
res.status(400).json({ error: "position (seconds) is required" });
|
||||
// typeof NaN === "number" and NaN < 0 is false, so a plain range
|
||||
// check lets NaN/Infinity through and later corrupts seekOffset.
|
||||
if (typeof position !== "number" || !Number.isFinite(position) || position < 0) {
|
||||
res
|
||||
.status(400)
|
||||
.json({ error: "position must be a finite non-negative number" });
|
||||
return;
|
||||
}
|
||||
bot.getPlayer().seek(position);
|
||||
@@ -153,8 +185,15 @@ export function createPlayerRouter(
|
||||
return;
|
||||
}
|
||||
const queue = bot.getQueueManager();
|
||||
bot.getPlayer().stop(); // Stop current playback first
|
||||
bot.getPlayer().resetFailures(); // Reset on user-initiated play
|
||||
// Validate the index BEFORE stopping current playback — otherwise an
|
||||
// invalid index silently kills the user's current song and leaves the
|
||||
// queue idle.
|
||||
if (index >= queue.size()) {
|
||||
res.status(400).json({ error: "Invalid queue index" });
|
||||
return;
|
||||
}
|
||||
bot.getPlayer().stop();
|
||||
bot.getPlayer().resetFailures();
|
||||
const song = queue.playAt(index);
|
||||
if (!song) {
|
||||
res.status(400).json({ error: "Invalid queue index" });
|
||||
@@ -175,9 +214,8 @@ export function createPlayerRouter(
|
||||
try {
|
||||
const bot = (req as any).bot;
|
||||
const { playlistId, platform } = req.body;
|
||||
const flags = platform === "bilibili" ? "-b" : platform === "qq" ? "-q" : "";
|
||||
const cmd = parseCommand(
|
||||
`!playlist ${flags} ${playlistId}`.trim(),
|
||||
`!playlist ${platformFlag(platform)} ${playlistId}`.trim(),
|
||||
"!"
|
||||
)!;
|
||||
const response = await bot.executeCommand(cmd);
|
||||
@@ -193,11 +231,13 @@ export function createPlayerRouter(
|
||||
try {
|
||||
const bot = (req as any).bot;
|
||||
const { playlistId, platform } = req.body;
|
||||
const provider = platform === "bilibili" ? bilibiliProvider : platform === "qq" ? qqProvider : neteaseProvider;
|
||||
if (!provider) {
|
||||
res.status(500).json({ error: "Provider not available" });
|
||||
return;
|
||||
}
|
||||
// Use the bot's own provider lookup — it already knows about youtube,
|
||||
// which the router's constructor params did not.
|
||||
const provider = bot.getProviderFor(
|
||||
platform === "bilibili" || platform === "qq" || platform === "youtube"
|
||||
? platform
|
||||
: "netease"
|
||||
);
|
||||
|
||||
// Stop current playback
|
||||
bot.getPlayer().stop();
|
||||
@@ -241,11 +281,11 @@ export function createPlayerRouter(
|
||||
try {
|
||||
const bot = (req as any).bot;
|
||||
const { songId, platform } = req.body;
|
||||
const provider = platform === "bilibili" ? bilibiliProvider : platform === "qq" ? qqProvider : neteaseProvider;
|
||||
if (!provider) {
|
||||
res.status(500).json({ error: "Provider not available" });
|
||||
return;
|
||||
}
|
||||
const provider = bot.getProviderFor(
|
||||
platform === "bilibili" || platform === "qq" || platform === "youtube"
|
||||
? platform
|
||||
: "netease"
|
||||
);
|
||||
|
||||
const song = await provider.getSongDetail(songId);
|
||||
if (!song) {
|
||||
@@ -276,11 +316,11 @@ export function createPlayerRouter(
|
||||
try {
|
||||
const bot = (req as any).bot;
|
||||
const { songId, platform } = req.body;
|
||||
const provider = platform === "bilibili" ? bilibiliProvider : platform === "qq" ? qqProvider : neteaseProvider;
|
||||
if (!provider) {
|
||||
res.status(500).json({ error: "Provider not available" });
|
||||
return;
|
||||
}
|
||||
const provider = bot.getProviderFor(
|
||||
platform === "bilibili" || platform === "qq" || platform === "youtube"
|
||||
? platform
|
||||
: "netease"
|
||||
);
|
||||
|
||||
const song = await provider.getSongDetail(songId);
|
||||
if (!song) {
|
||||
|
||||
+20
-1
@@ -114,13 +114,32 @@ export function setupWebSocket(
|
||||
const onBotInstance = (bot: BotInstance) => attachBotListener(bot);
|
||||
botManager.on("botInstance", onBotInstance);
|
||||
|
||||
// React when a bot is removed: detach its listener and tell clients to drop it
|
||||
const onBotInstanceRemoved = (id: string) => {
|
||||
detachBotListener(id);
|
||||
broadcast({ type: "botRemoved", botId: id });
|
||||
};
|
||||
botManager.on("botInstanceRemoved", onBotInstanceRemoved);
|
||||
|
||||
/** Drop attached listeners whose bot is no longer in the manager. */
|
||||
function reconcileAttachedBots(): void {
|
||||
const liveIds = new Set(botManager.getAllBots().map((b) => b.id));
|
||||
for (const id of Array.from(attachedBots.keys())) {
|
||||
if (!liveIds.has(id)) detachBotListener(id);
|
||||
}
|
||||
}
|
||||
|
||||
// Safety net: periodically re-check in case any bot was missed
|
||||
const intervalId = setInterval(ensureAllBotsAttached, 5000);
|
||||
const intervalId = setInterval(() => {
|
||||
reconcileAttachedBots();
|
||||
ensureAllBotsAttached();
|
||||
}, 5000);
|
||||
ensureAllBotsAttached();
|
||||
|
||||
return () => {
|
||||
clearInterval(intervalId);
|
||||
botManager.removeListener("botInstance", onBotInstance);
|
||||
botManager.removeListener("botInstanceRemoved", onBotInstanceRemoved);
|
||||
// Clean up all attached listeners (detach from stored bot refs, not live map)
|
||||
for (const id of Array.from(attachedBots.keys())) {
|
||||
detachBotListener(id);
|
||||
|
||||
@@ -36,6 +36,15 @@
|
||||
<span v-else-if="bot.connected" class="bot-idle-badge">空闲</span>
|
||||
<span v-else class="bot-offline-badge">离线</span>
|
||||
</button>
|
||||
<button
|
||||
class="bot-power-btn"
|
||||
:class="{ online: bot.connected }"
|
||||
:title="bot.connected ? `停止 ${bot.name}` : `启动 ${bot.name}`"
|
||||
:disabled="togglingBots[bot.id]"
|
||||
@click.stop="togglePower(bot)"
|
||||
>
|
||||
<Icon :icon="bot.connected ? 'mdi:power' : 'mdi:power-off'" />
|
||||
</button>
|
||||
<button class="bot-link-btn" :title="`复制 ${bot.name} 的专属链接`" @click.stop="copyBotLink(bot.id)">
|
||||
<Icon icon="mdi:link-variant" />
|
||||
</button>
|
||||
@@ -61,6 +70,7 @@ const store = usePlayerStore();
|
||||
const activeBot = computed(() => store.activeBot);
|
||||
const dropdownOpen = ref(false);
|
||||
const selectorRef = ref<HTMLElement | null>(null);
|
||||
const togglingBots = ref<Record<string, boolean>>({});
|
||||
|
||||
function selectBot(id: string) {
|
||||
store.setActiveBotId(id);
|
||||
@@ -74,6 +84,22 @@ function copyBotLink(id: string) {
|
||||
});
|
||||
}
|
||||
|
||||
async function togglePower(bot: { id: string; connected: boolean; name: string }) {
|
||||
if (togglingBots.value[bot.id]) return;
|
||||
togglingBots.value[bot.id] = true;
|
||||
try {
|
||||
if (bot.connected) {
|
||||
await store.stopBotInstance(bot.id);
|
||||
} else {
|
||||
await store.startBotInstance(bot.id);
|
||||
}
|
||||
} catch (err) {
|
||||
console.error(`Failed to toggle bot ${bot.name}`, err);
|
||||
} finally {
|
||||
togglingBots.value[bot.id] = false;
|
||||
}
|
||||
}
|
||||
|
||||
function onClickOutside(e: MouseEvent) {
|
||||
if (selectorRef.value && !selectorRef.value.contains(e.target as Node)) {
|
||||
dropdownOpen.value = false;
|
||||
@@ -274,6 +300,32 @@ onUnmounted(() => {
|
||||
}
|
||||
}
|
||||
|
||||
.bot-power-btn {
|
||||
flex-shrink: 0;
|
||||
padding: 6px 8px;
|
||||
border-radius: var(--radius-sm);
|
||||
font-size: 16px;
|
||||
opacity: 0.5;
|
||||
color: var(--text-tertiary);
|
||||
transition: opacity var(--transition-fast), background var(--transition-fast), color var(--transition-fast);
|
||||
cursor: pointer;
|
||||
|
||||
&:hover:not(:disabled) {
|
||||
opacity: 1;
|
||||
background: var(--hover-bg);
|
||||
}
|
||||
|
||||
&:disabled {
|
||||
opacity: 0.25;
|
||||
cursor: wait;
|
||||
}
|
||||
|
||||
&.online {
|
||||
color: #22c55e;
|
||||
opacity: 0.9;
|
||||
}
|
||||
}
|
||||
|
||||
.bot-playing-badge,
|
||||
.bot-paused-badge,
|
||||
.bot-idle-badge,
|
||||
|
||||
@@ -56,6 +56,13 @@ export function useWebSocket() {
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 'botRemoved':
|
||||
// Bot was deleted from the server — drop from local state entirely
|
||||
store.removeBotStatus(data.botId);
|
||||
if (store.activeBotId === data.botId) {
|
||||
store.activeBotId = store.bots[0]?.id ?? null;
|
||||
}
|
||||
break;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -168,6 +168,14 @@ export const usePlayerStore = defineStore('player', {
|
||||
if (saved) this.theme = saved;
|
||||
},
|
||||
|
||||
async startBotInstance(id: string) {
|
||||
await axios.post(`/api/bot/${id}/start`);
|
||||
},
|
||||
|
||||
async stopBotInstance(id: string) {
|
||||
await axios.post(`/api/bot/${id}/stop`);
|
||||
},
|
||||
|
||||
async fetchBots() {
|
||||
const res = await axios.get('/api/bot');
|
||||
this.bots = res.data.bots;
|
||||
|
||||
Reference in new issue
Block a user