@zyycn/claudex 1.0.3-fork.2a74621

package/dist/chunk-p331ghzg.js

@@ -0,0 +1,391 @@
+// @bun
+import"./chunk-6n2qgm9v.js";
+import {
+  getSecureSocketPath,
+  getSocketDir,
+  init_common
+} from "./chunk-j5hc27hv.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import {
+  exports_external,
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import {
+  init_slowOperations,
+  jsonParse,
+  jsonStringify
+} from "./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-qp2qdcda.js";
+
+// src/utils/claudeInChrome/chromeNativeHost.ts
+import {
+  appendFile,
+  chmod,
+  mkdir,
+  readdir,
+  rmdir,
+  stat,
+  unlink
+} from "fs/promises";
+import { createServer } from "net";
+import { homedir, platform } from "os";
+import { join } from "path";
+init_lazySchema();
+init_slowOperations();
+init_common();
+var VERSION = "1.0.0";
+var MAX_MESSAGE_SIZE = 1024 * 1024;
+var LOG_FILE = process.env.USER_TYPE === "ant" ? join(homedir(), ".claude", "debug", "chrome-native-host.txt") : undefined;
+function log(message, ...args) {
+  if (LOG_FILE) {
+    const timestamp = new Date().toISOString();
+    const formattedArgs = args.length > 0 ? " " + jsonStringify(args) : "";
+    const logLine = `[${timestamp}] [Claude Chrome Native Host] ${message}${formattedArgs}
+`;
+    appendFile(LOG_FILE, logLine).catch(() => {});
+  }
+  console.error(`[Claude Chrome Native Host] ${message}`, ...args);
+}
+function sendChromeMessage(message) {
+  const jsonBytes = Buffer.from(message, "utf-8");
+  const lengthBuffer = Buffer.alloc(4);
+  lengthBuffer.writeUInt32LE(jsonBytes.length, 0);
+  process.stdout.write(lengthBuffer);
+  process.stdout.write(jsonBytes);
+}
+async function runChromeNativeHost() {
+  log("Initializing...");
+  const host = new ChromeNativeHost;
+  const messageReader = new ChromeMessageReader;
+  await host.start();
+  while (true) {
+    const message = await messageReader.read();
+    if (message === null) {
+      break;
+    }
+    await host.handleMessage(message);
+  }
+  await host.stop();
+}
+var messageSchema = lazySchema(() => exports_external.object({
+  type: exports_external.string()
+}).passthrough());
+
+class ChromeNativeHost {
+  mcpClients = new Map;
+  nextClientId = 1;
+  server = null;
+  running = false;
+  socketPath = null;
+  async start() {
+    if (this.running) {
+      return;
+    }
+    this.socketPath = getSecureSocketPath();
+    if (platform() !== "win32") {
+      const socketDir = getSocketDir();
+      try {
+        const dirStats = await stat(socketDir);
+        if (!dirStats.isDirectory()) {
+          await unlink(socketDir);
+        }
+      } catch {}
+      await mkdir(socketDir, { recursive: true, mode: 448 });
+      await chmod(socketDir, 448).catch(() => {});
+      try {
+        const files = await readdir(socketDir);
+        for (const file of files) {
+          if (!file.endsWith(".sock")) {
+            continue;
+          }
+          const pid = parseInt(file.replace(".sock", ""), 10);
+          if (isNaN(pid)) {
+            continue;
+          }
+          try {
+            process.kill(pid, 0);
+          } catch {
+            await unlink(join(socketDir, file)).catch(() => {});
+            log(`Removed stale socket for PID ${pid}`);
+          }
+        }
+      } catch {}
+    }
+    log(`Creating socket listener: ${this.socketPath}`);
+    this.server = createServer((socket) => this.handleMcpClient(socket));
+    await new Promise((resolve, reject) => {
+      this.server.listen(this.socketPath, () => {
+        log("Socket server listening for connections");
+        this.running = true;
+        resolve();
+      });
+      this.server.on("error", (err) => {
+        log("Socket server error:", err);
+        reject(err);
+      });
+    });
+    if (platform() !== "win32") {
+      try {
+        await chmod(this.socketPath, 384);
+        log("Socket permissions set to 0600");
+      } catch (e) {
+        log("Failed to set socket permissions:", e);
+      }
+    }
+  }
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    for (const [, client] of this.mcpClients) {
+      client.socket.destroy();
+    }
+    this.mcpClients.clear();
+    if (this.server) {
+      await new Promise((resolve) => {
+        this.server.close(() => resolve());
+      });
+      this.server = null;
+    }
+    if (platform() !== "win32" && this.socketPath) {
+      try {
+        await unlink(this.socketPath);
+        log("Cleaned up socket file");
+      } catch {}
+      try {
+        const socketDir = getSocketDir();
+        const remaining = await readdir(socketDir);
+        if (remaining.length === 0) {
+          await rmdir(socketDir);
+          log("Removed empty socket directory");
+        }
+      } catch {}
+    }
+    this.running = false;
+  }
+  async isRunning() {
+    return this.running;
+  }
+  async getClientCount() {
+    return this.mcpClients.size;
+  }
+  async handleMessage(messageJson) {
+    let rawMessage;
+    try {
+      rawMessage = jsonParse(messageJson);
+    } catch (e) {
+      log("Invalid JSON from Chrome:", e.message);
+      sendChromeMessage(jsonStringify({
+        type: "error",
+        error: "Invalid message format"
+      }));
+      return;
+    }
+    const parsed = messageSchema().safeParse(rawMessage);
+    if (!parsed.success) {
+      log("Invalid message from Chrome:", parsed.error.message);
+      sendChromeMessage(jsonStringify({
+        type: "error",
+        error: "Invalid message format"
+      }));
+      return;
+    }
+    const message = parsed.data;
+    log(`Handling Chrome message type: ${message.type}`);
+    switch (message.type) {
+      case "ping":
+        log("Responding to ping");
+        sendChromeMessage(jsonStringify({
+          type: "pong",
+          timestamp: Date.now()
+        }));
+        break;
+      case "get_status":
+        sendChromeMessage(jsonStringify({
+          type: "status_response",
+          native_host_version: VERSION
+        }));
+        break;
+      case "tool_response": {
+        if (this.mcpClients.size > 0) {
+          log(`Forwarding tool response to ${this.mcpClients.size} MCP clients`);
+          const { type: _, ...data } = message;
+          const responseData = Buffer.from(jsonStringify(data), "utf-8");
+          const lengthBuffer = Buffer.alloc(4);
+          lengthBuffer.writeUInt32LE(responseData.length, 0);
+          const responseMsg = Buffer.concat([lengthBuffer, responseData]);
+          for (const [id, client] of this.mcpClients) {
+            try {
+              client.socket.write(responseMsg);
+            } catch (e) {
+              log(`Failed to send to MCP client ${id}:`, e);
+            }
+          }
+        }
+        break;
+      }
+      case "notification": {
+        if (this.mcpClients.size > 0) {
+          log(`Forwarding notification to ${this.mcpClients.size} MCP clients`);
+          const { type: _, ...data } = message;
+          const notificationData = Buffer.from(jsonStringify(data), "utf-8");
+          const lengthBuffer = Buffer.alloc(4);
+          lengthBuffer.writeUInt32LE(notificationData.length, 0);
+          const notificationMsg = Buffer.concat([
+            lengthBuffer,
+            notificationData
+          ]);
+          for (const [id, client] of this.mcpClients) {
+            try {
+              client.socket.write(notificationMsg);
+            } catch (e) {
+              log(`Failed to send notification to MCP client ${id}:`, e);
+            }
+          }
+        }
+        break;
+      }
+      default:
+        log(`Unknown message type: ${message.type}`);
+        sendChromeMessage(jsonStringify({
+          type: "error",
+          error: `Unknown message type: ${message.type}`
+        }));
+    }
+  }
+  handleMcpClient(socket) {
+    const clientId = this.nextClientId++;
+    const client = {
+      id: clientId,
+      socket,
+      buffer: Buffer.alloc(0)
+    };
+    this.mcpClients.set(clientId, client);
+    log(`MCP client ${clientId} connected. Total clients: ${this.mcpClients.size}`);
+    sendChromeMessage(jsonStringify({
+      type: "mcp_connected"
+    }));
+    socket.on("data", (data) => {
+      client.buffer = Buffer.concat([client.buffer, data]);
+      while (client.buffer.length >= 4) {
+        const length = client.buffer.readUInt32LE(0);
+        if (length === 0 || length > MAX_MESSAGE_SIZE) {
+          log(`Invalid message length from MCP client ${clientId}: ${length}`);
+          socket.destroy();
+          return;
+        }
+        if (client.buffer.length < 4 + length) {
+          break;
+        }
+        const messageBytes = client.buffer.slice(4, 4 + length);
+        client.buffer = client.buffer.slice(4 + length);
+        try {
+          const request = jsonParse(messageBytes.toString("utf-8"));
+          log(`Forwarding tool request from MCP client ${clientId}: ${request.method}`);
+          sendChromeMessage(jsonStringify({
+            type: "tool_request",
+            method: request.method,
+            params: request.params
+          }));
+        } catch (e) {
+          log(`Failed to parse tool request from MCP client ${clientId}:`, e);
+        }
+      }
+    });
+    socket.on("error", (err) => {
+      log(`MCP client ${clientId} error: ${err}`);
+    });
+    socket.on("close", () => {
+      log(`MCP client ${clientId} disconnected. Remaining clients: ${this.mcpClients.size - 1}`);
+      this.mcpClients.delete(clientId);
+      sendChromeMessage(jsonStringify({
+        type: "mcp_disconnected"
+      }));
+    });
+  }
+}
+
+class ChromeMessageReader {
+  buffer = Buffer.alloc(0);
+  pendingResolve = null;
+  closed = false;
+  constructor() {
+    process.stdin.on("data", (chunk) => {
+      this.buffer = Buffer.concat([this.buffer, chunk]);
+      this.tryProcessMessage();
+    });
+    process.stdin.on("end", () => {
+      this.closed = true;
+      if (this.pendingResolve) {
+        this.pendingResolve(null);
+        this.pendingResolve = null;
+      }
+    });
+    process.stdin.on("error", () => {
+      this.closed = true;
+      if (this.pendingResolve) {
+        this.pendingResolve(null);
+        this.pendingResolve = null;
+      }
+    });
+  }
+  tryProcessMessage() {
+    if (!this.pendingResolve) {
+      return;
+    }
+    if (this.buffer.length < 4) {
+      return;
+    }
+    const length = this.buffer.readUInt32LE(0);
+    if (length === 0 || length > MAX_MESSAGE_SIZE) {
+      log(`Invalid message length: ${length}`);
+      this.pendingResolve(null);
+      this.pendingResolve = null;
+      return;
+    }
+    if (this.buffer.length < 4 + length) {
+      return;
+    }
+    const messageBytes = this.buffer.subarray(4, 4 + length);
+    this.buffer = this.buffer.subarray(4 + length);
+    const message = messageBytes.toString("utf-8");
+    this.pendingResolve(message);
+    this.pendingResolve = null;
+  }
+  async read() {
+    if (this.closed) {
+      return null;
+    }
+    if (this.buffer.length >= 4) {
+      const length = this.buffer.readUInt32LE(0);
+      if (length > 0 && length <= MAX_MESSAGE_SIZE && this.buffer.length >= 4 + length) {
+        const messageBytes = this.buffer.subarray(4, 4 + length);
+        this.buffer = this.buffer.subarray(4 + length);
+        return messageBytes.toString("utf-8");
+      }
+    }
+    return new Promise((resolve) => {
+      this.pendingResolve = resolve;
+      this.tryProcessMessage();
+    });
+  }
+}
+export {
+  sendChromeMessage,
+  runChromeNativeHost
+};

