gclm-code 1.0.0 → 1.0.1

package/vendor/modules/node_modules/@ant/claude-for-chrome-mcp/src/mcpSocketPool.ts

@@ -0,0 +1,327 @@
+import {
+  createMcpSocketClient,
+  SocketConnectionError,
+} from "./mcpSocketClient.js";
+import type { McpSocketClient } from "./mcpSocketClient.js";
+import type {
+  ClaudeForChromeContext,
+  PermissionMode,
+  PermissionOverrides,
+} from "./types.js";
+
+/**
+ * Manages connections to multiple Chrome native host sockets (one per Chrome profile).
+ * Routes tool calls to the correct socket based on tab ID.
+ *
+ * For `tabs_context_mcp`: queries all connected sockets and merges results.
+ * For other tools: routes based on the `tabId` argument using a routing table
+ * built from tabs_context_mcp responses.
+ */
+export class McpSocketPool {
+  private clients: Map<string, McpSocketClient> = new Map();
+  private tabRoutes: Map<number, string> = new Map();
+  private context: ClaudeForChromeContext;
+  private notificationHandler:
+    | ((notification: { method: string; params?: Record<string, unknown> }) => void)
+    | null = null;
+
+  constructor(context: ClaudeForChromeContext) {
+    this.context = context;
+  }
+
+  public setNotificationHandler(
+    handler: (notification: {
+      method: string;
+      params?: Record<string, unknown>;
+    }) => void,
+  ): void {
+    this.notificationHandler = handler;
+    for (const client of this.clients.values()) {
+      client.setNotificationHandler(handler);
+    }
+  }
+
+  /**
+   * Discover available sockets and ensure at least one is connected.
+   */
+  public async ensureConnected(): Promise<boolean> {
+    const { logger, serverName } = this.context;
+
+    this.refreshClients();
+
+    // Try to connect any disconnected clients
+    const connectPromises: Promise<boolean>[] = [];
+    for (const client of this.clients.values()) {
+      if (!client.isConnected()) {
+        connectPromises.push(
+          client.ensureConnected().catch(() => false),
+        );
+      }
+    }
+
+    if (connectPromises.length > 0) {
+      await Promise.all(connectPromises);
+    }
+
+    const connectedCount = this.getConnectedClients().length;
+    if (connectedCount === 0) {
+      logger.info(`[${serverName}] No connected sockets in pool`);
+      return false;
+    }
+
+    logger.info(`[${serverName}] Socket pool: ${connectedCount} connected`);
+    return true;
+  }
+
+  /**
+   * Call a tool, routing to the correct socket based on tab ID.
+   * For tabs_context_mcp, queries all sockets and merges results.
+   */
+  public async callTool(
+    name: string,
+    args: Record<string, unknown>,
+    _permissionOverrides?: PermissionOverrides,
+  ): Promise<unknown> {
+    if (name === "tabs_context_mcp") {
+      return this.callTabsContext(args);
+    }
+
+    // Route by tabId if present
+    const tabId = args.tabId as number | undefined;
+    if (tabId !== undefined) {
+      const socketPath = this.tabRoutes.get(tabId);
+      if (socketPath) {
+        const client = this.clients.get(socketPath);
+        if (client?.isConnected()) {
+          return client.callTool(name, args);
+        }
+      }
+      // Tab route not found or client disconnected — fall through to any connected
+    }
+
+    // Fallback: use first connected client
+    const connected = this.getConnectedClients();
+    if (connected.length === 0) {
+      throw new SocketConnectionError(
+        `[${this.context.serverName}] No connected sockets available`,
+      );
+    }
+    return connected[0]!.callTool(name, args);
+  }
+
+  public async setPermissionMode(
+    mode: PermissionMode,
+    allowedDomains?: string[],
+  ): Promise<void> {
+    const connected = this.getConnectedClients();
+    await Promise.all(
+      connected.map((client) => client.setPermissionMode(mode, allowedDomains)),
+    );
+  }
+
+  public isConnected(): boolean {
+    return this.getConnectedClients().length > 0;
+  }
+
+  public disconnect(): void {
+    for (const client of this.clients.values()) {
+      client.disconnect();
+    }
+    this.clients.clear();
+    this.tabRoutes.clear();
+  }
+
+  private getConnectedClients(): McpSocketClient[] {
+    return [...this.clients.values()].filter((c) => c.isConnected());
+  }
+
+  /**
+   * Query all connected sockets for tabs and merge results.
+   * Updates the tab routing table.
+   */
+  private async callTabsContext(
+    args: Record<string, unknown>,
+  ): Promise<unknown> {
+    const { logger, serverName } = this.context;
+    const connected = this.getConnectedClients();
+
+    if (connected.length === 0) {
+      throw new SocketConnectionError(
+        `[${serverName}] No connected sockets available`,
+      );
+    }
+
+    // If only one client, skip merging overhead
+    if (connected.length === 1) {
+      const result = await connected[0]!.callTool("tabs_context_mcp", args);
+      this.updateTabRoutes(result, this.getSocketPathForClient(connected[0]!));
+      return result;
+    }
+
+    // Query all connected clients in parallel
+    const results = await Promise.allSettled(
+      connected.map(async (client) => {
+        const result = await client.callTool("tabs_context_mcp", args);
+        const socketPath = this.getSocketPathForClient(client);
+        return { result, socketPath };
+      }),
+    );
+
+    // Merge tab results
+    const mergedTabs: unknown[] = [];
+    this.tabRoutes.clear();
+
+    for (const settledResult of results) {
+      if (settledResult.status !== "fulfilled") {
+        logger.info(
+          `[${serverName}] tabs_context_mcp failed on one socket: ${settledResult.reason}`,
+        );
+        continue;
+      }
+
+      const { result, socketPath } = settledResult.value;
+      this.updateTabRoutes(result, socketPath);
+
+      const tabs = this.extractTabs(result);
+      if (tabs) {
+        mergedTabs.push(...tabs);
+      }
+    }
+
+    // Return merged result in the same format as the extension response
+    if (mergedTabs.length > 0) {
+      const tabListText = mergedTabs
+        .map((t) => {
+          const tab = t as { tabId: number; title: string; url: string };
+          return `  • tabId ${tab.tabId}: "${tab.title}" (${tab.url})`;
+        })
+        .join("\n");
+
+      return {
+        result: {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ availableTabs: mergedTabs }),
+            },
+            {
+              type: "text",
+              text: `\n\nTab Context:\n- Available tabs:\n${tabListText}`,
+            },
+          ],
+        },
+      };
+    }
+
+    // Fallback: return first successful result as-is
+    for (const settledResult of results) {
+      if (settledResult.status === "fulfilled") {
+        return settledResult.value.result;
+      }
+    }
+
+    throw new SocketConnectionError(
+      `[${serverName}] All sockets failed for tabs_context_mcp`,
+    );
+  }
+
+  /**
+   * Extract tab objects from a tool response to update routing table.
+   */
+  private updateTabRoutes(result: unknown, socketPath: string): void {
+    const tabs = this.extractTabs(result);
+    if (!tabs) return;
+
+    for (const tab of tabs) {
+      if (typeof tab === "object" && tab !== null && "tabId" in tab) {
+        const tabId = (tab as { tabId: number }).tabId;
+        this.tabRoutes.set(tabId, socketPath);
+      }
+    }
+  }
+
+  private extractTabs(result: unknown): unknown[] | null {
+    if (!result || typeof result !== "object") return null;
+
+    // Response format: { result: { content: [{ type: "text", text: "{\"availableTabs\":[...],\"tabGroupId\":...}" }] } }
+    const asResponse = result as {
+      result?: { content?: Array<{ type: string; text?: string }> };
+    };
+    const content = asResponse.result?.content;
+    if (!content || !Array.isArray(content)) return null;
+
+    for (const item of content) {
+      if (item.type === "text" && item.text) {
+        try {
+          const parsed = JSON.parse(item.text);
+          if (Array.isArray(parsed)) return parsed;
+          // Handle { availableTabs: [...] } format
+          if (parsed && Array.isArray(parsed.availableTabs)) {
+            return parsed.availableTabs;
+          }
+        } catch {
+          // Not JSON, skip
+        }
+      }
+    }
+    return null;
+  }
+
+  private getSocketPathForClient(client: McpSocketClient): string {
+    for (const [path, c] of this.clients.entries()) {
+      if (c === client) return path;
+    }
+    return "";
+  }
+
+  /**
+   * Scan for available sockets and create/remove clients as needed.
+   */
+  private refreshClients(): void {
+    const socketPaths = this.getAvailableSocketPaths();
+    const { logger, serverName } = this.context;
+
+    // Add new clients for newly discovered sockets
+    for (const path of socketPaths) {
+      if (!this.clients.has(path)) {
+        logger.info(`[${serverName}] Adding socket to pool: ${path}`);
+        const clientContext: ClaudeForChromeContext = {
+          ...this.context,
+          socketPath: path,
+          getSocketPath: undefined,
+          getSocketPaths: undefined,
+        };
+        const client = createMcpSocketClient(clientContext);
+        client.disableAutoReconnect = true;
+        if (this.notificationHandler) {
+          client.setNotificationHandler(this.notificationHandler);
+        }
+        this.clients.set(path, client);
+      }
+    }
+
+    // Remove clients for sockets that no longer exist
+    for (const [path, client] of this.clients.entries()) {
+      if (!socketPaths.includes(path)) {
+        logger.info(`[${serverName}] Removing stale socket from pool: ${path}`);
+        client.disconnect();
+        this.clients.delete(path);
+        for (const [tabId, socketPath] of this.tabRoutes.entries()) {
+          if (socketPath === path) {
+            this.tabRoutes.delete(tabId);
+          }
+        }
+      }
+    }
+  }
+
+  private getAvailableSocketPaths(): string[] {
+    return this.context.getSocketPaths?.() ?? [];
+  }
+}
+
+export function createMcpSocketPool(
+  context: ClaudeForChromeContext,
+): McpSocketPool {
+  return new McpSocketPool(context);
+}

