@stevenzxs/ccharness 1.0.0

package/dist/chunk-zvsevk48.js

@@ -0,0 +1,391 @@
+// @bun
+import"./chunk-375qesdp.js";
+import {
+  getSecureSocketPath,
+  getSocketDir,
+  init_common
+} from "./chunk-rrgnm3c8.js";
+import"./chunk-vwenx8ke.js";
+import"./chunk-rey3eqc4.js";
+import {
+  exports_external,
+  init_lazySchema,
+  lazySchema
+} from "./chunk-ma7acpng.js";
+import"./chunk-9z4fsn6r.js";
+import"./chunk-rgp8gbze.js";
+import"./chunk-sbe835v8.js";
+import"./chunk-mss2zjet.js";
+import"./chunk-m28vg9w4.js";
+import"./chunk-03eejbgx.js";
+import"./chunk-aeysytks.js";
+import {
+  init_slowOperations,
+  jsonParse,
+  jsonStringify
+} from "./chunk-7fxg2tat.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-347yx4gw.js";
+import"./chunk-11q9h2zt.js";
+import"./chunk-aheacmqy.js";
+import"./chunk-kv4bdhp2.js";
+import"./chunk-042vrke6.js";
+import"./chunk-hhsxm2yr.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/cli.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env bun
+// @bun
+import {
+  __require
+} from "./chunk-hhsxm2yr.js";
+
+// src/entrypoints/cli.tsx
+var feature = (_name) => false;
+if (typeof globalThis.MACRO === "undefined") {
+  globalThis.MACRO = {
+    VERSION: "2.1.888",
+    BUILD_TIME: new Date().toISOString(),
+    FEEDBACK_CHANNEL: "",
+    ISSUES_EXPLAINER: "",
+    NATIVE_PACKAGE_URL: "",
+    PACKAGE_URL: "",
+    VERSION_CHANGELOG: ""
+  };
+}
+globalThis.BUILD_TARGET = "external";
+globalThis.BUILD_ENV = "production";
+globalThis.INTERFACE_TYPE = "stdio";
+process.env.COREPACK_ENABLE_AUTO_PIN = "0";
+if (process.env.CLAUDE_CODE_REMOTE === "true") {
+  const existing = process.env.NODE_OPTIONS || "";
+  process.env.NODE_OPTIONS = existing ? `${existing} --max-old-space-size=8192` : "--max-old-space-size=8192";
+}
+if (feature("ABLATION_BASELINE") && process.env.CLAUDE_CODE_ABLATION_BASELINE) {
+  for (const k of [
+    "CLAUDE_CODE_SIMPLE",
+    "CLAUDE_CODE_DISABLE_THINKING",
+    "DISABLE_INTERLEAVED_THINKING",
+    "DISABLE_COMPACT",
+    "DISABLE_AUTO_COMPACT",
+    "CLAUDE_CODE_DISABLE_AUTO_MEMORY",
+    "CLAUDE_CODE_DISABLE_BACKGROUND_TASKS"
+  ]) {
+    process.env[k] ??= "1";
+  }
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 1 && (args[0] === "--version" || args[0] === "-v" || args[0] === "-V")) {
+    console.log(`${MACRO.VERSION} (Claude Code)`);
+    return;
+  }
+  const { profileCheckpoint } = await import("./chunk-gftcezc3.js");
+  profileCheckpoint("cli_entry");
+  if (feature("DUMP_SYSTEM_PROMPT") && args[0] === "--dump-system-prompt") {
+    profileCheckpoint("cli_dump_system_prompt_path");
+    const { enableConfigs } = await import("./chunk-5yc6h8kt.js");
+    enableConfigs();
+    const { getMainLoopModel } = await import("./chunk-yrrqkx5b.js");
+    const modelIdx = args.indexOf("--model");
+    const model = modelIdx !== -1 && args[modelIdx + 1] || getMainLoopModel();
+    const { getSystemPrompt } = await import("./chunk-3j4m1cvv.js");
+    const prompt = await getSystemPrompt([], model);
+    console.log(prompt.join(`
+`));
+    return;
+  }
+  if (process.argv[2] === "--claude-in-chrome-mcp") {
+    profileCheckpoint("cli_claude_in_chrome_mcp_path");
+    const { runClaudeInChromeMcpServer } = await import("./chunk-zqr80ypg.js");
+    await runClaudeInChromeMcpServer();
+    return;
+  } else if (process.argv[2] === "--chrome-native-host") {
+    profileCheckpoint("cli_chrome_native_host_path");
+    const { runChromeNativeHost } = await import("./chunk-zvsevk48.js");
+    await runChromeNativeHost();
+    return;
+  } else if (feature("CHICAGO_MCP") && process.argv[2] === "--computer-use-mcp") {
+    profileCheckpoint("cli_computer_use_mcp_path");
+    const { runComputerUseMcpServer } = await import("./chunk-3pvn6ah4.js");
+    await runComputerUseMcpServer();
+    return;
+  }
+  if (feature("DAEMON") && args[0] === "--daemon-worker") {
+    const { runDaemonWorker } = await import("./chunk-ytzryynn.js");
+    await runDaemonWorker(args[1]);
+    return;
+  }
+  if (feature("BRIDGE_MODE") && (args[0] === "remote-control" || args[0] === "rc" || args[0] === "remote" || args[0] === "sync" || args[0] === "bridge")) {
+    profileCheckpoint("cli_bridge_path");
+    const { enableConfigs } = await import("./chunk-5yc6h8kt.js");
+    enableConfigs();
+    const { getBridgeDisabledReason, checkBridgeMinVersion } = await import("./chunk-kf8wprgm.js");
+    const { BRIDGE_LOGIN_ERROR } = await import("./chunk-13qesvnw.js");
+    const { bridgeMain } = await import("./chunk-z76974hz.js");
+    const { exitWithError } = await import("./chunk-3vfxjn7g.js");
+    const { getClaudeAIOAuthTokens } = await import("./chunk-wzfrqg89.js");
+    if (!getClaudeAIOAuthTokens()?.accessToken) {
+      exitWithError(BRIDGE_LOGIN_ERROR);
+    }
+    const disabledReason = await getBridgeDisabledReason();
+    if (disabledReason) {
+      exitWithError(`Error: ${disabledReason}`);
+    }
+    const versionError = checkBridgeMinVersion();
+    if (versionError) {
+      exitWithError(versionError);
+    }
+    const { waitForPolicyLimitsToLoad, isPolicyAllowed } = await import("./chunk-bq1dmt8g.js");
+    await waitForPolicyLimitsToLoad();
+    if (!isPolicyAllowed("allow_remote_control")) {
+      exitWithError("Error: Remote Control is disabled by your organization's policy.");
+    }
+    await bridgeMain(args.slice(1));
+    return;
+  }
+  if (feature("DAEMON") && args[0] === "daemon") {
+    profileCheckpoint("cli_daemon_path");
+    const { enableConfigs } = await import("./chunk-5yc6h8kt.js");
+    enableConfigs();
+    const { initSinks } = await import("./chunk-26rd7jy7.js");
+    initSinks();
+    const { daemonMain } = await import("./chunk-fqc61q2v.js");
+    await daemonMain(args.slice(1));
+    return;
+  }
+  if (feature("BG_SESSIONS") && (args[0] === "ps" || args[0] === "logs" || args[0] === "attach" || args[0] === "kill" || args.includes("--bg") || args.includes("--background"))) {
+    profileCheckpoint("cli_bg_path");
+    const { enableConfigs } = await import("./chunk-5yc6h8kt.js");
+    enableConfigs();
+    const bg = await import("./chunk-nyygtkaf.js");
+    switch (args[0]) {
+      case "ps":
+        await bg.psHandler(args.slice(1));
+        break;
+      case "logs":
+        await bg.logsHandler(args[1]);
+        break;
+      case "attach":
+        await bg.attachHandler(args[1]);
+        break;
+      case "kill":
+        await bg.killHandler(args[1]);
+        break;
+      default:
+        await bg.handleBgFlag(args);
+    }
+    return;
+  }
+  if (feature("TEMPLATES") && (args[0] === "new" || args[0] === "list" || args[0] === "reply")) {
+    profileCheckpoint("cli_templates_path");
+    const { templatesMain } = await import("./chunk-7gyv4cj4.js");
+    await templatesMain(args);
+    process.exit(0);
+  }
+  if (feature("BYOC_ENVIRONMENT_RUNNER") && args[0] === "environment-runner") {
+    profileCheckpoint("cli_environment_runner_path");
+    const { environmentRunnerMain } = await import("./chunk-93a5my23.js");
+    await environmentRunnerMain(args.slice(1));
+    return;
+  }
+  if (feature("SELF_HOSTED_RUNNER") && args[0] === "self-hosted-runner") {
+    profileCheckpoint("cli_self_hosted_runner_path");
+    const { selfHostedRunnerMain } = await import("./chunk-h4przbpd.js");
+    await selfHostedRunnerMain(args.slice(1));
+    return;
+  }
+  const hasTmuxFlag = args.includes("--tmux") || args.includes("--tmux=classic");
+  if (hasTmuxFlag && (args.includes("-w") || args.includes("--worktree") || args.some((a) => a.startsWith("--worktree=")))) {
+    profileCheckpoint("cli_tmux_worktree_fast_path");
+    const { enableConfigs } = await import("./chunk-5yc6h8kt.js");
+    enableConfigs();
+    const { isWorktreeModeEnabled } = await import("./chunk-h12a4f4x.js");
+    if (isWorktreeModeEnabled()) {
+      const { execIntoTmuxWorktree } = await import("./chunk-p9kmn90n.js");
+      const result = await execIntoTmuxWorktree(args);
+      if (result.handled) {
+        return;
+      }
+      if (result.error) {
+        const { exitWithError } = await import("./chunk-3vfxjn7g.js");
+        exitWithError(result.error);
+      }
+    }
+  }
+  if (args.length === 1 && (args[0] === "--update" || args[0] === "--upgrade")) {
+    process.argv = [process.argv[0], process.argv[1], "update"];
+  }
+  if (args.includes("--bare")) {
+    process.env.CLAUDE_CODE_SIMPLE = "1";
+  }
+  const { startCapturingEarlyInput } = await import("./chunk-nbrtjcbx.js");
+  startCapturingEarlyInput();
+  profileCheckpoint("cli_before_main_import");
+  const { main: cliMain } = await import("./chunk-194x9yzh.js");
+  profileCheckpoint("cli_after_main_import");
+  await cliMain();
+  profileCheckpoint("cli_after_main_complete");
+}
+main();