@qqbrowser/openclaw-qbot 0.0.127 → 0.0.129

package/extensions/qbagent-mcp-server-x5uselocal-node/src/server.ts

@@ -1,135 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import express from "express";
-import { BrowserUseTool } from "./browser-use-tool.js";
-import { BROWSER_TOOLS } from "./tools.js";
-
-const HTTP_PORT = Number(process.env.MCP_HTTP_PORT ?? 38789);
-const WS_HOST = process.env.WS_HOST ?? "127.0.0.1";
-const WS_PORT = Number(process.env.WS_PORT ?? 8765); // 默认 8765
-const TOOL_TIMEOUT_MS = Number(process.env.TOOL_TIMEOUT_MS ?? 120000);
-
-const app = express();
-const browserTool = new BrowserUseTool({
-  wsHost: WS_HOST,
-  wsPort: WS_PORT,
-  toolTimeoutMs: TOOL_TIMEOUT_MS,
-});
-
-// 启动 WebSocket 服务器
-await browserTool.startWebSocket();
-console.log(`[server] WebSocket 服务器已启动在 ws://${WS_HOST}:${WS_PORT}`);
-
-// 存储活跃的 SSE transport
-const transports: Map<string, SSEServerTransport> = new Map();
-
-app.get("/sse", async (req, res) => {
-  const transport = new SSEServerTransport("/messages", res);
-  const sessionId = transport.sessionId;
-  transports.set(sessionId, transport);
-
-  res.on("close", () => {
-    transports.delete(sessionId);
-    console.log(`[server] SSE 连接断开: ${sessionId}`);
-  });
-
-  const server = createMcpServer();
-  await server.connect(transport);
-  console.log(`[server] SSE 连接建立: ${sessionId}`);
-});
-
-app.post("/messages", async (req, res) => {
-  const sessionId = req.query.sessionId as string;
-  const transport = transports.get(sessionId);
-  if (!transport) {
-    res.status(404).json({ error: "Session not found" });
-    return;
-  }
-  await transport.handlePostMessage(req, res);
-});
-
-function createMcpServer(): Server {
-  const server = new Server(
-    { name: "x5use-browser-control", version: "0.1.0" },
-    { capabilities: { tools: {} } },
-  );
-
-  // 处理 tools/list 请求
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-      tools: BROWSER_TOOLS.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        inputSchema: tool.schema,
-      })),
-    };
-  });
-
-  // 处理 tools/call 请求
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args = {} } = request.params;
-    console.log(`[server] Tool "${name}" 收到原始 args:`, JSON.stringify(args, null, 2));
-
-    const result = await browserTool.execute(name, args as Record<string, unknown>);
-    return {
-      content: result.map((item: Record<string, unknown>) => ({
-        type: "text" as const,
-        text: typeof item.text === "string" ? item.text : JSON.stringify(item),
-      })),
-    };
-  });
-
-  return server;
-}
-
-const httpServer = app.listen(HTTP_PORT, "127.0.0.1", () => {
-  console.log(`[server] MCP SSE 服务已启动在 http://127.0.0.1:${HTTP_PORT}`);
-  console.log(`[server] SSE 端点: http://127.0.0.1:${HTTP_PORT}/sse`);
-});
-
-// ===== 父进程退出检测 =====
-// 1. 监听 stdin 关闭（父进程退出时 pipe 会断开）
-process.stdin.resume();
-process.stdin.on("end", () => {
-  console.log("[server] 检测到 stdin 关闭（父进程可能已退出），正在自动关闭服务...");
-  shutdown();
-});
-process.stdin.on("error", () => {
-  console.log("[server] 检测到 stdin 错误（父进程可能已退出），正在自动关闭服务...");
-  shutdown();
-});
-
-// 2. 定期检查父进程是否存活（双重保险）
-const parentPid = process.ppid;
-const parentCheckInterval = setInterval(() => {
-  try {
-    // kill(pid, 0) 仅检查进程是否存在，不发送信号
-    process.kill(parentPid, 0);
-  } catch {
-    console.log(`[server] 父进程 (PID: ${parentPid}) 已退出，正在自动关闭服务...`);
-    clearInterval(parentCheckInterval);
-    shutdown();
-  }
-}, 2000);
-
-// 优雅退出
-let isShuttingDown = false;
-async function shutdown() {
-  if (isShuttingDown) return;
-  isShuttingDown = true;
-
-  console.log("[server] 正在关闭服务...");
-  clearInterval(parentCheckInterval);
-
-  // 关闭 HTTP 服务器，停止接受新连接
-  httpServer.close(() => {
-    console.log("[server] HTTP 服务器已关闭");
-  });
-
-  await browserTool.cleanup();
-  process.exit(0);
-}
-
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);

