@tgebrowser/mcp 1.0.6

package/build/server.js

@@ -0,0 +1,1010 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// ../core/src/client.ts
+var import_axios = __toESM(require("axios"));
+function parseArgs() {
+  const args = process.argv;
+  let port;
+  let apiKey;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--port" && i + 1 < args.length) {
+      port = args[i + 1];
+    }
+    if (args[i] === "--api-key" && i + 1 < args.length) {
+      apiKey = args[i + 1];
+    }
+  }
+  return {
+    port: port || process.env.PORT || "50326",
+    apiKey: apiKey || process.env.API_KEY
+  };
+}
+var config = parseArgs();
+var PORT = config.port;
+var API_KEY = config.apiKey;
+var BASE_URL = `http://127.0.0.1:${PORT}`;
+var ENDPOINTS = {
+  STATUS: "/api/status",
+  START_BROWSER: "/api/browser/start",
+  CLOSE_BROWSER: "/api/browser/stop",
+  CREATE_BROWSER: "/api/browser/create",
+  UPDATE_BROWSER: "/api/browser/update",
+  DELETE_BROWSER: "/api/browser/delete",
+  GET_BROWSER_LIST: "/api/browser/list",
+  GET_BROWSER_DETAIL: "/api/browser/detail",
+  CLOSE_ALL_PROFILES: "/api/browser/stop-all",
+  DELETE_CACHE_V2: "/api/browser/cache/delete",
+  GET_OPENED_BROWSER: "/api/browser/open/list",
+  GET_GROUP_LIST: "/api/groups/list",
+  GET_PROXY_LIST: "/api/proxies/list"
+};
+var apiClient = import_axios.default.create({
+  baseURL: BASE_URL,
+  timeout: 1e4,
+  headers: {
+    "Content-Type": "application/json",
+    ...API_KEY ? { "Authorization": `Bearer ${API_KEY}` } : {}
+  }
+});
+
+// ../core/src/profile/actions.ts
+function assertSuccess(data, action) {
+  if (data && data.success) return;
+  const message = data && typeof data.message === "string" ? data.message : "Unknown error";
+  throw new Error(`Failed to ${action}: ${message}`);
+}
+function buildBody(params) {
+  const body = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      const mapped = value.map((item) => item && typeof item === "object" ? buildBody(item) : item).filter((v) => v !== void 0);
+      if (mapped.length > 0) body[key] = mapped;
+    } else if (value && typeof value === "object") {
+      body[key] = buildBody(value);
+    } else {
+      body[key] = value;
+    }
+  }
+  return body;
+}
+var profileActions = {
+  async open({ envId, userIndex, args, port }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    if (args && args.length > 0) body.args = args;
+    if (port !== void 0) body.port = port;
+    const response = await apiClient.post(ENDPOINTS.START_BROWSER, body);
+    assertSuccess(response.data, "open browser");
+    const info = response.data.data || {};
+    const wsUrl = typeof info.ws === "object" ? info.ws?.puppeteer ?? info.ws?.selenium ?? JSON.stringify(info.ws) : info.ws;
+    return `Browser started: envId=${info.envId}, userIndex=${info.userIndex}, ws=${wsUrl}, http=${info.http}, port=${info.port}
+
+To automate this browser, use connect-browser-with-ws with wsUrl="${wsUrl}"`;
+  },
+  async close({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.CLOSE_BROWSER, body);
+    assertSuccess(response.data, "close browser");
+    return "Browser closed successfully";
+  },
+  async create(params) {
+    const response = await apiClient.post(ENDPOINTS.CREATE_BROWSER, buildBody(params));
+    assertSuccess(response.data, "create browser");
+    const info = response.data.data || {};
+    return `Browser created: envId=${info.envId}, userIndex=${info.userIndex}`;
+  },
+  async update(params) {
+    const response = await apiClient.post(ENDPOINTS.UPDATE_BROWSER, buildBody(params));
+    assertSuccess(response.data, "update browser");
+    const info = response.data.data || {};
+    return `Browser updated: envId=${info.envId ?? params.envId}`;
+  },
+  async delete({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.DELETE_BROWSER, body);
+    assertSuccess(response.data, "delete browser");
+    return `Browser deleted: envId=${body.envId ?? ""} userIndex=${body.userIndex ?? ""}`;
+  },
+  async list(params) {
+    const searchParams = {};
+    if (params.current !== void 0) searchParams.current = params.current.toString();
+    if (params.pageSize !== void 0) searchParams.pageSize = params.pageSize.toString();
+    if (params.keyword) searchParams.keyword = params.keyword;
+    if (params.groupId !== void 0) searchParams.groupId = params.groupId.toString();
+    const response = await apiClient.get(ENDPOINTS.GET_BROWSER_LIST, { params: searchParams });
+    assertSuccess(response.data, "get browser list");
+    const raw = response.data.data || {};
+    const summary = {
+      total: raw.total,
+      current: raw.current,
+      pageSize: raw.pageSize,
+      list: (raw.list || []).map((item) => ({
+        envId: item.envId,
+        userIndex: item.userIndex,
+        browserName: item.browserName,
+        groupId: item.groupId,
+        remark: item.remark,
+        lastOpenedTime: item.lastOpenedTime
+      }))
+    };
+    return `Browser list: ${JSON.stringify(summary, null, 2)}`;
+  },
+  async openedList() {
+    const response = await apiClient.get(ENDPOINTS.GET_OPENED_BROWSER);
+    assertSuccess(response.data, "get opened browsers");
+    return `Opened browser list: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async getCookies({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.GET_BROWSER_DETAIL, body);
+    assertSuccess(response.data, "get profile cookies");
+    return `Profile cookies: ${JSON.stringify(response.data.data?.cookie, null, 2)}`;
+  },
+  async getUa({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.GET_BROWSER_DETAIL, body);
+    assertSuccess(response.data, "get profile User-Agent");
+    const ua = response.data.data?.fingerprint?.userAgent;
+    return `Profile User-Agent: ${ua ?? ""}`;
+  },
+  async closeAll() {
+    const response = await apiClient.post(ENDPOINTS.CLOSE_ALL_PROFILES, {});
+    assertSuccess(response.data, "close all browsers");
+    return "All browsers stopped successfully";
+  },
+  async newFingerprint({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    body.fingerprint = { randomFingerprint: true };
+    const response = await apiClient.post(ENDPOINTS.UPDATE_BROWSER, body);
+    assertSuccess(response.data, "refresh fingerprint");
+    return `Fingerprint updated for envId=${body.envId ?? ""} userIndex=${body.userIndex ?? ""}`;
+  },
+  async deleteCache({ envId, userIndex }) {
+    const body = {};
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.DELETE_CACHE_V2, body);
+    assertSuccess(response.data, "delete cache");
+    return `Cache deleted for envId=${body.envId ?? ""} userIndex=${body.userIndex ?? ""}`;
+  },
+  async getActive(_params) {
+    const response = await apiClient.get(ENDPOINTS.GET_OPENED_BROWSER);
+    assertSuccess(response.data, "get active browsers");
+    return `Active browsers: ${JSON.stringify(response.data.data, null, 2)}`;
+  }
+};
+
+// ../core/src/profile/schema.ts
+var import_zod = require("zod");
+var CHROME_VERSIONS = [
+  "133",
+  "135",
+  "137",
+  "139",
+  "141",
+  "143",
+  "ua_auto"
+];
+var TLS_CIPHER_SUITES = {
+  TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384: "0xC02C",
+  TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384: "0xC030",
+  TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: "0xC02B",
+  TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256: "0xC02F",
+  TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256: "0xCCA9",
+  TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256: "0xCCA8",
+  TLS_DHE_RSA_WITH_AES_256_GCM_SHA384: "0x009F",
+  TLS_DHE_RSA_WITH_AES_128_GCM_SHA256: "0x009E",
+  TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384: "0xC024",
+  TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384: "0xC028",
+  TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA: "0xC00A",
+  TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA: "0xC014",
+  TLS_DHE_RSA_WITH_AES_256_CBC_SHA256: "0x006B",
+  TLS_DHE_RSA_WITH_AES_256_CBC_SHA: "0x0039",
+  TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256: "0xC023",
+  TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256: "0xC027",
+  TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA: "0xC009",
+  TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA: "0xC013",
+  TLS_DHE_RSA_WITH_AES_128_CBC_SHA256: "0x0067",
+  TLS_DHE_RSA_WITH_AES_128_CBC_SHA: "0x0033",
+  TLS_RSA_WITH_AES_256_GCM_SHA384: "0x009D",
+  TLS_RSA_WITH_AES_128_GCM_SHA256: "0x009C",
+  TLS_RSA_WITH_AES_256_CBC_SHA256: "0x003D",
+  TLS_RSA_WITH_AES_128_CBC_SHA256: "0x003C",
+  TLS_RSA_WITH_AES_256_CBC_SHA: "0x0035",
+  TLS_RSA_WITH_AES_128_CBC_SHA: "0x002F",
+  TLS_AES_128_CCM_8_SHA256: "0x1305",
+  TLS_AES_128_CCM_SHA256: "0x1304"
+};
+var TLS_HEX_CODES = Object.values(TLS_CIPHER_SUITES);
+var browserKernelConfigSchema = import_zod.z.object({
+  version: import_zod.z.union(
+    CHROME_VERSIONS.map((v) => import_zod.z.literal(v))
+  ).optional().describe("The version of the browser, supported: 133, 135, 137, 139, 141, 143, ua_auto"),
+  type: import_zod.z.literal("chrome").optional().describe("The type of the browser, only chrome is supported")
+}).optional().superRefine((data, ctx) => {
+  if (!data) return;
+  const version = data.version;
+  if (version === void 0) return;
+  if (!CHROME_VERSIONS.includes(version)) {
+    ctx.addIssue({ code: import_zod.z.ZodIssueCode.custom, message: `Unsupported version "${version}". Supported: ${CHROME_VERSIONS.join(", ")}` });
+  }
+});
+var randomUaConfigSchema = import_zod.z.object({
+  ua_version: import_zod.z.array(import_zod.z.string()).optional(),
+  ua_system_version: import_zod.z.array(
+    import_zod.z.enum([
+      "Android 9",
+      "Android 10",
+      "Android 11",
+      "Android 12",
+      "Android 13",
+      "Android 14",
+      "Android 15",
+      "iOS 14",
+      "iOS 15",
+      "iOS 16",
+      "iOS 17",
+      "iOS 18",
+      "Windows 7",
+      "Windows 8",
+      "Windows 10",
+      "Windows 11",
+      "Mac OS X 10",
+      "Mac OS X 11",
+      "Mac OS X 12",
+      "Mac OS X 13",
+      "Mac OS X 14",
+      "Mac OS X 15",
+      "Mac OS X",
+      "Windows",
+      "iOS",
+      "Android",
+      "Linux"
+    ])
+  ).optional()
+}).optional();
+var webglConfigSchema = import_zod.z.object({
+  unmasked_vendor: import_zod.z.string().describe("WebGL vendor string. Required when webgl=2."),
+  unmasked_renderer: import_zod.z.string().describe("WebGL renderer string. Required when webgl=2."),
+  webgpu: import_zod.z.object({
+    webgpu_switch: import_zod.z.enum(["0", "1", "2"])
+  }).optional()
+});
+var macAddressConfigSchema = import_zod.z.object({
+  model: import_zod.z.enum(["0", "1", "2"]),
+  address: import_zod.z.string().optional()
+});
+var mediaDevicesNumSchema = import_zod.z.object({
+  audioinput_num: import_zod.z.string().regex(/^[1-9]$/),
+  videoinput_num: import_zod.z.string().regex(/^[1-9]$/),
+  audiooutput_num: import_zod.z.string().regex(/^[1-9]$/)
+});
+var sharedFingerprintFields = {
+  mobileDeviceId: import_zod.z.number().optional(),
+  platformVersion: import_zod.z.number().optional(),
+  kernel: import_zod.z.string().optional(),
+  userAgent: import_zod.z.string().optional(),
+  webrtc: import_zod.z.string().optional(),
+  resolution: import_zod.z.string().optional(),
+  windowWidth: import_zod.z.number().optional(),
+  windowHeight: import_zod.z.number().optional(),
+  language: import_zod.z.string().optional(),
+  languageBaseIp: import_zod.z.boolean().optional(),
+  uiLanguage: import_zod.z.string().optional(),
+  uiLanguageBaseIp: import_zod.z.boolean().optional(),
+  timezone: import_zod.z.string().optional(),
+  timezoneBaseIp: import_zod.z.boolean().optional(),
+  geolocationBaseIp: import_zod.z.boolean().optional(),
+  lng: import_zod.z.string().optional(),
+  lat: import_zod.z.string().optional(),
+  canvas: import_zod.z.boolean().optional(),
+  audioContext: import_zod.z.boolean().optional(),
+  speechVoices: import_zod.z.boolean().optional(),
+  clientRects: import_zod.z.boolean().optional(),
+  fonts: import_zod.z.array(import_zod.z.string()).optional(),
+  disableTLS: import_zod.z.array(import_zod.z.string()).optional(),
+  ram: import_zod.z.number().optional(),
+  cpu: import_zod.z.number().optional(),
+  hardwareAcceleration: import_zod.z.boolean().optional(),
+  disableSandbox: import_zod.z.boolean().optional(),
+  startupParams: import_zod.z.string().optional(),
+  deviceName: import_zod.z.string().optional(),
+  deviceMedia: import_zod.z.boolean().optional(),
+  portScanProtection: import_zod.z.string().optional(),
+  randomFingerprint: import_zod.z.boolean().optional(),
+  blockLargeImages: import_zod.z.boolean().optional(),
+  maxImageKB: import_zod.z.number().optional(),
+  syncCookies: import_zod.z.boolean().optional(),
+  clearCacheOnStart: import_zod.z.boolean().optional(),
+  clearCachePreserveExtensionsOnStart: import_zod.z.boolean().optional(),
+  clearCookiesOnStart: import_zod.z.boolean().optional(),
+  clearHistoryOnStart: import_zod.z.boolean().optional(),
+  disableMediaAutoplay: import_zod.z.boolean().optional(),
+  muteAllMedia: import_zod.z.boolean().optional(),
+  disableGoogleTranslate: import_zod.z.boolean().optional(),
+  disableSavePasswordPrompt: import_zod.z.boolean().optional(),
+  disableNotifications: import_zod.z.boolean().optional(),
+  blockClipboardRead: import_zod.z.boolean().optional(),
+  stopOnNetworkIssue: import_zod.z.boolean().optional(),
+  stopOnIPChange: import_zod.z.boolean().optional(),
+  stopOnCountryChange: import_zod.z.boolean().optional()
+};
+var sharedProxyFields = {
+  host: import_zod.z.string().optional(),
+  port: import_zod.z.number().optional(),
+  username: import_zod.z.string().optional(),
+  password: import_zod.z.string().optional(),
+  timezone: import_zod.z.string().optional(),
+  proxyId: import_zod.z.number().optional()
+};
+var startInfoSchema = import_zod.z.object({
+  startPage: import_zod.z.object({
+    mode: import_zod.z.string().optional(),
+    value: import_zod.z.array(import_zod.z.string()).optional()
+  }).optional(),
+  otherConfig: import_zod.z.object({
+    openConfigPage: import_zod.z.boolean().optional(),
+    checkPage: import_zod.z.boolean().optional(),
+    extensionTab: import_zod.z.boolean().optional()
+  }).optional()
+}).optional();
+var profileSchemas = {
+  create: import_zod.z.object({
+    browserName: import_zod.z.string().describe("Environment name"),
+    groupId: import_zod.z.number().optional().describe("Group id of the environment"),
+    remark: import_zod.z.string().optional().describe("Remark for the environment"),
+    proxy: import_zod.z.object({
+      protocol: import_zod.z.string().describe("Proxy protocol, e.g. http, socks5, direct"),
+      ...sharedProxyFields
+    }).optional(),
+    fingerprint: import_zod.z.object({
+      os: import_zod.z.string().describe("Operating system, e.g. Windows, macOS, Android, iOS"),
+      ...sharedFingerprintFields
+    }).optional(),
+    startInfo: startInfoSchema,
+    Cookie: import_zod.z.any().optional()
+  }),
+  update: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id to update"),
+    browserName: import_zod.z.string().optional().describe("Environment name"),
+    groupId: import_zod.z.number().optional().describe("Group id"),
+    remark: import_zod.z.string().optional().describe("Remark"),
+    proxy: import_zod.z.object({
+      protocol: import_zod.z.string().optional(),
+      ipChecker: import_zod.z.string().optional(),
+      ...sharedProxyFields
+    }).optional(),
+    fingerprint: import_zod.z.object({
+      os: import_zod.z.string().optional(),
+      ...sharedFingerprintFields
+    }).optional(),
+    Cookie: import_zod.z.any().optional(),
+    startInfo: startInfoSchema
+  }),
+  open: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id to start"),
+    userIndex: import_zod.z.number().optional().describe("Environment index to start"),
+    args: import_zod.z.array(import_zod.z.string()).optional().describe("Extra browser args"),
+    port: import_zod.z.number().optional().describe("Custom remote debugging port")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  close: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id to stop"),
+    userIndex: import_zod.z.number().optional().describe("Environment index to stop")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  delete: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id to delete"),
+    userIndex: import_zod.z.number().optional().describe("Environment index to delete")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  list: import_zod.z.object({
+    current: import_zod.z.number().optional().describe("Current page"),
+    pageSize: import_zod.z.number().optional().describe("Page size"),
+    keyword: import_zod.z.string().optional().describe("Search keyword"),
+    groupId: import_zod.z.number().optional().describe("Group id")
+  }).strict(),
+  cookies: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().optional().describe("Environment index")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  ua: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().optional().describe("Environment index")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  closeAll: import_zod.z.object({}).strict(),
+  newFingerprint: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().optional().describe("Environment index")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  deleteCache: import_zod.z.object({
+    envId: import_zod.z.number().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().optional().describe("Environment index")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  active: import_zod.z.object({
+    profileId: import_zod.z.string().optional().describe("The profile id"),
+    profileNo: import_zod.z.string().optional().describe("The profile number")
+  }).refine((data) => data.profileId || data.profileNo, {
+    message: "Either profileId or profileNo must be provided"
+  }),
+  openedList: import_zod.z.object({}).strict()
+};
+
+// ../core/src/automation/actions.ts
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+
+// ../core/src/automation/session.ts
+var import_playwright = require("playwright");
+var BrowserSession = class {
+  browser;
+  page;
+  screenshots;
+  constructor() {
+    this.browser = null;
+    this.page = null;
+    this.screenshots = /* @__PURE__ */ new Map();
+  }
+  get browserInstance() {
+    return this.browser;
+  }
+  get pageInstance() {
+    return this.page;
+  }
+  set pageInstance(page) {
+    this.page = page;
+  }
+  get screenshotsInstance() {
+    return this.screenshots;
+  }
+  checkConnected() {
+    const error = new Error("Browser not connected, please connect browser first");
+    if (!this.browser) throw error;
+    if (!this.browser.isConnected()) throw error;
+    if (!this.page) throw error;
+  }
+  async connectWithWs(wsUrl) {
+    this.browser = await import_playwright.chromium.connectOverCDP(wsUrl);
+    const defaultContext = this.browser.contexts()[0];
+    this.page = defaultContext.pages()[0];
+    await this.page.bringToFront().catch((error) => {
+      console.error("Failed to bring page to front", error);
+    });
+  }
+  async reset() {
+    this.browser = null;
+    this.page = null;
+  }
+};
+var session_default = new BrowserSession();
+
+// ../core/src/automation/actions.ts
+var defaultDownloadsPath = import_path.default.join(import_os.default.homedir(), "Downloads");
+var automationActions = {
+  async connect({ wsUrl }) {
+    try {
+      await session_default.connectWithWs(wsUrl);
+      return `Browser connected successfully with: ${wsUrl}`;
+    } catch (error) {
+      return `Failed to connect browser with: ${error?.toString()}`;
+    }
+  },
+  async openNewPage() {
+    session_default.checkConnected();
+    const newPage = await session_default.pageInstance.context().newPage();
+    session_default.pageInstance = newPage;
+    return "New page opened successfully";
+  },
+  async navigate({ url }) {
+    session_default.checkConnected();
+    await session_default.pageInstance.goto(url);
+    return `Navigated to ${url} successfully`;
+  },
+  async screenshot({ savePath, isFullPage }) {
+    session_default.checkConnected();
+    const filename = `screenshot-${Date.now()}-${Math.random().toString(36).substring(2, 15)}.png`;
+    const outputPath = import_path.default.join(savePath || defaultDownloadsPath, filename);
+    const screenshot = await session_default.pageInstance.screenshot({ path: outputPath, fullPage: isFullPage });
+    const screenshotBase64 = screenshot.toString("base64");
+    session_default.screenshotsInstance.set(filename, screenshotBase64);
+    return [{
+      type: "image",
+      data: screenshotBase64,
+      mimeType: "image/png"
+    }];
+  },
+  async getPageVisibleText() {
+    session_default.checkConnected();
+    try {
+      const visibleText = await session_default.pageInstance.evaluate(() => {
+        const walker = document.createTreeWalker(
+          document.body,
+          NodeFilter.SHOW_TEXT,
+          {
+            acceptNode: (node2) => {
+              const style = window.getComputedStyle(node2.parentElement);
+              return style.display !== "none" && style.visibility !== "hidden" ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_REJECT;
+            }
+          }
+        );
+        let text = "";
+        let node;
+        while (node = walker.nextNode()) {
+          const trimmedText = node.textContent?.trim();
+          if (trimmedText) text += trimmedText + "\n";
+        }
+        return text.trim();
+      });
+      return `Visible text content:
+${visibleText}`;
+    } catch (error) {
+      return `Failed to get visible text content: ${error.message}`;
+    }
+  },
+  async getPageHtml() {
+    session_default.checkConnected();
+    return session_default.pageInstance.content();
+  },
+  async clickElement({ selector }) {
+    session_default.checkConnected();
+    await session_default.pageInstance.click(selector);
+    return `Clicked element with selector: ${selector} successfully`;
+  },
+  async iframeClickElement({ selector, iframeSelector }) {
+    session_default.checkConnected();
+    await session_default.pageInstance.waitForSelector(iframeSelector);
+    const frame = session_default.pageInstance.frameLocator(iframeSelector);
+    await frame.locator(selector).click();
+    return `Clicked element ${selector} inside iframe ${iframeSelector} successfully`;
+  },
+  async fillInput({ selector, text }) {
+    session_default.checkConnected();
+    await session_default.pageInstance.waitForSelector(selector);
+    await session_default.pageInstance.fill(selector, text);
+    return `Filled input with selector: ${selector} with text: ${text} successfully`;
+  },
+  async selectOption({ selector, value }) {
+    session_default.checkConnected();
+    await session_default.pageInstance.waitForSelector(selector);
+    await session_default.pageInstance.selectOption(selector, value);
+    return `Selected option with selector: ${selector} with value: ${value} successfully`;
+  },
+  async hoverElement({ selector }) {
+    session_default.checkConnected();
+    await session_default.pageInstance.waitForSelector(selector);
+    await session_default.pageInstance.hover(selector);
+    return `Hovered element with selector: ${selector} successfully`;
+  },
+  async scrollElement({ selector }) {
+    session_default.checkConnected();
+    await session_default.pageInstance.waitForSelector(selector);
+    await session_default.pageInstance.evaluate((sel) => {
+      document.querySelector(sel)?.scrollIntoView({ behavior: "smooth" });
+    }, selector);
+    return `Scrolled element with selector: ${selector} successfully`;
+  },
+  async pressKey({ key, selector }) {
+    session_default.checkConnected();
+    if (selector) {
+      await session_default.pageInstance.waitForSelector(selector);
+      await session_default.pageInstance.focus(selector);
+    }
+    await session_default.pageInstance.keyboard.press(key);
+    return `Pressed key: ${key} successfully`;
+  },
+  async evaluateScript({ script }) {
+    session_default.checkConnected();
+    return session_default.pageInstance.evaluate(script);
+  },
+  async dragElement({ selector, targetSelector }) {
+    session_default.checkConnected();
+    const sourceElement = await session_default.pageInstance.waitForSelector(selector);
+    const targetElement = await session_default.pageInstance.waitForSelector(targetSelector);
+    const sourceBound = await sourceElement.boundingBox();
+    const targetBound = await targetElement.boundingBox();
+    if (!sourceBound || !targetBound) {
+      return "Could not get element positions for drag operation";
+    }
+    await session_default.pageInstance.mouse.move(
+      sourceBound.x + sourceBound.width / 2,
+      sourceBound.y + sourceBound.height / 2
+    );
+    await session_default.pageInstance.mouse.down();
+    await session_default.pageInstance.mouse.move(
+      targetBound.x + targetBound.width / 2,
+      targetBound.y + targetBound.height / 2
+    );
+    await session_default.pageInstance.mouse.up();
+    return `Dragged element with selector: ${selector} to ${targetSelector} successfully`;
+  }
+};
+
+// ../core/src/automation/schema.ts
+var import_zod2 = require("zod");
+var automationSchemas = {
+  connect: import_zod2.z.object({
+    userId: import_zod2.z.string().optional().describe("The browser id of the browser to connect"),
+    serialNumber: import_zod2.z.string().optional().describe("The serial number of the browser to connect"),
+    wsUrl: import_zod2.z.string().describe("The ws url of the browser, get from the open-browser tool content `ws.puppeteer`")
+  }).strict(),
+  navigate: import_zod2.z.object({ url: import_zod2.z.string().describe("The url to navigate to") }).strict(),
+  screenshot: import_zod2.z.object({
+    savePath: import_zod2.z.string().optional().describe("The path to save the screenshot"),
+    isFullPage: import_zod2.z.boolean().optional().describe("The is full page of the screenshot")
+  }).strict(),
+  clickElement: import_zod2.z.object({ selector: import_zod2.z.string().describe("The selector of the element to click, find from the page source code") }).strict(),
+  fillInput: import_zod2.z.object({
+    selector: import_zod2.z.string().describe("The selector of the input to fill, find from the page source code"),
+    text: import_zod2.z.string().describe("The text to fill in the input")
+  }).strict(),
+  selectOption: import_zod2.z.object({
+    selector: import_zod2.z.string().describe("The selector of the option to select, find from the page source code"),
+    value: import_zod2.z.string().describe("The value of the option to select")
+  }).strict(),
+  hoverElement: import_zod2.z.object({ selector: import_zod2.z.string().describe("The selector of the element to hover, find from the page source code") }).strict(),
+  scrollElement: import_zod2.z.object({ selector: import_zod2.z.string().describe("The selector of the element to scroll, find from the page source code") }).strict(),
+  pressKey: import_zod2.z.object({
+    key: import_zod2.z.string().describe('The key to press, eg: "Enter"'),
+    selector: import_zod2.z.string().optional().describe("The selector of the element to press the key, find from the page source code")
+  }).strict(),
+  evaluateScript: import_zod2.z.object({ script: import_zod2.z.string().describe("The script to evaluate") }).strict(),
+  dragElement: import_zod2.z.object({
+    selector: import_zod2.z.string().describe("The selector of the element to drag, find from the page source code"),
+    targetSelector: import_zod2.z.string().describe("The selector of the element to drag to, find from the page source code")
+  }).strict(),
+  iframeClickElement: import_zod2.z.object({
+    selector: import_zod2.z.string().describe("The selector of the element to click, find from the page source code"),
+    iframeSelector: import_zod2.z.string().describe("The selector of the iframe to click, find from the page source code")
+  }).strict(),
+  empty: import_zod2.z.object({}).strict()
+};
+
+// ../core/src/group/actions.ts
+function assertSuccess2(data, action) {
+  if (data && data.success) return;
+  const message = data && typeof data.message === "string" ? data.message : "Unknown error";
+  throw new Error(`Failed to ${action}: ${message}`);
+}
+var groupActions = {
+  async list({ current, pageSize }) {
+    const params = {};
+    if (current !== void 0) params.current = current.toString();
+    if (pageSize !== void 0) params.pageSize = pageSize.toString();
+    const response = await apiClient.get(ENDPOINTS.GET_GROUP_LIST, { params });
+    assertSuccess2(response.data, "get group list");
+    return `Group list: ${JSON.stringify(response.data.data, null, 2)}`;
+  }
+};
+
+// ../core/src/group/schema.ts
+var import_zod3 = require("zod");
+var groupSchemas = {
+  list: import_zod3.z.object({
+    current: import_zod3.z.number().optional().describe("Current page"),
+    pageSize: import_zod3.z.number().optional().describe("Page size")
+  }).strict()
+};
+
+// ../core/src/proxy/actions.ts
+function assertSuccess3(data, action) {
+  if (data && data.success) return;
+  const message = data && typeof data.message === "string" ? data.message : "Unknown error";
+  throw new Error(`Failed to ${action}: ${message}`);
+}
+var proxyActions = {
+  async list({ current, pageSize }) {
+    const params = {};
+    if (current !== void 0) params.current = current.toString();
+    if (pageSize !== void 0) params.pageSize = pageSize.toString();
+    const response = await apiClient.get(ENDPOINTS.GET_PROXY_LIST, { params });
+    assertSuccess3(response.data, "get proxy list");
+    return `Proxy list: ${JSON.stringify(response.data.data, null, 2)}`;
+  }
+};
+
+// ../core/src/proxy/schema.ts
+var import_zod4 = require("zod");
+var proxySchemas = {
+  list: import_zod4.z.object({
+    current: import_zod4.z.number().optional().describe("Current page"),
+    pageSize: import_zod4.z.number().optional().describe("Page size")
+  }).strict()
+};
+
+// ../core/src/system/actions.ts
+var systemActions = {
+  async checkStatus() {
+    const response = await apiClient.get(ENDPOINTS.STATUS);
+    return `Connection status: ${JSON.stringify(response.data, null, 2)}`;
+  }
+};
+
+// src/wrap.ts
+function wrapHandler(handler) {
+  return async (params) => {
+    try {
+      const content = await handler(params);
+      if (typeof content === "string") {
+        return { content: [{ type: "text", text: content }] };
+      }
+      return { content };
+    } catch (error) {
+      let errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("Target page, context or browser has been closed") || errorMessage.includes("Target closed") || errorMessage.includes("Browser has been disconnected") || errorMessage.includes("Protocol error") || errorMessage.includes("Connection closed")) {
+        await session_default.reset();
+        errorMessage = `Browser connection error: ${errorMessage}. Connection has been reset - please retry the operation.`;
+      }
+      return { content: [{ type: "text", text: errorMessage }] };
+    }
+  };
+}
+
+// src/registry.ts
+function schemaShape(schema) {
+  if ("shape" in schema && typeof schema.shape === "object" && schema.shape !== null) {
+    return schema.shape;
+  }
+  if ("_def" in schema) {
+    const def = schema._def;
+    if (def && "schema" in def) return schemaShape(def.schema);
+  }
+  throw new Error(`Cannot extract shape from schema: ${schema._def?.typeName || "unknown"}`);
+}
+function registerTools(server2) {
+  server2.tool(
+    "open-browser",
+    "Open the browser (environment/profile). Requires envId OR userIndex. Use get-browser-list first to find envId/userIndex. After opening, call connect-browser-with-ws with the returned ws URL to enable automation tools (navigate, screenshot, click, etc.)",
+    schemaShape(profileSchemas.open),
+    wrapHandler(profileActions.open)
+  );
+  server2.tool(
+    "close-browser",
+    "Close the browser",
+    schemaShape(profileSchemas.close),
+    wrapHandler(profileActions.close)
+  );
+  server2.tool(
+    "create-browser",
+    "Create a browser",
+    profileSchemas.create.shape,
+    wrapHandler(profileActions.create)
+  );
+  server2.tool(
+    "update-browser",
+    "Update the browser",
+    profileSchemas.update.shape,
+    wrapHandler(profileActions.update)
+  );
+  server2.tool(
+    "delete-browser",
+    "Delete the browser",
+    schemaShape(profileSchemas.delete),
+    wrapHandler(profileActions.delete)
+  );
+  server2.tool(
+    "get-browser-list",
+    "Get a summary list of browsers (envId, userIndex, browserName, groupId, remark, lastOpenedTime). Use pageSize to limit results. Use envId or userIndex from results to open a browser.",
+    profileSchemas.list.shape,
+    wrapHandler(profileActions.list)
+  );
+  server2.tool(
+    "get-opened-browser",
+    "Get the list of opened browsers",
+    automationSchemas.empty.shape,
+    wrapHandler(profileActions.openedList)
+  );
+  server2.tool(
+    "get-profile-cookies",
+    "Query and return cookies of the specified profile. Only one profile can be queried per request.",
+    schemaShape(profileSchemas.cookies),
+    wrapHandler(profileActions.getCookies)
+  );
+  server2.tool(
+    "get-profile-ua",
+    "Query and return the User-Agent of specified profiles. Up to 10 profiles can be queried per request.",
+    schemaShape(profileSchemas.ua),
+    wrapHandler(profileActions.getUa)
+  );
+  server2.tool(
+    "close-all-profiles",
+    "Close all opened profiles on the current device",
+    profileSchemas.closeAll.shape,
+    wrapHandler(profileActions.closeAll)
+  );
+  server2.tool(
+    "new-fingerprint",
+    "Generate a new fingerprint for specified profiles. Up to 10 profiles are supported per request.",
+    schemaShape(profileSchemas.newFingerprint),
+    wrapHandler(profileActions.newFingerprint)
+  );
+  server2.tool(
+    "delete-cache-v2",
+    "Clear local cache of specific profiles. For account security, please ensure that there are no open browsers on the device when using this interface.",
+    schemaShape(profileSchemas.deleteCache),
+    wrapHandler(profileActions.deleteCache)
+  );
+  server2.tool(
+    "get-browser-active",
+    "Get active browser profile information",
+    schemaShape(profileSchemas.active),
+    wrapHandler(profileActions.getActive)
+  );
+  server2.tool(
+    "get-group-list",
+    "Get the list of groups",
+    groupSchemas.list.shape,
+    wrapHandler(groupActions.list)
+  );
+  server2.tool(
+    "get-proxy-list",
+    "Get the list of proxies",
+    proxySchemas.list.shape,
+    wrapHandler(proxyActions.list)
+  );
+  server2.tool(
+    "check-status",
+    "Check the availability of the current device API interface (Connection Status)",
+    automationSchemas.empty.shape,
+    wrapHandler(systemActions.checkStatus)
+  );
+  server2.tool(
+    "connect-browser-with-ws",
+    "Connect to an opened browser via WebSocket CDP URL (obtained from open-browser result). Must be called before using any automation tools (navigate, screenshot, click, fill-input, etc.)",
+    automationSchemas.connect.shape,
+    wrapHandler(automationActions.connect)
+  );
+  server2.tool(
+    "open-new-page",
+    "Open a new page",
+    automationSchemas.empty.shape,
+    wrapHandler(automationActions.openNewPage)
+  );
+  server2.tool(
+    "navigate",
+    "Navigate to the url",
+    automationSchemas.navigate.shape,
+    wrapHandler(automationActions.navigate)
+  );
+  server2.tool(
+    "screenshot",
+    "Take a screenshot of the current page. savePath is the directory to save to (default: ~/Downloads). Returns the screenshot image.",
+    automationSchemas.screenshot.shape,
+    wrapHandler(automationActions.screenshot)
+  );
+  server2.tool(
+    "get-page-visible-text",
+    "Get the visible text content of the page",
+    automationSchemas.empty.shape,
+    wrapHandler(automationActions.getPageVisibleText)
+  );
+  server2.tool(
+    "get-page-html",
+    "Get the html content of the page",
+    automationSchemas.empty.shape,
+    wrapHandler(automationActions.getPageHtml)
+  );
+  server2.tool(
+    "click-element",
+    "Click the element",
+    automationSchemas.clickElement.shape,
+    wrapHandler(automationActions.clickElement)
+  );
+  server2.tool(
+    "fill-input",
+    "Fill the input",
+    automationSchemas.fillInput.shape,
+    wrapHandler(automationActions.fillInput)
+  );
+  server2.tool(
+    "select-option",
+    "Select the option",
+    automationSchemas.selectOption.shape,
+    wrapHandler(automationActions.selectOption)
+  );
+  server2.tool(
+    "hover-element",
+    "Hover the element",
+    automationSchemas.hoverElement.shape,
+    wrapHandler(automationActions.hoverElement)
+  );
+  server2.tool(
+    "scroll-element",
+    "Scroll the element",
+    automationSchemas.scrollElement.shape,
+    wrapHandler(automationActions.scrollElement)
+  );
+  server2.tool(
+    "press-key",
+    "Press the key",
+    automationSchemas.pressKey.shape,
+    wrapHandler(automationActions.pressKey)
+  );
+  server2.tool(
+    "evaluate-script",
+    "Evaluate the script",
+    automationSchemas.evaluateScript.shape,
+    wrapHandler(automationActions.evaluateScript)
+  );
+  server2.tool(
+    "drag-element",
+    "Drag the element",
+    automationSchemas.dragElement.shape,
+    wrapHandler(automationActions.dragElement)
+  );
+  server2.tool(
+    "iframe-click-element",
+    "Click the element in the iframe",
+    automationSchemas.iframeClickElement.shape,
+    wrapHandler(automationActions.iframeClickElement)
+  );
+}
+
+// src/server.ts
+var server = new import_mcp.McpServer({
+  name: "tgebrowser-mcp-server",
+  version: "1.0.0",
+  capabilities: {
+    resources: {},
+    tools: {}
+  }
+});
+registerTools(server);
+async function main() {
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  console.error("TgeBrowser Local Api MCP Server running on stdio");
+}
+main().catch((error) => {
+  console.error("Fatal error in main():", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@tgebrowser/mcp",
+  "version": "1.0.6",
+  "main": "build/server.js",
+  "type": "commonjs",
+  "bin": {
+    "tgebrowser-local-api-mcp": "./build/server.js"
+  },
+  "scripts": {
+    "build": "tsup"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.7.0",
+    "axios": "^1.8.4",
+    "playwright": "^1.51.1",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@tgebrowser/core": "workspace:*",
+    "@types/node": "^22.13.13",
+    "typescript": "^5.8.2",
+    "tsup": "^8.5.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "build"
+  ]
+}