@zyycn/claudex 1.0.3-fork.63859d8

package/dist/chunk-j3a4p81y.js

@@ -0,0 +1,184 @@
+// @bun
+import {
+  require_dist_cjs as require_dist_cjs5
+} from "./chunk-2k995y2x.js";
+import {
+  require_dist_cjs3 as require_dist_cjs4
+} from "./chunk-wfz0qffj.js";
+import {
+  require_client
+} from "./chunk-b4wg70y1.js";
+import {
+  require_dist_cjs2
+} from "./chunk-nka1g8f4.js";
+import {
+  require_dist_cjs
+} from "./chunk-30rst83v.js";
+import {
+  require_dist_cjs as require_dist_cjs3
+} from "./chunk-hk9xz7gk.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@aws-sdk+credential-provider-http@3.972.26/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/checkUrl.js
+var import_property_provider, ECS_CONTAINER_HOST = "169.254.170.2", EKS_CONTAINER_HOST_IPv4 = "169.254.170.23", EKS_CONTAINER_HOST_IPv6 = "[fd00:ec2::23]", checkUrl = (url, logger) => {
+  if (url.protocol === "https:") {
+    return;
+  }
+  if (url.hostname === ECS_CONTAINER_HOST || url.hostname === EKS_CONTAINER_HOST_IPv4 || url.hostname === EKS_CONTAINER_HOST_IPv6) {
+    return;
+  }
+  if (url.hostname.includes("[")) {
+    if (url.hostname === "[::1]" || url.hostname === "[0000:0000:0000:0000:0000:0000:0000:0001]") {
+      return;
+    }
+  } else {
+    if (url.hostname === "localhost") {
+      return;
+    }
+    const ipComponents = url.hostname.split(".");
+    const inRange = (component) => {
+      const num = parseInt(component, 10);
+      return 0 <= num && num <= 255;
+    };
+    if (ipComponents[0] === "127" && inRange(ipComponents[1]) && inRange(ipComponents[2]) && inRange(ipComponents[3]) && ipComponents.length === 4) {
+      return;
+    }
+  }
+  throw new import_property_provider.CredentialsProviderError(`URL not accepted. It must either be HTTPS or match one of the following:
+  - loopback CIDR 127.0.0.0/8 or [::1/128]
+  - ECS container host 169.254.170.2
+  - EKS container host 169.254.170.23 or [fd00:ec2::23]`, { logger });
+};
+var init_checkUrl = __esm(() => {
+  import_property_provider = __toESM(require_dist_cjs3(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+credential-provider-http@3.972.26/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/requestHelpers.js
+function createGetRequest(url) {
+  return new import_protocol_http.HttpRequest({
+    protocol: url.protocol,
+    hostname: url.hostname,
+    port: Number(url.port),
+    path: url.pathname,
+    query: Array.from(url.searchParams.entries()).reduce((acc, [k, v]) => {
+      acc[k] = v;
+      return acc;
+    }, {}),
+    fragment: url.hash
+  });
+}
+async function getCredentials(response, logger) {
+  const stream = import_util_stream.sdkStreamMixin(response.body);
+  const str = await stream.transformToString();
+  if (response.statusCode === 200) {
+    const parsed = JSON.parse(str);
+    if (typeof parsed.AccessKeyId !== "string" || typeof parsed.SecretAccessKey !== "string" || typeof parsed.Token !== "string" || typeof parsed.Expiration !== "string") {
+      throw new import_property_provider2.CredentialsProviderError("HTTP credential provider response not of the required format, an object matching: " + "{ AccessKeyId: string, SecretAccessKey: string, Token: string, Expiration: string(rfc3339) }", { logger });
+    }
+    return {
+      accessKeyId: parsed.AccessKeyId,
+      secretAccessKey: parsed.SecretAccessKey,
+      sessionToken: parsed.Token,
+      expiration: import_smithy_client.parseRfc3339DateTime(parsed.Expiration)
+    };
+  }
+  if (response.statusCode >= 400 && response.statusCode < 500) {
+    let parsedBody = {};
+    try {
+      parsedBody = JSON.parse(str);
+    } catch (e) {}
+    throw Object.assign(new import_property_provider2.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger }), {
+      Code: parsedBody.Code,
+      Message: parsedBody.Message
+    });
+  }
+  throw new import_property_provider2.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger });
+}
+var import_property_provider2, import_protocol_http, import_smithy_client, import_util_stream;
+var init_requestHelpers = __esm(() => {
+  import_property_provider2 = __toESM(require_dist_cjs3(), 1);
+  import_protocol_http = __toESM(require_dist_cjs(), 1);
+  import_smithy_client = __toESM(require_dist_cjs5(), 1);
+  import_util_stream = __toESM(require_dist_cjs4(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+credential-provider-http@3.972.26/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/retry-wrapper.js
+var retryWrapper = (toRetry, maxRetries, delayMs) => {
+  return async () => {
+    for (let i = 0;i < maxRetries; ++i) {
+      try {
+        return await toRetry();
+      } catch (e) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+    return await toRetry();
+  };
+};
+var init_retry_wrapper = () => {};
+
+// node_modules/.bun/@aws-sdk+credential-provider-http@3.972.26/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js
+import fs from "fs/promises";
+var import_client, import_node_http_handler, import_property_provider3, AWS_CONTAINER_CREDENTIALS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", DEFAULT_LINK_LOCAL_HOST = "http://169.254.170.2", AWS_CONTAINER_CREDENTIALS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI", AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE = "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE", AWS_CONTAINER_AUTHORIZATION_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN", fromHttp = (options = {}) => {
+  options.logger?.debug("@aws-sdk/credential-provider-http - fromHttp");
+  let host;
+  const relative = options.awsContainerCredentialsRelativeUri ?? process.env[AWS_CONTAINER_CREDENTIALS_RELATIVE_URI];
+  const full = options.awsContainerCredentialsFullUri ?? process.env[AWS_CONTAINER_CREDENTIALS_FULL_URI];
+  const token = options.awsContainerAuthorizationToken ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN];
+  const tokenFile = options.awsContainerAuthorizationTokenFile ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE];
+  const warn = options.logger?.constructor?.name === "NoOpLogger" || !options.logger?.warn ? console.warn : options.logger.warn.bind(options.logger);
+  if (relative && full) {
+    warn("@aws-sdk/credential-provider-http: " + "you have set both awsContainerCredentialsRelativeUri and awsContainerCredentialsFullUri.");
+    warn("awsContainerCredentialsFullUri will take precedence.");
+  }
+  if (token && tokenFile) {
+    warn("@aws-sdk/credential-provider-http: " + "you have set both awsContainerAuthorizationToken and awsContainerAuthorizationTokenFile.");
+    warn("awsContainerAuthorizationToken will take precedence.");
+  }
+  if (full) {
+    host = full;
+  } else if (relative) {
+    host = `${DEFAULT_LINK_LOCAL_HOST}${relative}`;
+  } else {
+    throw new import_property_provider3.CredentialsProviderError(`No HTTP credential provider host provided.
+Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI.`, { logger: options.logger });
+  }
+  const url = new URL(host);
+  checkUrl(url, options.logger);
+  const requestHandler = import_node_http_handler.NodeHttpHandler.create({
+    requestTimeout: options.timeout ?? 1000,
+    connectionTimeout: options.timeout ?? 1000
+  });
+  return retryWrapper(async () => {
+    const request = createGetRequest(url);
+    if (token) {
+      request.headers.Authorization = token;
+    } else if (tokenFile) {
+      request.headers.Authorization = (await fs.readFile(tokenFile)).toString();
+    }
+    try {
+      const result = await requestHandler.handle(request);
+      return getCredentials(result.response).then((creds) => import_client.setCredentialFeature(creds, "CREDENTIALS_HTTP", "z"));
+    } catch (e) {
+      throw new import_property_provider3.CredentialsProviderError(String(e), { logger: options.logger });
+    }
+  }, options.maxRetries ?? 3, options.timeout ?? 1000);
+};
+var init_fromHttp = __esm(() => {
+  init_checkUrl();
+  init_requestHelpers();
+  init_retry_wrapper();
+  import_client = __toESM(require_client(), 1);
+  import_node_http_handler = __toESM(require_dist_cjs2(), 1);
+  import_property_provider3 = __toESM(require_dist_cjs3(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+credential-provider-http@3.972.26/node_modules/@aws-sdk/credential-provider-http/dist-es/index.js
+var init_dist_es = __esm(() => {
+  init_fromHttp();
+});
+
+export { fromHttp, init_dist_es };

package/dist/chunk-j5hc27hv.js

@@ -0,0 +1,444 @@
+// @bun
+import {
+  init_normalization,
+  normalizeNameForMCP
+} from "./chunk-3c25bcsw.js";
+import {
+  getPlatform,
+  init_platform
+} from "./chunk-nj17bhkh.js";
+import {
+  init_which,
+  which
+} from "./chunk-fbpftpf0.js";
+import {
+  execFileNoThrow,
+  init_execFileNoThrow
+} from "./chunk-gzzfhtdv.js";
+import {
+  init_debug,
+  init_errors,
+  isFsInaccessible,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/claudeInChrome/common.ts
+import { readdirSync } from "fs";
+import { stat } from "fs/promises";
+import { homedir, platform, tmpdir, userInfo } from "os";
+import { join } from "path";
+function getAllBrowserDataPaths() {
+  const platform2 = getPlatform();
+  const home = homedir();
+  const paths = [];
+  for (const browserId of BROWSER_DETECTION_ORDER) {
+    const config = CHROMIUM_BROWSERS[browserId];
+    let dataPath;
+    switch (platform2) {
+      case "macos":
+        dataPath = config.macos.dataPath;
+        break;
+      case "linux":
+      case "wsl":
+        dataPath = config.linux.dataPath;
+        break;
+      case "windows": {
+        if (config.windows.dataPath.length > 0) {
+          const appDataBase = config.windows.useRoaming ? join(home, "AppData", "Roaming") : join(home, "AppData", "Local");
+          paths.push({
+            browser: browserId,
+            path: join(appDataBase, ...config.windows.dataPath)
+          });
+        }
+        continue;
+      }
+    }
+    if (dataPath && dataPath.length > 0) {
+      paths.push({
+        browser: browserId,
+        path: join(home, ...dataPath)
+      });
+    }
+  }
+  return paths;
+}
+function getAllNativeMessagingHostsDirs() {
+  const platform2 = getPlatform();
+  const home = homedir();
+  const paths = [];
+  for (const browserId of BROWSER_DETECTION_ORDER) {
+    const config = CHROMIUM_BROWSERS[browserId];
+    switch (platform2) {
+      case "macos":
+        if (config.macos.nativeMessagingPath.length > 0) {
+          paths.push({
+            browser: browserId,
+            path: join(home, ...config.macos.nativeMessagingPath)
+          });
+        }
+        break;
+      case "linux":
+      case "wsl":
+        if (config.linux.nativeMessagingPath.length > 0) {
+          paths.push({
+            browser: browserId,
+            path: join(home, ...config.linux.nativeMessagingPath)
+          });
+        }
+        break;
+      case "windows":
+        break;
+    }
+  }
+  return paths;
+}
+function getAllWindowsRegistryKeys() {
+  const keys = [];
+  for (const browserId of BROWSER_DETECTION_ORDER) {
+    const config = CHROMIUM_BROWSERS[browserId];
+    if (config.windows.registryKey) {
+      keys.push({
+        browser: browserId,
+        key: config.windows.registryKey
+      });
+    }
+  }
+  return keys;
+}
+async function detectAvailableBrowser() {
+  const platform2 = getPlatform();
+  for (const browserId of BROWSER_DETECTION_ORDER) {
+    const config = CHROMIUM_BROWSERS[browserId];
+    switch (platform2) {
+      case "macos": {
+        const appPath = `/Applications/${config.macos.appName}.app`;
+        try {
+          const stats = await stat(appPath);
+          if (stats.isDirectory()) {
+            logForDebugging(`[Claude in Chrome] Detected browser: ${config.name}`);
+            return browserId;
+          }
+        } catch (e) {
+          if (!isFsInaccessible(e))
+            throw e;
+        }
+        break;
+      }
+      case "wsl":
+      case "linux": {
+        for (const binary of config.linux.binaries) {
+          if (await which(binary).catch(() => null)) {
+            logForDebugging(`[Claude in Chrome] Detected browser: ${config.name}`);
+            return browserId;
+          }
+        }
+        break;
+      }
+      case "windows": {
+        const home = homedir();
+        if (config.windows.dataPath.length > 0) {
+          const appDataBase = config.windows.useRoaming ? join(home, "AppData", "Roaming") : join(home, "AppData", "Local");
+          const dataPath = join(appDataBase, ...config.windows.dataPath);
+          try {
+            const stats = await stat(dataPath);
+            if (stats.isDirectory()) {
+              logForDebugging(`[Claude in Chrome] Detected browser: ${config.name}`);
+              return browserId;
+            }
+          } catch (e) {
+            if (!isFsInaccessible(e))
+              throw e;
+          }
+        }
+        break;
+      }
+    }
+  }
+  return null;
+}
+function isClaudeInChromeMCPServer(name) {
+  return normalizeNameForMCP(name) === CLAUDE_IN_CHROME_MCP_SERVER_NAME;
+}
+function trackClaudeInChromeTabId(tabId) {
+  if (trackedTabIds.size >= MAX_TRACKED_TABS && !trackedTabIds.has(tabId)) {
+    trackedTabIds.clear();
+  }
+  trackedTabIds.add(tabId);
+}
+async function openInChrome(url) {
+  const currentPlatform = getPlatform();
+  const browser = await detectAvailableBrowser();
+  if (!browser) {
+    logForDebugging("[Claude in Chrome] No compatible browser found");
+    return false;
+  }
+  const config = CHROMIUM_BROWSERS[browser];
+  switch (currentPlatform) {
+    case "macos": {
+      const { code } = await execFileNoThrow("open", [
+        "-a",
+        config.macos.appName,
+        url
+      ]);
+      return code === 0;
+    }
+    case "windows": {
+      const { code } = await execFileNoThrow("rundll32", ["url,OpenURL", url]);
+      return code === 0;
+    }
+    case "wsl":
+    case "linux": {
+      for (const binary of config.linux.binaries) {
+        const { code } = await execFileNoThrow(binary, [url]);
+        if (code === 0) {
+          return true;
+        }
+      }
+      return false;
+    }
+    default:
+      return false;
+  }
+}
+function getSocketDir() {
+  return `/tmp/claude-mcp-browser-bridge-${getUsername()}`;
+}
+function getSecureSocketPath() {
+  if (platform() === "win32") {
+    return `\\\\.\\pipe\\${getSocketName()}`;
+  }
+  return join(getSocketDir(), `${process.pid}.sock`);
+}
+function getAllSocketPaths() {
+  if (platform() === "win32") {
+    return [`\\\\.\\pipe\\${getSocketName()}`];
+  }
+  const paths = [];
+  const socketDir = getSocketDir();
+  try {
+    const files = readdirSync(socketDir);
+    for (const file of files) {
+      if (file.endsWith(".sock")) {
+        paths.push(join(socketDir, file));
+      }
+    }
+  } catch {}
+  const legacyName = `claude-mcp-browser-bridge-${getUsername()}`;
+  const legacyTmpdir = join(tmpdir(), legacyName);
+  const legacyTmp = `/tmp/${legacyName}`;
+  if (!paths.includes(legacyTmpdir)) {
+    paths.push(legacyTmpdir);
+  }
+  if (legacyTmpdir !== legacyTmp && !paths.includes(legacyTmp)) {
+    paths.push(legacyTmp);
+  }
+  return paths;
+}
+function getSocketName() {
+  return `claude-mcp-browser-bridge-${getUsername()}`;
+}
+function getUsername() {
+  try {
+    return userInfo().username || "default";
+  } catch {
+    return process.env.USER || process.env.USERNAME || "default";
+  }
+}
+var CLAUDE_IN_CHROME_MCP_SERVER_NAME = "claude-in-chrome", CHROMIUM_BROWSERS, BROWSER_DETECTION_ORDER, MAX_TRACKED_TABS = 200, trackedTabIds;
+var init_common = __esm(() => {
+  init_normalization();
+  init_debug();
+  init_errors();
+  init_execFileNoThrow();
+  init_platform();
+  init_which();
+  CHROMIUM_BROWSERS = {
+    chrome: {
+      name: "Google Chrome",
+      macos: {
+        appName: "Google Chrome",
+        dataPath: ["Library", "Application Support", "Google", "Chrome"],
+        nativeMessagingPath: [
+          "Library",
+          "Application Support",
+          "Google",
+          "Chrome",
+          "NativeMessagingHosts"
+        ]
+      },
+      linux: {
+        binaries: ["google-chrome", "google-chrome-stable"],
+        dataPath: [".config", "google-chrome"],
+        nativeMessagingPath: [".config", "google-chrome", "NativeMessagingHosts"]
+      },
+      windows: {
+        dataPath: ["Google", "Chrome", "User Data"],
+        registryKey: "HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts"
+      }
+    },
+    brave: {
+      name: "Brave",
+      macos: {
+        appName: "Brave Browser",
+        dataPath: [
+          "Library",
+          "Application Support",
+          "BraveSoftware",
+          "Brave-Browser"
+        ],
+        nativeMessagingPath: [
+          "Library",
+          "Application Support",
+          "BraveSoftware",
+          "Brave-Browser",
+          "NativeMessagingHosts"
+        ]
+      },
+      linux: {
+        binaries: ["brave-browser", "brave"],
+        dataPath: [".config", "BraveSoftware", "Brave-Browser"],
+        nativeMessagingPath: [
+          ".config",
+          "BraveSoftware",
+          "Brave-Browser",
+          "NativeMessagingHosts"
+        ]
+      },
+      windows: {
+        dataPath: ["BraveSoftware", "Brave-Browser", "User Data"],
+        registryKey: "HKCU\\Software\\BraveSoftware\\Brave-Browser\\NativeMessagingHosts"
+      }
+    },
+    arc: {
+      name: "Arc",
+      macos: {
+        appName: "Arc",
+        dataPath: ["Library", "Application Support", "Arc", "User Data"],
+        nativeMessagingPath: [
+          "Library",
+          "Application Support",
+          "Arc",
+          "User Data",
+          "NativeMessagingHosts"
+        ]
+      },
+      linux: {
+        binaries: [],
+        dataPath: [],
+        nativeMessagingPath: []
+      },
+      windows: {
+        dataPath: ["Arc", "User Data"],
+        registryKey: "HKCU\\Software\\ArcBrowser\\Arc\\NativeMessagingHosts"
+      }
+    },
+    chromium: {
+      name: "Chromium",
+      macos: {
+        appName: "Chromium",
+        dataPath: ["Library", "Application Support", "Chromium"],
+        nativeMessagingPath: [
+          "Library",
+          "Application Support",
+          "Chromium",
+          "NativeMessagingHosts"
+        ]
+      },
+      linux: {
+        binaries: ["chromium", "chromium-browser"],
+        dataPath: [".config", "chromium"],
+        nativeMessagingPath: [".config", "chromium", "NativeMessagingHosts"]
+      },
+      windows: {
+        dataPath: ["Chromium", "User Data"],
+        registryKey: "HKCU\\Software\\Chromium\\NativeMessagingHosts"
+      }
+    },
+    edge: {
+      name: "Microsoft Edge",
+      macos: {
+        appName: "Microsoft Edge",
+        dataPath: ["Library", "Application Support", "Microsoft Edge"],
+        nativeMessagingPath: [
+          "Library",
+          "Application Support",
+          "Microsoft Edge",
+          "NativeMessagingHosts"
+        ]
+      },
+      linux: {
+        binaries: ["microsoft-edge", "microsoft-edge-stable"],
+        dataPath: [".config", "microsoft-edge"],
+        nativeMessagingPath: [
+          ".config",
+          "microsoft-edge",
+          "NativeMessagingHosts"
+        ]
+      },
+      windows: {
+        dataPath: ["Microsoft", "Edge", "User Data"],
+        registryKey: "HKCU\\Software\\Microsoft\\Edge\\NativeMessagingHosts"
+      }
+    },
+    vivaldi: {
+      name: "Vivaldi",
+      macos: {
+        appName: "Vivaldi",
+        dataPath: ["Library", "Application Support", "Vivaldi"],
+        nativeMessagingPath: [
+          "Library",
+          "Application Support",
+          "Vivaldi",
+          "NativeMessagingHosts"
+        ]
+      },
+      linux: {
+        binaries: ["vivaldi", "vivaldi-stable"],
+        dataPath: [".config", "vivaldi"],
+        nativeMessagingPath: [".config", "vivaldi", "NativeMessagingHosts"]
+      },
+      windows: {
+        dataPath: ["Vivaldi", "User Data"],
+        registryKey: "HKCU\\Software\\Vivaldi\\NativeMessagingHosts"
+      }
+    },
+    opera: {
+      name: "Opera",
+      macos: {
+        appName: "Opera",
+        dataPath: ["Library", "Application Support", "com.operasoftware.Opera"],
+        nativeMessagingPath: [
+          "Library",
+          "Application Support",
+          "com.operasoftware.Opera",
+          "NativeMessagingHosts"
+        ]
+      },
+      linux: {
+        binaries: ["opera"],
+        dataPath: [".config", "opera"],
+        nativeMessagingPath: [".config", "opera", "NativeMessagingHosts"]
+      },
+      windows: {
+        dataPath: ["Opera Software", "Opera Stable"],
+        registryKey: "HKCU\\Software\\Opera Software\\Opera Stable\\NativeMessagingHosts",
+        useRoaming: true
+      }
+    }
+  };
+  BROWSER_DETECTION_ORDER = [
+    "chrome",
+    "brave",
+    "arc",
+    "edge",
+    "chromium",
+    "vivaldi",
+    "opera"
+  ];
+  trackedTabIds = new Set;
+});
+
+export { CLAUDE_IN_CHROME_MCP_SERVER_NAME, getAllBrowserDataPaths, getAllNativeMessagingHostsDirs, getAllWindowsRegistryKeys, isClaudeInChromeMCPServer, trackClaudeInChromeTabId, openInChrome, getSocketDir, getSecureSocketPath, getAllSocketPaths, init_common };