package/extensions/qbagent-mcp-server-x5uselocal-node/src/tools.ts

@@ -1,205 +0,0 @@
-export interface BrowserToolDef {
-  name: string;
-  description: string;
-  schema: Record<string, unknown>;
-}
-
-export const BROWSER_TOOLS: BrowserToolDef[] = [
-  {
-    name: "go_to_url",
-    description: "Visit a specific URL",
-    schema: {
-      type: "object",
-      properties: {
-        url: { type: "string", description: "The URL to navigate to" },
-      },
-      required: ["url"],
-    },
-  },
-  {
-    name: "go_back",
-    description: "Navigate back",
-    schema: { type: "object", properties: {} },
-  },
-  {
-    name: "wait",
-    description: "Wait for a specified amount of time",
-    schema: {
-      type: "object",
-      properties: {
-        seconds: { type: "integer", description: "Number of seconds to wait" },
-      },
-      required: ["seconds"],
-    },
-  },
-  {
-    name: "click_element",
-    description: "Click on a specific element",
-    schema: {
-      type: "object",
-      properties: {
-        index: { type: "integer", description: "Element index" },
-        xpath: { type: "string", description: "Element XPath" },
-      },
-      required: ["index"],
-    },
-  },
-  {
-    name: "input_text",
-    description: "Input text into a specific element",
-    schema: {
-      type: "object",
-      properties: {
-        index: { type: "integer", description: "Element index" },
-        text: { type: "string", description: "Text to input" },
-        xpath: { type: "string", description: "Element XPath" },
-      },
-      required: ["index", "text"],
-    },
-  },
-  {
-    name: "switch_tab",
-    description: "Switch to <page_id> tab",
-    schema: {
-      type: "object",
-      properties: {
-        page_id: { type: "integer", description: "Tab page ID" },
-      },
-      required: ["page_id"],
-    },
-  },
-  {
-    name: "open_tab",
-    description: "Open a new tab",
-    schema: {
-      type: "object",
-      properties: {
-        url: { type: "string", description: "URL to open in new tab" },
-      },
-      required: ["url"],
-    },
-  },
-  {
-    name: "get_content",
-    description:
-      "Get the content of the current page, in Markdown. Use this tool if you want to record the detailed information of the page, e.g. to generate cross-webpage report.",
-    schema: { type: "object", properties: {} },
-  },
-  {
-    name: "scroll_down",
-    description: "Scroll the page down",
-    schema: {
-      type: "object",
-      properties: {
-        amount: { type: "integer", description: "Scroll amount in pixels" },
-      },
-      required: ["amount"],
-    },
-  },
-  {
-    name: "scroll_up",
-    description: "Scroll the page up",
-    schema: {
-      type: "object",
-      properties: {
-        amount: { type: "integer", description: "Scroll amount in pixels" },
-      },
-      required: ["amount"],
-    },
-  },
-  {
-    name: "send_keys",
-    description: "Send special keys (e.g., Enter, Control+O)",
-    schema: {
-      type: "object",
-      properties: {
-        keys: { type: "string", description: "Keys to send, e.g. Enter, Control+O" },
-      },
-      required: ["keys"],
-    },
-  },
-  {
-    name: "scroll_to_text",
-    description: "Scroll to a specific text on the page",
-    schema: {
-      type: "object",
-      properties: {
-        text: { type: "string", description: "Text to scroll to" },
-      },
-      required: ["text"],
-    },
-  },
-  {
-    name: "get_dropdown_options",
-    description: "Get all options from a dropdown element",
-    schema: {
-      type: "object",
-      properties: {
-        index: { type: "integer", description: "Dropdown element index" },
-      },
-      required: ["index"],
-    },
-  },
-  {
-    name: "select_dropdown_option",
-    description: "Select an option from a dropdown element",
-    schema: {
-      type: "object",
-      properties: {
-        index: { type: "integer", description: "Dropdown element index" },
-        text: { type: "string", description: "Option text to select" },
-      },
-      required: ["index", "text"],
-    },
-  },
-  {
-    name: "done",
-    description: "Complete task with return text and success status",
-    schema: {
-      type: "object",
-      properties: {
-        text: { type: "string", description: "Result text" },
-        success: { type: "boolean", description: "Whether the task succeeded" },
-      },
-      required: ["text", "success"],
-    },
-  },
-  {
-    name: "find_text_on_page",
-    description:
-      "Searches for the specified text on the current webpage and scrolls to its location. If the function is called multiple times with the same text, it will navigate to the next occurrence of the text on subsequent calls.",
-    schema: {
-      type: "object",
-      properties: {
-        search_text: { type: "string", description: "Text to search for" },
-      },
-      required: ["search_text"],
-    },
-  },
-  {
-    name: "scroll_to_bottom",
-    description:
-      "Scrolls the current webpage to the bottom. This can be useful for loading additional content on infinite scrolling pages or for reaching the footer quickly.",
-    schema: { type: "object", properties: {} },
-  },
-  {
-    name: "scroll_to_top",
-    description:
-      "Scrolls the current webpage to the top. This is useful for quickly returning to the beginning of the page.",
-    schema: { type: "object", properties: {} },
-  },
-  {
-    name: "download_file",
-    description: "Download a file with the given index ID. It returns whether start downloading.",
-    schema: {
-      type: "object",
-      properties: {
-        index: { type: "integer", description: "File element index" },
-      },
-      required: ["index"],
-    },
-  },
-];
-
-// 所有工具名称集合，用于快速查找
-export const TOOL_NAMES = new Set(BROWSER_TOOLS.map((t) => t.name));

