dg-lab-mcp-sse-server 1.0.3

package/dist/cli.js

@@ -0,0 +1,3165 @@
+#!/usr/bin/env node
+
+// src/config.ts
+import * as os from "os";
+
+// src/errors.ts
+var AppError = class extends Error {
+  /** 错误码，用于程序化处理 */
+  code;
+  /** 是否可恢复（true 表示可以继续运行，false 表示需要终止） */
+  recoverable;
+  /** 错误上下文信息，包含相关的调试数据 */
+  context;
+  constructor(code, message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "AppError";
+    this.code = code;
+    this.recoverable = options?.recoverable ?? true;
+    this.context = options?.context;
+  }
+  /**
+   * 格式化错误信息，方便日志输出
+   * 
+   * 输出格式包含错误码、消息、上下文和原因，一目了然。
+   */
+  toLogString() {
+    const parts = [`[${this.code}] ${this.message}`];
+    if (this.context) {
+      parts.push(`Context: ${JSON.stringify(this.context)}`);
+    }
+    if (this.cause) {
+      parts.push(`Cause: ${this.cause}`);
+    }
+    return parts.join("\n  ");
+  }
+};
+var ConfigError = class extends AppError {
+  constructor(message, options) {
+    super(options?.code ?? "CONFIG_LOAD_FAILED" /* CONFIG_LOAD_FAILED */, message, {
+      recoverable: false,
+      context: options?.context,
+      cause: options?.cause
+    });
+    this.name = "ConfigError";
+  }
+};
+var ConnectionError = class extends AppError {
+  constructor(message, options) {
+    super(options?.code ?? "CONN_DEVICE_NOT_FOUND" /* CONN_DEVICE_NOT_FOUND */, message, {
+      recoverable: true,
+      context: options?.context,
+      cause: options?.cause
+    });
+    this.name = "ConnectionError";
+  }
+};
+var WaveformError = class extends AppError {
+  constructor(message, options) {
+    super(options?.code ?? "WAVEFORM_PARSE_FAILED" /* WAVEFORM_PARSE_FAILED */, message, {
+      recoverable: true,
+      context: options?.context,
+      cause: options?.cause
+    });
+    this.name = "WaveformError";
+  }
+};
+
+// src/config.ts
+function getEnvString(key, defaultValue) {
+  return process.env[key] ?? defaultValue;
+}
+function getEnvNumber(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0) return defaultValue;
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    throw new ConfigError(`\u73AF\u5883\u53D8\u91CF ${key} \u7684\u503C\u65E0\u6548: ${value}`, {
+      code: "CONFIG_LOAD_FAILED" /* CONFIG_LOAD_FAILED */,
+      context: { key, value }
+    });
+  }
+  return parsed;
+}
+function loadConfig() {
+  const config = {
+    port: getEnvNumber("PORT", 3323),
+    publicIp: getEnvString("PUBLIC_IP", ""),
+    ssePath: getEnvString("SSE_PATH", "/sse"),
+    postPath: getEnvString("POST_PATH", "/message"),
+    sessionStorePath: getEnvString("SESSION_STORE_PATH", "./data/sessions.json"),
+    waveformStorePath: getEnvString("WAVEFORM_STORE_PATH", "./data/waveforms.json"),
+    heartbeatInterval: getEnvNumber("HEARTBEAT_INTERVAL", 3e4),
+    staleDeviceTimeout: getEnvNumber("STALE_DEVICE_TIMEOUT", 36e5),
+    connectionTimeoutMinutes: getEnvNumber("CONNECTION_TIMEOUT_MINUTES", 5)
+  };
+  validateConfig(config);
+  return config;
+}
+function validateConfig(config) {
+  if (config.port < 1 || config.port > 65535) {
+    throw new ConfigError(`\u7AEF\u53E3\u65E0\u6548: ${config.port}\uFF0C\u5FC5\u987B\u5728 1-65535 \u8303\u56F4\u5185`, {
+      code: "CONFIG_INVALID_PORT" /* CONFIG_INVALID_PORT */,
+      context: { port: config.port }
+    });
+  }
+  if (config.publicIp) {
+    const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+    if (!ipv4Regex.test(config.publicIp)) {
+      console.warn(`[\u914D\u7F6E] \u26A0\uFE0F \u516C\u7F51IP\u683C\u5F0F\u65E0\u6548: ${config.publicIp}\uFF0C\u5C06\u4F7F\u7528\u672C\u5730IP`);
+      config.publicIp = "";
+    } else {
+      const parts = config.publicIp.split(".");
+      if (parts.some((part) => parseInt(part, 10) > 255)) {
+        console.warn(`[\u914D\u7F6E] \u26A0\uFE0F \u516C\u7F51IP\u683C\u5F0F\u65E0\u6548: ${config.publicIp}\uFF0C\u6BCF\u6BB5\u5FC5\u987B\u57280-255\u8303\u56F4\u5185\uFF0C\u5C06\u4F7F\u7528\u672C\u5730IP`);
+        config.publicIp = "";
+      }
+    }
+  }
+  if (!config.ssePath.startsWith("/")) {
+    throw new ConfigError(`SSE \u8DEF\u5F84\u65E0\u6548: ${config.ssePath}\uFF0C\u5FC5\u987B\u4EE5 / \u5F00\u5934`, {
+      code: "CONFIG_INVALID_PATH" /* CONFIG_INVALID_PATH */,
+      context: { path: config.ssePath, type: "ssePath" }
+    });
+  }
+  if (!config.postPath.startsWith("/")) {
+    throw new ConfigError(`POST \u8DEF\u5F84\u65E0\u6548: ${config.postPath}\uFF0C\u5FC5\u987B\u4EE5 / \u5F00\u5934`, {
+      code: "CONFIG_INVALID_PATH" /* CONFIG_INVALID_PATH */,
+      context: { path: config.postPath, type: "postPath" }
+    });
+  }
+  if (config.heartbeatInterval < 1e3) {
+    throw new ConfigError(`\u5FC3\u8DF3\u95F4\u9694\u65E0\u6548: ${config.heartbeatInterval}\uFF0C\u5FC5\u987B\u81F3\u5C11 1000ms`, {
+      code: "CONFIG_LOAD_FAILED" /* CONFIG_LOAD_FAILED */,
+      context: { heartbeatInterval: config.heartbeatInterval }
+    });
+  }
+  if (config.staleDeviceTimeout < 6e4) {
+    throw new ConfigError(`\u8BBE\u5907\u8FC7\u671F\u8D85\u65F6\u65E0\u6548: ${config.staleDeviceTimeout}\uFF0C\u5FC5\u987B\u81F3\u5C11 60000ms`, {
+      code: "CONFIG_LOAD_FAILED" /* CONFIG_LOAD_FAILED */,
+      context: { staleDeviceTimeout: config.staleDeviceTimeout }
+    });
+  }
+  if (config.connectionTimeoutMinutes < 1 || config.connectionTimeoutMinutes > 60) {
+    throw new ConfigError(`\u8FDE\u63A5\u8D85\u65F6\u65F6\u95F4\u65E0\u6548: ${config.connectionTimeoutMinutes}\uFF0C\u5FC5\u987B\u5728 1-60 \u5206\u949F\u8303\u56F4\u5185`, {
+      code: "CONFIG_LOAD_FAILED" /* CONFIG_LOAD_FAILED */,
+      context: { connectionTimeoutMinutes: config.connectionTimeoutMinutes }
+    });
+  }
+}
+var configInstance = null;
+function getConfig() {
+  if (!configInstance) {
+    configInstance = loadConfig();
+  }
+  return configInstance;
+}
+function getLocalIP() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name] || []) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return "localhost";
+}
+function getEffectiveIP(config) {
+  const cfg = config || getConfig();
+  return cfg.publicIp || getLocalIP();
+}
+
+// src/server.ts
+import express from "express";
+
+// src/sse-transport.ts
+import { v4 as uuidv4 } from "uuid";
+
+// src/types/jsonrpc.ts
+var JSON_RPC_ERRORS = {
+  /** 解析错误 - 无效的 JSON */
+  PARSE_ERROR: -32700,
+  /** 无效请求 - JSON 不是有效的请求对象 */
+  INVALID_REQUEST: -32600,
+  /** 方法未找到 */
+  METHOD_NOT_FOUND: -32601,
+  /** 无效参数 */
+  INVALID_PARAMS: -32602,
+  /** 内部错误 */
+  INTERNAL_ERROR: -32603
+};
+function isJsonRpcRequest(msg) {
+  if (typeof msg !== "object" || msg === null) return false;
+  const obj = msg;
+  return obj.jsonrpc === "2.0" && "method" in obj && typeof obj.method === "string" && "id" in obj && (typeof obj.id === "string" || typeof obj.id === "number");
+}
+function isJsonRpcNotification(msg) {
+  if (typeof msg !== "object" || msg === null) return false;
+  const obj = msg;
+  return obj.jsonrpc === "2.0" && "method" in obj && typeof obj.method === "string" && !("id" in obj);
+}
+function serialize(message) {
+  return JSON.stringify(message);
+}
+function deserialize(data) {
+  try {
+    const parsed = JSON.parse(data);
+    if (typeof parsed !== "object" || parsed === null) {
+      return {
+        success: false,
+        error: {
+          code: JSON_RPC_ERRORS.INVALID_REQUEST,
+          message: "\u65E0\u6548\u8BF7\u6C42: \u4E0D\u662F\u5BF9\u8C61"
+        }
+      };
+    }
+    if (parsed.jsonrpc !== "2.0") {
+      return {
+        success: false,
+        error: {
+          code: JSON_RPC_ERRORS.INVALID_REQUEST,
+          message: "\u65E0\u6548\u8BF7\u6C42: \u7F3A\u5C11\u6216\u65E0\u6548\u7684 jsonrpc \u7248\u672C"
+        }
+      };
+    }
+    return { success: true, message: parsed };
+  } catch {
+    return {
+      success: false,
+      error: {
+        code: JSON_RPC_ERRORS.PARSE_ERROR,
+        message: "\u89E3\u6790\u9519\u8BEF: \u65E0\u6548\u7684 JSON"
+      }
+    };
+  }
+}
+function createSuccessResponse(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function createErrorResponse(id, code, message, data) {
+  const error = { code, message };
+  if (data !== void 0) error.data = data;
+  return { jsonrpc: "2.0", id, error };
+}
+
+// src/sse-transport.ts
+var SSETransport = class {
+  connections = /* @__PURE__ */ new Map();
+  postPath;
+  baseUrl;
+  /**
+   * 创建 SSE 传输层
+   * @param postPath - POST 端点路径
+   * @param baseUrl - 基础 URL（可选）
+   */
+  constructor(postPath, baseUrl = "") {
+    this.postPath = postPath;
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * 建立 SSE 连接并发送 endpoint 事件
+   * @param req - HTTP 请求
+   * @param res - HTTP 响应
+   * @returns SSE 连接信息
+   */
+  connect(req, res) {
+    const connectionId = uuidv4();
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    const postEndpoint = `${this.baseUrl}${this.postPath}?sessionId=${connectionId}`;
+    const connection = {
+      id: connectionId,
+      response: res,
+      postEndpoint,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.connections.set(connectionId, connection);
+    this.sendEvent(connectionId, "endpoint", postEndpoint);
+    req.on("close", () => {
+      this.disconnect(connectionId);
+    });
+    return connection;
+  }
+  /**
+   * 向指定连接发送 SSE 事件
+   * @param connectionId - 连接 ID
+   * @param event - 事件名
+   * @param data - 数据
+   * @returns 是否发送成功
+   */
+  sendEvent(connectionId, event, data) {
+    const connection = this.connections.get(connectionId);
+    if (!connection) return false;
+    try {
+      connection.response.write(`event: ${event}
+`);
+      connection.response.write(`data: ${data}
+
+`);
+      return true;
+    } catch {
+      this.disconnect(connectionId);
+      return false;
+    }
+  }
+  /**
+   * 通过 SSE 发送 JSON-RPC 消息
+   * @param connectionId - 连接 ID
+   * @param message - JSON-RPC 消息
+   * @returns 是否发送成功
+   */
+  send(connectionId, message) {
+    const data = serialize(message);
+    return this.sendEvent(connectionId, "message", data);
+  }
+  /**
+   * 断开并清理 SSE 连接
+   * @param connectionId - 连接 ID
+   */
+  disconnect(connectionId) {
+    const connection = this.connections.get(connectionId);
+    if (connection) {
+      try {
+        connection.response.end();
+      } catch {
+      }
+      this.connections.delete(connectionId);
+    }
+  }
+  /**
+   * 根据 ID 获取连接
+   * @param connectionId - 连接 ID
+   * @returns 连接信息或 undefined
+   */
+  getConnection(connectionId) {
+    return this.connections.get(connectionId);
+  }
+  /**
+   * 检查连接是否存在
+   * @param connectionId - 连接 ID
+   * @returns 是否存在
+   */
+  hasConnection(connectionId) {
+    return this.connections.has(connectionId);
+  }
+  /**
+   * 获取所有活跃连接 ID
+   * @returns 连接 ID 数组
+   */
+  getConnectionIds() {
+    return Array.from(this.connections.keys());
+  }
+  /**
+   * 向所有连接广播消息
+   * @param message - JSON-RPC 消息
+   */
+  broadcast(message) {
+    for (const connectionId of this.connections.keys()) {
+      this.send(connectionId, message);
+    }
+  }
+  /**
+   * 获取连接数量
+   */
+  get connectionCount() {
+    return this.connections.size;
+  }
+};
+
+// src/jsonrpc-handler.ts
+var JsonRpcHandler = class {
+  requestHandlers = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Map();
+  options;
+  /**
+   * 创建 JSON-RPC 处理器
+   * @param options - 处理器选项
+   */
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * 注册请求处理函数
+   * @param method - 方法名
+   * @param handler - 处理函数
+   */
+  registerRequestHandler(method, handler) {
+    this.requestHandlers.set(method, handler);
+  }
+  /**
+   * 注册通知处理函数
+   * @param method - 方法名
+   * @param handler - 处理函数
+   */
+  registerNotificationHandler(method, handler) {
+    this.notificationHandlers.set(method, handler);
+  }
+  /**
+   * 处理 JSON-RPC 消息
+   * @param data - JSON 字符串
+   * @returns 响应对象（通知返回 null）
+   */
+  async handleMessage(data) {
+    const parseResult = deserialize(data);
+    if (!parseResult.success) {
+      const error2 = parseResult.error;
+      this.options.onError?.(error2);
+      return createErrorResponse(null, error2.code, error2.message, error2.data);
+    }
+    const message = parseResult.message;
+    if (isJsonRpcRequest(message)) {
+      return this.handleRequest(message);
+    }
+    if (isJsonRpcNotification(message)) {
+      await this.handleNotification(message);
+      return null;
+    }
+    const error = {
+      code: JSON_RPC_ERRORS.INVALID_REQUEST,
+      message: "\u65E0\u6548\u8BF7\u6C42: \u4E0D\u662F\u6709\u6548\u7684\u8BF7\u6C42\u6216\u901A\u77E5"
+    };
+    this.options.onError?.(error);
+    return createErrorResponse(null, error.code, error.message);
+  }
+  /**
+   * 处理请求
+   * @param request - 请求对象
+   * @returns 响应对象
+   */
+  async handleRequest(request) {
+    this.options.onRequest?.(request.method, request.params);
+    const handler = this.requestHandlers.get(request.method);
+    if (!handler) {
+      const error = {
+        code: JSON_RPC_ERRORS.METHOD_NOT_FOUND,
+        message: `\u65B9\u6CD5\u672A\u627E\u5230: ${request.method}`
+      };
+      this.options.onError?.(error);
+      return createErrorResponse(request.id, error.code, error.message);
+    }
+    try {
+      const result = await handler(request.params);
+      return createSuccessResponse(request.id, result);
+    } catch (err) {
+      const error = {
+        code: JSON_RPC_ERRORS.INTERNAL_ERROR,
+        message: err instanceof Error ? err.message : "\u5185\u90E8\u9519\u8BEF"
+      };
+      this.options.onError?.(error);
+      return createErrorResponse(request.id, error.code, error.message);
+    }
+  }
+  /**
+   * 处理通知
+   * @param notification - 通知对象
+   */
+  async handleNotification(notification) {
+    this.options.onNotification?.(notification.method, notification.params);
+    const handler = this.notificationHandlers.get(notification.method);
+    if (handler) {
+      try {
+        await handler(notification.params);
+      } catch (err) {
+        const error = {
+          code: JSON_RPC_ERRORS.INTERNAL_ERROR,
+          message: err instanceof Error ? err.message : "\u5185\u90E8\u9519\u8BEF"
+        };
+        this.options.onError?.(error);
+      }
+    }
+  }
+  /**
+   * 验证请求参数
+   * @param id - 请求 ID
+   * @param params - 参数
+   * @param required - 必需参数列表
+   * @returns 验证失败返回错误响应，成功返回 null
+   */
+  validateParams(id, params, required) {
+    if (!params && required.length > 0) {
+      return createErrorResponse(
+        id,
+        JSON_RPC_ERRORS.INVALID_PARAMS,
+        `\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: ${required.join(", ")}`
+      );
+    }
+    const missing = required.filter((key) => params?.[key] === void 0);
+    if (missing.length > 0) {
+      return createErrorResponse(
+        id,
+        JSON_RPC_ERRORS.INVALID_PARAMS,
+        `\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: ${missing.join(", ")}`
+      );
+    }
+    return null;
+  }
+};
+
+// src/server.ts
+function createServer(config) {
+  const app = express();
+  app.use((req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.header("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.sendStatus(200);
+      return;
+    }
+    next();
+  });
+  app.use(express.json());
+  app.use(express.text({ type: "application/json" }));
+  const sseTransport = new SSETransport(config.postPath);
+  const jsonRpcHandler = new JsonRpcHandler({
+    onError: (error) => {
+      console.error("[JSON-RPC \u9519\u8BEF]", error);
+    }
+  });
+  app.get(config.ssePath, (req, res) => {
+    console.log("[SSE] \u65B0\u8FDE\u63A5");
+    const connection = sseTransport.connect(req, res);
+    console.log(`[SSE] \u8FDE\u63A5\u5DF2\u5EFA\u7ACB: ${connection.id}`);
+  });
+  app.post(config.postPath, async (req, res) => {
+    const sessionId = req.query.sessionId;
+    if (!sessionId || !sseTransport.hasConnection(sessionId)) {
+      res.status(400).json({ error: "\u65E0\u6548\u6216\u7F3A\u5C11 sessionId" });
+      return;
+    }
+    let body;
+    if (typeof req.body === "string") {
+      body = req.body;
+    } else {
+      body = JSON.stringify(req.body);
+    }
+    console.log(`[POST] \u6536\u5230\u4F1A\u8BDD ${sessionId} \u7684\u6D88\u606F:`, body);
+    const response = await jsonRpcHandler.handleMessage(body);
+    if (response) {
+      sseTransport.send(sessionId, response);
+    }
+    res.status(202).json({ status: "accepted" });
+  });
+  app.get("/health", (_req, res) => {
+    res.json({
+      status: "ok",
+      connections: sseTransport.connectionCount
+    });
+  });
+  let httpServer = null;
+  return {
+    app,
+    httpServer: null,
+    sseTransport,
+    jsonRpcHandler,
+    async start() {
+      return new Promise((resolve) => {
+        httpServer = app.listen(config.port, () => {
+          console.log(`[\u670D\u52A1\u5668] MCP SSE \u670D\u52A1\u5668\u76D1\u542C\u7AEF\u53E3 ${config.port}`);
+          console.log(`[\u670D\u52A1\u5668] SSE \u7AEF\u70B9: ${config.ssePath}`);
+          console.log(`[\u670D\u52A1\u5668] POST \u7AEF\u70B9: ${config.postPath}`);
+          resolve();
+        });
+        this.httpServer = httpServer;
+      });
+    },
+    async stop() {
+      return new Promise((resolve) => {
+        if (httpServer && httpServer.listening) {
+          httpServer.close((err) => {
+            if (err) {
+              console.error("[\u670D\u52A1\u5668] \u5173\u95ED\u65F6\u51FA\u9519:", err);
+            } else {
+              console.log("[\u670D\u52A1\u5668] \u5DF2\u505C\u6B62");
+            }
+            resolve();
+          });
+        } else {
+          console.log("[\u670D\u52A1\u5668] \u672A\u542F\u52A8\u6216\u5DF2\u5173\u95ED");
+          resolve();
+        }
+      });
+    }
+  };
+}
+function broadcastNotification(server, method, params) {
+  const notification = {
+    jsonrpc: "2.0",
+    method,
+    params
+  };
+  server.sseTransport.broadcast(notification);
+}
+
+// src/mcp-protocol.ts
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+var SERVER_INFO = {
+  name: "dg-lab-mcp-server",
+  version: "1.0.0"
+};
+var SERVER_CAPABILITIES = {
+  tools: {
+    listChanged: true
+  }
+};
+function registerMCPProtocol(handler, onInitialized) {
+  handler.registerRequestHandler("initialize", async (params) => {
+    const initParams = params;
+    if (initParams?.protocolVersion && initParams.protocolVersion !== MCP_PROTOCOL_VERSION) {
+      console.log(`[MCP] \u5BA2\u6237\u7AEF\u8BF7\u6C42\u7684\u534F\u8BAE\u7248\u672C: ${initParams.protocolVersion}`);
+    }
+    const result = {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: SERVER_CAPABILITIES,
+      serverInfo: SERVER_INFO
+    };
+    console.log("[MCP] \u6536\u5230\u521D\u59CB\u5316\u8BF7\u6C42\uFF0C\u8FD4\u56DE\u670D\u52A1\u5668\u80FD\u529B");
+    return result;
+  });
+  handler.registerNotificationHandler("initialized", async () => {
+    console.log("[MCP] \u521D\u59CB\u5316\u5B8C\u6210");
+    onInitialized?.();
+  });
+  handler.registerRequestHandler("ping", async () => {
+    return {};
+  });
+}
+
+// src/tool-manager.ts
+function createToolResult(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+function createToolError(message) {
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+var ToolManager = class {
+  tools = /* @__PURE__ */ new Map();
+  onToolsChanged;
+  /**
+   * 创建工具管理器实例
+   * 
+   * @param onToolsChanged - 可选的回调函数，当工具列表变化时调用
+   */
+  constructor(onToolsChanged) {
+    this.onToolsChanged = onToolsChanged;
+  }
+  /**
+   * 注册新工具
+   * 
+   * @param name - 工具名称，必须唯一
+   * @param description - 工具描述，供 AI 理解工具用途
+   * @param inputSchema - 参数 Schema，定义工具接受的参数
+   * @param handler - 处理函数，实际执行工具逻辑
+   */
+  registerTool(name, description, inputSchema, handler) {
+    this.tools.set(name, {
+      name,
+      description,
+      inputSchema,
+      handler
+    });
+    this.onToolsChanged?.();
+  }
+  /**
+   * 注销工具
+   * 
+   * @param name - 要注销的工具名称
+   * @returns 是否成功注销（false 表示工具不存在）
+   */
+  unregisterTool(name) {
+    const result = this.tools.delete(name);
+    if (result) {
+      this.onToolsChanged?.();
+    }
+    return result;
+  }
+  /**
+   * 列出所有已注册的工具
+   * 
+   * 返回工具的元信息（不包含处理函数），供 AI 发现可用工具。
+   * 
+   * @returns 工具定义数组
+   */
+  listTools() {
+    return Array.from(this.tools.values()).map(({ name, description, inputSchema }) => ({
+      name,
+      description,
+      inputSchema
+    }));
+  }
+  /**
+   * 按名称调用工具
+   * 
+   * 查找并执行指定的工具，自动处理异常并返回错误结果。
+   * 
+   * @param name - 工具名称
+   * @param params - 调用参数
+   * @returns 工具执行结果
+   */
+  async callTool(name, params) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return createToolError(`\u5DE5\u5177\u672A\u627E\u5230: ${name}`);
+    }
+    try {
+      return await tool.handler(params);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "\u672A\u77E5\u9519\u8BEF";
+      return createToolError(message);
+    }
+  }
+  /**
+   * 检查工具是否已注册
+   */
+  hasTool(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * 获取已注册的工具数量
+   */
+  get toolCount() {
+    return this.tools.size;
+  }
+};
+function registerToolHandlers(jsonRpcHandler, toolManager) {
+  jsonRpcHandler.registerRequestHandler("tools/list", async () => {
+    const tools = toolManager.listTools();
+    return { tools };
+  });
+  jsonRpcHandler.registerRequestHandler("tools/call", async (params) => {
+    const name = params?.name;
+    const args = params?.arguments ?? {};
+    if (!name) {
+      return createToolError("\u7F3A\u5C11\u5DE5\u5177\u540D\u79F0");
+    }
+    return toolManager.callTool(name, args);
+  });
+}
+
+// src/session-manager.ts
+import { v4 as uuidv42 } from "uuid";
+var SESSION_TTL_MS = 60 * 60 * 1e3;
+var CLEANUP_INTERVAL_MS = 5 * 60 * 1e3;
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  cleanupTimer = null;
+  /** 连接超时时间（毫秒） */
+  connectionTimeoutMs;
+  constructor(connectionTimeoutMinutes = 5) {
+    this.connectionTimeoutMs = connectionTimeoutMinutes * 60 * 1e3;
+    this.startCleanupTimer();
+    console.log(`[\u4F1A\u8BDD] \u8FDE\u63A5\u8D85\u65F6\u8BBE\u7F6E: ${connectionTimeoutMinutes} \u5206\u949F`);
+  }
+  /**
+   * 创建新的设备会话
+   * 
+   * 生成唯一的 deviceId 并初始化会话状态。
+   * 新会话默认未连接、未绑定，强度为 0，上限为 200。
+   * 会启动连接超时计时器，如果在超时时间内未绑定 APP 则自动销毁。
+   * 
+   * @returns 新创建的会话对象
+   */
+  createSession() {
+    const deviceId = uuidv42();
+    const now = /* @__PURE__ */ new Date();
+    const session = {
+      deviceId,
+      alias: null,
+      clientId: null,
+      targetId: null,
+      ws: null,
+      connected: false,
+      boundToApp: false,
+      strengthA: 0,
+      strengthB: 0,
+      strengthLimitA: 200,
+      strengthLimitB: 200,
+      lastActive: now,
+      createdAt: now,
+      connectionTimeoutId: null
+    };
+    session.connectionTimeoutId = setTimeout(() => {
+      const currentSession = this.sessions.get(deviceId);
+      if (currentSession && !currentSession.boundToApp) {
+        console.log(`[\u4F1A\u8BDD] \u8FDE\u63A5\u8D85\u65F6: ${deviceId} (${this.connectionTimeoutMs / 6e4} \u5206\u949F\u5185\u672A\u7ED1\u5B9A APP)`);
+        this.deleteSession(deviceId);
+      }
+    }, this.connectionTimeoutMs);
+    this.sessions.set(deviceId, session);
+    console.log(`[\u4F1A\u8BDD] \u5DF2\u521B\u5EFA: ${deviceId}`);
+    return session;
+  }
+  /**
+   * 根据 deviceId 获取会话
+   * 
+   * 如果会话已过期，会自动删除并返回 null。
+   * 
+   * @param deviceId - 设备 ID
+   * @returns 会话对象，如果不存在或已过期则返回 null
+   */
+  getSession(deviceId) {
+    const session = this.sessions.get(deviceId);
+    if (session) {
+      if (this.isExpired(session)) {
+        this.deleteSession(deviceId);
+        return null;
+      }
+    }
+    return session ?? null;
+  }
+  /**
+   * 根据 clientId 获取会话
+   * 
+   * clientId 是 WebSocket 服务器分配的标识符，用于关联 MCP 会话和 WS 连接。
+   * 
+   * @param clientId - WebSocket 客户端 ID
+   * @returns 会话对象，如果不存在或已过期则返回 null
+   */
+  getSessionByClientId(clientId) {
+    for (const session of this.sessions.values()) {
+      if (session.clientId === clientId && !this.isExpired(session)) {
+        return session;
+      }
+    }
+    return null;
+  }
+  /**
+   * 列出所有活跃会话
+   * 
+   * 返回前会先清理过期会话，确保返回的都是有效会话。
+   * 
+   * @returns 所有活跃会话的数组
+   */
+  listSessions() {
+    this.cleanupExpiredSessions();
+    return Array.from(this.sessions.values());
+  }
+  /**
+   * 删除会话
+   * 
+   * 会关闭关联的 WebSocket 连接、清理超时计时器并从内存中移除会话数据。
+   * 
+   * @param deviceId - 要删除的设备 ID
+   * @returns 是否成功删除（false 表示会话不存在）
+   */
+  deleteSession(deviceId) {
+    const session = this.sessions.get(deviceId);
+    if (session) {
+      if (session.connectionTimeoutId) {
+        clearTimeout(session.connectionTimeoutId);
+        session.connectionTimeoutId = null;
+      }
+      if (session.ws) {
+        try {
+          session.ws.close();
+        } catch {
+        }
+      }
+      this.sessions.delete(deviceId);
+      console.log(`[\u4F1A\u8BDD] \u5DF2\u5220\u9664: ${deviceId}`);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 设置设备别名
+   * 
+   * 别名用于方便识别设备，支持中文和特殊字符。
+   * 设置别名会同时更新会话的活跃时间。
+   * 
+   * @param deviceId - 设备 ID
+   * @param alias - 新的别名
+   * @returns 是否成功设置（false 表示设备不存在或已过期）
+   */
+  setAlias(deviceId, alias) {
+    const session = this.sessions.get(deviceId);
+    if (session && !this.isExpired(session)) {
+      session.alias = alias;
+      session.lastActive = /* @__PURE__ */ new Date();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 根据别名查找会话
+   * 
+   * 支持大小写不敏感的精确匹配。
+   * 
+   * @param alias - 要查找的别名
+   * @returns 所有匹配的会话数组
+   */
+  findByAlias(alias) {
+    const lowerAlias = alias.toLowerCase();
+    return Array.from(this.sessions.values()).filter(
+      (s) => !this.isExpired(s) && s.alias?.toLowerCase() === lowerAlias
+    );
+  }
+  /**
+   * 更新会话连接状态
+   * 
+   * 用于在 WebSocket 连接建立或断开时更新会话状态。
+   * 
+   * @param deviceId - 设备 ID
+   * @param updates - 要更新的字段
+   * @returns 是否成功更新
+   */
+  updateConnectionState(deviceId, updates) {
+    const session = this.sessions.get(deviceId);
+    if (session) {
+      Object.assign(session, updates);
+      session.lastActive = /* @__PURE__ */ new Date();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 更新会话强度值
+   * 
+   * 当收到 APP 的强度反馈时调用，同步更新会话中的强度数据。
+   * 
+   * @param deviceId - 设备 ID
+   * @param strengthA - A 通道当前强度
+   * @param strengthB - B 通道当前强度
+   * @param strengthLimitA - A 通道强度上限
+   * @param strengthLimitB - B 通道强度上限
+   * @returns 是否成功更新
+   */
+  updateStrength(deviceId, strengthA, strengthB, strengthLimitA, strengthLimitB) {
+    const session = this.sessions.get(deviceId);
+    if (session) {
+      session.strengthA = strengthA;
+      session.strengthB = strengthB;
+      session.strengthLimitA = strengthLimitA;
+      session.strengthLimitB = strengthLimitB;
+      session.lastActive = /* @__PURE__ */ new Date();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 触摸会话以保持活跃
+   * 
+   * 更新 lastActive 时间戳，防止会话因不活动而过期。
+   * 每次对设备的操作都应该调用此方法。
+   * 
+   * @param deviceId - 设备 ID
+   * @returns 是否成功
+   */
+  touchSession(deviceId) {
+    const session = this.sessions.get(deviceId);
+    if (session) {
+      session.lastActive = /* @__PURE__ */ new Date();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * APP 绑定成功时调用
+   * 
+   * 取消连接超时计时器，因为设备已成功绑定 APP。
+   * 同时更新会话的 boundToApp 状态。
+   * 
+   * @param deviceId - 设备 ID
+   * @returns 是否成功
+   */
+  onAppBound(deviceId) {
+    const session = this.sessions.get(deviceId);
+    if (session) {
+      if (session.connectionTimeoutId) {
+        clearTimeout(session.connectionTimeoutId);
+        session.connectionTimeoutId = null;
+        console.log(`[\u4F1A\u8BDD] \u5DF2\u53D6\u6D88\u8FDE\u63A5\u8D85\u65F6: ${deviceId} (APP \u5DF2\u7ED1\u5B9A)`);
+      }
+      session.boundToApp = true;
+      session.lastActive = /* @__PURE__ */ new Date();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 获取当前会话数量
+   */
+  get sessionCount() {
+    return this.sessions.size;
+  }
+  /**
+   * 检查会话是否已过期
+   */
+  isExpired(session) {
+    return Date.now() - session.lastActive.getTime() > SESSION_TTL_MS;
+  }
+  /**
+   * 清理所有过期会话
+   * 
+   * 遍历所有会话，删除超过 TTL 的会话并关闭其 WebSocket 连接。
+   * 
+   * @returns 清理的会话数量
+   */
+  cleanupExpiredSessions() {
+    let cleaned = 0;
+    const now = Date.now();
+    for (const [deviceId, session] of this.sessions) {
+      const age = now - session.lastActive.getTime();
+      if (age > SESSION_TTL_MS) {
+        if (session.connectionTimeoutId) {
+          clearTimeout(session.connectionTimeoutId);
+        }
+        if (session.ws) {
+          try {
+            session.ws.close();
+          } catch {
+          }
+        }
+        this.sessions.delete(deviceId);
+        console.log(`[\u4F1A\u8BDD] \u5DF2\u8FC7\u671F: ${deviceId} (\u4E0D\u6D3B\u8DC3 ${Math.round(age / 6e4)} \u5206\u949F)`);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+  /**
+   * 启动定期清理定时器
+   */
+  startCleanupTimer() {
+    this.cleanupTimer = setInterval(() => {
+      const cleaned = this.cleanupExpiredSessions();
+      if (cleaned > 0) {
+        console.log(`[\u4F1A\u8BDD] \u6E05\u7406: ${cleaned} \u4E2A\u8FC7\u671F\uFF0C\u5269\u4F59 ${this.sessions.size} \u4E2A`);
+      }
+    }, CLEANUP_INTERVAL_MS);
+  }
+  /**
+   * 停止定期清理定时器
+   * 
+   * 在服务器关闭时调用，防止内存泄漏。
+   */
+  stopCleanupTimer() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+  /**
+   * 清除所有会话
+   * 
+   * 关闭所有 WebSocket 连接、清理所有计时器并清空会话存储。
+   * 通常在服务器关闭或重置时调用。
+   */
+  clearAll() {
+    for (const session of this.sessions.values()) {
+      if (session.connectionTimeoutId) {
+        clearTimeout(session.connectionTimeoutId);
+      }
+      if (session.ws) {
+        try {
+          session.ws.close();
+        } catch {
+        }
+      }
+    }
+    this.sessions.clear();
+  }
+};
+
+// src/ws-server.ts
+import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
+import { v4 as uuidv43 } from "uuid";
+
+// src/ws-bridge.ts
+import WebSocket from "ws";
+
+// src/ws-server.ts
+var DGLabWSServer = class {
+  wss = null;
+  clients = /* @__PURE__ */ new Map();
+  relations = /* @__PURE__ */ new Map();
+  waveformTimers = /* @__PURE__ */ new Map();
+  /** 持续播放状态 Map，key 格式: controllerId-channel */
+  continuousPlaybacks = /* @__PURE__ */ new Map();
+  heartbeatTimer = null;
+  options;
+  attachedPort = 0;
+  constructor(options) {
+    this.options = {
+      heartbeatInterval: 6e4,
+      onStrengthUpdate: () => {
+      },
+      onFeedback: () => {
+      },
+      onBindChange: () => {
+      },
+      ...options
+    };
+  }
+  /** 启动独立的 WebSocket 服务器（使用独立端口） */
+  start() {
+    if (!this.options.port) {
+      throw new Error("\u72EC\u7ACB\u542F\u52A8\u9700\u8981\u6307\u5B9A port");
+    }
+    this.wss = new WebSocketServer({ port: this.options.port });
+    this.wss.on("connection", (ws, req) => {
+      this.handleConnection(ws, req);
+    });
+    this.startHeartbeat();
+    this.attachedPort = this.options.port;
+    console.log(`[WS \u670D\u52A1\u5668] \u72EC\u7ACB\u76D1\u542C\u7AEF\u53E3 ${this.options.port}`);
+  }
+  /** 附加到现有的 HTTP 服务器（共享端口） */
+  attachToServer(httpServer, port) {
+    this.wss = new WebSocketServer({ noServer: true });
+    httpServer.on("upgrade", (request, socket, head) => {
+      this.wss.handleUpgrade(request, socket, head, (ws) => {
+        this.wss.emit("connection", ws, request);
+      });
+    });
+    this.wss.on("connection", (ws, req) => {
+      this.handleConnection(ws, req);
+    });
+    this.startHeartbeat();
+    this.attachedPort = port;
+    console.log(`[WS \u670D\u52A1\u5668] \u5DF2\u9644\u52A0\u5230 HTTP \u670D\u52A1\u5668\uFF0C\u5171\u4EAB\u7AEF\u53E3 ${port}`);
+  }
+  /** 启动心跳定时器 */
+  startHeartbeat() {
+    this.heartbeatTimer = setInterval(() => {
+      this.sendHeartbeats();
+    }, this.options.heartbeatInterval);
+  }
+  /** 停止 WebSocket 服务器 */
+  stop() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    for (const timer of this.waveformTimers.values()) {
+      clearInterval(timer.timerId);
+    }
+    this.waveformTimers.clear();
+    for (const playback of this.continuousPlaybacks.values()) {
+      if (playback.timerId) {
+        clearInterval(playback.timerId);
+      }
+    }
+    this.continuousPlaybacks.clear();
+    for (const client of this.clients.values()) {
+      client.ws.close();
+    }
+    this.clients.clear();
+    this.relations.clear();
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+    console.log("[WS \u670D\u52A1\u5668] \u5DF2\u505C\u6B62");
+  }
+  /** 处理新的 WebSocket 连接 */
+  handleConnection(ws, _req) {
+    const clientId = uuidv43();
+    const clientInfo = {
+      id: clientId,
+      ws,
+      type: "unknown",
+      boundTo: null,
+      lastActive: Date.now()
+    };
+    this.clients.set(clientId, clientInfo);
+    console.log(`[WS \u670D\u52A1\u5668] \u65B0\u8FDE\u63A5: ${clientId}`);
+    this.send(ws, { type: "bind", clientId, targetId: "", message: "targetId" });
+    ws.on("message", (data) => this.handleMessage(clientId, data.toString()));
+    ws.on("close", () => this.handleClose(clientId));
+    ws.on("error", (error) => {
+      console.error(`[WS \u670D\u52A1\u5668] \u9519\u8BEF ${clientId}:`, error.message);
+      this.handleError(clientId, error);
+    });
+  }
+  /** 处理收到的消息 */
+  handleMessage(clientId, rawData) {
+    console.log(`[WS \u670D\u52A1\u5668] \u6536\u5230 ${clientId}: ${rawData}`);
+    const client = this.clients.get(clientId);
+    if (!client) return;
+    client.lastActive = Date.now();
+    let data;
+    try {
+      data = JSON.parse(rawData);
+    } catch {
+      this.send(client.ws, { type: "msg", clientId: "", targetId: "", message: "403" });
+      return;
+    }
+    if (data.clientId !== clientId && data.targetId !== clientId) {
+      if (!(data.type === "bind" && data.message === "DGLAB")) {
+        this.send(client.ws, { type: "msg", clientId: "", targetId: "", message: "404" });
+        return;
+      }
+    }
+    switch (data.type) {
+      case "bind":
+        this.handleBind(clientId, data);
+        break;
+      case "msg":
+        this.handleMsg(clientId, data);
+        break;
+      case "heartbeat":
+        break;
+      default:
+        this.forwardMessage(clientId, data);
+        break;
+    }
+  }
+  /** 处理绑定请求 */
+  handleBind(clientId, data) {
+    const client = this.clients.get(clientId);
+    if (!client) return;
+    if (data.message === "DGLAB" && data.clientId && data.targetId) {
+      const controllerId = data.clientId;
+      const appId = data.targetId;
+      if (!this.clients.has(controllerId) || !this.clients.has(appId)) {
+        this.send(client.ws, { type: "bind", clientId: controllerId, targetId: appId, message: "401" });
+        return;
+      }
+      const alreadyBound = [controllerId, appId].some(
+        (id) => this.relations.has(id) || [...this.relations.values()].includes(id)
+      );
+      if (alreadyBound) {
+        this.send(client.ws, { type: "bind", clientId: controllerId, targetId: appId, message: "400" });
+        return;
+      }
+      this.relations.set(controllerId, appId);
+      const controllerClient = this.clients.get(controllerId);
+      const appClient = this.clients.get(appId);
+      if (controllerClient) {
+        controllerClient.type = "controller";
+        controllerClient.boundTo = appId;
+      }
+      if (appClient) {
+        appClient.type = "app";
+        appClient.boundTo = controllerId;
+      }
+      const successMsg = { type: "bind", clientId: controllerId, targetId: appId, message: "200" };
+      if (controllerClient) this.send(controllerClient.ws, successMsg);
+      if (appClient) this.send(appClient.ws, successMsg);
+      if (this.options.onBindChange) {
+        this.options.onBindChange(controllerId, appId);
+      }
+      console.log(`[WS \u670D\u52A1\u5668] \u5DF2\u7ED1\u5B9A: ${controllerId} <-> ${appId}`);
+    }
+  }
+  /** 处理 msg 类型消息 */
+  handleMsg(clientId, data) {
+    const { message } = data;
+    if (message.startsWith("strength-")) {
+      const parsed = this.parseStrengthMessage(message);
+      if (parsed) {
+        const client = this.clients.get(clientId);
+        if (client?.boundTo && this.options.onStrengthUpdate) {
+          this.options.onStrengthUpdate(client.boundTo, parsed.strengthA, parsed.strengthB, parsed.limitA, parsed.limitB);
+        }
+        this.forwardMessage(clientId, data);
+      }
+      return;
+    }
+    if (message.startsWith("feedback-")) {
+      const index = parseInt(message.substring(9));
+      if (!isNaN(index)) {
+        const client = this.clients.get(clientId);
+        if (client?.boundTo && this.options.onFeedback) {
+          this.options.onFeedback(client.boundTo, index);
+        }
+      }
+      this.forwardMessage(clientId, data);
+      return;
+    }
+    this.forwardMessage(clientId, data);
+  }
+  /** 转发消息给绑定的对方 */
+  forwardMessage(fromClientId, data) {
+    const client = this.clients.get(fromClientId);
+    if (!client?.boundTo) return;
+    const boundId = this.relations.get(fromClientId) || [...this.relations.entries()].find(([_, v]) => v === fromClientId)?.[0];
+    if (!boundId) {
+      this.send(client.ws, { type: "bind", clientId: data.clientId, targetId: data.targetId, message: "402" });
+      return;
+    }
+    const targetClient = this.clients.get(client.boundTo);
+    if (targetClient) {
+      this.send(targetClient.ws, data);
+    } else {
+      this.send(client.ws, { type: "msg", clientId: data.clientId, targetId: data.targetId, message: "404" });
+    }
+  }
+  /** 处理客户端断开 */
+  handleClose(clientId) {
+    console.log(`[WS \u670D\u52A1\u5668] \u65AD\u5F00: ${clientId}`);
+    const client = this.clients.get(clientId);
+    if (!client) return;
+    for (const [key, timer] of this.waveformTimers.entries()) {
+      if (key.startsWith(clientId + "-")) {
+        clearInterval(timer.timerId);
+        this.waveformTimers.delete(key);
+      }
+    }
+    for (const [key, playback] of this.continuousPlaybacks.entries()) {
+      if (playback.controllerId === clientId) {
+        if (playback.timerId) {
+          clearInterval(playback.timerId);
+        }
+        this.continuousPlaybacks.delete(key);
+        console.log(`[WS \u670D\u52A1\u5668] \u5DF2\u505C\u6B62\u6301\u7EED\u64AD\u653E: ${key}`);
+      }
+    }
+    if (client.type === "app") {
+      for (const [controllerId, appId] of this.relations.entries()) {
+        if (appId === clientId) {
+          const controller = this.clients.get(controllerId);
+          if (controller) {
+            this.send(controller.ws, {
+              type: "break",
+              clientId: controllerId,
+              targetId: clientId,
+              message: "209"
+            });
+            controller.boundTo = null;
+          }
+          this.relations.delete(controllerId);
+          if (this.options.onBindChange) {
+            this.options.onBindChange(controllerId, null);
+          }
+        }
+      }
+      if (this.options.onAppDisconnect) {
+        this.options.onAppDisconnect(clientId);
+      }
+    } else if (client.type === "controller") {
+      if (client.boundTo) {
+        const partner = this.clients.get(client.boundTo);
+        if (partner) {
+          this.send(partner.ws, { type: "break", clientId: client.boundTo, targetId: clientId, message: "209" });
+          partner.boundTo = null;
+        }
+        this.relations.delete(clientId);
+        if (this.options.onBindChange) {
+          this.options.onBindChange(clientId, null);
+        }
+      }
+      if (this.options.onControllerDisconnect) {
+        this.options.onControllerDisconnect(clientId);
+      }
+    } else {
+      if (client.boundTo) {
+        const partner = this.clients.get(client.boundTo);
+        if (partner) {
+          this.send(partner.ws, { type: "break", clientId: client.boundTo, targetId: clientId, message: "209" });
+          partner.boundTo = null;
+        }
+        this.relations.delete(clientId);
+        this.relations.delete(client.boundTo);
+      }
+    }
+    this.clients.delete(clientId);
+    console.log(`[WS \u670D\u52A1\u5668] \u5DF2\u6E05\u7406 ${clientId}\uFF0C\u5BA2\u6237\u7AEF\u6570: ${this.clients.size}`);
+  }
+  /** 处理客户端错误 */
+  handleError(clientId, error) {
+    const client = this.clients.get(clientId);
+    if (!client?.boundTo) return;
+    const partner = this.clients.get(client.boundTo);
+    if (partner) {
+      this.send(partner.ws, { type: "error", clientId: client.boundTo, targetId: clientId, message: "500" });
+    }
+  }
+  /** 发送心跳给所有客户端 */
+  sendHeartbeats() {
+    if (this.clients.size === 0) return;
+    console.log(`[WS \u670D\u52A1\u5668] \u53D1\u9001\u5FC3\u8DF3\u7ED9 ${this.clients.size} \u4E2A\u5BA2\u6237\u7AEF`);
+    for (const [clientId, client] of this.clients.entries()) {
+      this.send(client.ws, { type: "heartbeat", clientId, targetId: client.boundTo || "", message: "200" });
+    }
+  }
+  /** 发送消息到 WebSocket */
+  send(ws, msg) {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  /** 解析强度消息 */
+  parseStrengthMessage(message) {
+    const match = message.match(/^strength-(\d+)\+(\d+)\+(\d+)\+(\d+)$/);
+    if (!match) return null;
+    return { strengthA: parseInt(match[1], 10), strengthB: parseInt(match[2], 10), limitA: parseInt(match[3], 10), limitB: parseInt(match[4], 10) };
+  }
+  // ============ MCP 工具公共 API ============
+  /** 创建控制器（用于 dg_connect） */
+  createController() {
+    const clientId = uuidv43();
+    const mockWs = this.createMockWebSocket(clientId);
+    const clientInfo = { id: clientId, ws: mockWs, type: "controller", boundTo: null, lastActive: Date.now() };
+    this.clients.set(clientId, clientInfo);
+    console.log(`[WS \u670D\u52A1\u5668] \u521B\u5EFA\u63A7\u5236\u5668: ${clientId}`);
+    return clientId;
+  }
+  /** 创建内部控制器的模拟 WebSocket */
+  createMockWebSocket(clientId) {
+    return {
+      readyState: WebSocket2.OPEN,
+      send: (data) => {
+        console.log(`[WS \u670D\u52A1\u5668] \u53D1\u9001\u7ED9\u63A7\u5236\u5668 ${clientId}: ${data}`);
+      },
+      close: () => {
+      }
+    };
+  }
+  /** 检查控制器是否已绑定 APP */
+  isControllerBound(controllerId) {
+    return this.relations.has(controllerId);
+  }
+  /** 获取绑定到控制器的 APP clientId */
+  getBoundAppId(controllerId) {
+    return this.relations.get(controllerId) || null;
+  }
+  /** 获取控制器信息 */
+  getController(controllerId) {
+    const client = this.clients.get(controllerId);
+    return client?.type === "controller" ? client : null;
+  }
+  /** 列出所有控制器 */
+  listControllers() {
+    const result = [];
+    for (const client of this.clients.values()) {
+      if (client.type === "controller") {
+        result.push({ id: client.id, boundTo: client.boundTo, lastActive: client.lastActive });
+      }
+    }
+    return result;
+  }
+  /** 移除控制器 */
+  removeController(controllerId) {
+    const client = this.clients.get(controllerId);
+    if (!client || client.type !== "controller") return false;
+    this.handleClose(controllerId);
+    return true;
+  }
+  /**
+   * 断开指定控制器的连接
+   * @param controllerId - 控制器 ID
+   * @returns 是否成功断开
+   */
+  disconnectController(controllerId) {
+    const client = this.clients.get(controllerId);
+    if (!client) {
+      return false;
+    }
+    for (const [key, timer] of this.waveformTimers.entries()) {
+      if (key.startsWith(controllerId + "-")) {
+        clearInterval(timer.timerId);
+        this.waveformTimers.delete(key);
+      }
+    }
+    for (const channel of ["A", "B"]) {
+      const key = `${controllerId}-${channel}`;
+      const state = this.continuousPlaybacks.get(key);
+      if (state) {
+        if (state.timerId) {
+          clearInterval(state.timerId);
+        }
+        this.continuousPlaybacks.delete(key);
+        console.log(`[WS \u670D\u52A1\u5668] \u5DF2\u505C\u6B62\u6301\u7EED\u64AD\u653E: ${key}`);
+      }
+    }
+    if (client.boundTo) {
+      const appClient = this.clients.get(client.boundTo);
+      if (appClient && appClient.ws.readyState === WebSocket2.OPEN) {
+        this.send(appClient.ws, {
+          type: "break",
+          clientId: controllerId,
+          targetId: client.boundTo,
+          message: "209"
+        });
+      }
+      this.relations.delete(controllerId);
+      if (appClient) {
+        appClient.boundTo = null;
+      }
+      if (this.options.onBindChange) {
+        this.options.onBindChange(controllerId, null);
+      }
+    }
+    if (client.ws.readyState === WebSocket2.OPEN) {
+      client.ws.close(1e3, "Disconnected by user");
+    }
+    this.clients.delete(controllerId);
+    if (this.options.onControllerDisconnect) {
+      this.options.onControllerDisconnect(controllerId);
+    }
+    console.log(`[WS \u670D\u52A1\u5668] \u63A7\u5236\u5668\u5DF2\u65AD\u5F00: ${controllerId}`);
+    return true;
+  }
+  /** 发送强度命令到 APP */
+  sendStrength(controllerId, channel, mode, value) {
+    const appId = this.relations.get(controllerId);
+    if (!appId) return false;
+    const appClient = this.clients.get(appId);
+    if (!appClient) return false;
+    const channelNum = channel === "A" ? 1 : 2;
+    const modeNum = mode === "decrease" ? 0 : mode === "increase" ? 1 : 2;
+    const message = `strength-${channelNum}+${modeNum}+${value}`;
+    this.send(appClient.ws, { type: "msg", clientId: controllerId, targetId: appId, message });
+    return true;
+  }
+  /** 发送波形到 APP */
+  sendWaveform(controllerId, channel, waveforms) {
+    const appId = this.relations.get(controllerId);
+    if (!appId) return false;
+    const appClient = this.clients.get(appId);
+    if (!appClient) return false;
+    const message = `pulse-${channel}:${JSON.stringify(waveforms)}`;
+    this.send(appClient.ws, { type: "msg", clientId: controllerId, targetId: appId, message });
+    return true;
+  }
+  /** 清空波形队列 */
+  clearWaveform(controllerId, channel) {
+    const appId = this.relations.get(controllerId);
+    if (!appId) return false;
+    const appClient = this.clients.get(appId);
+    if (!appClient) return false;
+    const channelNum = channel === "A" ? 1 : 2;
+    this.send(appClient.ws, { type: "msg", clientId: controllerId, targetId: appId, message: `clear-${channelNum}` });
+    return true;
+  }
+  // ============ 持续播放 API ============
+  /**
+   * 启动持续播放
+   * 
+   * 循环发送波形数据到指定通道，直到手动停止。
+   * 每次发送一批波形，按间隔循环发送。
+   * 
+   * @param controllerId - 控制器 ID
+   * @param channel - 目标通道 A 或 B
+   * @param waveforms - 要循环播放的波形数据
+   * @param interval - 发送间隔（毫秒），默认 100ms
+   * @param batchSize - 每次发送的波形数量，默认 5
+   * @returns 是否成功启动
+   */
+  startContinuousPlayback(controllerId, channel, waveforms, interval = 100, batchSize = 5) {
+    if (!this.isControllerBound(controllerId)) {
+      console.log(`[WS \u670D\u52A1\u5668] \u6301\u7EED\u64AD\u653E\u5931\u8D25: \u63A7\u5236\u5668 ${controllerId} \u672A\u7ED1\u5B9A APP`);
+      return false;
+    }
+    if (!waveforms || waveforms.length === 0) {
+      console.log(`[WS \u670D\u52A1\u5668] \u6301\u7EED\u64AD\u653E\u5931\u8D25: \u6CE2\u5F62\u6570\u636E\u4E3A\u7A7A`);
+      return false;
+    }
+    const key = `${controllerId}-${channel}`;
+    if (this.continuousPlaybacks.has(key)) {
+      this.stopContinuousPlayback(controllerId, channel);
+    }
+    const state = {
+      controllerId,
+      channel,
+      waveforms,
+      currentIndex: 0,
+      interval,
+      batchSize,
+      timerId: null,
+      active: true
+    };
+    state.timerId = setInterval(() => {
+      if (!state.active) {
+        return;
+      }
+      const batch = [];
+      for (let i = 0; i < state.batchSize; i++) {
+        batch.push(state.waveforms[state.currentIndex]);
+        state.currentIndex = (state.currentIndex + 1) % state.waveforms.length;
+      }
+      const success = this.sendWaveform(controllerId, channel, batch);
+      if (!success) {
+        console.log(`[WS \u670D\u52A1\u5668] \u6301\u7EED\u64AD\u653E\u53D1\u9001\u5931\u8D25\uFF0C\u505C\u6B62\u64AD\u653E: ${key}`);
+        this.stopContinuousPlayback(controllerId, channel);
+      }
+    }, interval);
+    this.continuousPlaybacks.set(key, state);
+    console.log(`[WS \u670D\u52A1\u5668] \u5DF2\u542F\u52A8\u6301\u7EED\u64AD\u653E: ${key}\uFF0C\u6CE2\u5F62\u6570: ${waveforms.length}\uFF0C\u95F4\u9694: ${interval}ms`);
+    return true;
+  }
+  /**
+   * 停止持续播放
+   * 
+   * 停止指定通道的持续播放并清空波形队列。
+   * 
+   * @param controllerId - 控制器 ID
+   * @param channel - 目标通道 A 或 B
+   * @returns 是否成功停止
+   */
+  stopContinuousPlayback(controllerId, channel) {
+    const key = `${controllerId}-${channel}`;
+    const state = this.continuousPlaybacks.get(key);
+    if (!state) {
+      console.log(`[WS \u670D\u52A1\u5668] \u505C\u6B62\u6301\u7EED\u64AD\u653E\u5931\u8D25: ${key} \u4E0D\u5B58\u5728`);
+      return false;
+    }
+    state.active = false;
+    if (state.timerId) {
+      clearInterval(state.timerId);
+      state.timerId = null;
+    }
+    this.clearWaveform(controllerId, channel);
+    this.continuousPlaybacks.delete(key);
+    console.log(`[WS \u670D\u52A1\u5668] \u5DF2\u505C\u6B62\u6301\u7EED\u64AD\u653E: ${key}`);
+    return true;
+  }
+  /**
+   * 检查是否正在持续播放
+   * 
+   * @param controllerId - 控制器 ID
+   * @param channel - 目标通道 A 或 B
+   * @returns 是否正在持续播放
+   */
+  isContinuousPlaying(controllerId, channel) {
+    const key = `${controllerId}-${channel}`;
+    const state = this.continuousPlaybacks.get(key);
+    return state?.active ?? false;
+  }
+  /**
+   * 获取持续播放状态
+   * 
+   * @param controllerId - 控制器 ID
+   * @param channel - 目标通道 A 或 B
+   * @returns 持续播放状态或 null
+   */
+  getContinuousPlaybackState(controllerId, channel) {
+    const key = `${controllerId}-${channel}`;
+    const state = this.continuousPlaybacks.get(key);
+    if (!state) return null;
+    return {
+      waveformCount: state.waveforms.length,
+      interval: state.interval,
+      batchSize: state.batchSize,
+      active: state.active
+    };
+  }
+  /** 获取 APP 扫描的二维码 URL */
+  getQRCodeUrl(controllerId, host) {
+    const wsUrl = `ws://${host}:${this.attachedPort}/${controllerId}`;
+    return `https://www.dungeon-lab.com/app-download.php#DGLAB-SOCKET#${wsUrl}`;
+  }
+  /** 获取 APP 连接的 WebSocket URL */
+  getWSUrl(controllerId, host) {
+    return `ws://${host}:${this.attachedPort}/${controllerId}`;
+  }
+  /** 获取服务器端口 */
+  getPort() {
+    return this.attachedPort;
+  }
+  /** 获取客户端数量 */
+  getClientCount() {
+    return this.clients.size;
+  }
+  /** 获取绑定关系数量 */
+  getRelationCount() {
+    return this.relations.size;
+  }
+};
+
+// src/tools/device-tools.ts
+function registerDeviceTools(toolManager, sessionManager, wsServer, publicIp) {
+  const localIp = getLocalIP();
+  const ipAddress = publicIp || localIp;
+  console.log(`[\u8BBE\u5907\u5DE5\u5177] PUBLIC_IP \u914D\u7F6E: "${publicIp || "(\u672A\u8BBE\u7F6E)"}"`);
+  console.log(`[\u8BBE\u5907\u5DE5\u5177] \u672C\u5730 IP: ${localIp}`);
+  console.log(`[\u8BBE\u5907\u5DE5\u5177] \u4F7F\u7528 IP: ${ipAddress}`);
+  toolManager.registerTool(
+    "dg_connect",
+    `\u3010\u7B2C\u4E00\u6B65\u3011\u521B\u5EFADG-LAB\u8BBE\u5907\u8FDE\u63A5\u3002\u8FD4\u56DEdeviceId\uFF08\u540E\u7EED\u64CD\u4F5C\u5FC5\u9700\uFF09\u548CqrCodeUrl\uFF08\u4E8C\u7EF4\u7801\u94FE\u63A5\uFF09\u3002
+\u4F7F\u7528\u6D41\u7A0B\uFF1A1.\u8C03\u7528\u6B64\u5DE5\u5177\u83B7\u53D6\u4E8C\u7EF4\u7801 \u2192 2.\u751F\u6210\u4E8C\u7EF4\u7801\u540E\u8BA9\u7528\u6237\u7528DG-LAB APP\u626B\u7801 \u2192 3.\u7528\u6237\u8BF4\u626B\u4E86\u7801\u540E\u7528dg_get_status\u68C0\u67E5boundToApp\u662F\u5426\u4E3Atrue \u2192 4.boundToApp\u4E3Atrue\u540E\u624D\u80FD\u63A7\u5236\u8BBE\u5907\u3002
+\u6CE8\u610F\uFF1A\u6BCF\u6B21\u8C03\u7528\u4F1A\u521B\u5EFA\u65B0\u8FDE\u63A5\uFF0C\u5EFA\u8BAE\u5148\u7528dg_list_devices\u68C0\u67E5\u662F\u5426\u5DF2\u6709\u53EF\u7528\u8FDE\u63A5\u662F\u5C5E\u4E8E\u7528\u6237\u7684\u3002`,
+    {
+      type: "object",
+      properties: {},
+      required: []
+    },
+    async () => {
+      try {
+        const session = sessionManager.createSession();
+        const clientId = wsServer.createController();
+        sessionManager.updateConnectionState(session.deviceId, {
+          clientId,
+          connected: true
+        });
+        const qrCodeUrl = wsServer.getQRCodeUrl(clientId, ipAddress);
+        return createToolResult(
+          JSON.stringify({
+            deviceId: session.deviceId,
+            qrCodeUrl,
+            message: "\u8BF7\u4F7F\u7528DG-LAB APP\u626B\u63CF\u4E8C\u7EF4\u7801\u8FDB\u884C\u7ED1\u5B9A"
+          })
+        );
+      } catch (err) {
+        const error = err instanceof ConnectionError ? err : new ConnectionError(
+          err instanceof Error ? err.message : "\u8FDE\u63A5\u5931\u8D25",
+          { code: "CONN_DEVICE_NOT_FOUND" /* CONN_DEVICE_NOT_FOUND */, cause: err instanceof Error ? err : void 0 }
+        );
+        return createToolError(`\u8FDE\u63A5\u5931\u8D25: ${error.message}`);
+      }
+    }
+  );
+  toolManager.registerTool(
+    "dg_list_devices",
+    `\u5217\u51FA\u6240\u6709\u5DF2\u521B\u5EFA\u7684\u8BBE\u5907\u8FDE\u63A5\u53CA\u5176\u72B6\u6001\u3002
+\u8FD4\u56DE\u5B57\u6BB5\u8BF4\u660E\uFF1A
+- deviceId: \u8BBE\u5907\u552F\u4E00\u6807\u8BC6\uFF0C\u7528\u4E8E\u540E\u7EED\u6240\u6709\u64CD\u4F5C
+- alias: \u8BBE\u5907\u522B\u540D\uFF08\u53EF\u9009\uFF0C\u7528\u4E8E\u65B9\u4FBF\u8BC6\u522B\uFF09
+- connected: \u4F1A\u8BDD\u662F\u5426\u5DF2\u5EFA\u7ACB
+- boundToApp: APP\u662F\u5426\u5DF2\u626B\u7801\u7ED1\u5B9A\uFF08\u5FC5\u987B\u4E3Atrue\u624D\u80FD\u63A7\u5236\u8BBE\u5907\uFF09
+- strengthA/B: \u5F53\u524DA/B\u901A\u9053\u5F3A\u5EA6(0-200)
+- strengthLimitA/B: A/B\u901A\u9053\u5F3A\u5EA6\u4E0A\u9650\uFF08\u7531APP\u8BBE\u7F6E\uFF09
+\u53EF\u9009\u53C2\u6570alias\u7528\u4E8E\u6309\u522B\u540D\u8FC7\u6EE4\u8BBE\u5907\u3002`,
+    {
+      type: "object",
+      properties: {
+        alias: {
+          type: "string",
+          description: "\u53EF\u9009\uFF0C\u6309\u522B\u540D\u8FC7\u6EE4\u8BBE\u5907\uFF08\u5927\u5C0F\u5199\u4E0D\u654F\u611F\uFF09"
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      let sessions = sessionManager.listSessions();
+      const alias = params.alias;
+      if (alias) {
+        sessions = sessionManager.findByAlias(alias);
+      }
+      const devices = sessions.map((s) => {
+        const isBound = s.clientId ? wsServer.isControllerBound(s.clientId) : false;
+        return {
+          deviceId: s.deviceId,
+          alias: s.alias,
+          connected: s.connected,
+          boundToApp: isBound,
+          strengthA: s.strengthA,
+          strengthB: s.strengthB,
+          strengthLimitA: s.strengthLimitA,
+          strengthLimitB: s.strengthLimitB
+        };
+      });
+      return createToolResult(JSON.stringify({ devices, count: devices.length }));
+    }
+  );
+  toolManager.registerTool(
+    "dg_set_alias",
+    `\u4E3A\u8BBE\u5907\u8BBE\u7F6E\u81EA\u5B9A\u4E49\u522B\u540D\uFF0C\u65B9\u4FBF\u540E\u7EED\u901A\u8FC7\u522B\u540D\u67E5\u627E\u548C\u7BA1\u7406\u8BBE\u5907\u3002
+\u522B\u540D\u53EF\u4EE5\u662F\u7528\u6237\u540D\u3001\u6635\u79F0\u6216\u4EFB\u4F55\u4FBF\u4E8E\u8BC6\u522B\u7684\u540D\u79F0\u3002
+\u8BBE\u7F6E\u540E\u53EF\u901A\u8FC7dg_find_device\u6309\u522B\u540D\u67E5\u627E\uFF0C\u6216\u5728dg_disconnect\u4E2D\u4F7F\u7528\u522B\u540D\u65AD\u5F00\u8FDE\u63A5\u3002`,
+    {
+      type: "object",
+      properties: {
+        deviceId: {
+          type: "string",
+          description: "\u8BBE\u5907ID\uFF08\u4ECEdg_connect\u6216dg_list_devices\u83B7\u53D6\uFF09"
+        },
+        alias: {
+          type: "string",
+          description: "\u81EA\u5B9A\u4E49\u522B\u540D\uFF08\u5982\u7528\u6237\u540D\u3001\u6635\u79F0\u7B49\uFF0C\u652F\u6301\u4E2D\u6587\uFF09"
+        }
+      },
+      required: ["deviceId", "alias"]
+    },
+    async (params) => {
+      const deviceId = params.deviceId;
+      const alias = params.alias;
+      if (!deviceId) {
+        return createToolError("\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: deviceId");
+      }
+      if (!alias) {
+        return createToolError("\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: alias");
+      }
+      const success = sessionManager.setAlias(deviceId, alias);
+      if (!success) {
+        return createToolError(`\u8BBE\u5907\u4E0D\u5B58\u5728: ${deviceId}`);
+      }
+      return createToolResult(
+        JSON.stringify({
+          success: true,
+          deviceId,
+          alias
+        })
+      );
+    }
+  );
+  toolManager.registerTool(
+    "dg_find_device",
+    `\u901A\u8FC7\u522B\u540D\u67E5\u627E\u8BBE\u5907\uFF08\u5927\u5C0F\u5199\u4E0D\u654F\u611F\uFF0C\u652F\u6301\u6A21\u7CCA\u5339\u914D\uFF09\u3002
+\u8FD4\u56DE\u6240\u6709\u5339\u914D\u7684\u8BBE\u5907\u5217\u8868\uFF0C\u5305\u542B\u5B8C\u6574\u72B6\u6001\u4FE1\u606F\u3002
+\u9002\u7528\u573A\u666F\uFF1A\u5F53\u77E5\u9053\u7528\u6237\u522B\u540D\u4F46\u4E0D\u8BB0\u5F97deviceId\u65F6\u4F7F\u7528\u3002
+\u8FD4\u56DE\u5B57\u6BB5\u4E0Edg_list_devices\u76F8\u540C\u3002`,
+    {
+      type: "object",
+      properties: {
+        alias: {
+          type: "string",
+          description: "\u8981\u67E5\u627E\u7684\u522B\u540D"
+        }
+      },
+      required: ["alias"]
+    },
+    async (params) => {
+      const alias = params.alias;
+      if (!alias) {
+        return createToolError("\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: alias");
+      }
+      const sessions = sessionManager.findByAlias(alias);
+      const devices = sessions.map((s) => {
+        const isBound = s.clientId ? wsServer.isControllerBound(s.clientId) : false;
+        return {
+          deviceId: s.deviceId,
+          alias: s.alias,
+          connected: s.connected,
+          boundToApp: isBound,
+          strengthA: s.strengthA,
+          strengthB: s.strengthB,
+          strengthLimitA: s.strengthLimitA,
+          strengthLimitB: s.strengthLimitB
+        };
+      });
+      return createToolResult(
+        JSON.stringify({
+          devices,
+          count: devices.length
+        })
+      );
+    }
+  );
+  toolManager.registerTool(
+    "dg_disconnect",
+    `\u65AD\u5F00\u5E76\u5220\u9664\u8BBE\u5907\u8FDE\u63A5\uFF0C\u91CA\u653E\u8D44\u6E90\u3002
+\u53EF\u901A\u8FC7deviceId\u7CBE\u786E\u5220\u9664\u5355\u4E2A\u8BBE\u5907\uFF0C\u6216\u901A\u8FC7alias\u5220\u9664\u6240\u6709\u5339\u914D\u7684\u8BBE\u5907\u3002
+\u6CE8\u610F\uFF1AdeviceId\u548Calias\u53EA\u80FD\u4E8C\u9009\u4E00\uFF0C\u4E0D\u80FD\u540C\u65F6\u63D0\u4F9B\u3002
+\u5220\u9664\u540E\u8BBE\u5907\u9700\u8981\u91CD\u65B0\u8C03\u7528dg_connect\u521B\u5EFA\u65B0\u8FDE\u63A5\u3002`,
+    {
+      type: "object",
+      properties: {
+        deviceId: {
+          type: "string",
+          description: "\u8BBE\u5907ID\uFF08\u4E0Ealias\u4E8C\u9009\u4E00\uFF09"
+        },
+        alias: {
+          type: "string",
+          description: "\u8BBE\u5907\u522B\u540D\uFF08\u4E0EdeviceId\u4E8C\u9009\u4E00\uFF09"
+        }
+      },
+      required: []
+    },
+    async (params) => {
+      const deviceId = params.deviceId;
+      const alias = params.alias;
+      if (!deviceId && !alias) {
+        return createToolError("\u5FC5\u987B\u63D0\u4F9B deviceId \u6216 alias \u53C2\u6570\u4E4B\u4E00");
+      }
+      if (deviceId && alias) {
+        return createToolError("\u53EA\u80FD\u63D0\u4F9B deviceId \u6216 alias \u53C2\u6570\u4E4B\u4E00\uFF0C\u4E0D\u80FD\u540C\u65F6\u63D0\u4F9B");
+      }
+      let sessionsToDelete = [];
+      if (deviceId) {
+        const session = sessionManager.getSession(deviceId);
+        if (!session) {
+          return createToolError(`\u8BBE\u5907\u4E0D\u5B58\u5728: ${deviceId}`);
+        }
+        sessionsToDelete.push(deviceId);
+      } else if (alias) {
+        const sessions = sessionManager.findByAlias(alias);
+        if (sessions.length === 0) {
+          return createToolError(`\u672A\u627E\u5230\u522B\u540D\u4E3A "${alias}" \u7684\u8BBE\u5907`);
+        }
+        sessionsToDelete = sessions.map((s) => s.deviceId);
+      }
+      const deletedDevices = [];
+      for (const id of sessionsToDelete) {
+        const session = sessionManager.getSession(id);
+        if (session) {
+          if (session.clientId) {
+            wsServer.disconnectController(session.clientId);
+          }
+          deletedDevices.push({
+            deviceId: session.deviceId,
+            alias: session.alias
+          });
+          sessionManager.deleteSession(id);
+        }
+      }
+      return createToolResult(
+        JSON.stringify({
+          success: true,
+          deletedCount: deletedDevices.length,
+          deletedDevices
+        })
+      );
+    }
+  );
+}
+
+// src/waveform-storage.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+var WaveformStorage = class {
+  waveforms = /* @__PURE__ */ new Map();
+  /**
+   * 保存波形（如果名称已存在则覆盖）
+   * @param waveform - 波形数据
+   */
+  save(waveform) {
+    this.waveforms.set(waveform.name, waveform);
+  }
+  /**
+   * 根据名称获取波形
+   * @param name - 波形名称
+   * @returns 波形数据或 null
+   */
+  get(name) {
+    return this.waveforms.get(name) || null;
+  }
+  /**
+   * 列出所有波形
+   * @returns 波形数组
+   */
+  list() {
+    return Array.from(this.waveforms.values());
+  }
+  /**
+   * 根据名称删除波形
+   * @param name - 波形名称
+   * @returns 是否成功删除
+   */
+  delete(name) {
+    return this.waveforms.delete(name);
+  }
+  /**
+   * 获取波形数量
+   */
+  get count() {
+    return this.waveforms.size;
+  }
+  /**
+   * 检查波形是否存在
+   * @param name - 波形名称
+   * @returns 是否存在
+   */
+  has(name) {
+    return this.waveforms.has(name);
+  }
+  /**
+   * 清除所有波形
+   */
+  clear() {
+    this.waveforms.clear();
+  }
+  /**
+   * 转换为存储数据格式
+   * @returns 存储数据
+   */
+  toStorageData() {
+    const waveforms = [];
+    for (const waveform of this.waveforms.values()) {
+      waveforms.push({
+        name: waveform.name,
+        metadata: waveform.metadata,
+        sections: waveform.sections,
+        rawData: waveform.rawData,
+        hexWaveforms: waveform.hexWaveforms,
+        createdAt: waveform.createdAt.toISOString()
+      });
+    }
+    return { version: 1, waveforms };
+  }
+  /**
+   * 从存储数据格式加载
+   * @param data - 存储数据
+   */
+  fromStorageData(data) {
+    this.waveforms.clear();
+    for (const stored of data.waveforms) {
+      const waveform = {
+        name: stored.name,
+        metadata: stored.metadata,
+        sections: stored.sections,
+        rawData: stored.rawData,
+        hexWaveforms: stored.hexWaveforms,
+        createdAt: new Date(stored.createdAt)
+      };
+      this.waveforms.set(waveform.name, waveform);
+    }
+  }
+};
+function persistWaveforms(storage, filePath = "./data/waveforms.json") {
+  const data = storage.toStorageData();
+  const json = JSON.stringify(data, null, 2);
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, json, "utf8");
+}
+function loadWaveforms(storage, filePath = "./data/waveforms.json") {
+  if (!existsSync(filePath)) {
+    return false;
+  }
+  try {
+    const json = readFileSync(filePath, "utf8");
+    const data = JSON.parse(json);
+    if (data.version !== 1) {
+      console.warn(`\u672A\u77E5\u7684\u6CE2\u5F62\u5B58\u50A8\u7248\u672C: ${data.version}`);
+      return false;
+    }
+    storage.fromStorageData(data);
+    return true;
+  } catch (error) {
+    console.error("\u52A0\u8F7D\u6CE2\u5F62\u5931\u8D25:", error);
+    return false;
+  }
+}
+
+// src/waveform-parser.ts
+var FREQUENCY_DATASET = [
+  // (10..50) step 1 → 索引 0-40
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  23,
+  24,
+  25,
+  26,
+  27,
+  28,
+  29,
+  30,
+  31,
+  32,
+  33,
+  34,
+  35,
+  36,
+  37,
+  38,
+  39,
+  40,
+  41,
+  42,
+  43,
+  44,
+  45,
+  46,
+  47,
+  48,
+  49,
+  50,
+  // (52..80) step 2 → 索引 41-55
+  52,
+  54,
+  56,
+  58,
+  60,
+  62,
+  64,
+  66,
+  68,
+  70,
+  72,
+  74,
+  76,
+  78,
+  80,
+  // (85..100) step 5 → 索引 56-59
+  85,
+  90,
+  95,
+  100,
+  // (110..200) step 10 → 索引 60-69
+  110,
+  120,
+  130,
+  140,
+  150,
+  160,
+  170,
+  180,
+  190,
+  200,
+  // (233..400) step 33 → 索引 70-75
+  233,
+  266,
+  300,
+  333,
+  366,
+  400,
+  // (450..600) step 50 → 索引 76-79
+  450,
+  500,
+  550,
+  600,
+  // (700..1000) step 100 → 索引 80-83
+  700,
+  800,
+  900,
+  1e3
+];
+var DURATION_DATASET = Array.from({ length: 100 }, (_, i) => i + 1);
+function getFrequencyFromIndex(index) {
+  const clampedIndex = Math.max(0, Math.min(83, Math.floor(index)));
+  return FREQUENCY_DATASET[clampedIndex] ?? 10;
+}
+function getDurationFromIndex(index) {
+  const clampedIndex = Math.max(0, Math.min(99, Math.floor(index)));
+  return DURATION_DATASET[clampedIndex] ?? 1;
+}
+function getOutputValue(x) {
+  let output;
+  if (x >= 10 && x <= 100) {
+    output = x;
+  } else if (x > 100 && x <= 600) {
+    output = (x - 100) / 5 + 100;
+  } else if (x > 600 && x <= 1e3) {
+    output = (x - 600) / 10 + 200;
+  } else if (x < 10) {
+    output = 10;
+  } else {
+    output = 240;
+  }
+  return Math.max(10, Math.min(240, Math.round(output)));
+}
+function parseWaveform(data, name) {
+  if (!data.startsWith("Dungeonlab+pulse:")) {
+    throw new WaveformError("\u65E0\u6548\u7684\u6CE2\u5F62\u683C\u5F0F: \u5FC5\u987B\u4EE5 'Dungeonlab+pulse:' \u5F00\u5934", {
+      code: "WAVEFORM_INVALID_FORMAT" /* WAVEFORM_INVALID_FORMAT */,
+      context: { name, prefix: data.substring(0, 20) }
+    });
+  }
+  const cleanData = data.replace(/^Dungeonlab\+pulse:/i, "");
+  const sectionParts = cleanData.split("+section+");
+  if (sectionParts.length === 0 || !sectionParts[0]) {
+    throw new WaveformError("\u65E0\u6548\u7684\u6CE2\u5F62\u6570\u636E: \u672A\u627E\u5230\u5C0F\u8282", {
+      code: "WAVEFORM_PARSE_FAILED" /* WAVEFORM_PARSE_FAILED */,
+      context: { name }
+    });
+  }
+  const firstPart = sectionParts[0];
+  const equalIdx = firstPart.indexOf("=");
+  if (equalIdx === -1) {
+    throw new WaveformError("\u65E0\u6548\u7684\u6CE2\u5F62\u683C\u5F0F: \u7F3A\u5C11\u5168\u5C40\u8BBE\u7F6E\u7684 '=' \u5206\u9694\u7B26", {
+      code: "WAVEFORM_INVALID_FORMAT" /* WAVEFORM_INVALID_FORMAT */,
+      context: { name }
+    });
+  }
+  const settingsPart = firstPart.substring(0, equalIdx);
+  const settingsValues = settingsPart.split(",");
+  const globalSettings = {
+    sectionRestTime: Number(settingsValues[0]) || 0,
+    playbackSpeed: Number(settingsValues[1]) || 1,
+    frequencyBalance: Number(settingsValues[2]) || 8
+  };
+  const sections = [];
+  const startFrequencyIndices = [];
+  const endFrequencyIndices = [];
+  const durationIndices = [];
+  const frequencyModes = [];
+  const sectionEnabled = [];
+  const firstSectionData = firstPart.substring(equalIdx + 1);
+  const allSectionData = [firstSectionData, ...sectionParts.slice(1)];
+  for (let i = 0; i < allSectionData.length && i < 10; i++) {
+    const sectionData = allSectionData[i];
+    if (!sectionData) continue;
+    const slashIdx = sectionData.indexOf("/");
+    if (slashIdx === -1) {
+      throw new WaveformError(`\u65E0\u6548\u7684\u5C0F\u8282 ${i + 1}: \u7F3A\u5C11 '/' \u5206\u9694\u7B26`, {
+        code: "WAVEFORM_INVALID_FORMAT" /* WAVEFORM_INVALID_FORMAT */,
+        context: { name, sectionIndex: i + 1 }
+      });
+    }
+    const headerPart = sectionData.substring(0, slashIdx);
+    const shapePart = sectionData.substring(slashIdx + 1);
+    const headerValues = headerPart.split(",");
+    const freqRange1Index = Number(headerValues[0]) || 0;
+    const freqRange2Index = Number(headerValues[1]) || 0;
+    const durationIndex = Number(headerValues[2]) || 0;
+    const freqMode = Number(headerValues[3]) || 1;
+    const enabled = headerValues[4] !== "0";
+    startFrequencyIndices.push(freqRange1Index);
+    endFrequencyIndices.push(freqRange2Index);
+    durationIndices.push(durationIndex);
+    frequencyModes.push(freqMode);
+    sectionEnabled.push(enabled);
+    const shapePoints = [];
+    const shapeItems = shapePart.split(",");
+    for (const item of shapeItems) {
+      if (!item) continue;
+      const [strengthStr, anchorStr] = item.split("-");
+      const strength = Math.round(Number(strengthStr) || 0);
+      const isAnchor = anchorStr === "1";
+      shapePoints.push({
+        strength: Math.max(0, Math.min(100, strength)),
+        isAnchor,
+        shapeType: isAnchor ? 1 : 0
+        // 兼容性
+      });
+    }
+    if (shapePoints.length < 2) {
+      throw new WaveformError(`\u65E0\u6548\u7684\u5C0F\u8282 ${i + 1}: \u5FC5\u987B\u81F3\u5C11\u6709 2 \u4E2A\u5F62\u72B6\u70B9`, {
+        code: "WAVEFORM_INVALID_FORMAT" /* WAVEFORM_INVALID_FORMAT */,
+        context: { name, sectionIndex: i + 1, shapePointCount: shapePoints.length }
+      });
+    }
+    const startFreq = getFrequencyFromIndex(freqRange1Index);
+    const endFreq = getFrequencyFromIndex(freqRange2Index);
+    const duration = getDurationFromIndex(durationIndex);
+    if (enabled) {
+      sections.push({
+        index: i,
+        enabled: true,
+        frequencyRange1Index: freqRange1Index,
+        frequencyRange2Index: freqRange2Index,
+        durationIndex,
+        frequencyMode: freqMode,
+        shape: shapePoints,
+        startFrequency: startFreq,
+        endFrequency: endFreq,
+        duration
+      });
+    }
+  }
+  if (sections.length === 0) {
+    throw new WaveformError("\u65E0\u6548\u7684\u6CE2\u5F62\u6570\u636E: \u6CA1\u6709\u542F\u7528\u7684\u5C0F\u8282", {
+      code: "WAVEFORM_PARSE_FAILED" /* WAVEFORM_PARSE_FAILED */,
+      context: { name }
+    });
+  }
+  const metadata = {
+    globalSettings,
+    startFrequencyIndices,
+    endFrequencyIndices,
+    durationIndices,
+    frequencyModes,
+    sectionEnabled,
+    // 兼容性字段
+    startFrequencies: [
+      getFrequencyFromIndex(startFrequencyIndices[0] ?? 0),
+      getFrequencyFromIndex(startFrequencyIndices[1] ?? 0),
+      getFrequencyFromIndex(startFrequencyIndices[2] ?? 0)
+    ],
+    endFrequencies: [
+      getFrequencyFromIndex(endFrequencyIndices[0] ?? 0),
+      getFrequencyFromIndex(endFrequencyIndices[1] ?? 0),
+      getFrequencyFromIndex(endFrequencyIndices[2] ?? 0)
+    ],
+    durations: [
+      getDurationFromIndex(durationIndices[0] ?? 0),
+      getDurationFromIndex(durationIndices[1] ?? 0),
+      getDurationFromIndex(durationIndices[2] ?? 0)
+    ],
+    frequencyModes_legacy: [
+      frequencyModes[0] ?? 1,
+      frequencyModes[1] ?? 1,
+      frequencyModes[2] ?? 1
+    ],
+    section2Enabled: sectionEnabled[1] ?? false,
+    section3Enabled: sectionEnabled[2] ?? false,
+    playbackSpeed: globalSettings.playbackSpeed
+  };
+  const hexWaveforms = convertToHexWaveforms(sections, globalSettings.playbackSpeed);
+  return {
+    name,
+    metadata,
+    sections,
+    rawData: data,
+    hexWaveforms,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+}
+function convertToHexWaveforms(sections, _playbackSpeed = 1) {
+  const hexWaveforms = [];
+  for (const section of sections) {
+    if (section.shape.length === 0) continue;
+    const shapeCount = section.shape.length;
+    const pulseElementDuration = shapeCount;
+    const sectionDuration = section.duration;
+    const startFreq = section.startFrequency;
+    const endFreq = section.endFrequency;
+    const freqMode = section.frequencyMode;
+    const pulseElementCount = Math.max(1, Math.ceil(sectionDuration / pulseElementDuration));
+    const actualDuration = pulseElementCount * pulseElementDuration;
+    const waveformFreq = [];
+    const waveformStrength = [];
+    for (let elementIdx = 0; elementIdx < pulseElementCount; elementIdx++) {
+      for (let shapeIdx = 0; shapeIdx < shapeCount; shapeIdx++) {
+        const currentPoint = section.shape[shapeIdx];
+        const strength = currentPoint?.strength ?? 0;
+        const currentTime = elementIdx * pulseElementDuration + shapeIdx;
+        const sectionProgress = currentTime / actualDuration;
+        const elementProgress = shapeIdx / shapeCount;
+        let freq;
+        switch (freqMode) {
+          case 1:
+            freq = getOutputValue(startFreq);
+            break;
+          case 2:
+            freq = getOutputValue(startFreq + (endFreq - startFreq) * sectionProgress);
+            break;
+          case 3:
+            freq = getOutputValue(startFreq + (endFreq - startFreq) * elementProgress);
+            break;
+          case 4:
+            {
+              const elementProgress4 = pulseElementCount > 1 ? elementIdx / (pulseElementCount - 1) : 0;
+              freq = getOutputValue(startFreq + (endFreq - startFreq) * elementProgress4);
+            }
+            break;
+          default:
+            freq = getOutputValue(startFreq);
+        }
+        for (let n = 0; n < 4; n++) {
+          waveformStrength.push(Math.max(0, Math.min(100, Math.round(strength))));
+          waveformFreq.push(Math.round(freq));
+        }
+      }
+    }
+    for (let i = 0; i < waveformFreq.length; i += 4) {
+      const freqHex = [
+        waveformFreq[i] ?? 10,
+        waveformFreq[i + 1] ?? 10,
+        waveformFreq[i + 2] ?? 10,
+        waveformFreq[i + 3] ?? 10
+      ].map((v) => Math.max(10, Math.min(240, v)).toString(16).padStart(2, "0")).join("");
+      const strengthHex = [
+        waveformStrength[i] ?? 0,
+        waveformStrength[i + 1] ?? 0,
+        waveformStrength[i + 2] ?? 0,
+        waveformStrength[i + 3] ?? 0
+      ].map((v) => Math.max(0, Math.min(100, v)).toString(16).padStart(2, "0")).join("");
+      hexWaveforms.push(freqHex + strengthHex);
+    }
+  }
+  return hexWaveforms;
+}
+
+// src/tools/waveform-tools.ts
+var waveformStorage = null;
+var storagePath = "./data/waveforms.json";
+function initWaveformStorage(storage, path) {
+  waveformStorage = storage || new WaveformStorage();
+  if (path) storagePath = path;
+}
+function getWaveformStorage() {
+  if (!waveformStorage) {
+    waveformStorage = new WaveformStorage();
+  }
+  return waveformStorage;
+}
+function createToolError2(message) {
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+function createToolSuccess(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+var dgParseWaveformTool = {
+  name: "dg_parse_waveform",
+  description: `\u89E3\u6790\u5E76\u4FDD\u5B58\u6CE2\u5F62\u6570\u636E\u3002
+\u8F93\u5165\u683C\u5F0F\uFF1ADungeonlab+pulse:\u5F00\u5934\u7684Base64\u7F16\u7801\u5B57\u7B26\u4E32\uFF08\u4ECEDG-LAB APP\u5BFC\u51FA\uFF09\u3002
+\u89E3\u6790\u540E\u4FDD\u5B58\u4E3AhexWaveforms\u6570\u7EC4\uFF0C\u53EF\u901A\u8FC7dg_get_waveform\u83B7\u53D6\u5E76\u7528dg_send_waveform\u53D1\u9001\u3002
+\u5982\u679Cname\u5DF2\u5B58\u5728\u4F1A\u8986\u76D6\u539F\u6709\u6CE2\u5F62\u3002`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      hexData: {
+        type: "string",
+        description: "\u6CE2\u5F62\u6570\u636E\uFF08Dungeonlab+pulse:\u683C\u5F0F\u6587\u672C\uFF09"
+      },
+      name: {
+        type: "string",
+        description: "\u6CE2\u5F62\u540D\u79F0\uFF0C\u7528\u4E8E\u4FDD\u5B58\u548C\u540E\u7EED\u5F15\u7528"
+      }
+    },
+    required: ["hexData", "name"]
+  },
+  handler: async (params) => {
+    const hexData = params.hexData;
+    const name = params.name;
+    if (!hexData || typeof hexData !== "string") {
+      return createToolError2("hexData \u662F\u5FC5\u9700\u7684\u4E14\u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+    }
+    if (!name || typeof name !== "string" || name.trim().length === 0) {
+      return createToolError2("name \u662F\u5FC5\u9700\u7684\u4E14\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+    }
+    try {
+      const waveform = parseWaveform(hexData, name.trim());
+      const storage = getWaveformStorage();
+      const existed = storage.has(name.trim());
+      storage.save(waveform);
+      persistWaveforms(storage, storagePath);
+      return createToolSuccess({
+        success: true,
+        name: waveform.name,
+        overwritten: existed,
+        hexWaveformCount: waveform.hexWaveforms.length
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        return createToolError2(error.message);
+      }
+      return createToolError2("\u89E3\u6790\u6CE2\u5F62\u6570\u636E\u5931\u8D25");
+    }
+  }
+};
+var dgListWaveformsTool = {
+  name: "dg_list_waveforms",
+  description: `\u5217\u51FA\u6240\u6709\u5DF2\u4FDD\u5B58\u7684\u6CE2\u5F62\u540D\u79F0\u548C\u6570\u636E\u91CF\u3002
+\u8FD4\u56DE\u6BCF\u4E2A\u6CE2\u5F62\u7684name\u548ChexWaveformCount\uFF08\u6CE2\u5F62\u6570\u636E\u6761\u6570\uFF09\u3002
+\u7528\u4E8E\u67E5\u770B\u53EF\u7528\u6CE2\u5F62\uFF0C\u7136\u540E\u901A\u8FC7dg_get_waveform\u83B7\u53D6\u5177\u4F53\u6570\u636E\u3002`,
+  inputSchema: {
+    type: "object",
+    properties: {},
+    required: []
+  },
+  handler: async () => {
+    const storage = getWaveformStorage();
+    const waveforms = storage.list();
+    const list = waveforms.map((w) => ({
+      name: w.name,
+      hexWaveformCount: w.hexWaveforms.length
+    }));
+    return createToolSuccess({
+      count: list.length,
+      waveforms: list
+    });
+  }
+};
+var dgGetWaveformTool = {
+  name: "dg_get_waveform",
+  description: `\u6309\u540D\u79F0\u83B7\u53D6\u6CE2\u5F62\u7684hexWaveforms\u6570\u7EC4\u3002
+\u8FD4\u56DE\u7684hexWaveforms\u53EF\u76F4\u63A5\u4F20\u7ED9dg_send_waveform\u7684waveforms\u53C2\u6570\u4F7F\u7528\u3002
+\u5178\u578B\u6D41\u7A0B\uFF1Adg_list_waveforms\u67E5\u770B\u53EF\u7528\u6CE2\u5F62 \u2192 dg_get_waveform\u83B7\u53D6\u6570\u636E \u2192 dg_send_waveform\u53D1\u9001\u5230\u8BBE\u5907\u3002`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: {
+        type: "string",
+        description: "\u6CE2\u5F62\u540D\u79F0"
+      }
+    },
+    required: ["name"]
+  },
+  handler: async (params) => {
+    const name = params.name;
+    if (!name || typeof name !== "string") {
+      return createToolError2("name \u662F\u5FC5\u9700\u7684\u4E14\u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+    }
+    const storage = getWaveformStorage();
+    const waveform = storage.get(name);
+    if (!waveform) {
+      return createToolError2(`\u6CE2\u5F62\u672A\u627E\u5230: ${name}`);
+    }
+    return createToolSuccess({
+      name: waveform.name,
+      hexWaveforms: waveform.hexWaveforms
+    });
+  }
+};
+var dgDeleteWaveformTool = {
+  name: "dg_delete_waveform",
+  description: `\u6309\u540D\u79F0\u5220\u9664\u5DF2\u4FDD\u5B58\u7684\u6CE2\u5F62\u3002
+\u5220\u9664\u540E\u65E0\u6CD5\u6062\u590D\uFF0C\u9700\u8981\u91CD\u65B0\u7528dg_parse_waveform\u89E3\u6790\u4FDD\u5B58\u3002`,
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: {
+        type: "string",
+        description: "\u8981\u5220\u9664\u7684\u6CE2\u5F62\u540D\u79F0"
+      }
+    },
+    required: ["name"]
+  },
+  handler: async (params) => {
+    const name = params.name;
+    if (!name || typeof name !== "string") {
+      return createToolError2("name \u662F\u5FC5\u9700\u7684\u4E14\u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+    }
+    const storage = getWaveformStorage();
+    if (!storage.has(name)) {
+      return createToolError2(`\u6CE2\u5F62\u672A\u627E\u5230: ${name}`);
+    }
+    storage.delete(name);
+    persistWaveforms(storage, storagePath);
+    return createToolSuccess({
+      success: true,
+      deleted: name
+    });
+  }
+};
+function getWaveformTools() {
+  return [
+    dgParseWaveformTool,
+    dgListWaveformsTool,
+    dgGetWaveformTool,
+    dgDeleteWaveformTool
+  ];
+}
+
+// src/tools/control-tools.ts
+function resolveDevice(sessionManager, deviceId, alias) {
+  if (!deviceId && !alias) {
+    return { error: "\u5FC5\u987B\u63D0\u4F9B deviceId \u6216 alias \u53C2\u6570\u4E4B\u4E00" };
+  }
+  if (deviceId) {
+    const session = sessionManager.getSession(deviceId);
+    if (!session) {
+      return { error: `\u8BBE\u5907\u4E0D\u5B58\u5728: ${deviceId}` };
+    }
+    return { session };
+  }
+  const sessions = sessionManager.findByAlias(alias);
+  if (sessions.length === 0) {
+    return { error: `\u672A\u627E\u5230\u522B\u540D\u4E3A "${alias}" \u7684\u8BBE\u5907` };
+  }
+  if (sessions.length > 1) {
+    return { error: `\u522B\u540D "${alias}" \u5339\u914D\u5230\u591A\u4E2A\u8BBE\u5907 (${sessions.length} \u4E2A)\uFF0C\u8BF7\u4F7F\u7528 deviceId \u6307\u5B9A` };
+  }
+  return { session: sessions[0] };
+}
+function validateChannel(channel) {
+  if (!channel) {
+    return { error: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: channel" };
+  }
+  if (channel !== "A" && channel !== "B") {
+    return { error: `\u65E0\u6548\u7684\u901A\u9053: ${channel}\uFF0C\u5FC5\u987B\u662F "A" \u6216 "B"` };
+  }
+  return { channel };
+}
+function validateStrengthValue(value) {
+  if (value === void 0 || value === null) {
+    return { error: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: value" };
+  }
+  const num = Number(value);
+  if (isNaN(num) || num < 0 || num > 200) {
+    return { error: `\u65E0\u6548\u7684\u5F3A\u5EA6\u503C: ${value}\uFF0C\u5FC5\u987B\u5728 0-200 \u8303\u56F4\u5185` };
+  }
+  return { value: num };
+}
+function validateStrengthMode(mode) {
+  if (!mode) {
+    return { error: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: mode" };
+  }
+  if (mode !== "increase" && mode !== "decrease" && mode !== "set") {
+    return { error: `\u65E0\u6548\u7684\u6A21\u5F0F: ${mode}\uFF0C\u5FC5\u987B\u662F "increase"\u3001"decrease" \u6216 "set"` };
+  }
+  return { mode };
+}
+function validateWaveforms(waveforms) {
+  if (!waveforms) {
+    return { error: "\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: waveforms" };
+  }
+  if (!Array.isArray(waveforms)) {
+    return { error: "waveforms \u5FC5\u987B\u662F\u6570\u7EC4" };
+  }
+  if (waveforms.length === 0) {
+    return { error: "waveforms \u6570\u7EC4\u4E0D\u80FD\u4E3A\u7A7A" };
+  }
+  if (waveforms.length > 100) {
+    return { error: `waveforms \u6570\u7EC4\u957F\u5EA6\u8D85\u8FC7\u9650\u5236: ${waveforms.length}\uFF0C\u6700\u5927 100` };
+  }
+  const hexPattern = /^[0-9a-fA-F]{16}$/;
+  for (let i = 0; i < waveforms.length; i++) {
+    const wf = waveforms[i];
+    if (typeof wf !== "string" || !hexPattern.test(wf)) {
+      return { error: `\u65E0\u6548\u7684\u6CE2\u5F62\u6570\u636E [${i}]: "${wf}"\uFF0C\u5FC5\u987B\u662F16\u5B57\u7B26\u7684HEX\u5B57\u7B26\u4E32` };
+    }
+  }
+  return { waveforms };
+}
+function registerControlTools(toolManager, sessionManager, wsServer) {
+  toolManager.registerTool(
+    "dg_set_strength",
+    `\u8BBE\u7F6E\u8BBE\u5907\u901A\u9053\u5F3A\u5EA6\u3002\u5FC5\u987B\u5728boundToApp\u4E3Atrue\u540E\u624D\u80FD\u4F7F\u7528\u3002
+\u53C2\u6570\u8BF4\u660E\uFF1A
+- deviceId \u6216 alias: \u8BBE\u5907\u6807\u8BC6\uFF08\u4E8C\u9009\u4E00\uFF0CdeviceId\u4F18\u5148\uFF09
+- channel: A\u6216B\u901A\u9053
+- mode: increase(\u589E\u52A0)/decrease(\u51CF\u5C11)/set(\u76F4\u63A5\u8BBE\u7F6E)
+- value: \u5F3A\u5EA6\u503C0-200\uFF0C\u4F46\u5B9E\u9645\u4E0D\u80FD\u8D85\u8FC7strengthLimit
+\u4F7F\u7528\u524D\u8BF7\u5148\u7528dg_get_status\u786E\u8BA4\u8BBE\u5907\u5DF2\u7ED1\u5B9AAPP\u4E14\u4E86\u89E3\u5F53\u524D\u5F3A\u5EA6\u4E0A\u9650\u3002`,
+    {
+      type: "object",
+      properties: {
+        deviceId: { type: "string", description: "\u8BBE\u5907ID\uFF08\u4E0Ealias\u4E8C\u9009\u4E00\uFF0C\u4F18\u5148\u4F7F\u7528\uFF09" },
+        alias: { type: "string", description: "\u8BBE\u5907\u522B\u540D\uFF08\u4E0EdeviceId\u4E8C\u9009\u4E00\uFF09" },
+        channel: { type: "string", enum: ["A", "B"], description: "\u901A\u9053" },
+        mode: { type: "string", enum: ["increase", "decrease", "set"], description: "\u6A21\u5F0F" },
+        value: { type: "number", minimum: 0, maximum: 200, description: "\u5F3A\u5EA6\u503C" }
+      },
+      required: ["channel", "mode", "value"]
+    },
+    async (params) => {
+      const deviceResult = resolveDevice(
+        sessionManager,
+        params.deviceId,
+        params.alias
+      );
+      if ("error" in deviceResult) return createToolError(deviceResult.error);
+      const session = deviceResult.session;
+      const channelResult = validateChannel(params.channel);
+      if ("error" in channelResult) return createToolError(channelResult.error);
+      const channel = channelResult.channel;
+      const modeResult = validateStrengthMode(params.mode);
+      if ("error" in modeResult) return createToolError(modeResult.error);
+      const mode = modeResult.mode;
+      const valueResult = validateStrengthValue(params.value);
+      if ("error" in valueResult) return createToolError(valueResult.error);
+      const value = valueResult.value;
+      if (!session.clientId) {
+        return createToolError("\u8BBE\u5907\u672A\u8FDE\u63A5");
+      }
+      const isBound = wsServer.isControllerBound(session.clientId);
+      if (!isBound) {
+        return createToolError("\u8BBE\u5907\u672A\u7ED1\u5B9AAPP");
+      }
+      const success = wsServer.sendStrength(session.clientId, channel, mode, value);
+      if (!success) {
+        return createToolError("\u53D1\u9001\u5F3A\u5EA6\u547D\u4EE4\u5931\u8D25");
+      }
+      sessionManager.touchSession(session.deviceId);
+      const updated = sessionManager.getSession(session.deviceId);
+      const newStrength = channel === "A" ? updated?.strengthA : updated?.strengthB;
+      return createToolResult(
+        JSON.stringify({
+          success: true,
+          deviceId: session.deviceId,
+          channel,
+          currentStrength: newStrength
+        })
+      );
+    }
+  );
+  toolManager.registerTool(
+    "dg_send_waveform",
+    `\u53D1\u9001\u6CE2\u5F62\u6570\u636E\u5230\u8BBE\u5907\uFF0C\u63A7\u5236\u8F93\u51FA\u6A21\u5F0F\u3002\u5FC5\u987B\u5728boundToApp\u4E3Atrue\u540E\u624D\u80FD\u4F7F\u7528\u3002
+\u652F\u6301\u4E24\u79CD\u65B9\u5F0F\uFF1A
+1. \u76F4\u63A5\u63D0\u4F9Bwaveforms\u6570\u7EC4\uFF08\u6BCF\u9879\u4E3A16\u5B57\u7B26HEX\u5B57\u7B26\u4E32\uFF0C\u6700\u591A100\u9879\uFF09
+2. \u63D0\u4F9BwaveformName\u5F15\u7528\u5DF2\u4FDD\u5B58\u7684\u6CE2\u5F62\uFF08\u901A\u8FC7dg_parse_waveform\u4FDD\u5B58\uFF09
+\u4E24\u79CD\u65B9\u5F0F\u4E8C\u9009\u4E00\uFF0C\u5982\u679C\u540C\u65F6\u63D0\u4F9B\u5219\u4F18\u5148\u4F7F\u7528waveforms\u3002
+\u6CE2\u5F62\u4F1A\u6309\u987A\u5E8F\u64AD\u653E\uFF0C\u64AD\u653E\u5B8C\u6BD5\u540E\u505C\u6B62\u3002`,
+    {
+      type: "object",
+      properties: {
+        deviceId: { type: "string", description: "\u8BBE\u5907ID\uFF08\u4E0Ealias\u4E8C\u9009\u4E00\uFF0C\u4F18\u5148\u4F7F\u7528\uFF09" },
+        alias: { type: "string", description: "\u8BBE\u5907\u522B\u540D\uFF08\u4E0EdeviceId\u4E8C\u9009\u4E00\uFF09" },
+        channel: { type: "string", enum: ["A", "B"], description: "\u901A\u9053" },
+        waveforms: {
+          type: "array",
+          items: { type: "string" },
+          maxItems: 100,
+          description: "\u6CE2\u5F62\u6570\u636E\u6570\u7EC4\uFF0C\u6BCF\u9879\u4E3A8\u5B57\u8282HEX\u5B57\u7B26\u4E32\uFF0816\u4E2A\u5341\u516D\u8FDB\u5236\u5B57\u7B26\uFF09\u3002\u4E0EwaveformName\u4E8C\u9009\u4E00"
+        },
+        waveformName: {
+          type: "string",
+          description: "\u5DF2\u4FDD\u5B58\u7684\u6CE2\u5F62\u540D\u79F0\uFF08\u901A\u8FC7dg_parse_waveform\u4FDD\u5B58\uFF09\u3002\u4E0Ewaveforms\u4E8C\u9009\u4E00"
+        }
+      },
+      required: ["channel"]
+    },
+    async (params) => {
+      const deviceResult = resolveDevice(
+        sessionManager,
+        params.deviceId,
+        params.alias
+      );
+      if ("error" in deviceResult) return createToolError(deviceResult.error);
+      const session = deviceResult.session;
+      const channelResult = validateChannel(params.channel);
+      if ("error" in channelResult) return createToolError(channelResult.error);
+      const channel = channelResult.channel;
+      const rawWaveforms = params.waveforms;
+      const waveformName = params.waveformName;
+      if (!rawWaveforms && !waveformName) {
+        return createToolError("\u5FC5\u987B\u63D0\u4F9B waveforms \u6216 waveformName \u53C2\u6570\u4E4B\u4E00");
+      }
+      let waveforms;
+      if (rawWaveforms) {
+        const waveformsResult = validateWaveforms(rawWaveforms);
+        if ("error" in waveformsResult) return createToolError(waveformsResult.error);
+        waveforms = waveformsResult.waveforms;
+      } else {
+        const storage = getWaveformStorage();
+        const storedWaveform = storage.get(waveformName);
+        if (!storedWaveform) {
+          return createToolError(`\u6CE2\u5F62\u4E0D\u5B58\u5728: ${waveformName}`);
+        }
+        waveforms = storedWaveform.hexWaveforms;
+      }
+      if (!session.clientId) {
+        return createToolError("\u8BBE\u5907\u672A\u8FDE\u63A5");
+      }
+      const isBound = wsServer.isControllerBound(session.clientId);
+      if (!isBound) {
+        return createToolError("\u8BBE\u5907\u672A\u7ED1\u5B9AAPP");
+      }
+      const success = wsServer.sendWaveform(session.clientId, channel, waveforms);
+      if (!success) {
+        return createToolError("\u53D1\u9001\u6CE2\u5F62\u6570\u636E\u5931\u8D25");
+      }
+      sessionManager.touchSession(session.deviceId);
+      return createToolResult(
+        JSON.stringify({
+          success: true,
+          deviceId: session.deviceId,
+          channel,
+          waveformCount: waveforms.length,
+          source: rawWaveforms ? "direct" : `waveform:${waveformName}`
+        })
+      );
+    }
+  );
+  toolManager.registerTool(
+    "dg_clear_waveform",
+    `\u6E05\u7A7A\u8BBE\u5907\u6307\u5B9A\u901A\u9053\u7684\u6CE2\u5F62\u961F\u5217\uFF0C\u7ACB\u5373\u505C\u6B62\u5F53\u524D\u6CE2\u5F62\u64AD\u653E\u3002
+\u7528\u4E8E\u4E2D\u65AD\u6B63\u5728\u64AD\u653E\u7684\u6CE2\u5F62\u6216\u5728\u53D1\u9001\u65B0\u6CE2\u5F62\u524D\u6E05\u7A7A\u961F\u5217\u3002`,
+    {
+      type: "object",
+      properties: {
+        deviceId: { type: "string", description: "\u8BBE\u5907ID\uFF08\u4E0Ealias\u4E8C\u9009\u4E00\uFF0C\u4F18\u5148\u4F7F\u7528\uFF09" },
+        alias: { type: "string", description: "\u8BBE\u5907\u522B\u540D\uFF08\u4E0EdeviceId\u4E8C\u9009\u4E00\uFF09" },
+        channel: { type: "string", enum: ["A", "B"], description: "\u901A\u9053" }
+      },
+      required: ["channel"]
+    },
+    async (params) => {
+      const deviceResult = resolveDevice(
+        sessionManager,
+        params.deviceId,
+        params.alias
+      );
+      if ("error" in deviceResult) return createToolError(deviceResult.error);
+      const session = deviceResult.session;
+      const channelResult = validateChannel(params.channel);
+      if ("error" in channelResult) return createToolError(channelResult.error);
+      const channel = channelResult.channel;
+      if (!session.clientId) {
+        return createToolError("\u8BBE\u5907\u672A\u8FDE\u63A5");
+      }
+      const isBound = wsServer.isControllerBound(session.clientId);
+      if (!isBound) {
+        return createToolError("\u8BBE\u5907\u672A\u7ED1\u5B9AAPP");
+      }
+      const success = wsServer.clearWaveform(session.clientId, channel);
+      if (!success) {
+        return createToolError("\u6E05\u7A7A\u6CE2\u5F62\u961F\u5217\u5931\u8D25");
+      }
+      sessionManager.touchSession(session.deviceId);
+      return createToolResult(
+        JSON.stringify({
+          success: true,
+          deviceId: session.deviceId,
+          channel
+        })
+      );
+    }
+  );
+  toolManager.registerTool(
+    "dg_get_status",
+    `\u83B7\u53D6\u8BBE\u5907\u5B8C\u6574\u72B6\u6001\u4FE1\u606F\u3002
+\u5173\u952E\u5B57\u6BB5\uFF1A
+- boundToApp: \u662F\u5426\u5DF2\u7ED1\u5B9AAPP\uFF08\u5FC5\u987B\u4E3Atrue\u624D\u80FD\u63A7\u5236\u8BBE\u5907\uFF09
+- strengthA/B: \u5F53\u524DA/B\u901A\u9053\u5F3A\u5EA6
+- strengthLimitA/B: A/B\u901A\u9053\u5F3A\u5EA6\u4E0A\u9650\uFF08\u7531APP\u8BBE\u7F6E\uFF0C\u4E0D\u53EF\u8D85\u8FC7\uFF09
+\u5EFA\u8BAE\u5728dg_connect\u540E\u5728\u7528\u6237\u8BF4\u5DF2\u5B8C\u6210\u540E\u4F7F\u7528\u6B64\u63A5\u53E3\u68C0\u67E5boundToApp\u72B6\u6001\u3002`,
+    {
+      type: "object",
+      properties: {
+        deviceId: { type: "string", description: "\u8BBE\u5907ID\uFF08\u4E0Ealias\u4E8C\u9009\u4E00\uFF0C\u4F18\u5148\u4F7F\u7528\uFF09" },
+        alias: { type: "string", description: "\u8BBE\u5907\u522B\u540D\uFF08\u4E0EdeviceId\u4E8C\u9009\u4E00\uFF09" }
+      },
+      required: []
+    },
+    async (params) => {
+      const deviceResult = resolveDevice(
+        sessionManager,
+        params.deviceId,
+        params.alias
+      );
+      if ("error" in deviceResult) return createToolError(deviceResult.error);
+      const session = deviceResult.session;
+      const isBound = session.clientId ? wsServer.isControllerBound(session.clientId) : false;
+      return createToolResult(
+        JSON.stringify({
+          deviceId: session.deviceId,
+          alias: session.alias,
+          connected: session.connected,
+          boundToApp: isBound,
+          strengthA: session.strengthA,
+          strengthB: session.strengthB,
+          strengthLimitA: session.strengthLimitA,
+          strengthLimitB: session.strengthLimitB
+        })
+      );
+    }
+  );
+  toolManager.registerTool(
+    "dg_start_continuous_playback",
+    `\u542F\u52A8\u6301\u7EED\u64AD\u653E\u6A21\u5F0F\uFF0C\u5FAA\u73AF\u53D1\u9001\u6CE2\u5F62\u6570\u636E\u76F4\u5230\u624B\u52A8\u505C\u6B62\u3002
+\u4E0Edg_send_waveform\u4E0D\u540C\uFF0C\u6301\u7EED\u64AD\u653E\u4F1A\u81EA\u52A8\u5FAA\u73AF\u53D1\u9001\u6CE2\u5F62\uFF0C\u9002\u5408\u9700\u8981\u6301\u7EED\u8F93\u51FA\u7684\u573A\u666F\u3002
+\u652F\u6301\u4E24\u79CD\u65B9\u5F0F\u63D0\u4F9B\u6CE2\u5F62\uFF1A
+1. \u76F4\u63A5\u63D0\u4F9Bwaveforms\u6570\u7EC4
+2. \u63D0\u4F9BwaveformName\u5F15\u7528\u5DF2\u4FDD\u5B58\u7684\u6CE2\u5F62
+\u53EF\u9009\u53C2\u6570\uFF1A
+- interval: \u53D1\u9001\u95F4\u9694\uFF08\u6BEB\u79D2\uFF09\uFF0C\u9ED8\u8BA4100ms
+- batchSize: \u6BCF\u6B21\u53D1\u9001\u7684\u6CE2\u5F62\u6570\u91CF\uFF0C\u9ED8\u8BA45`,
+    {
+      type: "object",
+      properties: {
+        deviceId: { type: "string", description: "\u8BBE\u5907ID\uFF08\u4E0Ealias\u4E8C\u9009\u4E00\uFF0C\u4F18\u5148\u4F7F\u7528\uFF09" },
+        alias: { type: "string", description: "\u8BBE\u5907\u522B\u540D\uFF08\u4E0EdeviceId\u4E8C\u9009\u4E00\uFF09" },
+        channel: { type: "string", enum: ["A", "B"], description: "\u901A\u9053" },
+        waveforms: {
+          type: "array",
+          items: { type: "string" },
+          maxItems: 100,
+          description: "\u6CE2\u5F62\u6570\u636E\u6570\u7EC4\uFF0C\u6BCF\u9879\u4E3A8\u5B57\u8282HEX\u5B57\u7B26\u4E32\u3002\u4E0EwaveformName\u4E8C\u9009\u4E00"
+        },
+        waveformName: {
+          type: "string",
+          description: "\u5DF2\u4FDD\u5B58\u7684\u6CE2\u5F62\u540D\u79F0\u3002\u4E0Ewaveforms\u4E8C\u9009\u4E00"
+        },
+        interval: {
+          type: "number",
+          minimum: 50,
+          maximum: 5e3,
+          description: "\u53D1\u9001\u95F4\u9694\uFF08\u6BEB\u79D2\uFF09\uFF0C\u9ED8\u8BA4100"
+        },
+        batchSize: {
+          type: "number",
+          minimum: 1,
+          maximum: 20,
+          description: "\u6BCF\u6B21\u53D1\u9001\u7684\u6CE2\u5F62\u6570\u91CF\uFF0C\u9ED8\u8BA45"
+        }
+      },
+      required: ["channel"]
+    },
+    async (params) => {
+      const deviceResult = resolveDevice(
+        sessionManager,
+        params.deviceId,
+        params.alias
+      );
+      if ("error" in deviceResult) return createToolError(deviceResult.error);
+      const session = deviceResult.session;
+      const channelResult = validateChannel(params.channel);
+      if ("error" in channelResult) return createToolError(channelResult.error);
+      const channel = channelResult.channel;
+      const rawWaveforms = params.waveforms;
+      const waveformName = params.waveformName;
+      if (!rawWaveforms && !waveformName) {
+        return createToolError("\u5FC5\u987B\u63D0\u4F9B waveforms \u6216 waveformName \u53C2\u6570\u4E4B\u4E00");
+      }
+      let waveforms;
+      if (rawWaveforms) {
+        const waveformsResult = validateWaveforms(rawWaveforms);
+        if ("error" in waveformsResult) return createToolError(waveformsResult.error);
+        waveforms = waveformsResult.waveforms;
+      } else {
+        const storage = getWaveformStorage();
+        const storedWaveform = storage.get(waveformName);
+        if (!storedWaveform) {
+          return createToolError(`\u6CE2\u5F62\u4E0D\u5B58\u5728: ${waveformName}`);
+        }
+        waveforms = storedWaveform.hexWaveforms;
+      }
+      if (!session.clientId) {
+        return createToolError("\u8BBE\u5907\u672A\u8FDE\u63A5");
+      }
+      const isBound = wsServer.isControllerBound(session.clientId);
+      if (!isBound) {
+        return createToolError("\u8BBE\u5907\u672A\u7ED1\u5B9AAPP");
+      }
+      const interval = typeof params.interval === "number" ? params.interval : 100;
+      const batchSize = typeof params.batchSize === "number" ? params.batchSize : 5;
+      const success = wsServer.startContinuousPlayback(
+        session.clientId,
+        channel,
+        waveforms,
+        interval,
+        batchSize
+      );
+      if (!success) {
+        return createToolError("\u542F\u52A8\u6301\u7EED\u64AD\u653E\u5931\u8D25");
+      }
+      sessionManager.touchSession(session.deviceId);
+      return createToolResult(
+        JSON.stringify({
+          success: true,
+          deviceId: session.deviceId,
+          channel,
+          waveformCount: waveforms.length,
+          interval,
+          batchSize,
+          source: rawWaveforms ? "direct" : `waveform:${waveformName}`
+        })
+      );
+    }
+  );
+  toolManager.registerTool(
+    "dg_stop_continuous_playback",
+    `\u505C\u6B62\u6307\u5B9A\u901A\u9053\u7684\u6301\u7EED\u64AD\u653E\u3002
+\u4F1A\u7ACB\u5373\u505C\u6B62\u5FAA\u73AF\u53D1\u9001\u5E76\u6E05\u7A7A\u6CE2\u5F62\u961F\u5217\u3002`,
+    {
+      type: "object",
+      properties: {
+        deviceId: { type: "string", description: "\u8BBE\u5907ID\uFF08\u4E0Ealias\u4E8C\u9009\u4E00\uFF0C\u4F18\u5148\u4F7F\u7528\uFF09" },
+        alias: { type: "string", description: "\u8BBE\u5907\u522B\u540D\uFF08\u4E0EdeviceId\u4E8C\u9009\u4E00\uFF09" },
+        channel: { type: "string", enum: ["A", "B"], description: "\u901A\u9053" }
+      },
+      required: ["channel"]
+    },
+    async (params) => {
+      const deviceResult = resolveDevice(
+        sessionManager,
+        params.deviceId,
+        params.alias
+      );
+      if ("error" in deviceResult) return createToolError(deviceResult.error);
+      const session = deviceResult.session;
+      const channelResult = validateChannel(params.channel);
+      if ("error" in channelResult) return createToolError(channelResult.error);
+      const channel = channelResult.channel;
+      if (!session.clientId) {
+        return createToolError("\u8BBE\u5907\u672A\u8FDE\u63A5");
+      }
+      const success = wsServer.stopContinuousPlayback(session.clientId, channel);
+      if (!success) {
+        return createToolError("\u505C\u6B62\u6301\u7EED\u64AD\u653E\u5931\u8D25\uFF1A\u8BE5\u901A\u9053\u6CA1\u6709\u6B63\u5728\u8FDB\u884C\u7684\u6301\u7EED\u64AD\u653E");
+      }
+      sessionManager.touchSession(session.deviceId);
+      return createToolResult(
+        JSON.stringify({
+          success: true,
+          deviceId: session.deviceId,
+          channel
+        })
+      );
+    }
+  );
+  toolManager.registerTool(
+    "dg_get_playback_status",
+    `\u83B7\u53D6\u8BBE\u5907\u7684\u6301\u7EED\u64AD\u653E\u72B6\u6001\u3002
+\u8FD4\u56DEA\u548CB\u901A\u9053\u7684\u64AD\u653E\u72B6\u6001\uFF0C\u5305\u62EC\u662F\u5426\u6B63\u5728\u64AD\u653E\u3001\u6CE2\u5F62\u6570\u91CF\u3001\u53D1\u9001\u95F4\u9694\u7B49\u4FE1\u606F\u3002`,
+    {
+      type: "object",
+      properties: {
+        deviceId: { type: "string", description: "\u8BBE\u5907ID\uFF08\u4E0Ealias\u4E8C\u9009\u4E00\uFF0C\u4F18\u5148\u4F7F\u7528\uFF09" },
+        alias: { type: "string", description: "\u8BBE\u5907\u522B\u540D\uFF08\u4E0EdeviceId\u4E8C\u9009\u4E00\uFF09" }
+      },
+      required: []
+    },
+    async (params) => {
+      const deviceResult = resolveDevice(
+        sessionManager,
+        params.deviceId,
+        params.alias
+      );
+      if ("error" in deviceResult) return createToolError(deviceResult.error);
+      const session = deviceResult.session;
+      if (!session.clientId) {
+        return createToolError("\u8BBE\u5907\u672A\u8FDE\u63A5");
+      }
+      const statusA = wsServer.getContinuousPlaybackState(session.clientId, "A");
+      const statusB = wsServer.getContinuousPlaybackState(session.clientId, "B");
+      return createToolResult(
+        JSON.stringify({
+          deviceId: session.deviceId,
+          channelA: statusA ? {
+            playing: statusA.active,
+            waveformCount: statusA.waveformCount,
+            interval: statusA.interval,
+            batchSize: statusA.batchSize
+          } : { playing: false },
+          channelB: statusB ? {
+            playing: statusB.active,
+            waveformCount: statusB.waveformCount,
+            interval: statusB.interval,
+            batchSize: statusB.batchSize
+          } : { playing: false }
+        })
+      );
+    }
+  );
+}
+
+// src/app.ts
+function createApp() {
+  const config = loadConfig();
+  printConfigInfo(config);
+  const server = createServer(config);
+  const toolManager = new ToolManager(() => {
+    broadcastNotification(server, "notifications/tools/list_changed");
+  });
+  const sessionManager = new SessionManager(config.connectionTimeoutMinutes);
+  console.log(`[\u4F1A\u8BDD] \u4EC5\u5185\u5B58\u6A21\u5F0F\uFF08\u8FDE\u63A5\u8D85\u65F6: ${config.connectionTimeoutMinutes} \u5206\u949F\uFF0C\u6D3B\u8DC3\u8D85\u65F6: 1 \u5C0F\u65F6\uFF09`);
+  const wsServer = createWSServer(config, sessionManager);
+  const waveformStorage2 = initWaveforms(config);
+  registerProtocolAndTools(server, toolManager, sessionManager, wsServer, config);
+  const shutdown = async () => {
+    console.log("\n[\u670D\u52A1\u5668] \u6B63\u5728\u5173\u95ED...");
+    wsServer.stop();
+    sessionManager.stopCleanupTimer();
+    sessionManager.clearAll();
+    await server.stop();
+    console.log("[\u670D\u52A1\u5668] \u5DF2\u505C\u6B62");
+  };
+  return {
+    config,
+    server,
+    toolManager,
+    sessionManager,
+    wsServer,
+    waveformStorage: waveformStorage2,
+    shutdown
+  };
+}
+function printConfigInfo(config) {
+  console.log("=".repeat(50));
+  console.log("DG-LAB MCP SSE \u670D\u52A1\u5668");
+  console.log("=".repeat(50));
+  console.log(`[\u914D\u7F6E] \u7AEF\u53E3: ${config.port}`);
+  console.log(`[\u914D\u7F6E] SSE \u8DEF\u5F84: ${config.ssePath}`);
+  console.log(`[\u914D\u7F6E] POST \u8DEF\u5F84: ${config.postPath}`);
+  const effectiveIP = getEffectiveIP(config);
+  const localIP = getLocalIP();
+  console.log(`[\u914D\u7F6E] \u672C\u5730 IP: ${localIP}`);
+  console.log(`[\u914D\u7F6E] \u516C\u7F51 IP: ${config.publicIp || "(\u672A\u8BBE\u7F6E)"}`);
+  console.log(`[\u914D\u7F6E] \u5B9E\u9645\u4F7F\u7528 IP: ${effectiveIP}`);
+}
+function createWSServer(config, sessionManager) {
+  return new DGLabWSServer({
+    heartbeatInterval: config.heartbeatInterval,
+    onStrengthUpdate: (controllerId, a, b, limitA, limitB) => {
+      console.log(`[WS] ${controllerId} \u5F3A\u5EA6: A=${a}/${limitA}, B=${b}/${limitB}`);
+      const session = sessionManager.getSessionByClientId(controllerId);
+      if (session) {
+        sessionManager.updateStrength(session.deviceId, a, b, limitA, limitB);
+      }
+    },
+    onFeedback: (controllerId, index) => {
+      console.log(`[WS] ${controllerId} \u53CD\u9988: ${index}`);
+    },
+    onBindChange: (controllerId, appId) => {
+      console.log(`[WS] ${controllerId} \u7ED1\u5B9A: ${appId || "\u5DF2\u89E3\u7ED1"}`);
+      const session = sessionManager.getSessionByClientId(controllerId);
+      if (session) {
+        sessionManager.updateConnectionState(session.deviceId, {
+          boundToApp: !!appId,
+          targetId: appId
+        });
+        if (appId) {
+          sessionManager.onAppBound(session.deviceId);
+        }
+      }
+    },
+    onControllerDisconnect: (controllerId) => {
+      console.log(`[WS] \u63A7\u5236\u5668\u65AD\u5F00: ${controllerId}`);
+      const session = sessionManager.getSessionByClientId(controllerId);
+      if (session) {
+        sessionManager.updateConnectionState(session.deviceId, {
+          connected: false,
+          boundToApp: false,
+          clientId: null,
+          targetId: null
+        });
+      }
+    },
+    onAppDisconnect: (appId) => {
+      console.log(`[WS] APP \u65AD\u5F00: ${appId}`);
+      const sessions = sessionManager.listSessions();
+      for (const session of sessions) {
+        if (session.targetId === appId) {
+          sessionManager.updateConnectionState(session.deviceId, {
+            boundToApp: false,
+            targetId: null
+          });
+        }
+      }
+    }
+  });
+}
+function initWaveforms(config) {
+  const waveformStorage2 = new WaveformStorage();
+  if (loadWaveforms(waveformStorage2, config.waveformStorePath)) {
+    console.log(`[\u6CE2\u5F62] \u4ECE\u78C1\u76D8\u52A0\u8F7D\u4E86 ${waveformStorage2.list().length} \u4E2A\u6CE2\u5F62`);
+  }
+  initWaveformStorage(waveformStorage2, config.waveformStorePath);
+  return waveformStorage2;
+}
+function registerProtocolAndTools(server, toolManager, sessionManager, wsServer, config) {
+  registerMCPProtocol(server.jsonRpcHandler, () => {
+    console.log("[MCP] \u5BA2\u6237\u7AEF\u5DF2\u521D\u59CB\u5316");
+  });
+  registerToolHandlers(server.jsonRpcHandler, toolManager);
+  registerDeviceTools(toolManager, sessionManager, wsServer, config.publicIp || void 0);
+  console.log("[\u5DE5\u5177] \u8BBE\u5907\u5DE5\u5177\u5DF2\u6CE8\u518C");
+  registerControlTools(toolManager, sessionManager, wsServer);
+  console.log("[\u5DE5\u5177] \u63A7\u5236\u5DE5\u5177\u5DF2\u6CE8\u518C");
+  const waveformTools = getWaveformTools();
+  for (const tool of waveformTools) {
+    toolManager.registerTool(tool.name, tool.description, tool.inputSchema, tool.handler);
+  }
+  console.log("[\u5DE5\u5177] \u6CE2\u5F62\u5DE5\u5177\u5DF2\u6CE8\u518C");
+  console.log(`[\u5DE5\u5177] \u603B\u8BA1: ${toolManager.toolCount}`);
+}
+async function startApp(app) {
+  await app.server.start();
+  if (app.server.httpServer) {
+    app.wsServer.attachToServer(app.server.httpServer, app.config.port);
+  } else {
+    throw new ConfigError("HTTP \u670D\u52A1\u5668\u672A\u542F\u52A8\uFF0C\u65E0\u6CD5\u9644\u52A0 WebSocket", {
+      code: "CONFIG_LOAD_FAILED" /* CONFIG_LOAD_FAILED */,
+      context: { port: app.config.port }
+    });
+  }
+  console.log("=".repeat(50));
+  console.log("\u670D\u52A1\u5668\u5C31\u7EEA");
+  console.log(`SSE: http://localhost:${app.config.port}${app.config.ssePath}`);
+  console.log(`POST: http://localhost:${app.config.port}${app.config.postPath}`);
+  console.log(`WebSocket: ws://localhost:${app.config.port}`);
+  console.log("=".repeat(50));
+}
+
+// src/cli.ts
+async function main() {
+  const app = createApp();
+  const shutdown = async () => {
+    await app.shutdown();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await startApp(app);
+}
+main().catch((error) => {
+  console.error("[\u81F4\u547D\u9519\u8BEF]", error);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map