package/dist/chunk-p3g43fdn.js

@@ -0,0 +1,61 @@
+// @bun
+import {
+  getEventSamplingConfig,
+  init_firstPartyEventLogger,
+  initialize1PEventLogging,
+  is1PEventLoggingEnabled,
+  logEventTo1P,
+  logGrowthBookExperimentTo1P,
+  reinitialize1PEventLoggingIfConfigChanged,
+  shouldSampleEvent,
+  shutdown1PEventLogging
+} from "./chunk-3zzszjst.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_firstPartyEventLogger();
+
+export {
+  shutdown1PEventLogging,
+  shouldSampleEvent,
+  reinitialize1PEventLoggingIfConfigChanged,
+  logGrowthBookExperimentTo1P,
+  logEventTo1P,
+  is1PEventLoggingEnabled,
+  initialize1PEventLogging,
+  getEventSamplingConfig
+};

package/dist/chunk-p87jnvhk.js

@@ -0,0 +1,97 @@
+// @bun
+import {
+  Spinner,
+  init_Spinner
+} from "./chunk-1m68rrvt.js";
+import {
+  ThemedBox_default,
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-adg4351g.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/design-system/LoadingState.tsx
+function LoadingState(t0) {
+  const $ = import_compiler_runtime.c(10);
+  const {
+    message,
+    bold: t1,
+    dimColor: t2,
+    subtitle
+  } = t0;
+  const bold = t1 === undefined ? false : t1;
+  const dimColor = t2 === undefined ? false : t2;
+  let t3;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Spinner, {}, undefined, false, undefined, this);
+    $[0] = t3;
+  } else {
+    t3 = $[0];
+  }
+  let t4;
+  if ($[1] !== bold || $[2] !== dimColor || $[3] !== message) {
+    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "row",
+      children: [
+        t3,
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          bold,
+          dimColor,
+          children: [
+            " ",
+            message
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+    $[1] = bold;
+    $[2] = dimColor;
+    $[3] = message;
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  let t5;
+  if ($[5] !== subtitle) {
+    t5 = subtitle && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: subtitle
+    }, undefined, false, undefined, this);
+    $[5] = subtitle;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  let t6;
+  if ($[7] !== t4 || $[8] !== t5) {
+    t6 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      children: [
+        t4,
+        t5
+      ]
+    }, undefined, true, undefined, this);
+    $[7] = t4;
+    $[8] = t5;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  return t6;
+}
+var import_compiler_runtime, jsx_dev_runtime;
+var init_LoadingState = __esm(() => {
+  init_ink();
+  init_Spinner();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { LoadingState, init_LoadingState };

package/dist/chunk-pb04jxp7.js

@@ -0,0 +1,158 @@
+// @bun
+import {
+  getBridgeBaseUrlOverride,
+  getBridgeTokenOverride,
+  init_bridgeConfig
+} from "./chunk-pe0s50gj.js";
+import {
+  generateSessionName,
+  init_generateSessionName
+} from "./chunk-r0v9bxma.js";
+import"./chunk-wz2ekprb.js";
+import {
+  getMessagesAfterCompactBoundary,
+  getTranscriptPath,
+  init_messages1 as init_messages,
+  init_sessionStorage,
+  saveAgentName,
+  saveCustomTitle
+} from "./chunk-1m68rrvt.js";
+import"./chunk-sdxgmmma.js";
+import"./chunk-qjg7a3vk.js";
+import"./chunk-nypgx8vs.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-41m5za5y.js";
+import"./chunk-gz457zg6.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-x7vg43fv.js";
+import"./chunk-vn1e1j7w.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-s5dg9njs.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-dnqqes3z.js";
+import"./chunk-ph936yc1.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-wt69n71b.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-z7ns4g0p.js";
+import"./chunk-adg4351g.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-0hw5q246.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-8smr33wf.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-wq8v0d1k.js";
+import"./chunk-3zzszjst.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.js";
+import {
+  init_teammate,
+  isTeammate
+} from "./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-res15ktd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/rename/rename.ts
+async function call(onDone, context, args) {
+  if (isTeammate()) {
+    onDone("Cannot rename: This session is a swarm teammate. Teammate names are set by the team leader.", { display: "system" });
+    return null;
+  }
+  let newName;
+  if (!args || args.trim() === "") {
+    const generated = await generateSessionName(getMessagesAfterCompactBoundary(context.messages), context.abortController.signal);
+    if (!generated) {
+      onDone("Could not generate a name: no conversation context yet. Usage: /rename <name>", { display: "system" });
+      return null;
+    }
+    newName = generated;
+  } else {
+    newName = args.trim();
+  }
+  const sessionId = getSessionId();
+  const fullPath = getTranscriptPath();
+  await saveCustomTitle(sessionId, newName, fullPath);
+  const appState = context.getAppState();
+  const bridgeSessionId = appState.replBridgeSessionId;
+  if (bridgeSessionId) {
+    const tokenOverride = getBridgeTokenOverride();
+    import("./chunk-s2t8vg8q.js").then(({ updateBridgeSessionTitle }) => updateBridgeSessionTitle(bridgeSessionId, newName, {
+      baseUrl: getBridgeBaseUrlOverride(),
+      getAccessToken: tokenOverride ? () => tokenOverride : undefined
+    }).catch(() => {}));
+  }
+  await saveAgentName(sessionId, newName, fullPath);
+  context.setAppState((prev) => ({
+    ...prev,
+    standaloneAgentContext: {
+      ...prev.standaloneAgentContext,
+      name: newName
+    }
+  }));
+  onDone(`Session renamed to: ${newName}`, { display: "system" });
+  return null;
+}
+var init_rename = __esm(() => {
+  init_state();
+  init_bridgeConfig();
+  init_messages();
+  init_sessionStorage();
+  init_teammate();
+  init_generateSessionName();
+});
+init_rename();
+
+export {
+  call
+};