package/extensions/qbagent-mcp-server-x5uselocal-node/src/websocket-manager.ts

@@ -1,351 +0,0 @@
-import type { IncomingMessage } from "node:http";
-import { v4 as uuidv4 } from "uuid";
-import { WebSocketServer, WebSocket } from "ws";
-
-/** 请求队列项 */
-interface QueueItem {
-  message: { actionName: string; actionParams: string };
-  timeout: number;
-  resolve: (value: string) => void;
-  reject: (reason?: unknown) => void;
-}
-
-// 允许连接的IP地址列表
-const ALLOWED_IPS = ["127.0.0.1", "::1", "::ffff:127.0.0.1"];
-
-interface ClientConnection {
-  ip: string;
-  connectedAt: number;
-  ws: WebSocket;
-}
-
-interface ResponseFuture {
-  resolve: (value: unknown) => void;
-  reject: (reason?: unknown) => void;
-}
-
-export interface WebSocketManagerOptions {
-  host?: string;
-  port?: number;
-}
-
-export class WebSocketManager {
-  /** 已连接的客户端集合 */
-  private _connectedClients: Set<WebSocket> = new Set();
-  /** 客户端连接信息 */
-  private _clientConnections: Map<string, ClientConnection> = new Map();
-  /** 服务器是否已启动 */
-  _serverStarted = false;
-  /** WebSocket 服务器实例 */
-  private _server: WebSocketServer | null = null;
-  /** 当前正在等待响应的 Future（同一时间只有一个） */
-  private _pendingFuture: ResponseFuture | null = null;
-  /** 请求队列（串行化，避免并发竞态） */
-  private _requestQueue: QueueItem[] = [];
-  /** 是否正在处理请求 */
-  private _processing = false;
-
-  private _host: string;
-  private _port: number;
-
-  constructor(options: WebSocketManagerOptions = {}) {
-    this._host = options.host ?? "127.0.0.1";
-    this._port = options.port ?? 8765;
-  }
-
-  /**
-   * 启动 WebSocket 服务器
-   */
-  async startServer(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      try {
-        this._server = new WebSocketServer({
-          host: this._host,
-          port: this._port,
-        });
-
-        this._server.on("listening", () => {
-          console.log(
-            `[WebSocketManager] WebSocket 服务器已启动在 ws://${this._host}:${this._port}`,
-          );
-          console.log(`[WebSocketManager] 允许连接的IP地址: ${ALLOWED_IPS.join(", ")}`);
-          this._serverStarted = true;
-          resolve();
-        });
-
-        this._server.on("connection", (ws: WebSocket, req: IncomingMessage) => {
-          this._handleClient(ws, req);
-        });
-
-        this._server.on("error", (err: Error) => {
-          console.error("[WebSocketManager] 启动 WebSocket 服务器失败:", err);
-          reject(err);
-        });
-      } catch (err) {
-        console.error("[WebSocketManager] 启动 WebSocket 服务器失败:", err);
-        reject(err);
-      }
-    });
-  }
-
-  /**
-   * 处理 WebSocket 客户端连接
-   */
-  private _handleClient(clientWs: WebSocket, req: IncomingMessage): void {
-    const clientIp = req.socket.remoteAddress ?? "unknown";
-    const clientId = uuidv4();
-
-    this._clientConnections.set(clientId, {
-      ip: clientIp,
-      connectedAt: Date.now(),
-      ws: clientWs,
-    });
-    this._connectedClients.add(clientWs);
-
-    console.log(`[WebSocketManager] 新客户端连接 (ID: ${clientId}, IP: ${clientIp})`);
-
-    // 发送初始化消息
-    const initMessage = {
-      type: "init",
-      client_id: clientId,
-      message: "请发送 connection_confirm 消息以确认连接",
-    };
-    const initMessageStr = JSON.stringify(initMessage);
-    clientWs.send(initMessageStr);
-    console.log(`[WebSocketManager] >>> 发送给客户端 ${clientId}: ${initMessageStr}`);
-
-    // 设置心跳检测
-    (clientWs as WebSocket & { isAlive?: boolean }).isAlive = true;
-    clientWs.on("pong", () => {
-      (clientWs as WebSocket & { isAlive?: boolean }).isAlive = true;
-    });
-
-    // 处理接收到的消息
-    clientWs.on("message", (rawMessage: Buffer) => {
-      try {
-        const message = rawMessage.toString();
-        console.log(
-          `[WebSocketManager] <<< 收到客户端 ${clientId} 的消息: ${String(message).slice(0, 50)}`,
-        );
-        const data = JSON.parse(message) as Record<string, unknown>;
-
-        // 处理连接确认消息
-        if (data.type === "connection_confirm") {
-          console.log(`[WebSocketManager] 客户端 ${clientId} 已确认连接`);
-          return;
-        }
-
-        // 将响应交给当前正在等待的 future（串行队列，无需 requestId 匹配）
-        if (this._pendingFuture) {
-          const future = this._pendingFuture;
-          this._pendingFuture = null;
-          // 响应内容优先取 actionResult，否则取整个 data
-          const result = data.actionResult !== undefined ? data.actionResult : data;
-          future.resolve(result);
-          return;
-        }
-
-        console.warn(`[WebSocketManager] 收到响应但没有等待中的请求，忽略: ${message}`);
-      } catch {
-        console.log(
-          `[WebSocketManager] <<< 收到客户端 ${clientId} 的原始消息(非JSON): ${rawMessage.toString()}`,
-        );
-      }
-    });
-
-    // 处理连接关闭
-    clientWs.on("close", (code: number, reason: Buffer) => {
-      console.log(
-        `[WebSocketManager] 客户端 ${clientId} 断开连接 - 状态码: ${code}, 原因: ${reason.toString()}`,
-      );
-      this._handleConnectionClosed(clientWs, clientId);
-    });
-
-    // 处理错误
-    clientWs.on("error", (err: Error) => {
-      console.error(`[WebSocketManager] 客户端 ${clientId} 连接错误:`, err);
-      this._handleConnectionClosed(clientWs, clientId);
-    });
-  }
-
-  /**
-   * 处理连接关闭
-   */
-  private _handleConnectionClosed(clientWs: WebSocket, clientId: string): void {
-    console.log(`[WebSocketManager] 客户端 ${clientId} 断开连接`);
-    this._connectedClients.delete(clientWs);
-    this._clientConnections.delete(clientId);
-    console.log(`[WebSocketManager] 当前连接数: ${this._connectedClients.size}`);
-  }
-
-  /**
-   * 发送消息并等待响应（通过队列串行化，避免并发竞态，无需客户端支持 requestId）
-   */
-  async sendMessage(
-    message: { actionName: string; actionParams: string },
-    timeout = 30000,
-  ): Promise<string> {
-    // 将请求加入队列，返回一个 Promise 等待队列处理完成
-    return new Promise<string>((resolve, reject) => {
-      this._requestQueue.push({ message, timeout, resolve, reject });
-      this._processQueue();
-    });
-  }
-
-  /**
-   * 处理请求队列（串行，每次只处理一个请求）
-   */
-  private _processQueue(): void {
-    // 如果正在处理或队列为空，直接返回
-    if (this._processing || this._requestQueue.length === 0) return;
-    this._processing = true;
-
-    const item = this._requestQueue.shift()!;
-    this._executeRequest(item).finally(() => {
-      this._processing = false;
-      // 处理完后继续处理下一个
-      this._processQueue();
-    });
-  }
-
-  /**
-   * 实际执行单个请求（等待客户端连接、发送消息、等待响应）
-   */
-  private async _executeRequest(item: QueueItem): Promise<void> {
-    const { message, timeout, resolve, reject } = item;
-    const action = message.actionName;
-    const deadline = Date.now() + timeout;
-
-    // 等待客户端连接（受 timeout 约束，避免 MCP 超时后无限阻塞队列）
-    while (this._connectedClients.size === 0) {
-      if (Date.now() >= deadline) {
-        console.warn(`[WebSocketManager] 等待客户端连接超时，放弃请求: ${action}`);
-        reject(new Error(`等待客户端连接超时: ${action}`));
-        return;
-      }
-      console.log("[WebSocketManager] 等待客户端连接...");
-      await new Promise<void>((r) => setTimeout(r, 1000));
-    }
-
-    const sendStartTime = Date.now();
-
-    // 计算剩余超时时间（扣除等待客户端连接消耗的时间）
-    const remainingTimeout = deadline - Date.now();
-    if (remainingTimeout <= 0) {
-      console.warn(`[WebSocketManager] 等待客户端连接后已无剩余时间，放弃请求: ${action}`);
-      reject(new Error(`等待客户端连接后已无剩余时间: ${action}`));
-      return;
-    }
-
-    // 创建 Promise 用于等待响应
-    let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
-    const responsePromise = new Promise<unknown>((res, rej) => {
-      this._pendingFuture = { resolve: res, reject: rej };
-      timeoutHandle = setTimeout(() => {
-        if (this._pendingFuture) {
-          this._pendingFuture = null;
-          rej(new Error(`等待响应超时: ${JSON.stringify(message)}`));
-        }
-      }, remainingTimeout);
-    });
-
-    try {
-      console.log(`[WebSocketManager] 发送消息: ${JSON.stringify(message)}`);
-
-      // 向所有连接的客户端发送消息
-      const closedClients = new Set<WebSocket>();
-      let successCount = 0;
-
-      for (const client of this._connectedClients) {
-        try {
-          let clientId: string | null = null;
-          for (const [cid, conn] of this._clientConnections.entries()) {
-            if (conn.ws === client) {
-              clientId = cid;
-              break;
-            }
-          }
-
-          if (clientId && client.readyState === WebSocket.OPEN) {
-            const msgStr = JSON.stringify(message);
-            console.log(`[WebSocketManager] >>> 发送给客户端 ${clientId}: ${msgStr}`);
-            client.send(msgStr);
-            successCount++;
-          } else {
-            console.warn("[WebSocketManager] 找不到客户端ID或连接不可用，跳过发送消息");
-            closedClients.add(client);
-          }
-        } catch (err) {
-          console.warn(
-            `[WebSocketManager] 向客户端发送消息失败: ${err instanceof Error ? err.message : String(err)}`,
-          );
-          closedClients.add(client);
-        }
-      }
-
-      // 清理已关闭的连接
-      for (const client of closedClients) {
-        this._connectedClients.delete(client);
-        for (const [clientId, conn] of this._clientConnections.entries()) {
-          if (conn.ws === client) {
-            this._clientConnections.delete(clientId);
-            break;
-          }
-        }
-      }
-
-      if (successCount === 0) {
-        if (timeoutHandle) clearTimeout(timeoutHandle);
-        this._pendingFuture = null;
-        resolve("Error: No active client connections");
-        return;
-      }
-
-      console.log(`[WebSocketManager] 消息已成功发送给 ${successCount} 个客户端`);
-
-      // 等待响应
-      const response = await responsePromise;
-      if (timeoutHandle) clearTimeout(timeoutHandle);
-      const elapsed = Date.now() - sendStartTime;
-      console.log(`[WebSocketManager] 收到响应: ${JSON.stringify(response)}`);
-      console.log(`[WebSocketManager] ⏱ 请求耗时 [${action}]: ${elapsed}ms`);
-      resolve(typeof response === "string" ? response : JSON.stringify(response));
-    } catch (err) {
-      if (timeoutHandle) clearTimeout(timeoutHandle);
-      this._pendingFuture = null;
-      console.error(
-        `[WebSocketManager] 发送消息时出错: ${err instanceof Error ? err.message : String(err)}`,
-      );
-      reject(err);
-    }
-  }
-
-  /**
-   * 清理所有资源
-   */
-  async cleanup(): Promise<void> {
-    console.log(`[WebSocketManager] 开始清理连接 - 当前连接数: ${this._connectedClients.size}`);
-
-    for (const clientWs of this._connectedClients) {
-      try {
-        clientWs.close();
-      } catch (err) {
-        console.error("[WebSocketManager] 关闭客户端连接时出错:", err);
-      }
-    }
-
-    this._connectedClients.clear();
-    this._clientConnections.clear();
-    console.log("[WebSocketManager] 所有客户端连接已关闭");
-
-    if (this._server) {
-      return new Promise<void>((resolve) => {
-        this._server!.close(() => {
-          this._server = null;
-          console.log("[WebSocketManager] WebSocket 服务器已关闭");
-          resolve();
-        });
-      });
-    }
-  }
-}