feat: add web backend — Express REST API, WebSocket, full wiring in entry point

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

src/web/api/auth.ts

@@ -0,0 +1,104 @@
+import { Router } from "express";
+import type { MusicProvider } from "../../music/provider.js";
+import type { Logger } from "../../logger.js";
+
+export function createAuthRouter(
+  neteaseProvider: MusicProvider,
+  qqProvider: MusicProvider,
+  logger: Logger
+): Router {
+  const router = Router();
+
+  function getProvider(platform?: string): MusicProvider {
+    return platform === "qq" ? qqProvider : neteaseProvider;
+  }
+
+  router.get("/status", async (req, res) => {
+    try {
+      const platform = req.query.platform as string;
+      const provider = getProvider(platform);
+      const status = await provider.getAuthStatus();
+      res.json({ platform: provider.platform, ...status });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.post("/qrcode", async (req, res) => {
+    try {
+      const { platform } = req.body;
+      const provider = getProvider(platform);
+      const qr = await provider.getQrCode();
+      res.json(qr);
+    } catch (err) {
+      logger.error({ err }, "QR code generation failed");
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.get("/qrcode/status", async (req, res) => {
+    try {
+      const { key, platform } = req.query;
+      if (!key) {
+        res.status(400).json({ error: "key is required" });
+        return;
+      }
+      const provider = getProvider(platform as string);
+      const status = await provider.checkQrCodeStatus(key as string);
+      res.json({ status });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.post("/sms/send", async (req, res) => {
+    try {
+      const { phone } = req.body;
+      if (!phone) {
+        res.status(400).json({ error: "phone is required" });
+        return;
+      }
+      if (!neteaseProvider.sendSmsCode) {
+        res
+          .status(400)
+          .json({ error: "SMS login not supported for this platform" });
+        return;
+      }
+      const success = await neteaseProvider.sendSmsCode(phone);
+      res.json({ success });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.post("/sms/verify", async (req, res) => {
+    try {
+      const { phone, code } = req.body;
+      if (!phone || !code) {
+        res.status(400).json({ error: "phone and code are required" });
+        return;
+      }
+      if (!neteaseProvider.loginWithSms) {
+        res.status(400).json({ error: "SMS login not supported" });
+        return;
+      }
+      const success = await neteaseProvider.loginWithSms(phone, code);
+      res.json({ success });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.post("/cookie", (req, res) => {
+    const { platform, cookie } = req.body;
+    if (!cookie) {
+      res.status(400).json({ error: "cookie is required" });
+      return;
+    }
+    const provider = getProvider(platform);
+    provider.setCookie(cookie);
+    res.json({ success: true });
+  });
+
+  return router;
+}

src/web/api/bot.ts

@@ -0,0 +1,88 @@
+import { Router } from "express";
+import type { BotManager } from "../../bot/manager.js";
+import type { BotConfig } from "../../data/config.js";
+import type { Logger } from "../../logger.js";
+
+export function createBotRouter(
+  botManager: BotManager,
+  config: BotConfig,
+  logger: Logger
+): Router {
+  const router = Router();
+
+  router.get("/", (_req, res) => {
+    const bots = botManager.getAllBots().map((b) => b.getStatus());
+    res.json({ bots });
+  });
+
+  router.get("/:id", (req, res) => {
+    const bot = botManager.getBot(req.params.id);
+    if (!bot) {
+      res.status(404).json({ error: "Bot not found" });
+      return;
+    }
+    res.json(bot.getStatus());
+  });
+
+  router.post("/", async (req, res) => {
+    try {
+      const {
+        name,
+        serverAddress,
+        serverPort,
+        nickname,
+        defaultChannel,
+        channelPassword,
+        autoStart,
+      } = req.body;
+      if (!name || !serverAddress || !nickname) {
+        res
+          .status(400)
+          .json({ error: "name, serverAddress, and nickname are required" });
+        return;
+      }
+      const bot = await botManager.createBot({
+        name,
+        serverAddress,
+        serverPort: serverPort ?? 9987,
+        nickname,
+        defaultChannel,
+        channelPassword,
+        autoStart: autoStart ?? false,
+      });
+      res.status(201).json(bot.getStatus());
+    } catch (err) {
+      logger.error({ err }, "Failed to create bot");
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.delete("/:id", async (req, res) => {
+    try {
+      await botManager.removeBot(req.params.id);
+      res.json({ success: true });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.post("/:id/start", async (req, res) => {
+    try {
+      await botManager.startBot(req.params.id);
+      res.json({ success: true });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.post("/:id/stop", (req, res) => {
+    try {
+      botManager.stopBot(req.params.id);
+      res.json({ success: true });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  return router;
+}

src/web/api/music.ts

@@ -0,0 +1,90 @@
+import { Router } from "express";
+import type { MusicProvider } from "../../music/provider.js";
+import type { Logger } from "../../logger.js";
+
+export function createMusicRouter(
+  neteaseProvider: MusicProvider,
+  qqProvider: MusicProvider,
+  logger: Logger
+): Router {
+  const router = Router();
+
+  function getProvider(platform?: string): MusicProvider {
+    return platform === "qq" ? qqProvider : neteaseProvider;
+  }
+
+  router.get("/search", async (req, res) => {
+    try {
+      const { q, platform, limit } = req.query;
+      if (!q) {
+        res.status(400).json({ error: "q (query) is required" });
+        return;
+      }
+      const provider = getProvider(platform as string);
+      const result = await provider.search(
+        q as string,
+        parseInt(limit as string) || 20
+      );
+      res.json(result);
+    } catch (err) {
+      logger.error({ err }, "Search failed");
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.get("/song/:id", async (req, res) => {
+    try {
+      const provider = getProvider(req.query.platform as string);
+      const song = await provider.getSongDetail(req.params.id);
+      if (!song) {
+        res.status(404).json({ error: "Song not found" });
+        return;
+      }
+      res.json(song);
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.get("/playlist/:id", async (req, res) => {
+    try {
+      const provider = getProvider(req.query.platform as string);
+      const songs = await provider.getPlaylistSongs(req.params.id);
+      res.json({ songs });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.get("/recommend/playlists", async (req, res) => {
+    try {
+      const provider = getProvider(req.query.platform as string);
+      const playlists = await provider.getRecommendPlaylists();
+      res.json({ playlists });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.get("/album/:id", async (req, res) => {
+    try {
+      const provider = getProvider(req.query.platform as string);
+      const songs = await provider.getAlbumSongs(req.params.id);
+      res.json({ songs });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.get("/lyrics/:id", async (req, res) => {
+    try {
+      const provider = getProvider(req.query.platform as string);
+      const lyrics = await provider.getLyrics(req.params.id);
+      res.json({ lyrics });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  return router;
+}

src/web/api/player.ts

@@ -0,0 +1,152 @@
+import { Router } from "express";
+import type { BotManager } from "../../bot/manager.js";
+import type { Logger } from "../../logger.js";
+import { parseCommand } from "../../bot/commands.js";
+
+export function createPlayerRouter(
+  botManager: BotManager,
+  logger: Logger
+): Router {
+  const router = Router();
+
+  router.use("/:botId", (req, res, next) => {
+    const bot = botManager.getBot(req.params.botId);
+    if (!bot) {
+      res.status(404).json({ error: "Bot not found" });
+      return;
+    }
+    (req as any).bot = bot;
+    next();
+  });
+
+  router.post("/:botId/play", async (req, res) => {
+    try {
+      const bot = (req as any).bot;
+      const { query, platform } = req.body;
+      if (!query) {
+        res.status(400).json({ error: "query is required" });
+        return;
+      }
+      const flags = platform === "qq" ? "-q" : "";
+      const cmd = parseCommand(`!play ${flags} ${query}`.trim(), "!");
+      if (!cmd) {
+        res.status(400).json({ error: "Invalid command" });
+        return;
+      }
+      const response = await bot.executeCommand(cmd);
+      res.json({ message: response });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.post("/:botId/add", async (req, res) => {
+    try {
+      const bot = (req as any).bot;
+      const { query, platform } = req.body;
+      const flags = platform === "qq" ? "-q" : "";
+      const cmd = parseCommand(`!add ${flags} ${query}`.trim(), "!");
+      if (!cmd) {
+        res.status(400).json({ error: "Invalid command" });
+        return;
+      }
+      const response = await bot.executeCommand(cmd);
+      res.json({ message: response });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.post("/:botId/pause", async (req, res) => {
+    const bot = (req as any).bot;
+    const cmd = parseCommand("!pause", "!")!;
+    const response = await bot.executeCommand(cmd);
+    res.json({ message: response });
+  });
+
+  router.post("/:botId/resume", async (req, res) => {
+    const bot = (req as any).bot;
+    const cmd = parseCommand("!resume", "!")!;
+    const response = await bot.executeCommand(cmd);
+    res.json({ message: response });
+  });
+
+  router.post("/:botId/next", async (req, res) => {
+    const bot = (req as any).bot;
+    const cmd = parseCommand("!next", "!")!;
+    const response = await bot.executeCommand(cmd);
+    res.json({ message: response });
+  });
+
+  router.post("/:botId/prev", async (req, res) => {
+    const bot = (req as any).bot;
+    const cmd = parseCommand("!prev", "!")!;
+    const response = await bot.executeCommand(cmd);
+    res.json({ message: response });
+  });
+
+  router.post("/:botId/stop", async (req, res) => {
+    const bot = (req as any).bot;
+    const cmd = parseCommand("!stop", "!")!;
+    const response = await bot.executeCommand(cmd);
+    res.json({ message: response });
+  });
+
+  router.post("/:botId/volume", async (req, res) => {
+    const bot = (req as any).bot;
+    const { volume } = req.body;
+    const cmd = parseCommand(`!vol ${volume}`, "!")!;
+    const response = await bot.executeCommand(cmd);
+    res.json({ message: response });
+  });
+
+  router.post("/:botId/mode", async (req, res) => {
+    const bot = (req as any).bot;
+    const { mode } = req.body;
+    const cmd = parseCommand(`!mode ${mode}`, "!")!;
+    const response = await bot.executeCommand(cmd);
+    res.json({ message: response });
+  });
+
+  router.get("/:botId/queue", (req, res) => {
+    const bot = (req as any).bot;
+    res.json({ queue: bot.getQueue(), status: bot.getStatus() });
+  });
+
+  router.post("/:botId/clear", async (req, res) => {
+    const bot = (req as any).bot;
+    const cmd = parseCommand("!clear", "!")!;
+    const response = await bot.executeCommand(cmd);
+    res.json({ message: response });
+  });
+
+  router.delete("/:botId/queue/:index", async (req, res) => {
+    const bot = (req as any).bot;
+    const cmd = parseCommand(`!remove ${req.params.index}`, "!")!;
+    const response = await bot.executeCommand(cmd);
+    res.json({ message: response });
+  });
+
+  router.post("/:botId/playlist", async (req, res) => {
+    try {
+      const bot = (req as any).bot;
+      const { playlistId, platform } = req.body;
+      const flags = platform === "qq" ? "-q" : "";
+      const cmd = parseCommand(
+        `!playlist ${flags} ${playlistId}`.trim(),
+        "!"
+      )!;
+      const response = await bot.executeCommand(cmd);
+      res.json({ message: response });
+    } catch (err) {
+      res.status(500).json({ error: (err as Error).message });
+    }
+  });
+
+  router.get("/:botId/history", (req, res) => {
+    // Will be wired when database access is available through bot
+    res.json({ history: [] });
+  });
+
+  return router;
+}