package/vendor/modules/node_modules/@ant/claude-for-chrome-mcp/src/toolCalls.ts

@@ -0,0 +1,301 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+
+import { SocketConnectionError } from "./mcpSocketClient.js";
+import type {
+  ClaudeForChromeContext,
+  PermissionMode,
+  PermissionOverrides,
+  SocketClient,
+} from "./types.js";
+
+export const handleToolCall = async (
+  context: ClaudeForChromeContext,
+  socketClient: SocketClient,
+  name: string,
+  args: Record<string, unknown>,
+  permissionOverrides?: PermissionOverrides,
+): Promise<CallToolResult> => {
+  // Handle permission mode changes locally (not forwarded to extension)
+  if (name === "set_permission_mode") {
+    return handleSetPermissionMode(socketClient, args);
+  }
+
+  // Handle switch_browser outside the normal tool call flow (manages its own connection)
+  if (name === "switch_browser") {
+    return handleSwitchBrowser(context, socketClient);
+  }
+
+  try {
+    const isConnected = await socketClient.ensureConnected();
+
+    context.logger.silly(
+      `[${context.serverName}] Server is connected: ${isConnected}. Received tool call: ${name} with args: ${JSON.stringify(args)}.`,
+    );
+
+    if (isConnected) {
+      return await handleToolCallConnected(
+        context,
+        socketClient,
+        name,
+        args,
+        permissionOverrides,
+      );
+    }
+
+    return handleToolCallDisconnected(context);
+  } catch (error) {
+    context.logger.info(`[${context.serverName}] Error calling tool:`, error);
+
+    if (error instanceof SocketConnectionError) {
+      return handleToolCallDisconnected(context);
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error calling tool, please try again. : ${error instanceof Error ? error.message : String(error)}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+};
+
+async function handleToolCallConnected(
+  context: ClaudeForChromeContext,
+  socketClient: SocketClient,
+  name: string,
+  args: Record<string, unknown>,
+  permissionOverrides?: PermissionOverrides,
+): Promise<CallToolResult> {
+  const response = await socketClient.callTool(name, args, permissionOverrides);
+
+  context.logger.silly(
+    `[${context.serverName}] Received result from socket bridge: ${JSON.stringify(response)}`,
+  );
+
+  if (response === null || response === undefined) {
+    return {
+      content: [{ type: "text", text: "Tool execution completed" }],
+    };
+  }
+
+  // Response will have either result or error field
+  const { result, error } = response as {
+    result?: { content: unknown[] | string };
+    error?: { content: unknown[] | string };
+  };
+
+  // Determine which field has the content and whether it's an error
+  const contentData = error || result;
+  const isError = !!error;
+
+  if (!contentData) {
+    return {
+      content: [{ type: "text", text: "Tool execution completed" }],
+    };
+  }
+
+  if (isError && isAuthenticationError(contentData.content)) {
+    context.onAuthenticationError();
+  }
+
+  const { content } = contentData;
+
+  if (content && Array.isArray(content)) {
+    if (isError) {
+      return {
+        content: content.map((item: unknown) => {
+          if (typeof item === "object" && item !== null && "type" in item) {
+            return item;
+          }
+
+          return { type: "text", text: String(item) };
+        }),
+        isError: true,
+      } as CallToolResult;
+    }
+
+    const convertedContent = content.map((item: unknown) => {
+      if (
+        typeof item === "object" &&
+        item !== null &&
+        "type" in item &&
+        "source" in item
+      ) {
+        const typedItem = item;
+        if (
+          typedItem.type === "image" &&
+          typeof typedItem.source === "object" &&
+          typedItem.source !== null &&
+          "data" in typedItem.source
+        ) {
+          return {
+            type: "image",
+            data: typedItem.source.data,
+            mimeType:
+              "media_type" in typedItem.source
+                ? typedItem.source.media_type || "image/png"
+                : "image/png",
+          };
+        }
+      }
+
+      if (typeof item === "object" && item !== null && "type" in item) {
+        return item;
+      }
+
+      return { type: "text", text: String(item) };
+    });
+
+    return {
+      content: convertedContent,
+      isError,
+    } as CallToolResult;
+  }
+
+  // Handle string content
+  if (typeof content === "string") {
+    return {
+      content: [{ type: "text", text: content }],
+      isError,
+    } as CallToolResult;
+  }
+
+  // Fallback for unexpected result format
+  context.logger.warn(
+    `[${context.serverName}] Unexpected result format from socket bridge`,
+    response,
+  );
+
+  return {
+    content: [{ type: "text", text: JSON.stringify(response) }],
+    isError,
+  };
+}
+
+function handleToolCallDisconnected(
+  context: ClaudeForChromeContext,
+): CallToolResult {
+  const text = context.onToolCallDisconnected();
+  return {
+    content: [{ type: "text", text }],
+  };
+}
+
+/**
+ * Handle set_permission_mode tool call locally.
+ * This is security-sensitive as it controls whether permission prompts are shown.
+ */
+async function handleSetPermissionMode(
+  socketClient: SocketClient,
+  args: Record<string, unknown>,
+): Promise<CallToolResult> {
+  // Validate permission mode at runtime
+  const validModes = [
+    "ask",
+    "skip_all_permission_checks",
+    "follow_a_plan",
+  ] as const;
+  const mode = args.mode as string | undefined;
+  const permissionMode: PermissionMode =
+    mode && validModes.includes(mode as PermissionMode)
+      ? (mode as PermissionMode)
+      : "ask";
+
+  if (socketClient.setPermissionMode) {
+    await socketClient.setPermissionMode(
+      permissionMode,
+      args.allowed_domains as string[] | undefined,
+    );
+  }
+
+  return {
+    content: [
+      { type: "text", text: `Permission mode set to: ${permissionMode}` },
+    ],
+  };
+}
+
+/**
+ * Handle switch_browser tool call. Broadcasts a pairing request and blocks
+ * until a browser responds or timeout.
+ */
+async function handleSwitchBrowser(
+  context: ClaudeForChromeContext,
+  socketClient: SocketClient,
+): Promise<CallToolResult> {
+  if (!context.bridgeConfig) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Browser switching is only available with bridge connections.",
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  const isConnected = await socketClient.ensureConnected();
+  if (!isConnected) {
+    return handleToolCallDisconnected(context);
+  }
+
+  const result = (await socketClient.switchBrowser?.()) ?? null;
+
+  if (result === "no_other_browsers") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "No other browsers available to switch to. Open Chrome with the Claude extension in another browser to switch.",
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  if (result) {
+    return {
+      content: [
+        { type: "text", text: `Connected to browser "${result.name}".` },
+      ],
+    };
+  }
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: "No browser responded within the timeout. Make sure Chrome is open with the Claude extension installed, then try again.",
+      },
+    ],
+    isError: true,
+  };
+}
+
+/**
+ * Check if the error content indicates an authentication issue
+ */
+function isAuthenticationError(content: unknown[] | string): boolean {
+  const errorText = Array.isArray(content)
+    ? content
+        .map((item) => {
+          if (typeof item === "string") return item;
+          if (
+            typeof item === "object" &&
+            item !== null &&
+            "text" in item &&
+            typeof item.text === "string"
+          ) {
+            return item.text;
+          }
+          return "";
+        })
+        .join(" ")
+    : String(content);
+
+  return errorText.toLowerCase().includes("re-authenticated");
+}