@tgebrowser/mcp 1.1.0 → 1.1.2

package/build/server.js

@@ -57,13 +57,28 @@ var ENDPOINTS = {
   CREATE_BROWSER: "/api/browser/create",
   UPDATE_BROWSER: "/api/browser/update",
   DELETE_BROWSER: "/api/browser/delete",
+  BATCH_DELETE_BROWSER: "/api/browser/delete/batch",
   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",
+  BATCH_DELETE_CACHE: "/api/browser/batch/delete-cache",
   GET_OPENED_BROWSER: "/api/browser/open/list",
+  GET_MOBILE_DEVICES: "/api/browser/mobile-devices",
+  WINDOW_SORT: "/api/windowbounds/sort",
+  WINDOW_SORT_CUSTOM: "/api/windowbounds/sort/custom",
   GET_GROUP_LIST: "/api/groups/list",
-  GET_PROXY_LIST: "/api/proxies/list"
+  CREATE_GROUP: "/api/groups",
+  UPDATE_GROUP: (groupId) => `/api/groups/${groupId}`,
+  DELETE_GROUP: (groupId) => `/api/groups/${groupId}`,
+  GET_PROXY_LIST: "/api/proxies/list",
+  CREATE_PROXY: "/api/proxies",
+  UPDATE_PROXY: (proxyId) => `/api/proxies/${proxyId}`,
+  DELETE_PROXY: (proxyId) => `/api/proxies/${proxyId}`,
+  WINDOW_HIDE: "/api/window/hide",
+  WINDOW_SHOW: "/api/window/show",
+  UPDATE_COOKIE: "/api/browser/cookie/update",
+  BATCH_UPDATE: "/api/browser/batch/update"
 };
 var apiClient = import_axios.default.create({
   baseURL: BASE_URL,
@@ -210,6 +225,54 @@ To automate this browser, use connect-browser-with-ws with wsUrl="${wsUrl}"`;
     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)}`;
+  },
+  async batchDelete({ envIds, userIndexes, permanent }) {
+    const body = {};
+    if (envIds && envIds.length > 0) body.envIds = envIds;
+    if (userIndexes && userIndexes.length > 0) body.userIndexes = userIndexes;
+    if (permanent !== void 0) body.permanent = permanent;
+    const response = await apiClient.post(ENDPOINTS.BATCH_DELETE_BROWSER, body);
+    assertSuccess(response.data, "batch delete browsers");
+    const info = response.data.data || {};
+    return `Batch delete result: total=${info.total}, deleted=${JSON.stringify(info.deleted)}, failed=${JSON.stringify(info.failed)}`;
+  },
+  async batchDeleteCache({ envIds, userIndexes }) {
+    const body = {};
+    if (envIds && envIds.length > 0) body.envIds = envIds;
+    if (userIndexes && userIndexes.length > 0) body.userIndexes = userIndexes;
+    const response = await apiClient.post(ENDPOINTS.BATCH_DELETE_CACHE, body);
+    assertSuccess(response.data, "batch delete cache");
+    const info = response.data.data || {};
+    return `Batch delete cache result: total=${info.total}, success=${info.success}, failed=${info.failed}`;
+  },
+  async getMobileDevices({ os: os2 }) {
+    const params = {};
+    if (os2) params.os = os2;
+    const response = await apiClient.get(ENDPOINTS.GET_MOBILE_DEVICES, { params });
+    assertSuccess(response.data, "get mobile devices");
+    return `Mobile devices: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async getDetail({ 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 browser detail");
+    return `Browser detail: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async updateCookie({ envId, userIndex, cookie }) {
+    const body = { cookie };
+    if (envId !== void 0) body.envId = envId;
+    if (userIndex !== void 0) body.userIndex = userIndex;
+    const response = await apiClient.post(ENDPOINTS.UPDATE_COOKIE, body);
+    assertSuccess(response.data, "update cookie");
+    return `Cookie updated for envId=${body.envId ?? ""} userIndex=${body.userIndex ?? ""}`;
+  },
+  async batchUpdate({ envIds, field, value }) {
+    const response = await apiClient.put(ENDPOINTS.BATCH_UPDATE, { envIds, field, value });
+    assertSuccess(response.data, "batch update");
+    const info = response.data.data || {};
+    return `Batch update result: total=${info.total}, success=${info.success}, failed=${info.failed}`;
   }
 };
 
@@ -404,8 +467,8 @@ var profileSchemas = {
     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"),
+    envId: import_zod.z.number().describe("Environment id to update"),
+    browserName: import_zod.z.string().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({
@@ -477,7 +540,41 @@ var profileSchemas = {
   }).refine((data) => data.profileId || data.profileNo, {
     message: "Either profileId or profileNo must be provided"
   }),
-  openedList: import_zod.z.object({}).strict()
+  openedList: import_zod.z.object({}).strict(),
+  batchDelete: import_zod.z.object({
+    envIds: import_zod.z.array(import_zod.z.number().int().positive()).optional().describe("Array of environment ids to delete"),
+    userIndexes: import_zod.z.array(import_zod.z.number().int().min(1)).optional().describe("Array of environment indexes to delete"),
+    permanent: import_zod.z.boolean().optional().describe("true=hard delete, false=soft delete (default)")
+  }).refine((data) => data.envIds && data.envIds.length > 0 || data.userIndexes && data.userIndexes.length > 0, {
+    message: "Either envIds or userIndexes must be provided"
+  }),
+  batchDeleteCache: import_zod.z.object({
+    envIds: import_zod.z.array(import_zod.z.number().int().positive()).optional().describe("Array of environment ids"),
+    userIndexes: import_zod.z.array(import_zod.z.number().int().min(1)).optional().describe("Array of environment indexes")
+  }).refine((data) => data.envIds && data.envIds.length > 0 || data.userIndexes && data.userIndexes.length > 0, {
+    message: "Either envIds or userIndexes must be provided"
+  }),
+  mobileDevices: import_zod.z.object({
+    os: import_zod.z.enum(["Android", "iOS"]).optional().describe("Filter by OS: Android or iOS")
+  }).strict(),
+  detail: import_zod.z.object({
+    envId: import_zod.z.number().int().positive().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().int().min(1).optional().describe("Environment index")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  updateCookie: import_zod.z.object({
+    envId: import_zod.z.number().int().positive().optional().describe("Environment id"),
+    userIndex: import_zod.z.number().int().min(1).optional().describe("Environment index"),
+    cookie: import_zod.z.string().describe("Cookie string. Empty string or null clears the cookie.")
+  }).refine((data) => data.envId !== void 0 || data.userIndex !== void 0, {
+    message: "Either envId or userIndex must be provided"
+  }),
+  batchUpdate: import_zod.z.object({
+    envIds: import_zod.z.array(import_zod.z.number().int().positive()).describe("Array of environment ids"),
+    field: import_zod.z.string().describe('Field name to update, e.g. "browserName", "remark", "fingerprint"'),
+    value: import_zod.z.any().describe("New value for the field")
+  })
 };
 
 // ../core/src/automation/actions.ts
@@ -723,6 +820,21 @@ var groupActions = {
     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)}`;
+  },
+  async create({ name }) {
+    const response = await apiClient.post(ENDPOINTS.CREATE_GROUP, { name });
+    assertSuccess2(response.data, "create group");
+    return `Group created: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async update({ groupId, name }) {
+    const response = await apiClient.put(ENDPOINTS.UPDATE_GROUP(groupId), { name });
+    assertSuccess2(response.data, "update group");
+    return `Group updated: groupId=${groupId}`;
+  },
+  async delete({ groupId }) {
+    const response = await apiClient.delete(ENDPOINTS.DELETE_GROUP(groupId));
+    assertSuccess2(response.data, "delete group");
+    return `Group deleted: groupId=${groupId}`;
   }
 };
 
@@ -732,6 +844,16 @@ 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(),
+  create: import_zod3.z.object({
+    name: import_zod3.z.string().describe("Group name")
+  }).strict(),
+  update: import_zod3.z.object({
+    groupId: import_zod3.z.number().int().positive().describe("Group id to update"),
+    name: import_zod3.z.string().describe("New group name")
+  }).strict(),
+  delete: import_zod3.z.object({
+    groupId: import_zod3.z.number().int().positive().describe("Group id to delete")
   }).strict()
 };
 
@@ -749,6 +871,21 @@ var proxyActions = {
     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)}`;
+  },
+  async create(params) {
+    const response = await apiClient.post(ENDPOINTS.CREATE_PROXY, params);
+    assertSuccess3(response.data, "create proxy");
+    return `Proxy created: ${JSON.stringify(response.data.data, null, 2)}`;
+  },
+  async update({ proxyId, ...rest }) {
+    const response = await apiClient.put(ENDPOINTS.UPDATE_PROXY(proxyId), rest);
+    assertSuccess3(response.data, "update proxy");
+    return `Proxy updated: proxyId=${proxyId}`;
+  },
+  async delete({ proxyId }) {
+    const response = await apiClient.delete(ENDPOINTS.DELETE_PROXY(proxyId));
+    assertSuccess3(response.data, "delete proxy");
+    return `Proxy deleted: proxyId=${proxyId}`;
   }
 };
 
@@ -758,21 +895,98 @@ 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(),
+  create: import_zod4.z.object({
+    protocol: import_zod4.z.enum(["http", "socks5"]).describe("Proxy protocol: http or socks5"),
+    host: import_zod4.z.string().optional().describe("Proxy host (required for http/socks5)"),
+    port: import_zod4.z.number().optional().describe("Proxy port (required for http/socks5)"),
+    username: import_zod4.z.string().optional().describe("Proxy username"),
+    password: import_zod4.z.string().optional().describe("Proxy password"),
+    ipChecker: import_zod4.z.enum(["iptrush", "ip234", "ipinfo", "ipapi"]).optional().describe("IP checker service")
+  }).strict(),
+  update: import_zod4.z.object({
+    proxyId: import_zod4.z.number().int().positive().describe("Proxy id to update"),
+    protocol: import_zod4.z.enum(["http", "socks5"]).optional().describe("Proxy protocol"),
+    host: import_zod4.z.string().optional().describe("Proxy host"),
+    port: import_zod4.z.number().optional().describe("Proxy port"),
+    username: import_zod4.z.string().optional().describe("Proxy username"),
+    password: import_zod4.z.string().optional().describe("Proxy password"),
+    ipChecker: import_zod4.z.enum(["iptrush", "ip234", "ipinfo", "ipapi"]).optional().describe("IP checker service")
+  }).strict(),
+  delete: import_zod4.z.object({
+    proxyId: import_zod4.z.number().int().positive().describe("Proxy id to delete")
   }).strict()
 };
 
 // ../core/src/system/actions.ts
+function assertSuccess4(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 systemActions = {
   async checkStatus() {
     const response = await apiClient.get(ENDPOINTS.STATUS);
     return `Connection status: ${JSON.stringify(response.data, null, 2)}`;
+  },
+  async windowSort({ envIds }) {
+    const body = {};
+    if (envIds && envIds.length > 0) body.envIds = envIds;
+    const response = await apiClient.post(ENDPOINTS.WINDOW_SORT, body);
+    assertSuccess4(response.data, "sort windows");
+    return `Window sort result: ${response.data.message || JSON.stringify(response.data.data)}`;
+  },
+  async windowSortCustom(params) {
+    const response = await apiClient.post(ENDPOINTS.WINDOW_SORT_CUSTOM, params);
+    assertSuccess4(response.data, "custom sort windows");
+    return `Custom window sort result: ${response.data.message || JSON.stringify(response.data.data)}`;
+  },
+  async windowHide() {
+    const response = await apiClient.post(ENDPOINTS.WINDOW_HIDE, {});
+    assertSuccess4(response.data, "hide window");
+    return `Window hidden: ${JSON.stringify(response.data.data)}`;
+  },
+  async windowShow() {
+    const response = await apiClient.post(ENDPOINTS.WINDOW_SHOW, {});
+    assertSuccess4(response.data, "show window");
+    return `Window shown: ${JSON.stringify(response.data.data)}`;
   }
 };
 
+// ../core/src/system/schema.ts
+var import_zod5 = require("zod");
+var systemSchemas = {
+  windowSort: import_zod5.z.object({
+    envIds: import_zod5.z.array(import_zod5.z.number().int().positive()).optional().describe("Target environment ids to sort. If omitted, sorts all open windows.")
+  }).strict(),
+  windowSortCustom: import_zod5.z.object({
+    type: import_zod5.z.enum(["box", "diagonal"]).describe("Layout type: box (grid) or diagonal"),
+    width: import_zod5.z.number().positive().describe("Window width"),
+    height: import_zod5.z.number().positive().describe("Window height"),
+    col: import_zod5.z.number().int().positive().describe("Column count"),
+    startX: import_zod5.z.number().describe("Starting X coordinate"),
+    startY: import_zod5.z.number().describe("Starting Y coordinate"),
+    spaceX: import_zod5.z.number().describe("Horizontal spacing between windows"),
+    spaceY: import_zod5.z.number().describe("Vertical spacing between windows"),
+    offsetX: import_zod5.z.number().describe("X offset"),
+    offsetY: import_zod5.z.number().describe("Y offset"),
+    envIds: import_zod5.z.array(import_zod5.z.number().int().positive()).optional().describe("Target environment ids"),
+    minWindowCount: import_zod5.z.number().int().positive().optional().describe("Minimum number of windows to trigger sort")
+  }).strict()
+};
+
 // src/wrap.ts
-function wrapHandler(handler) {
+function wrapHandler(handler, schema) {
   return async (params) => {
     try {
+      if (schema) {
+        const result = schema.safeParse(params);
+        if (!result.success) {
+          const messages = result.error.errors.map((e) => e.message).join("; ");
+          return { content: [{ type: "text", text: `Invalid parameters: ${messages}` }] };
+        }
+        params = result.data;
+      }
       const content = await handler(params);
       if (typeof content === "string") {
         return { content: [{ type: "text", text: content }] };
@@ -805,37 +1019,37 @@ function registerTools(server2) {
     "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)
+    wrapHandler(profileActions.open, profileSchemas.open)
   );
   server2.tool(
     "close-browser",
     "Close the browser",
     schemaShape(profileSchemas.close),
-    wrapHandler(profileActions.close)
+    wrapHandler(profileActions.close, profileSchemas.close)
   );
   server2.tool(
     "create-browser",
     "Create a browser",
     profileSchemas.create.shape,
-    wrapHandler(profileActions.create)
+    wrapHandler(profileActions.create, profileSchemas.create)
   );
   server2.tool(
     "update-browser",
-    "Update the browser",
+    "Update the browser. envId and browserName are required.",
     profileSchemas.update.shape,
-    wrapHandler(profileActions.update)
+    wrapHandler(profileActions.update, profileSchemas.update)
   );
   server2.tool(
     "delete-browser",
     "Delete the browser",
     schemaShape(profileSchemas.delete),
-    wrapHandler(profileActions.delete)
+    wrapHandler(profileActions.delete, profileSchemas.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)
+    wrapHandler(profileActions.list, profileSchemas.list)
   );
   server2.tool(
     "get-opened-browser",
@@ -847,13 +1061,13 @@ function registerTools(server2) {
     "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)
+    wrapHandler(profileActions.getCookies, profileSchemas.cookies)
   );
   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)
+    wrapHandler(profileActions.getUa, profileSchemas.ua)
   );
   server2.tool(
     "close-all-profiles",
@@ -865,31 +1079,103 @@ function registerTools(server2) {
     "new-fingerprint",
     "Generate a new fingerprint for specified profiles. Up to 10 profiles are supported per request.",
     schemaShape(profileSchemas.newFingerprint),
-    wrapHandler(profileActions.newFingerprint)
+    wrapHandler(profileActions.newFingerprint, profileSchemas.newFingerprint)
   );
   server2.tool(
-    "delete-cache-v2",
+    "delete-cache",
     "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)
+    wrapHandler(profileActions.deleteCache, profileSchemas.deleteCache)
   );
   server2.tool(
     "get-browser-active",
     "Get active browser profile information",
     schemaShape(profileSchemas.active),
-    wrapHandler(profileActions.getActive)
+    wrapHandler(profileActions.getActive, profileSchemas.active)
+  );
+  server2.tool(
+    "delete-browser-batch",
+    "Batch delete multiple browser environments at once",
+    schemaShape(profileSchemas.batchDelete),
+    wrapHandler(profileActions.batchDelete, profileSchemas.batchDelete)
+  );
+  server2.tool(
+    "delete-cache-batch",
+    "Clear local cache for multiple browser profiles at once",
+    schemaShape(profileSchemas.batchDeleteCache),
+    wrapHandler(profileActions.batchDeleteCache, profileSchemas.batchDeleteCache)
+  );
+  server2.tool(
+    "get-mobile-devices",
+    "Get available mobile device models for Android/iOS fingerprinting",
+    profileSchemas.mobileDevices.shape,
+    wrapHandler(profileActions.getMobileDevices, profileSchemas.mobileDevices)
+  );
+  server2.tool(
+    "get-browser-detail",
+    "Get detailed information for a single browser environment",
+    profileSchemas.detail.shape,
+    wrapHandler(profileActions.getDetail, profileSchemas.detail)
+  );
+  server2.tool(
+    "update-cookie",
+    "Update the cookie for a specific environment. Pass empty string to clear.",
+    schemaShape(profileSchemas.updateCookie),
+    wrapHandler(profileActions.updateCookie, profileSchemas.updateCookie)
+  );
+  server2.tool(
+    "batch-update",
+    "Batch update a specific field across multiple environments",
+    profileSchemas.batchUpdate.shape,
+    wrapHandler(profileActions.batchUpdate, profileSchemas.batchUpdate)
   );
   server2.tool(
     "get-group-list",
     "Get the list of groups",
     groupSchemas.list.shape,
-    wrapHandler(groupActions.list)
+    wrapHandler(groupActions.list, groupSchemas.list)
+  );
+  server2.tool(
+    "create-group",
+    "Create a new browser environment group",
+    groupSchemas.create.shape,
+    wrapHandler(groupActions.create, groupSchemas.create)
+  );
+  server2.tool(
+    "update-group",
+    "Update an existing group name",
+    groupSchemas.update.shape,
+    wrapHandler(groupActions.update, groupSchemas.update)
+  );
+  server2.tool(
+    "delete-group",
+    "Delete a group by groupId",
+    groupSchemas.delete.shape,
+    wrapHandler(groupActions.delete, groupSchemas.delete)
   );
   server2.tool(
     "get-proxy-list",
     "Get the list of proxies",
     proxySchemas.list.shape,
-    wrapHandler(proxyActions.list)
+    wrapHandler(proxyActions.list, proxySchemas.list)
+  );
+  server2.tool(
+    "create-proxy",
+    "Create a new proxy configuration",
+    proxySchemas.create.shape,
+    wrapHandler(proxyActions.create, proxySchemas.create)
+  );
+  server2.tool(
+    "update-proxy",
+    "Update an existing proxy configuration",
+    proxySchemas.update.shape,
+    wrapHandler(proxyActions.update, proxySchemas.update)
+  );
+  server2.tool(
+    "delete-proxy",
+    "Delete a proxy configuration by proxyId",
+    proxySchemas.delete.shape,
+    wrapHandler(proxyActions.delete, proxySchemas.delete)
   );
   server2.tool(
     "check-status",
@@ -897,6 +1183,30 @@ function registerTools(server2) {
     automationSchemas.empty.shape,
     wrapHandler(systemActions.checkStatus)
   );
+  server2.tool(
+    "window-sort",
+    "Auto-arrange open browser windows to fit the screen",
+    systemSchemas.windowSort.shape,
+    wrapHandler(systemActions.windowSort, systemSchemas.windowSort)
+  );
+  server2.tool(
+    "window-sort-custom",
+    "Arrange browser windows using a custom layout (grid or diagonal)",
+    systemSchemas.windowSortCustom.shape,
+    wrapHandler(systemActions.windowSortCustom, systemSchemas.windowSortCustom)
+  );
+  server2.tool(
+    "window-hide",
+    "Hide the TgeBrowser client window",
+    automationSchemas.empty.shape,
+    wrapHandler(systemActions.windowHide)
+  );
+  server2.tool(
+    "window-show",
+    "Show the TgeBrowser client window",
+    automationSchemas.empty.shape,
+    wrapHandler(systemActions.windowShow)
+  );
   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.)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tgebrowser/mcp",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "main": "build/server.js",
   "type": "commonjs",
   "bin": {