@roxybrowser/openapi 1.0.10-beta.0 → 1.0.10-beta.2

package/lib/cli.cjs

@@ -0,0 +1,3113 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var index_js = require('@modelcontextprotocol/sdk/server/index.js');
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+
+// src/types.ts
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+
+// src/utils/index.ts
+var DEFAULT_CONFIG = {
+  apiHost: "http://127.0.0.1:50000",
+  timeout: 3e4
+};
+var ENV_KEYS = {
+  apiHost: "ROXY_API_HOST",
+  apiKey: "ROXY_API_KEY",
+  timeout: "ROXY_TIMEOUT"
+};
+function resolveConfig() {
+  const envHost = process.env[ENV_KEYS.apiHost];
+  const envKey = process.env[ENV_KEYS.apiKey];
+  const envTimeout = process.env[ENV_KEYS.timeout];
+  return {
+    apiHost: envHost ?? DEFAULT_CONFIG.apiHost,
+    apiKey: envKey ?? "",
+    timeout: envTimeout != null && envTimeout !== "" ? Number.parseInt(envTimeout, 10) : DEFAULT_CONFIG.timeout
+  };
+}
+function requireConfig() {
+  const config = resolveConfig();
+  if (!config.apiKey || config.apiKey.trim() === "") {
+    throw new ConfigError(
+      "API key is required. Set ROXY_API_KEY or pass --api-key. Get your key from RoxyBrowser: API \u2192 API\u914D\u7F6E \u2192 API Key"
+    );
+  }
+  return config;
+}
+async function request(endpoint, options = {}) {
+  const config = requireConfig();
+  const url = `${config.apiHost.replace(/\/$/, "")}${endpoint}`;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        "token": config.apiKey,
+        ...options.headers
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const responseText = await response.text().catch(() => "Unknown error");
+      throw new Error(
+        `HTTP ${response.status}: ${response.statusText} ${responseText}`
+      );
+    }
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+
+// src/modules/account.ts
+var ListAccounts = class {
+  name = "roxy_list_accounts";
+  description = "Get list of accounts (platform credentials) in specified workspace";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      accountId: {
+        type: "number",
+        description: "Account ID to filter by"
+      },
+      pageIndex: {
+        type: "number",
+        description: "Page index for pagination (default: 1)",
+        default: 1
+      },
+      pageSize: {
+        type: "number",
+        description: "Number of items per page (default: 15)",
+        default: 15
+      }
+    },
+    required: ["workspaceId"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("workspaceId", params.workspaceId.toString());
+    if (params.accountId)
+      searchParams.append("accountId", params.accountId.toString());
+    if (params.pageIndex)
+      searchParams.append("page_index", params.pageIndex.toString());
+    if (params.pageSize)
+      searchParams.append("page_size", params.pageSize.toString());
+    const result = await request(`/account/list?${searchParams}`, {
+      method: "GET"
+    });
+    const data = result.data;
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to list accounts:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `Found ${data.total} accounts in workspace ${params.workspaceId}:
+
+${data.rows.map(
+        (account) => `**${account.platformName}** (ID: ${account.id})
+  - Username: ${account.platformUserName}
+  - Platform URL: ${account.platformUrl}
+  - Remarks: ${account.platformRemarks || "N/A"}
+  - Created: ${account.createTime}`
+      ).join("\n\n")}`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var CreateAccount = class {
+  name = "roxy_create_account";
+  description = "Create a new platform account with credentials";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      platformUrl: {
+        type: "string",
+        description: "Business platform URL (e.g., https://www.tiktok.com/)"
+      },
+      platformUserName: {
+        type: "string",
+        description: "Account username"
+      },
+      platformPassword: {
+        type: "string",
+        description: "Account password"
+      },
+      platformEfa: {
+        type: "string",
+        description: "Account EFA"
+      },
+      platformCookies: {
+        type: "array",
+        description: "Account cookies",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            value: { type: "string" },
+            domain: { type: "string" }
+          },
+          required: ["name", "value", "domain"]
+        }
+      },
+      platformName: {
+        type: "string",
+        description: "Platform name"
+      },
+      platformRemarks: {
+        type: "string",
+        description: "Platform remarks/notes"
+      }
+    },
+    required: ["workspaceId", "platformUrl", "platformUserName", "platformPassword"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.platformUrl || !params.platformUserName || !params.platformPassword) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to create account:**\n\n workspaceId, platformUrl, platformUserName, and platformPassword are required"
+          }
+        ]
+      };
+    }
+    const { workspaceId, ...accountData } = params;
+    const result = await request("/account/create", {
+      method: "POST",
+      body: JSON.stringify({ workspaceId, ...accountData })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to create account:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `\u2705 **Account Created Successfully**
+
+**Platform:** ${params.platformName || params.platformUrl}
+**Username:** ${params.platformUserName}
+**Platform URL:** ${params.platformUrl}${params.platformRemarks ? `
+**Remarks:** ${params.platformRemarks}` : ""}${params.platformEfa ? `
+**EFA:** ${params.platformEfa}` : ""}${params.platformCookies && params.platformCookies.length > 0 ? `
+**Cookies:** ${params.platformCookies.length} cookie(s)` : ""}
+
+*Account has been created successfully.*`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var BatchCreateAccounts = class {
+  name = "roxy_batch_create_accounts";
+  description = "Batch create multiple platform accounts";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      accountList: {
+        type: "array",
+        description: "Array of account configurations",
+        items: {
+          type: "object",
+          properties: {
+            platformUrl: { type: "string" },
+            platformUserName: { type: "string" },
+            platformPassword: { type: "string" },
+            platformEfa: { type: "string" },
+            platformCookies: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  value: { type: "string" },
+                  domain: { type: "string" }
+                },
+                required: ["name", "value", "domain"]
+              }
+            },
+            platformName: { type: "string" },
+            platformRemarks: { type: "string" }
+          },
+          required: ["platformUrl", "platformUserName", "platformPassword"]
+        }
+      }
+    },
+    required: ["workspaceId", "accountList"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.accountList || params.accountList.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to batch create accounts:**\n\n workspaceId and accountList are required"
+          }
+        ]
+      };
+    }
+    const { workspaceId, accountList } = params;
+    const result = await request("/account/batch_create", {
+      method: "POST",
+      body: JSON.stringify({ workspaceId, accountList })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to batch create accounts:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `\u2705 **Batch Account Creation Successful**
+
+**Count:** ${params.accountList.length} account(s)
+**Workspace:** ${params.workspaceId}
+
+*All accounts have been created successfully.*`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var ModifyAccount = class {
+  name = "roxy_modify_account";
+  description = "Modify/update an existing platform account";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      id: {
+        type: "number",
+        description: "Account ID to modify"
+      },
+      platformUrl: {
+        type: "string",
+        description: "Business platform URL"
+      },
+      platformUserName: {
+        type: "string",
+        description: "Account username"
+      },
+      platformPassword: {
+        type: "string",
+        description: "Account password"
+      },
+      platformEfa: {
+        type: "string",
+        description: "Account EFA"
+      },
+      platformCookies: {
+        type: "array",
+        description: "Account cookies",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            value: { type: "string" },
+            domain: { type: "string" }
+          },
+          required: ["name", "value", "domain"]
+        }
+      },
+      platformName: {
+        type: "string",
+        description: "Platform name"
+      },
+      platformRemarks: {
+        type: "string",
+        description: "Platform remarks/notes"
+      }
+    },
+    required: ["workspaceId", "id"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.id) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to modify account:**\n\n workspaceId and id are required"
+          }
+        ]
+      };
+    }
+    const { workspaceId, ...accountData } = params;
+    const result = await request("/account/modify", {
+      method: "POST",
+      body: JSON.stringify({ workspaceId, ...accountData })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to modify account:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `\u2705 **Account Modified Successfully**
+
+**Account ID:** ${params.id}${params.platformName ? `
+**Platform:** ${params.platformName}` : ""}${params.platformUrl ? `
+**Platform URL:** ${params.platformUrl}` : ""}${params.platformUserName ? `
+**Username:** ${params.platformUserName}` : ""}${params.platformRemarks ? `
+**Remarks:** ${params.platformRemarks}` : ""}
+
+*Account configuration has been updated.*`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var DeleteAccounts = class {
+  name = "roxy_delete_accounts";
+  description = "Delete one or more platform accounts";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      ids: {
+        type: "array",
+        items: { type: "number" },
+        description: "Array of account IDs to delete"
+      }
+    },
+    required: ["workspaceId", "ids"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.ids || params.ids.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to delete accounts:**\n\n workspaceId and ids are required"
+          }
+        ]
+      };
+    }
+    const { workspaceId, ids } = params;
+    const result = await request("/account/delete", {
+      method: "POST",
+      body: JSON.stringify({ workspaceId, ids })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to delete accounts:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `\u2705 **Accounts Deleted Successfully**
+
+**Count:** ${params.ids.length} account(s)
+**Workspace:** ${params.workspaceId}
+
+**Deleted Account IDs:**
+${params.ids.map((id, index) => `  ${index + 1}. ${id}`).join("\n")}
+
+\u26A0\uFE0F **Warning:** Deleted accounts cannot be recovered.`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var listAccounts = new ListAccounts();
+var createAccount = new CreateAccount();
+var batchCreateAccounts = new BatchCreateAccounts();
+var modifyAccount = new ModifyAccount();
+var deleteAccounts = new DeleteAccounts();
+
+// src/modules/proxy.ts
+var channelList = [
+  {
+    label: "IPRust.io",
+    type: "checkChannel",
+    value: "http://iprust.io/ip.json"
+  },
+  {
+    label: "IP-API",
+    type: "checkChannel",
+    value: "http://pro.ip-api.com/json?key=c1ulk9X5j8NKqTV"
+  },
+  {
+    label: "IP123.in",
+    type: "checkChannel",
+    value: "http://ip123.in/ip.json"
+  },
+  {
+    label: "IPinfo",
+    type: "checkChannel",
+    value: "http://ipinfo.io"
+  }
+];
+var ProxyList = class {
+  name = "roxy_list_proxies";
+  /**
+   * 仅当用户没有指定商店时调用
+   */
+  description = "Get list of proxy configurations. If you want to get the list of proxies configurations you've bought, please use `roxy_store_proxies`.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      id: {
+        type: "number",
+        description: "Filter by proxy ID"
+      },
+      pageIndex: {
+        type: "number",
+        description: "Page index for pagination (default: 1)",
+        default: 1
+      },
+      pageSize: {
+        type: "number",
+        description: "Number of items per page (default: 15)",
+        default: 15
+      }
+    },
+    required: ["workspaceId"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("workspaceId", params.workspaceId);
+    if (params.id)
+      searchParams.append("id", params.id);
+    if (params.page_index)
+      searchParams.append("page_index", params.pageIndex);
+    if (params.page_size)
+      searchParams.append("page_size", params.pageSize);
+    if (!params.workspaceId) {
+      throw new Error("workspaceId is required");
+    }
+    const result = await request(`/proxy/list?${searchParams}`);
+    let text = "";
+    if (result.code === 0) {
+      const data = result.data;
+      const proxyListText = data.rows.length > 0 ? data.rows.map((proxy, index) => {
+        const statusText = proxy.checkStatus === 1 ? "\u2705 available" : proxy.checkStatus === 2 ? "\u274C unavailable" : "\u23F3 not checked";
+        const name = `proxy (id: ${proxy.id}) ${proxy.remark ? `remark: ${proxy.remark}` : ""}`;
+        const location = proxy.lastCountry ? `${proxy.lastCity || ""}${proxy.lastCity && proxy.lastCountry ? ", " : ""}${proxy.lastCountry}` : null;
+        let baseInfo = `${index + 1}. ${statusText} **${name}**
+protocol: ${proxy.protocol || "N/A"}
+ipType: ${proxy.ipType || "N/A"}
+bind profile count: ${proxy.bindCount || "N/A"}
+Detection channel: ${proxy.checkChannel || "N/A"}`;
+        const ipInfo = [];
+        if (proxy.host && proxy.port) {
+          ipInfo.push(...[proxy.host, ":", proxy.port]);
+          if (proxy.proxyUserName && proxy.proxyPassword) {
+            ipInfo.push(...["@", proxy.proxyUserName, ":", proxy.proxyPassword]);
+          }
+        }
+        if (location) {
+          baseInfo += `
+${ipInfo.length > 0 ? `${ipInfo.join("")}
+` : ""}
+\u{1F4CD} ${location}`;
+        }
+        return baseInfo;
+      }).join("\n\n") : "";
+      text = `\u{1F4CB} **proxy list** (total: ${data.total})
+
+${proxyListText}`;
+    } else {
+      text = `\u274C **get proxy list failed**
+
+${result.msg}`;
+    }
+    return { content: [{ type: "text", text }] };
+  }
+};
+var ProxyStore = class {
+  name = "roxy_store_proxies";
+  description = "Get list of proxy configurations in the Proxy Store";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      pageIndex: {
+        type: "number",
+        description: "Page index for pagination (default: 1)",
+        default: 1
+      },
+      pageSize: {
+        type: "number",
+        description: "Number of items per page (default: 15)",
+        default: 15
+      },
+      type: {
+        type: "number",
+        description: "Type of proxies to get (0: list_use, 1: available_list)",
+        default: 0
+      }
+    },
+    required: ["workspaceId"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("workspaceId", params.workspaceId.toString());
+    if (params.page_index)
+      searchParams.append("page_index", params.page_index.toString());
+    if (params.page_size)
+      searchParams.append("page_size", params.page_size.toString());
+    if (params.type)
+      searchParams.append("type", params.type.toString());
+    const result = await request(`/proxy/bought_list?${searchParams}`);
+    let text = "";
+    if (result.code === 0) {
+      const data = result.data;
+      const proxyListText = data.rows.length > 0 ? data.rows.map((proxy, index) => {
+        const statusText = proxy.checkStatus === 1 ? "\u2705 available" : proxy.checkStatus === 2 ? "\u274C unavailable" : "\u23F3 not checked";
+        const name = `proxy (id: ${proxy.id}) ${proxy.remark ? `remark: ${proxy.remark}` : ""}`;
+        const location = proxy.lastCountry ? `${proxy.lastCity || ""}${proxy.lastCity && proxy.lastCountry ? ", " : ""}${proxy.lastCountry}` : null;
+        let baseInfo = `${index + 1}. ${statusText} **${name}**
+protocol: ${proxy.protocol || "N/A"}
+ipType: ${proxy.ipType || "N/A"}
+bind profile count: ${proxy.bindCount || "N/A"}
+Detection channel: ${proxy.checkChannel || "N/A"}
+expire date: ${proxy.expireDate}`;
+        const ipInfo = [proxy.host, ":", proxy.port];
+        if (proxy.proxyUserName) {
+          ipInfo.push(...[proxy.proxyUserName, "@", proxy.proxyPassword]);
+        }
+        if (location) {
+          baseInfo += `
+${ipInfo.join("")}
+\u{1F4CD} ${location}`;
+        }
+        return baseInfo;
+      }).join("\n\n") : "";
+      text = `\u{1F4CB} **proxy store** (total: ${data.total})
+
+${proxyListText}`;
+    } else {
+      text = `\u274C **get proxy store failed**
+
+${result.msg}`;
+    }
+    return { content: [{ type: "text", text }] };
+  }
+};
+var CreateProxy = class {
+  name = "roxy_create_proxy";
+  description = "Create a new proxy configuration with automatic IP detection";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      protocol: {
+        type: "string",
+        enum: ["HTTP", "HTTPS", "SOCKS5", "SSH"],
+        description: "Proxy protocol type"
+      },
+      host: {
+        type: "string",
+        description: "Proxy host/IP address"
+      },
+      port: {
+        type: "string",
+        description: "Proxy port"
+      },
+      proxyUserName: {
+        type: "string",
+        description: "Proxy username"
+      },
+      proxyPassword: {
+        type: "string",
+        description: "Proxy password"
+      },
+      ipType: {
+        type: "string",
+        enum: ["IPV4", "IPV6"],
+        description: "IP type (default: IPV4)"
+      },
+      checkChannel: {
+        type: "string",
+        enum: channelList.map((item) => item.label),
+        description: "IP detection channel (default: IP123.in)"
+      },
+      refreshUrl: {
+        type: "string",
+        description: "Refresh URL for dynamic proxies"
+      },
+      remark: {
+        type: "string",
+        description: "Proxy remark/notes"
+      }
+    },
+    required: ["workspaceId", "protocol", "host", "port"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.protocol || !params.host || !params.port) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to create proxy:**\n\n workspaceId, protocol, host, and port are required"
+          }
+        ]
+      };
+    }
+    const { workspaceId, ipType = "IPV4", checkChannel = "IP123.in", ...proxyData } = params;
+    const proxyParams = {
+      workspaceId,
+      ...proxyData,
+      ipType,
+      checkChannel: checkChannel ? channelList.find((item) => item.label === checkChannel)?.value : null,
+      proxyCategory: params.protocol
+    };
+    const result = await request("/proxy/create", {
+      method: "POST",
+      body: JSON.stringify(proxyParams)
+    });
+    let text = "";
+    if (result.code !== 0) {
+      if (result.data) {
+        text = `\u274C **Failed to create proxy:**
+
+ error message: ${result.msg}
+
+${result.data.map((item) => `  - index: ${item.index}, error message: ${item.msg.join(", ")}`).join("\n")}`;
+      } else {
+        text = `\u274C **Failed to create proxy:**
+
+ error message: ${result.msg}`;
+      }
+    } else {
+      text = `\u2705 **Proxy Created Successfully**
+
+**Protocol:** ${params.protocol}
+**Host:** ${params.host}:${params.port}${params.proxyUserName ? `
+**Username:** ${params.proxyUserName}` : ""}${params.remark ? `
+**Remark:** ${params.remark}` : ""}${params.checkChannel ? `
+**Check Channel:** ${params.checkChannel}` : ""}
+
+*Proxy configuration created. IP detection will be performed automatically.*`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var BatchCreateProxies = class {
+  name = "roxy_batch_create_proxies";
+  description = "Batch create multiple proxy configurations";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      // checkChannel: {
+      //   type: 'string',
+      //   enum: channelList.map(item => item.label),
+      //   description: 'Default IP detection channel for all proxies',
+      // },
+      proxyList: {
+        type: "array",
+        description: "Array of proxy configurations",
+        items: {
+          type: "object",
+          properties: {
+            protocol: { type: "string", enum: ["HTTP", "HTTPS", "SOCKS5", "SSH"] },
+            host: { type: "string" },
+            port: { type: "string" },
+            proxyUserName: { type: "string" },
+            proxyPassword: { type: "string" },
+            ipType: { type: "string", enum: ["IPV4", "IPV6"] },
+            checkChannel: { type: "string", enum: channelList.map((item) => item.label) },
+            refreshUrl: { type: "string" },
+            remark: { type: "string" }
+          },
+          required: ["protocol", "host", "port"]
+        }
+      }
+    },
+    required: ["workspaceId", "proxyList"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.proxyList || params.proxyList.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to batch create proxies:**\n\n workspaceId and proxyList are required"
+          }
+        ]
+      };
+    }
+    const { workspaceId, proxyList: proxyList2 } = params;
+    proxyList2.forEach((item) => {
+      item.ipType = item.ipType ? item.ipType : "IPV4";
+      item.checkChannel = item.checkChannel ? channelList.find((channel) => channel.label === item.checkChannel)?.value : null;
+    });
+    const result = await request("/proxy/batch_create", {
+      method: "POST",
+      body: JSON.stringify({ workspaceId, proxyList: proxyList2 })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      if (result.data) {
+        text = `\u274C **Failed to batch create proxies:**
+
+ error message: ${result.msg}
+
+${result.data.map((item) => `  - index: ${item.index}, error message: ${item.msg.join(", ")}`).join("\n")}`;
+      } else {
+        text = `\u274C **Failed to batch create proxies:**
+
+ error message: ${result.msg}`;
+      }
+    } else {
+      text = `\u2705 **Batch Proxy Creation Successful**
+
+**Count:** ${params.proxyList.length} proxy/proxies
+**Workspace:** ${params.workspaceId}${params.checkChannel ? `
+**Default Check Channel:** ${params.checkChannel}` : ""}
+
+*All proxies have been created. IP detection will be performed automatically.*`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var DetectProxy = class {
+  name = "roxy_detect_proxy";
+  description = "Detect/test a proxy configuration and update its IP information";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      id: {
+        type: "number",
+        description: "Proxy ID to detect"
+      }
+    },
+    required: ["workspaceId", "id"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.id) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to detect proxy:**\n\n workspaceId and id are required"
+          }
+        ]
+      };
+    }
+    const { workspaceId, id } = params;
+    const result = await request("/proxy/detect", {
+      method: "POST",
+      body: JSON.stringify({ workspaceId, id })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to detect proxy:**
+
+ error message: ${result.msg}`;
+    } else {
+      const data = result.data;
+      if (data) {
+        text = `\u2705 **Proxy Detection ${data.checkStatus === 1 ? "Success" : data.checkStatus === 2 ? "Failed" : ""}**
+
+**ip address:** ${data.lastIp}
+**country:** ${data.lastCountry}
+**city:** ${data.lastCity}
+**timezone:** ${data.timezone ? data.timezone : "N/A"}
+`;
+      } else {
+        text = `\u2705 **Proxy Detection Started**
+
+**Proxy ID:** ${params.id}
+**Workspace:** ${params.workspaceId}
+
+*Proxy detection is in progress. This may take a few seconds. Use \`roxy_list_proxies\` | \`roxy_store_proxies\` to check the updated status.*
+`;
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var ModifyProxy = class {
+  name = "roxy_modify_proxy";
+  description = "Modify/update an existing proxy configuration";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      id: {
+        type: "number",
+        description: "Proxy ID to modify"
+      },
+      protocol: {
+        type: "string",
+        enum: ["HTTP", "HTTPS", "SOCKS5", "SSH"],
+        description: "Proxy protocol type"
+      },
+      host: {
+        type: "string",
+        description: "Proxy host/IP address"
+      },
+      port: {
+        type: "string",
+        description: "Proxy port"
+      },
+      proxyUserName: {
+        type: "string",
+        description: "Proxy username"
+      },
+      proxyPassword: {
+        type: "string",
+        description: "Proxy password"
+      },
+      ipType: {
+        type: "string",
+        enum: ["IPV4", "IPV6"],
+        description: "IP type"
+      },
+      checkChannel: {
+        type: "string",
+        enum: channelList.map((item) => item.label),
+        description: "IP detection channel"
+      },
+      refreshUrl: {
+        type: "string",
+        description: "Refresh URL for dynamic proxies"
+      },
+      remark: {
+        type: "string",
+        description: "Proxy remark/notes"
+      }
+    },
+    required: ["workspaceId", "id"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.id) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to modify proxy:**\n\n workspaceId and id are required"
+          }
+        ]
+      };
+    }
+    const { workspaceId, checkChannel = "IPRust.io", ...proxyData } = params;
+    const proxyParams = {
+      workspaceId,
+      ...proxyData,
+      checkChannel: checkChannel ? channelList.find((item) => item.label === checkChannel)?.value : null,
+      proxyCategory: params.protocol
+    };
+    const result = await request("/proxy/modify", {
+      method: "POST",
+      body: JSON.stringify(proxyParams)
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to modify proxy:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `\u2705 **Proxy Modified Successfully**
+
+**Proxy ID:** ${params.id}${params.protocol ? `
+**Protocol:** ${params.protocol}` : ""}${params.host ? `
+**Host:** ${params.host}${params.port ? `:${params.port}` : ""}` : ""}${params.remark ? `
+**Remark:** ${params.remark}` : ""}
+
+*Proxy configuration has been updated. Use \`roxy_detect_proxy\` to test the new configuration.*`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var DeleteProxies = class {
+  name = "roxy_delete_proxies";
+  description = "Delete one or more proxy configurations";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      ids: {
+        type: "array",
+        items: { type: "number" },
+        description: "Array of proxy IDs to delete"
+      }
+    },
+    required: ["workspaceId", "ids"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.ids || params.ids.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to delete proxies:**\n\n workspaceId and ids are required"
+          }
+        ]
+      };
+    }
+    const { workspaceId, ids } = params;
+    const result = await request("/proxy/delete", {
+      method: "POST",
+      body: JSON.stringify({ workspaceId, ids })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to delete proxies:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `\u2705 **Proxies Deleted Successfully**
+
+**Count:** ${params.ids.length} proxy/proxies
+**Workspace:** ${params.workspaceId}
+
+**Deleted Proxy IDs:**
+${params.ids.map((id, index) => `  ${index + 1}. ${id}`).join("\n")}
+
+\u26A0\uFE0F **Warning:** Deleted proxies cannot be recovered.`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var proxyList = new ProxyList();
+var proxyStore = new ProxyStore();
+var createProxy = new CreateProxy();
+var batchCreateProxies = new BatchCreateProxies();
+var detectProxy = new DetectProxy();
+var modifyProxy = new ModifyProxy();
+var deleteProxies = new DeleteProxies();
+
+// src/modules/browser.ts
+var osversion_windows = [
+  {
+    label: "11",
+    type: "osVersion-Windows",
+    value: "11"
+  },
+  {
+    label: "10",
+    type: "osVersion-Windows",
+    value: "10"
+  },
+  {
+    label: "8",
+    type: "osVersion-Windows",
+    value: "8"
+  },
+  {
+    label: "7",
+    type: "osVersion-Windows",
+    value: "7"
+  }
+];
+var osversion_macos = [
+  {
+    label: "15.3.2",
+    type: "osVersion-macOS",
+    value: "15.3.2"
+  },
+  {
+    label: "15.3.1",
+    type: "osVersion-macOS",
+    value: "15.3.1"
+  },
+  {
+    label: "15.3",
+    type: "osVersion-macOS",
+    value: "15.3"
+  },
+  {
+    label: "15.2",
+    type: "osVersion-macOS",
+    value: "15.2"
+  },
+  {
+    label: "15.1",
+    type: "osVersion-macOS",
+    value: "15.1"
+  },
+  {
+    label: "15.0.1",
+    type: "osVersion-macOS",
+    value: "15.0.1"
+  },
+  {
+    label: "15.0",
+    type: "osVersion-macOS",
+    value: "15.0"
+  },
+  {
+    label: "14.7.4",
+    type: "osVersion-macOS",
+    value: "14.7.4"
+  },
+  {
+    label: "14.7.3",
+    type: "osVersion-macOS",
+    value: "14.7.3"
+  },
+  {
+    label: "14.7.2",
+    type: "osVersion-macOS",
+    value: "14.7.2"
+  },
+  {
+    label: "14.7.1",
+    type: "osVersion-macOS",
+    value: "14.7.1"
+  },
+  {
+    label: "14.7",
+    type: "osVersion-macOS",
+    value: "14.7"
+  },
+  {
+    label: "14.6.1",
+    type: "osVersion-macOS",
+    value: "14.6.1"
+  },
+  {
+    label: "14.6",
+    type: "osVersion-macOS",
+    value: "14.6"
+  },
+  {
+    label: "14.5",
+    type: "osVersion-macOS",
+    value: "14.5"
+  },
+  {
+    label: "14.4.1",
+    type: "osVersion-macOS",
+    value: "14.4.1"
+  },
+  {
+    label: "14.4",
+    type: "osVersion-macOS",
+    value: "14.4"
+  },
+  {
+    label: "14.3.1",
+    type: "osVersion-macOS",
+    value: "14.3.1"
+  },
+  {
+    label: "14.3",
+    type: "osVersion-macOS",
+    value: "14.3"
+  },
+  {
+    label: "14.2.1",
+    type: "osVersion-macOS",
+    value: "14.2.1"
+  },
+  {
+    label: "14.2",
+    type: "osVersion-macOS",
+    value: "14.2"
+  },
+  {
+    label: "14.1",
+    type: "osVersion-macOS",
+    value: "14.1"
+  },
+  {
+    label: "13.7.4",
+    type: "osVersion-macOS",
+    value: "13.7.4"
+  },
+  {
+    label: "13.7.3",
+    type: "osVersion-macOS",
+    value: "13.7.3"
+  },
+  {
+    label: "13.7.2",
+    type: "osVersion-macOS",
+    value: "13.7.2"
+  },
+  {
+    label: "13.7.1",
+    type: "osVersion-macOS",
+    value: "13.7.1"
+  },
+  {
+    label: "13.7",
+    type: "osVersion-macOS",
+    value: "13.7"
+  },
+  {
+    label: "ALL",
+    type: "osVersion-macOS",
+    value: "ALL"
+  }
+];
+var osversion_linux = [
+  {
+    label: "ALL",
+    type: "osVersion-Linux",
+    value: "ALL"
+  }
+];
+var osversion_android = [
+  {
+    label: "15",
+    type: "osVersion-Android",
+    value: "15"
+  },
+  {
+    label: "14",
+    type: "osVersion-Android",
+    value: "14"
+  },
+  {
+    label: "13",
+    type: "osVersion-Android",
+    value: "13"
+  },
+  {
+    label: "12",
+    type: "osVersion-Android",
+    value: "12"
+  },
+  {
+    label: "11",
+    type: "osVersion-Android",
+    value: "11"
+  },
+  {
+    label: "10",
+    type: "osVersion-Android",
+    value: "10"
+  },
+  {
+    label: "9",
+    type: "osVersion-Android",
+    value: "9"
+  }
+];
+var osversion_ios = [
+  {
+    label: "18.2",
+    type: "osVersion-IOS",
+    value: "18.2"
+  },
+  {
+    label: "18.1",
+    type: "osVersion-IOS",
+    value: "18.1"
+  },
+  {
+    label: "18.0",
+    type: "osVersion-IOS",
+    value: "18.0"
+  },
+  {
+    label: "17.0",
+    type: "osVersion-IOS",
+    value: "17.0"
+  },
+  {
+    label: "16.6",
+    type: "osVersion-IOS",
+    value: "16.6"
+  },
+  {
+    label: "16.5",
+    type: "osVersion-IOS",
+    value: "16.5"
+  },
+  {
+    label: "16.4",
+    type: "osVersion-IOS",
+    value: "16.4"
+  },
+  {
+    label: "16.3",
+    type: "osVersion-IOS",
+    value: "16.3"
+  },
+  {
+    label: "16.2",
+    type: "osVersion-IOS",
+    value: "16.2"
+  },
+  {
+    label: "16.1",
+    type: "osVersion-IOS",
+    value: "16.1"
+  },
+  {
+    label: "16.0",
+    type: "osVersion-IOS",
+    value: "16.0"
+  },
+  {
+    label: "15.7",
+    type: "osVersion-IOS",
+    value: "15.7"
+  },
+  {
+    label: "15.6",
+    type: "osVersion-IOS",
+    value: "15.6"
+  },
+  {
+    label: "15.5",
+    type: "osVersion-IOS",
+    value: "15.5"
+  },
+  {
+    label: "15.4",
+    type: "osVersion-IOS",
+    value: "15.4"
+  },
+  {
+    label: "15.3",
+    type: "osVersion-IOS",
+    value: "15.3"
+  },
+  {
+    label: "15.2",
+    type: "osVersion-IOS",
+    value: "15.2"
+  },
+  {
+    label: "15.1",
+    type: "osVersion-IOS",
+    value: "15.1"
+  },
+  {
+    label: "15.0",
+    type: "osVersion-IOS",
+    value: "15.0"
+  },
+  {
+    label: "14.7",
+    type: "osVersion-IOS",
+    value: "14.7"
+  },
+  {
+    label: "14.6",
+    type: "osVersion-IOS",
+    value: "14.6"
+  },
+  {
+    label: "14.5",
+    type: "osVersion-IOS",
+    value: "14.5"
+  },
+  {
+    label: "14.4",
+    type: "osVersion-IOS",
+    value: "14.4"
+  },
+  {
+    label: "14.3",
+    type: "osVersion-IOS",
+    value: "14.3"
+  },
+  {
+    label: "14.2",
+    type: "osVersion-IOS",
+    value: "14.2"
+  },
+  {
+    label: "14.1",
+    type: "osVersion-IOS",
+    value: "14.1"
+  },
+  {
+    label: "14.0",
+    type: "osVersion-IOS",
+    value: "14.0"
+  }
+];
+var coreVersion = [
+  {
+    label: "RoxyChrome 144",
+    type: "coreVersion",
+    value: "144"
+  },
+  {
+    label: "RoxyChrome 143",
+    type: "coreVersion",
+    value: "143"
+  },
+  {
+    label: "RoxyChrome 142",
+    type: "coreVersion",
+    value: "142"
+  },
+  {
+    label: "RoxyChrome 141",
+    type: "coreVersion",
+    value: "141"
+  },
+  {
+    label: "RoxyChrome 140",
+    type: "coreVersion",
+    value: "140"
+  },
+  {
+    label: "RoxyChrome 139",
+    type: "coreVersion",
+    value: "139"
+  },
+  {
+    label: "RoxyChrome 138",
+    type: "coreVersion",
+    value: "138"
+  },
+  {
+    label: "RoxyChrome 137",
+    type: "coreVersion",
+    value: "137"
+  },
+  {
+    label: "RoxyChrome 136",
+    type: "coreVersion",
+    value: "136"
+  },
+  {
+    label: "RoxyChrome 135",
+    type: "coreVersion",
+    value: "135"
+  },
+  {
+    label: "RoxyChrome 133",
+    type: "coreVersion",
+    value: "133"
+  },
+  {
+    label: "RoxyChrome 130",
+    type: "coreVersion",
+    value: "130"
+  },
+  {
+    label: "RoxyChrome 125",
+    type: "coreVersion",
+    value: "125"
+  },
+  {
+    label: "RoxyChrome 117",
+    type: "coreVersion",
+    value: "117"
+  },
+  {
+    label: "RoxyChrome 109",
+    type: "coreVersion",
+    value: "109"
+  }
+];
+function osVersionString() {
+  return `Windows: ${osversion_windows.map((item) => item.value).join(",")}; macOS: ${osversion_macos.map((item) => item.value).join(",")}; Linux: ${osversion_linux.map((item) => item.value).join(",")}; Android: ${osversion_android.map((item) => item.value).join(",")}; IOS: ${osversion_ios.map((item) => item.value).join(",")}`;
+}
+var CreateBrowser = class {
+  name = "roxy_create_browser";
+  description = "Create a browser with complete configuration control - for expert users needing full parameter access";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      windowName: {
+        type: "string",
+        description: "Browser window name"
+      },
+      coreVersion: {
+        type: "string",
+        enum: coreVersion.map((item) => item.value),
+        description: "Browser core version. If not provided, the latest available core version will be used."
+      },
+      os: {
+        type: "string",
+        enum: ["Windows", "macOS", "Linux", "IOS", "Android"],
+        description: "Operating system (default: Windows)"
+      },
+      osVersion: {
+        type: "string",
+        description: osVersionString()
+      },
+      userAgent: {
+        type: "string",
+        description: "Custom user agent"
+      },
+      cookie: {
+        type: "array",
+        description: "Cookie list",
+        items: { type: "object" }
+      },
+      searchEngine: {
+        type: "string",
+        enum: ["Google", "Microsoft Bing", "Yahoo", "Yandex", "DuckDuckGo"],
+        description: "Default search engine"
+      },
+      labelIds: {
+        type: "array",
+        items: { type: "number" },
+        description: "Label IDs to assign"
+      },
+      defaultOpenUrl: {
+        type: "array",
+        items: { type: "string" },
+        description: "URLs to open by default"
+      },
+      windowRemark: {
+        type: "string",
+        description: "Window remarks/notes"
+      },
+      projectId: {
+        type: "number",
+        description: "Project ID"
+      },
+      windowPlatformList: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            // 平台账号id，非必传，通过平台账号列表接口【roxy_list_accounts】获取，可以判定已在平台账号列表中的账号，有该参数时其他参数不需要传。
+            id: { type: "number", description: "Platform account ID, which can be obtained from [roxy_list_accounts] (field: id). Used to bind an account that already exists in the platform account list. If this parameter is provided, other parameters do not need to be passed." },
+            platformUrl: { type: "string", description: "Platform URL" },
+            platformUserName: { type: "string", description: "Platform username" },
+            platformPassword: { type: "string", description: "Platform password" },
+            platformEfa: { type: "string", description: "Platform EFA" },
+            platformRemarks: { type: "string", description: "Platform remarks" }
+          }
+        },
+        description: "Platform account information"
+      },
+      proxyInfo: {
+        type: "object",
+        description: "Complete proxy configuration object",
+        properties: {
+          // 如果有 moduleId ，则其他参数不可传递 (moduleId 可通过 roxy_list_proxies 或 roxy_store_proxies 获取) 优先使用该参数来绑定代理IP
+          moduleId: { type: "number", description: `If moduleId is provided, no other parameters may be passed. (moduleId can be obtained via ${proxyList.name} or ${proxyStore.name}. field: id) Priority to use this parameter to bind proxy IP` },
+          proxyMethod: { type: "string", enum: ["custom", "choose", "api"] },
+          proxyCategory: { type: "string", enum: ["noproxy", "HTTP", "HTTPS", "SOCKS5", "SSH"] },
+          ipType: { type: "string", enum: ["IPV4", "IPV6"] },
+          protocol: { type: "string", enum: ["HTTP", "HTTPS", "SOCKS5"] },
+          host: { type: "string" },
+          port: { type: "string" },
+          proxyUserName: { type: "string" },
+          proxyPassword: { type: "string" },
+          refreshUrl: { type: "string" },
+          checkChannel: { type: "string", enum: ["IPRust.io", "IP-API", "IP123.in"] }
+        }
+      },
+      fingerInfo: {
+        type: "object",
+        description: "Complete fingerprint configuration",
+        properties: {
+          // Language and timezone
+          isLanguageBaseIp: { type: "boolean", description: "Follow IP for browser language" },
+          language: { type: "string", description: "Custom browser language" },
+          isDisplayLanguageBaseIp: { type: "boolean", description: "Follow IP for display language" },
+          displayLanguage: { type: "string", description: "Custom display language" },
+          isTimeZone: { type: "boolean", description: "Follow IP for timezone" },
+          timeZone: { type: "string", description: "Custom timezone" },
+          // Geolocation
+          position: { type: "number", enum: [0, 1, 2], description: "Geolocation prompt: 0=ask, 1=allow, 2=deny" },
+          isPositionBaseIp: { type: "boolean", description: "Follow IP for geolocation" },
+          longitude: { type: "string", description: "Custom longitude" },
+          latitude: { type: "string", description: "Custom latitude" },
+          precisionPos: { type: "string", description: "Precision in meters" },
+          // Media settings
+          forbidAudio: { type: "boolean", description: "Enable/disable sound" },
+          forbidImage: { type: "boolean", description: "Enable/disable image loading" },
+          forbiddenPictureSize: { type: "number", description: "Image load size threshold (bytes). When forbidImage is false, set forbiddenPictureSize = 0 to disable all image loading. Default 0." },
+          forbidMedia: { type: "boolean", description: "Enable/disable video playback" },
+          // Window settings
+          openWidth: { type: "string", description: "Window width" },
+          openHeight: { type: "string", description: "Window height" },
+          openBookmarks: { type: "boolean", description: "Enable bookmarks" },
+          positionSwitch: { type: "boolean", description: "Window position switch" },
+          windowRatioPosition: { type: "string", description: "Window position ratio" },
+          isDisplayName: { type: "boolean", description: "Show window name in title bar" },
+          // Sync settings
+          syncBookmark: { type: "boolean", description: "Sync bookmarks" },
+          syncHistory: { type: "boolean", description: "Sync history" },
+          syncTab: { type: "boolean", description: "Sync tabs" },
+          syncCookie: { type: "boolean", description: "Sync cookies" },
+          syncExtensions: { type: "boolean", description: "Sync extensions" },
+          syncPassword: { type: "boolean", description: "Sync saved passwords" },
+          syncIndexedDb: { type: "boolean", description: "Sync IndexedDB" },
+          syncLocalStorage: { type: "boolean", description: "Sync LocalStorage" },
+          // Cleanup settings
+          clearCacheFile: { type: "boolean", description: "Clear cache files on startup" },
+          clearCookie: { type: "boolean", description: "Clear cookies on startup" },
+          clearLocalStorage: { type: "boolean", description: "Clear LocalStorage on startup" },
+          // Advanced settings
+          randomFingerprint: { type: "boolean", description: "Generate random fingerprint" },
+          forbidSavePassword: { type: "boolean", description: "Disable password save prompts" },
+          stopOpenNet: { type: "boolean", description: "Stop opening if network fails" },
+          stopOpenIP: { type: "boolean", description: "Stop opening if IP changes" },
+          stopOpenPosition: { type: "boolean", description: "Stop opening if IP location changes" },
+          openWorkbench: { type: "number", enum: [0, 1, 2], description: "Open workbench: 0=close, 1=open, 2=follow app" },
+          // Display settings
+          resolutionType: { type: "boolean", description: "Custom resolution vs follow system" },
+          resolutionX: { type: "string", description: "Custom resolution width" },
+          resolutionY: { type: "string", description: "Custom resolution height" },
+          fontType: { type: "boolean", description: "Random fonts vs system fonts" },
+          // Browser fingerprint settings
+          webRTC: { type: "number", enum: [0, 1, 2], description: "WebRTC: 0=replace, 1=real, 2=disable" },
+          webGL: { type: "boolean", description: "WebGL: random vs real" },
+          webGLInfo: { type: "boolean", description: "WebGL info: custom vs real" },
+          webGLManufacturer: { type: "string", description: "Custom WebGL manufacturer" },
+          webGLRender: { type: "string", description: "Custom WebGL renderer" },
+          webGpu: { type: "string", enum: ["webgl", "real", "block"], description: "WebGPU setting" },
+          canvas: { type: "boolean", description: "Canvas: random vs real" },
+          audioContext: { type: "boolean", description: "AudioContext: random vs real" },
+          speechVoices: { type: "boolean", description: "Speech Voices: random vs real" },
+          doNotTrack: { type: "boolean", description: "Enable Do Not Track" },
+          clientRects: { type: "boolean", description: "ClientRects: random vs real" },
+          deviceInfo: { type: "boolean", description: "Media devices: random vs real" },
+          deviceNameSwitch: { type: "boolean", description: "Device names: random vs real" },
+          macInfo: { type: "boolean", description: "MAC address: custom vs real" },
+          // Hardware settings
+          hardwareConcurrent: { type: "string", description: "Hardware concurrency" },
+          deviceMemory: { type: "string", description: "Device memory" },
+          // Security settings
+          disableSsl: { type: "boolean", description: "SSL fingerprint settings" },
+          disableSslList: { type: "array", items: { type: "string" }, description: "SSL feature list" },
+          portScanProtect: { type: "boolean", description: "Port scan protection" },
+          portScanList: { type: "string", description: "Port scan whitelist" },
+          useGpu: { type: "boolean", description: "Use GPU acceleration" },
+          sandboxPermission: { type: "boolean", description: "Disable sandbox" },
+          startupParam: { type: "string", description: "Browser startup parameters (--headless=new startup headless)" }
+        }
+      }
+    },
+    required: ["workspaceId"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    const result = await request("/browser/create", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+    const data = result.data;
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to create browser:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `\u2705 **Simple Browser Created**
+
+**Browser ID:** \`${data.dirId}\`
+*Use this browser ID with \`roxy_open_browsers\` to start the browser and get CDP endpoints for automation.*`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var createBrowser = new CreateBrowser();
+var BatchCreateBrowsers = class {
+  name = "roxy_batch_create_browsers";
+  description = "Create multiple browsers in batch by passing an array of browser configurations";
+  inputSchema = {
+    type: "object",
+    properties: {
+      browsers: {
+        type: "array",
+        description: "Array of browser configuration objects to create",
+        items: {
+          type: "object",
+          properties: createBrowser.inputSchema.properties,
+          required: ["workspaceId"]
+        }
+      }
+    },
+    required: ["browsers"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!Array.isArray(params.browsers) || params.browsers.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to create browsers:**\n\n browsers array is required and must not be empty"
+          }
+        ]
+      };
+    }
+    const results = [];
+    const createPromises = params.browsers.map(async (browserParams, index) => {
+      try {
+        const result = await request("/browser/create", {
+          method: "POST",
+          body: JSON.stringify(browserParams)
+        });
+        if (result.code !== 0) {
+          return {
+            index,
+            success: false,
+            error: result.msg
+          };
+        }
+        return {
+          index,
+          success: true,
+          dirId: result.data?.dirId
+        };
+      } catch (error) {
+        return {
+          index,
+          success: false,
+          error: error.message || "Unknown error"
+        };
+      }
+    });
+    const createResults = await Promise.all(createPromises);
+    results.push(...createResults);
+    const successResults = results.filter((r) => r.success);
+    const failureResults = results.filter((r) => !r.success);
+    const successText = successResults.length > 0 ? `\u2705 **Successfully created ${successResults.length} browsers**
+
+${successResults.map(
+      (r) => `  - #${r.index + 1}${r.dirId ? ` (ID: \`${r.dirId}\`)` : ""}`
+    ).join("\n")}` : "";
+    const failureText = failureResults.length > 0 ? `\u274C **Failed to create ${failureResults.length} browsers:**
+
+${failureResults.map(
+      (r) => `  - #${r.index + 1}: ${r.error}`
+    ).join("\n")}` : "";
+    const summaryLines = [
+      `**Total Requests:** ${results.length}`,
+      `**Success:** ${successResults.length}`,
+      `**Failed:** ${failureResults.length}`,
+      "",
+      ...[successText, failureText].filter(Boolean)
+    ];
+    const summaryText = summaryLines.join("\n");
+    return {
+      content: [
+        {
+          type: "text",
+          text: summaryText
+        }
+      ]
+    };
+  }
+};
+var batchCreateBrowsers = new BatchCreateBrowsers();
+var UpdateBrowser = class {
+  name = "roxy_update_browser";
+  description = "Update a browser with complete configuration control - for expert users needing full parameter access";
+  inputSchema = {
+    type: "object",
+    properties: {
+      ...createBrowser.inputSchema.properties
+    },
+    required: ["workspaceId", "dirId"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    const result = await request("/browser/mdf", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to update browser:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = "\u2705 **Browser Updated Successfully**";
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var OpenBrowser = class {
+  name = "roxy_open_browsers";
+  description = "Open one or multiple browsers and return their CDP WebSocket endpoints for automation";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      dirIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of browser directory IDs to open"
+      },
+      forceOpen: {
+        type: "boolean",
+        // 即使浏览器已被其他用户打开，还是强制打开
+        description: "Force open browser even if it is already opened by other users (default: true)",
+        default: true
+      },
+      args: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional browser startup arguments (--headless=new startup headless)"
+      }
+    },
+    required: ["workspaceId", "dirIds"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    const { workspaceId, dirIds, forceOpen = true, args } = params;
+    if (!workspaceId || !Array.isArray(dirIds) || dirIds.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to open browsers:**\n\n workspaceId and dirIds are required, and dirIds must not be empty"
+          }
+        ]
+      };
+    }
+    const results = [];
+    const openPromises = dirIds.map(async (dirId) => {
+      try {
+        const result = await request("/browser/open", {
+          method: "POST",
+          body: JSON.stringify({
+            workspaceId,
+            dirId,
+            forceOpen,
+            args
+          })
+        });
+        if (result.code !== 0) {
+          return {
+            dirId,
+            success: false,
+            error: result.msg
+          };
+        }
+        return {
+          dirId,
+          success: true,
+          data: result.data
+        };
+      } catch (error) {
+        return {
+          dirId,
+          success: false,
+          error: error.message || "Unknown error"
+        };
+      }
+    });
+    const openResults = await Promise.all(openPromises);
+    results.push(...openResults);
+    const successResults = results.filter((r) => r.success);
+    const failureResults = results.filter((r) => !r.success);
+    const successText = successResults.length > 0 ? [
+      `\u2705 **Successfully opened ${successResults.length} browser(s):**`,
+      "",
+      ...successResults.map((r) => {
+        const data = r.data || {};
+        return [
+          `**Browser ${data.dirId || r.dirId || "Unknown"}** (PID:${data.pid ?? "Unknown"})`,
+          `  - CDP WebSocket: \`${data.ws ?? "N/A"}\``,
+          `  - HTTP Endpoint: \`${data.http ?? "N/A"}\``,
+          `  - Core Version: ${data.coreVersion ?? "Unknown"}`
+        ].join("\n");
+      })
+    ].join("\n") : "";
+    const failureText = failureResults.length > 0 ? [
+      `\u274C **Failed to open ${failureResults.length} browser(s):**`,
+      "",
+      ...failureResults.map(
+        (r) => `  - ${r.dirId}: ${r.error}`
+      )
+    ].join("\n") : "";
+    const summaryLines = [
+      `**Workspace:** ${workspaceId}`,
+      `**Total Requests:** ${results.length}`,
+      `**Success:** ${successResults.length}`,
+      `**Failed:** ${failureResults.length}`,
+      "",
+      ...[successText, failureText].filter(Boolean)
+    ];
+    const summaryText = summaryLines.join("\n");
+    return {
+      content: [
+        {
+          type: "text",
+          text: summaryText
+        }
+      ]
+    };
+  }
+};
+var ListBrowsers = class {
+  name = "roxy_list_browsers";
+  description = "Get list of browsers in specified workspace/project";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      projectIds: {
+        type: "string",
+        description: "Comma-separated project IDs"
+      },
+      windowName: {
+        type: "string",
+        description: "Filter by browser window name"
+      },
+      pageIndex: {
+        type: "number",
+        description: "Page index for pagination (default: 1)",
+        default: 1
+      },
+      pageSize: {
+        type: "number",
+        description: "Number of items per page (default: 15)",
+        default: 15
+      }
+    },
+    required: ["workspaceId"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    const searchParams = new URLSearchParams();
+    searchParams.append("workspaceId", params.workspaceId.toString());
+    if (params.projectIds)
+      searchParams.append("projectIds", params.projectIds);
+    if (params.windowName)
+      searchParams.append("windowName", params.windowName);
+    if (params.pageIndex)
+      searchParams.append("page_index", params.pageIndex.toString());
+    if (params.pageSize)
+      searchParams.append("page_size", params.pageSize.toString());
+    const result = await request(`/browser/list_v3?${searchParams}`, {
+      method: "GET"
+    });
+    const data = result.data;
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to list browsers:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `Found ${data.total} browsers in workspace ${params.workspaceId}:
+
+${data.rows.map(
+        (browser) => `**${browser.windowName || "Unnamed"}** (ID: ${browser.dirId})
+  - Project: ${browser.projectId}
+  - Sort: ${browser.sortNum}
+  - OS: ${browser.os}
+  - Status: ${browser.status}`
+      ).join("\n\n")}`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var CloseBrowsers = class {
+  name = "roxy_close_browsers";
+  description = "Close multiple browsers by their directory IDs";
+  inputSchema = {
+    type: "object",
+    properties: {
+      dirIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of browser directory IDs to close"
+      }
+    },
+    required: ["dirIds"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.dirIds || params.dirIds.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to close browsers:**\n\n dirIds are required"
+          }
+        ]
+      };
+    }
+    const results = [];
+    const closePromises = params.dirIds.map(async (dirId) => {
+      try {
+        const result = await request("/browser/close", {
+          method: "POST",
+          body: JSON.stringify({ dirId })
+        });
+        if (result.code !== 0) {
+          return { dirId, success: false, error: result.msg };
+        }
+        return { dirId, success: true };
+      } catch (error) {
+        return { dirId, success: false, error: error.message || "Unknown error" };
+      }
+    });
+    const closeResults = await Promise.all(closePromises);
+    results.push(...closeResults);
+    const successCount = results.filter((r) => r.success).length;
+    const failureCount = results.filter((r) => !r.success).length;
+    const successText = successCount > 0 ? `\u2705 Successfully closed ${successCount} browsers` : "";
+    const failureText = failureCount > 0 ? `\u274C Failed to close ${failureCount} browsers:
+${results.filter((r) => !r.success).map(
+      (r) => `  - ${r.dirId}: ${r.error}`
+    ).join("\n")}` : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: [successText, failureText].filter(Boolean).join("\n\n")
+        }
+      ]
+    };
+  }
+};
+var DeleteBrowsers = class {
+  name = "roxy_delete_browsers";
+  description = "Delete multiple browsers permanently by their directory IDs";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      dirIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of browser directory IDs to delete"
+      }
+    },
+    required: ["workspaceId", "dirIds"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.dirIds || params.dirIds.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to delete browsers:**\n\n workspaceId and dirIds are required"
+          }
+        ]
+      };
+    }
+    const result = await request("/browser/delete", {
+      method: "POST",
+      body: JSON.stringify({
+        workspaceId: params.workspaceId,
+        dirIds: params.dirIds,
+        isSoftDelete: true
+      })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Browser Deletion Failed**
+
+**Error:** ${result.msg}
+**Workspace:** ${params.workspaceId}
+**Failed Browsers:** ${params.dirIds.length}
+
+**Browser IDs:**
+${params.dirIds.map((dirId, index) => `  ${index + 1}. \`${dirId}\``).join("\n")}`;
+    } else {
+      text = `\u2705 **Browsers Deleted Successfully**
+
+**Count:** ${params.dirIds.length} browser(s)
+**Workspace:** ${params.workspaceId}
+
+**Deleted Browsers:**
+${params.dirIds.map((dirId, index) => `  ${index + 1}. \`${dirId}\``).join("\n")}`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var GetBrowserDetail = class {
+  name = "roxy_get_browser_detail";
+  description = "Get detailed information for a specific browser window";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      dirId: {
+        type: "string",
+        description: "Browser directory ID"
+      }
+    },
+    required: ["workspaceId", "dirId"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.dirId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to get browser detail:**\n\n workspaceId and dirId are required"
+          }
+        ]
+      };
+    }
+    const searchParams = new URLSearchParams();
+    searchParams.append("workspaceId", params.workspaceId.toString());
+    searchParams.append("dirId", params.dirId);
+    const result = await request(`/browser/detail?${searchParams}`, {
+      method: "GET"
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to get browser detail:**
+
+ error message: ${result.msg}`;
+    } else {
+      const detail = result.data.rows && result.data.rows.length > 0 ? result.data.rows[0] : null;
+      if (!detail) {
+        text = "\u274C **Browser not found or no data returned**";
+      } else {
+        const cookieCount = detail.cookie?.length || 0;
+        const { cookie: _cookie, ...detailWithoutCookies } = detail;
+        text = `**Browser Details Summary**
+
+**ID:** \`${detail.dirId}\`
+**Name:** ${detail.windowName}
+**Sort Number:** ${detail.windowSortNum}
+**Project:** ${detail.projectName} (ID: ${detail.projectId})
+**OS:** ${detail.os} ${detail.osVersion}
+**Core Version:** ${detail.coreVersion}
+**Search Engine:** ${detail.searchEngine}
+**Open Status:** ${detail.openStatus ? "\u2705 Opened" : "\u274C Closed"}
+**Cookies:** ${cookieCount} stored (excluded from response to save tokens)
+
+**Full Details (JSON):**
+\`\`\`json
+${JSON.stringify(detailWithoutCookies, null, 2)}
+\`\`\``;
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var ClearLocalCache = class {
+  name = "roxy_clear_local_cache";
+  description = "Clear local cache for specified browsers";
+  inputSchema = {
+    type: "object",
+    properties: {
+      dirIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of browser directory IDs"
+      }
+    },
+    required: ["dirIds"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.dirIds || params.dirIds.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to clear local cache:**\n\n dirIds are required"
+          }
+        ]
+      };
+    }
+    const result = await request("/browser/clear_local_cache", {
+      method: "POST",
+      body: JSON.stringify({ dirIds: params.dirIds })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to clear local cache:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `\u2705 **Local Cache Cleared**
+
+**Browser Count:** ${params.dirIds.length}
+
+**Browser IDs:**
+${params.dirIds.map((id, index) => `  ${index + 1}. \`${id}\``).join("\n")}`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var ClearServerCache = class {
+  name = "roxy_clear_server_cache";
+  description = "Clear server-side cache for specified browsers";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      dirIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of browser directory IDs"
+      }
+    },
+    required: ["workspaceId", "dirIds"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.dirIds || params.dirIds.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to clear server cache:**\n\n workspaceId and dirIds are required"
+          }
+        ]
+      };
+    }
+    const result = await request("/browser/clear_server_cache", {
+      method: "POST",
+      body: JSON.stringify({
+        workspaceId: params.workspaceId,
+        dirIds: params.dirIds
+      })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to clear server cache:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `\u2705 **Server Cache Cleared**
+
+**Workspace:** ${params.workspaceId}
+**Browser Count:** ${params.dirIds.length}
+
+**Browser IDs:**
+${params.dirIds.map((id, index) => `  ${index + 1}. \`${id}\``).join("\n")}`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var RandomFingerprint = class {
+  name = "roxy_random_fingerprint";
+  description = "Randomize browser fingerprint for a specific browser";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      },
+      dirId: {
+        type: "string",
+        description: "Browser directory ID"
+      }
+    },
+    required: ["workspaceId", "dirId"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId || !params.dirId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to randomize fingerprint:**\n\n workspaceId and dirId are required"
+          }
+        ]
+      };
+    }
+    const result = await request("/browser/random_env", {
+      method: "POST",
+      body: JSON.stringify({
+        workspaceId: params.workspaceId,
+        dirId: params.dirId
+      })
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to randomize fingerprint:**
+
+ error message: ${result.msg}`;
+    } else {
+      text = `\u2705 **Browser Fingerprint Randomized**
+
+**Browser ID:** \`${params.dirId}\`
+**Workspace:** ${params.workspaceId}
+
+*Browser fingerprint has been randomized. Restart the browser to apply changes.*`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var ListLabels = class {
+  name = "roxy_list_labels";
+  description = "Get list of labels in specified workspace";
+  inputSchema = {
+    type: "object",
+    properties: {
+      workspaceId: {
+        type: "number",
+        description: "Workspace ID"
+      }
+    },
+    required: ["workspaceId"]
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    if (!params.workspaceId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "\u274C **Failed to list labels:**\n\n workspaceId is required"
+          }
+        ]
+      };
+    }
+    const searchParams = new URLSearchParams();
+    searchParams.append("workspaceId", params.workspaceId.toString());
+    const result = await request(`/browser/label?${searchParams}`, {
+      method: "GET"
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to list labels:**
+
+ error message: ${result.msg}`;
+    } else {
+      const labels = result.data || [];
+      text = `Found ${labels.length} labels in workspace ${params.workspaceId}:
+
+${labels.map(
+        (label) => `**${label.name}** (ID: ${label.id})
+  - Color: ${label.color}`
+      ).join("\n\n")}`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var GetConnectionInfo = class {
+  name = "roxy_get_connection_info";
+  description = "Get connection information (CDP endpoints, PIDs) for currently opened browsers";
+  inputSchema = {
+    type: "object",
+    properties: {
+      dirIds: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of browser directory IDs to query (optional, returns all if not specified)"
+      }
+    }
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    const searchParams = new URLSearchParams();
+    if (params.dirIds && params.dirIds.length > 0) {
+      searchParams.append("dirIds", params.dirIds.join(","));
+    }
+    const queryString = searchParams.toString();
+    const endpoint = queryString ? `/browser/connection_info?${queryString}` : "/browser/connection_info";
+    const result = await request(endpoint, {
+      method: "GET"
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to get connection info:**
+
+ error message: ${result.msg}`;
+    } else {
+      const connections = result.data || [];
+      if (connections.length === 0) {
+        text = "\u26A0\uFE0F No opened browsers found.\n\nUse `roxy_open_browsers` to open browsers first.";
+      } else {
+        text = `Found ${connections.length} opened browser(s):
+
+${connections.map(
+          (conn) => `**${conn.windowName || "Unnamed"}** (${conn.dirId})
+  - PID: ${conn.pid}
+  - CDP WebSocket: \`${conn.ws}\`
+  - HTTP Endpoint: \`${conn.http}\`
+  - Core Version: ${conn.coreVersion}
+  - Driver: ${conn.driver}`
+        ).join("\n\n")}`;
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var openBrowser = new OpenBrowser();
+var updateBrowser = new UpdateBrowser();
+var listBrowsers = new ListBrowsers();
+var closeBrowsers = new CloseBrowsers();
+var deleteBrowsers = new DeleteBrowsers();
+var getBrowserDetail = new GetBrowserDetail();
+var clearLocalCache = new ClearLocalCache();
+var clearServerCache = new ClearServerCache();
+var randomFingerprint = new RandomFingerprint();
+var listLabels = new ListLabels();
+var getConnectionInfo = new GetConnectionInfo();
+
+// src/modules/other.ts
+var ListWorkspaces = class {
+  name = "roxy_list_workspaces";
+  description = "Get list of all workspaces and their projects from RoxyBrowser";
+  inputSchema = {
+    type: "object",
+    properties: {
+      pageIndex: {
+        type: "number",
+        description: "Page index for pagination (default: 1)",
+        default: 1
+      },
+      pageSize: {
+        type: "number",
+        description: "Number of items per page (default: 15)",
+        default: 15
+      }
+    }
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    const { pageIndex = 1, pageSize = 15 } = params || {};
+    const searchParams = new URLSearchParams();
+    searchParams.append("page_index", pageIndex.toString());
+    searchParams.append("page_size", pageSize.toString());
+    const result = await request(`/browser/workspace?${searchParams}`, {
+      method: "GET"
+    });
+    let text = "";
+    if (result.code !== 0) {
+      text = `\u274C **Failed to list workspaces:**
+
+ error message: ${result.msg}`;
+    } else {
+      const data = result.data;
+      text = `Found ${data.total} workspaces:
+
+${data.rows.map(
+        (ws) => `**${ws.workspaceName}** (ID: ${ws.id})
+${ws.project_details.map(
+          (proj) => `  - ${proj.projectName} (ID: ${proj.projectId})`
+        ).join("\n")}`
+      ).join("\n\n")}`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var HealthCheck = class {
+  name = "roxy_health_check";
+  description = "Check if the target server is alive and healthy. This tool performs a health check to verify server connectivity and status.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      includeWorkspaceCheck: {
+        type: "boolean",
+        description: "Include workspace connectivity tests (optional, default: true)",
+        default: true
+      },
+      includeBrowserCheck: {
+        type: "boolean",
+        description: "Include browser availability checks (optional, default: true)",
+        default: true
+      },
+      verbose: {
+        type: "boolean",
+        description: "Include detailed diagnostic information (optional, default: false)",
+        default: false
+      }
+    }
+  };
+  get schema() {
+    return {
+      name: this.name,
+      description: this.description,
+      inputSchema: this.inputSchema
+    };
+  }
+  async handle(params) {
+    const { includeWorkspaceCheck = true, includeBrowserCheck = true, verbose = false } = params || {};
+    let healthStatus = "unknown";
+    let healthError = "";
+    try {
+      const healthResult = await request("/health", {
+        method: "GET"
+      });
+      if (healthResult.code === 0 || healthResult.code === void 0) {
+        healthStatus = "healthy";
+      } else {
+        healthStatus = "unhealthy";
+        healthError = healthResult.msg || "Health check failed";
+      }
+    } catch (error) {
+      healthStatus = "unhealthy";
+      healthError = error.message || "Failed to connect to server";
+    }
+    let text = `## \u{1F50D} \u5065\u5EB7\u68C0\u67E5\u62A5\u544A / Health Check Report
+
+`;
+    text += `### \u{1F310} \u670D\u52A1\u5668\u72B6\u6001 / Server Status
+`;
+    text += `- **\u670D\u52A1\u5668\u8FDE\u63A5 / Server Connection**: ${healthStatus === "healthy" ? "\u2705 \u6B63\u5E38" : "\u274C \u5F02\u5E38"}
+`;
+    if (healthStatus !== "healthy" && healthError) {
+      text += `- **\u9519\u8BEF\u4FE1\u606F / Error**: ${healthError}
+`;
+    }
+    if (includeWorkspaceCheck && healthStatus === "healthy") {
+      try {
+        const workspaceResult = await request("/browser/workspace?page_index=1&page_size=5", {
+          method: "GET"
+        });
+        if (workspaceResult.code === 0) {
+          const workspaces = workspaceResult.data;
+          text += `
+### \u{1F4C1} \u5DE5\u4F5C\u533A\u4FE1\u606F / Workspace Information
+`;
+          text += `- **\u53EF\u7528\u5DE5\u4F5C\u533A / Available Workspaces**: ${workspaces.total}
+`;
+          if (workspaces.rows && workspaces.rows.length > 0) {
+            text += `- **\u5DE5\u4F5C\u533A\u8BE6\u60C5 / Workspace Details**:
+`;
+            workspaces.rows.slice(0, 3).forEach((ws) => {
+              const projectCount = ws.project_details?.length || 0;
+              text += `  - ${ws.workspaceName} (ID: ${ws.id}) - ${projectCount} projects
+`;
+            });
+            if (workspaces.total > 3) {
+              text += `  - ... and ${workspaces.total - 3} more
+`;
+            }
+          }
+        } else {
+          text += `
+### \u{1F4C1} \u5DE5\u4F5C\u533A\u4FE1\u606F / Workspace Information
+`;
+          text += `- **\u72B6\u6001**: \u26A0\uFE0F \u65E0\u6CD5\u83B7\u53D6\u5DE5\u4F5C\u533A\u4FE1\u606F
+`;
+          text += `- **\u9519\u8BEF**: ${workspaceResult.msg}
+`;
+        }
+      } catch (error) {
+        text += `
+### \u{1F4C1} \u5DE5\u4F5C\u533A\u4FE1\u606F / Workspace Information
+`;
+        text += `- **\u72B6\u6001**: \u274C \u65E0\u6CD5\u83B7\u53D6\u5DE5\u4F5C\u533A\u4FE1\u606F
+`;
+        text += `- **\u9519\u8BEF**: ${error.message || "Unknown error"}
+`;
+      }
+    }
+    if (includeBrowserCheck && healthStatus === "healthy") {
+      try {
+        const workspaceResult = await request("/browser/workspace?page_index=1&page_size=1", {
+          method: "GET"
+        });
+        if (workspaceResult.code === 0 && workspaceResult.data.rows && workspaceResult.data.rows.length > 0) {
+          const firstWorkspace = workspaceResult.data.rows[0];
+          const browserResult = await request(`/browser/list_v3?workspaceId=${firstWorkspace.id}&page_index=1&page_size=5`, {
+            method: "GET"
+          });
+          if (browserResult.code === 0) {
+            const browsers = browserResult.data;
+            text += `
+### \u{1F310} \u6D4F\u89C8\u5668\u4FE1\u606F / Browser Information
+`;
+            text += `- **\u5DE5\u4F5C\u533A / Workspace**: ${firstWorkspace.workspaceName} (ID: ${firstWorkspace.id})
+`;
+            text += `- **\u6D4F\u89C8\u5668\u603B\u6570 / Total Browsers**: ${browsers.total}
+`;
+            if (browsers.rows && browsers.rows.length > 0) {
+              text += `- **\u6D4F\u89C8\u5668\u793A\u4F8B / Browser Examples**:
+`;
+              browsers.rows.slice(0, 3).forEach((browser) => {
+                text += `  - ${browser.windowName || "Unnamed"} (ID: ${browser.dirId}) - ${browser.status}
+`;
+              });
+            }
+          }
+        }
+      } catch (error) {
+        text += `
+### \u{1F310} \u6D4F\u89C8\u5668\u4FE1\u606F / Browser Information
+`;
+        text += `- **\u72B6\u6001**: \u26A0\uFE0F \u65E0\u6CD5\u83B7\u53D6\u6D4F\u89C8\u5668\u4FE1\u606F
+`;
+        text += `- **\u9519\u8BEF**: ${error.message || "Unknown error"}
+`;
+      }
+    }
+    if (verbose && healthStatus === "healthy") {
+      text += `
+### \u{1F4CA} \u8BE6\u7EC6\u4FE1\u606F / Detailed Information
+`;
+      text += `- **\u5065\u5EB7\u68C0\u67E5\u65F6\u95F4 / Check Time**: ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+      text += `- **\u68C0\u67E5\u6A21\u5F0F / Check Mode**: ${includeWorkspaceCheck ? "Workspace + " : ""}${includeBrowserCheck ? "Browser" : ""}
+`;
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    };
+  }
+};
+var listWorkspaces = new ListWorkspaces();
+var healthCheck = new HealthCheck();
+
+// src/index.ts
+var TOOLS = [
+  listBrowsers.schema,
+  batchCreateBrowsers.schema,
+  createBrowser.schema,
+  openBrowser.schema,
+  updateBrowser.schema,
+  closeBrowsers.schema,
+  deleteBrowsers.schema,
+  getBrowserDetail.schema,
+  clearLocalCache.schema,
+  clearServerCache.schema,
+  randomFingerprint.schema,
+  listLabels.schema,
+  getConnectionInfo.schema,
+  proxyList.schema,
+  proxyStore.schema,
+  createProxy.schema,
+  batchCreateProxies.schema,
+  detectProxy.schema,
+  modifyProxy.schema,
+  deleteProxies.schema,
+  // getDetectChannels.schema,
+  listAccounts.schema,
+  createAccount.schema,
+  batchCreateAccounts.schema,
+  modifyAccount.schema,
+  deleteAccounts.schema,
+  listWorkspaces.schema,
+  healthCheck.schema
+];
+var RoxyBrowserMCPServer = class {
+  server;
+  constructor() {
+    this.server = new index_js.Server(
+      {
+        name: "roxybrowser-openapi-mcp",
+        version: "1.0.0"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.setupHandlers();
+  }
+  setupHandlers() {
+    this.server.setRequestHandler(types_js.ListToolsRequestSchema, async () => ({
+      tools: TOOLS
+    }));
+    this.server.setRequestHandler(types_js.CallToolRequestSchema, async (request2) => {
+      const { name, arguments: args } = request2.params;
+      try {
+        switch (name) {
+          // 浏览器相关
+          case listBrowsers.name:
+            return await listBrowsers.handle(args);
+          case createBrowser.name:
+            return await createBrowser.handle(args);
+          case openBrowser.name:
+            return await openBrowser.handle(args);
+          case updateBrowser.name:
+            return await updateBrowser.handle(args);
+          case closeBrowsers.name:
+            return await closeBrowsers.handle(args);
+          case deleteBrowsers.name:
+            return await deleteBrowsers.handle(args);
+          case batchCreateBrowsers.name:
+            return await batchCreateBrowsers.handle(args);
+          case listLabels.name:
+            return await listLabels.handle(args);
+          case getConnectionInfo.name:
+            return await getConnectionInfo.handle(args);
+          case randomFingerprint.name:
+            return await randomFingerprint.handle(args);
+          case clearLocalCache.name:
+            return await clearLocalCache.handle(args);
+          case clearServerCache.name:
+            return await clearServerCache.handle(args);
+          case getBrowserDetail.name:
+            return await getBrowserDetail.handle(args);
+          // 账号相关
+          case listAccounts.name:
+            return await listAccounts.handle(args);
+          case createAccount.name:
+            return await createAccount.handle(args);
+          case batchCreateAccounts.name:
+            return await batchCreateAccounts.handle(args);
+          case modifyAccount.name:
+            return await modifyAccount.handle(args);
+          case deleteAccounts.name:
+            return await deleteAccounts.handle(args);
+          // 代理相关
+          case proxyList.name:
+            return await proxyList.handle(args);
+          case proxyStore.name:
+            return await proxyStore.handle(args);
+          case createProxy.name:
+            return await createProxy.handle(args);
+          case batchCreateProxies.name:
+            return await batchCreateProxies.handle(args);
+          case detectProxy.name:
+            return await detectProxy.handle(args);
+          case modifyProxy.name:
+            return await modifyProxy.handle(args);
+          case deleteProxies.name:
+            return await deleteProxies.handle(args);
+          // 空间列表
+          case listWorkspaces.name:
+            return await listWorkspaces.handle(args);
+          // 健康检查
+          case healthCheck.name:
+            return await healthCheck.handle(args);
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: error instanceof Error ? error.message : "Unknown error"
+            }
+          ]
+        };
+      }
+    });
+  }
+  async run() {
+    console.error("\u{1F680} Starting RoxyBrowser MCP Server...");
+    const transport = new stdio_js.StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("\u2705 RoxyBrowser MCP Server is running");
+  }
+};
+async function runServer() {
+  const server = new RoxyBrowserMCPServer();
+  await server.run();
+}
+
+// src/cli.ts
+var PKG_VERSION = "1.0.9";
+var program = new commander.Command();
+program.name("roxy-browser-mcp").description("RoxyBrowser MCP Server - Model Context Protocol server for RoxyBrowser automation").version(PKG_VERSION, "-V, --version", "Show version").option(
+  "-H, --api-host <url>",
+  "RoxyBrowser API base URL",
+  process.env.ROXY_API_HOST ?? "http://127.0.0.1:50000"
+).option(
+  "-k, --api-key <key>",
+  "API key (or set ROXY_API_KEY)",
+  process.env.ROXY_API_KEY ?? ""
+).option(
+  "-t, --timeout <ms>",
+  "Request timeout in milliseconds",
+  (v) => v != null && v !== "" ? Number.parseInt(v, 10) : 3e4,
+  process.env.ROXY_TIMEOUT != null ? Number(process.env.ROXY_TIMEOUT) : 3e4
+).addHelpText(
+  "after",
+  `
+Environment (used when option not passed):
+  ROXY_API_HOST   API base URL (default: http://127.0.0.1:50000)
+  ROXY_API_KEY    API key (required)
+  ROXY_TIMEOUT    Timeout in ms (default: 30000)
+
+Examples:
+  roxy-browser-mcp --api-key "your-key"
+  roxy-browser-mcp -k "your-key" -H http://127.0.0.1:50000
+  ROXY_API_KEY=your-key roxy-browser-mcp
+`
+);
+async function main() {
+  program.parse();
+  const opts = program.opts();
+  if (opts.apiHost != null && opts.apiHost !== "") process.env.ROXY_API_HOST = opts.apiHost;
+  if (opts.apiKey != null && opts.apiKey !== "") process.env.ROXY_API_KEY = opts.apiKey;
+  if (opts.timeout != null) process.env.ROXY_TIMEOUT = String(opts.timeout);
+  try {
+    await runServer();
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      console.error(`\u274C Configuration Error: ${error.message}`);
+      process.exit(1);
+    }
+    console.error("\u274C Unexpected error:", error);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map