@ctliz/agent-intercom-claude 0.12.0-connect.3

package/claude/cci.ts

@@ -0,0 +1,512 @@
+import { once } from "node:events";
+import { createHash } from "node:crypto";
+import { spawn, spawnSync, type ChildProcess } from "node:child_process";
+import { existsSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
+import { ClaudeWorkerDaemon } from "./worker-daemon.ts";
+import { defaultInboxPath } from "./inbox.ts";
+import { ensureIntercomRuntimeDir, getIntercomDirPath, restrictIntercomRuntimeFile } from "../broker/paths.ts";
+import { DEFAULT_WORKER_STATE_PATH, type WorkerAgentConfig, type WorkerConfig } from "./worker-config.ts";
+import {
+  resolveClaudePermissionPolicy,
+  validateClaudePermissionMode,
+  type ClaudePermissionMode,
+} from "./permission-policy.ts";
+import {
+  parseClaudeIntercomTransport,
+  resolveClaudeIntercomTransport,
+  type ClaudeIntercomTransport,
+  type ResolvedClaudeIntercomTransport,
+} from "./transport.ts";
+import { NativeClaudeBrokerBridge } from "./native-bridge.ts";
+import { waitForNativeClaudePeer } from "./native-protocol.ts";
+import { INTERCOM_SCOPE_ENV, intercomScopeIdFromEnvForRegistration } from "../protocol-v4/contract.ts";
+
+export interface CciOptions {
+  id?: string;
+  name?: string;
+  cwd: string;
+  instructions?: string;
+  model?: string;
+  effort?: string;
+  statePath?: string;
+  permissionMode?: ClaudePermissionMode;
+  dangerouslySkipPermissions: boolean;
+  addDirs: string[];
+  mcpConfig?: string;
+  minimal: boolean;
+  tui: boolean;
+  claudeCommand: string;
+  transport: ClaudeIntercomTransport;
+  intercomEnv?: NodeJS.ProcessEnv;
+}
+
+interface IdentityInput {
+  cwd: string;
+  pid: number;
+  gitRoot?: string | null;
+  branch?: string | null;
+}
+
+export function sanitizeSegment(value: string): string {
+  return value
+    .replace(/[^a-zA-Z0-9._:-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase() || "claude";
+}
+
+function shortHash(value: string): string {
+  return createHash("sha1").update(value).digest("hex").slice(0, 8);
+}
+
+function gitString(cwd: string, args: string[]): string | null {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  if (result.status !== 0) return null;
+  const trimmed = result.stdout.trim();
+  return trimmed || null;
+}
+
+export function createDefaultIdentity(input: IdentityInput): { id: string; name: string } {
+  const root = input.gitRoot || input.cwd;
+  const repo = basename(root) || "claude";
+  const branch = input.branch || "worktree";
+  const readable = `${repo}:${branch}`;
+  const suffix = `${shortHash(input.cwd)}-${input.pid}`;
+  return {
+    id: sanitizeSegment(`claude-${repo}-${branch}-${suffix}`),
+    name: `claude:${readable}#${input.pid}`,
+  };
+}
+
+function capturedScopeEnv(scopeId: string | undefined): NodeJS.ProcessEnv {
+  return scopeId === undefined ? { [INTERCOM_SCOPE_ENV]: "" } : { [INTERCOM_SCOPE_ENV]: scopeId };
+}
+
+function detectIdentity(cwd: string): { id: string; name: string } {
+  return createDefaultIdentity({
+    cwd,
+    pid: process.pid,
+    gitRoot: gitString(cwd, ["rev-parse", "--show-toplevel"]),
+    branch: gitString(cwd, ["branch", "--show-current"]),
+  });
+}
+
+function readValue(args: string[], index: number, option: string): string {
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${option} requires a value`);
+  }
+  return value;
+}
+
+export function parseCciArgs(argv: string[], env: NodeJS.ProcessEnv = process.env): CciOptions {
+  const options: Partial<CciOptions> & { addDirs: string[] } = { addDirs: [] };
+  let dangerouslySkipPermissions: boolean | undefined;
+  let minimal = false;
+  let tui = false;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const [key, inlineValue] = arg.includes("=") ? arg.split(/=(.*)/s, 2) : [arg, undefined];
+    const value = inlineValue ?? null;
+
+    switch (key) {
+      case "--name":
+        options.name = value ?? readValue(argv, index++, key);
+        break;
+      case "--id":
+        options.id = value ?? readValue(argv, index++, key);
+        break;
+      case "--cwd":
+        options.cwd = resolve(value ?? readValue(argv, index++, key));
+        break;
+      case "--instructions":
+        options.instructions = value ?? readValue(argv, index++, key);
+        break;
+      case "--model":
+        options.model = value ?? readValue(argv, index++, key);
+        break;
+      case "--effort":
+        options.effort = value ?? readValue(argv, index++, key);
+        break;
+      case "--state":
+        options.statePath = resolve(value ?? readValue(argv, index++, key));
+        break;
+      case "--permission-mode":
+        options.permissionMode = validateClaudePermissionMode(value ?? readValue(argv, index++, key), "--permission-mode");
+        break;
+      case "--add-dir":
+        options.addDirs.push(resolve(value ?? readValue(argv, index++, key)));
+        break;
+      case "--mcp-config":
+        options.mcpConfig = value ?? readValue(argv, index++, key);
+        break;
+      case "--claude":
+        options.claudeCommand = value ?? readValue(argv, index++, key);
+        break;
+      case "--transport":
+        options.transport = parseClaudeIntercomTransport(value ?? readValue(argv, index++, key), key);
+        break;
+      case "--yolo":
+      case "--dangerously-skip-permissions":
+        dangerouslySkipPermissions = true;
+        break;
+      case "--safe":
+        dangerouslySkipPermissions = false;
+        options.permissionMode = options.permissionMode ?? "manual";
+        break;
+      case "--minimal":
+      case "--bare":
+        minimal = true;
+        break;
+      case "--tui":
+      case "--live":
+        tui = true;
+        break;
+      default:
+        break;
+    }
+  }
+
+  const permission = resolveClaudePermissionPolicy({
+    permissionMode: dangerouslySkipPermissions ? undefined : options.permissionMode,
+    dangerouslySkipPermissions: dangerouslySkipPermissions ?? false,
+  });
+
+  return {
+    cwd: resolve(options.cwd ?? env.CLAUDE_INTERCOM_CWD ?? process.cwd()),
+    id: options.id ?? env.CLAUDE_INTERCOM_SESSION_ID,
+    name: options.name ?? env.CLAUDE_INTERCOM_NAME,
+    instructions: options.instructions ?? env.CLAUDE_INTERCOM_INSTRUCTIONS,
+    model: options.model ?? env.CLAUDE_INTERCOM_MODEL,
+    effort: options.effort ?? env.CLAUDE_INTERCOM_EFFORT,
+    statePath: options.statePath,
+    permissionMode: permission.permissionMode,
+    dangerouslySkipPermissions: permission.dangerouslySkipPermissions,
+    addDirs: options.addDirs,
+    mcpConfig: options.mcpConfig,
+    minimal,
+    tui,
+    claudeCommand: options.claudeCommand || env.CLAUDE_INTERCOM_CLAUDE_COMMAND || "claude",
+    transport: parseClaudeIntercomTransport(options.transport ?? env.CLAUDE_INTERCOM_TRANSPORT, "CLAUDE_INTERCOM_TRANSPORT"),
+    intercomEnv: Object.hasOwn(env, INTERCOM_SCOPE_ENV) ? { [INTERCOM_SCOPE_ENV]: env[INTERCOM_SCOPE_ENV] } : {},
+  };
+}
+
+export function resolveIntercomSelection(selection: string, sessionCount: number): number | null {
+  const trimmed = selection.trim();
+  if (!/^\d+$/.test(trimmed)) return null;
+  const index = Number(trimmed) - 1;
+  return index >= 0 && index < sessionCount ? index : null;
+}
+
+async function openIntercomComposer(daemon: ClaudeWorkerDaemon): Promise<void> {
+  const sessions = await daemon.listPrimaryPeers();
+  if (!sessions.length) {
+    process.stderr.write("No other intercom sessions are connected.\n");
+    return;
+  }
+
+  process.stderr.write("\nIntercom sessions:\n");
+  sessions.forEach((session, index) => {
+    const status = session.status ? `, ${session.status}` : "";
+    process.stderr.write(`  ${index + 1}. ${session.name || "unnamed"} (${session.id.slice(0, 8)}) — ${session.cwd} [${session.model}${status}]\n`);
+  });
+
+  const terminal = createInterface({ input: process.stdin, output: process.stderr, terminal: true });
+  try {
+    const selection = await terminal.question("Send to (number, blank to cancel): ");
+    if (!selection.trim()) {
+      process.stderr.write("Intercom message cancelled.\n");
+      return;
+    }
+    const selectedIndex = resolveIntercomSelection(selection, sessions.length);
+    if (selectedIndex === null) {
+      process.stderr.write("Invalid intercom session selection.\n");
+      return;
+    }
+    const message = await terminal.question("Message (blank to cancel): ");
+    if (!message.trim()) {
+      process.stderr.write("Intercom message cancelled.\n");
+      return;
+    }
+    const status = await daemon.sendFromPrimary(sessions[selectedIndex].id, message);
+    process.stderr.write(`${status}\n`);
+  } finally {
+    terminal.close();
+  }
+}
+
+function repoRoot(): string {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "..");
+}
+
+export function writeDefaultWorkerMcpConfig(
+  root: string = repoRoot(),
+  intercomDir: string = getIntercomDirPath(),
+): string {
+  const serverPath = join(root, "dist", "claude-server.mjs");
+  if (!existsSync(serverPath)) {
+    throw new Error(`Claude intercom MCP server is missing. Run \`npm run build\` in ${root}.`);
+  }
+  ensureIntercomRuntimeDir(intercomDir);
+  const path = join(intercomDir, `claude-worker-mcp-${shortHash(root)}.json`);
+  writeFileSync(path, `${JSON.stringify({ mcpServers: { "claude-intercom": { command: process.execPath, args: [serverPath] } } }, null, 2)}\n`, { mode: 0o600 });
+  restrictIntercomRuntimeFile(path);
+  return path;
+}
+
+export function buildTuiAppendSystemPrompt(
+  name: string,
+  id: string,
+  transport: ResolvedClaudeIntercomTransport = "mcp",
+): string {
+  const common = `You are a Claude Code session connected to a local intercom as "${name}" (id ${id}).`;
+  if (transport === "native") {
+    return [
+      common,
+      "Other local coding-agent sessions can message you through Claude's native cross-session channel. Inbound requests begin with \"[Intercom message from\".",
+      "Treat each as a peer request. After acting, use Claude's built-in SendMessage tool to send your answer or acknowledgement back to the same native peer. A normal assistant response is visible only in this TUI and does not reach the blocking sender.",
+      "Do not claim intercom_send or intercom_reply tools are available unless another configured plugin actually provides them.",
+    ].join("\n");
+  }
+  return [
+    common,
+    "Other local coding-agent sessions can message you. Inbound messages are delivered automatically as monitor events that begin with \"Intercom message from\".",
+    "When such an event arrives, treat it as a request from that peer:",
+    "- If it is marked \"[asking — awaiting your reply]\", the sender is BLOCKING on your answer. Do the work if appropriate, then answer with the intercom_reply tool: intercom_reply({ message: \"...\" }).",
+    "- Otherwise, act if needed and use intercom_send to respond or acknowledge.",
+    "Use intercom_team to find your manager and managed coworkers. You also have intercom_list, intercom_whoami, intercom_status, intercom_pending, and intercom_set_summary. Keep intercom replies concise.",
+  ].join("\n");
+}
+
+export function nativeClaudeFeatureEnv(transport: ResolvedClaudeIntercomTransport): Record<string, string> {
+  return transport === "native" ? { CLAUDE_CODE_HARBOR_KITE: "1" } : {};
+}
+
+export async function waitForChildExit(child: ChildProcess): Promise<[number | null, NodeJS.Signals | null]> {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return [child.exitCode, child.signalCode];
+  }
+  return once(child, "exit") as Promise<[number | null, NodeJS.Signals | null]>;
+}
+
+// Live TUI mode: run an interactive `claude` and attach either the native
+// socket bridge or the preserved plugin/inbox/Monitor transport, giving the
+// coi-style "sit in it and get woken" experience without an Anthropic relay.
+async function runCciTui(options: CciOptions, id: string, name: string, scopeId: string | undefined): Promise<number> {
+  const scopeEnv = capturedScopeEnv(scopeId);
+  const resolution = resolveClaudeIntercomTransport({
+    requested: options.transport,
+    claudeCommand: options.claudeCommand,
+  });
+  const root = repoRoot();
+  const serverPath = join(root, "dist", "claude-server.mjs");
+  const monitorPath = join(root, "dist", "inbox-monitor.mjs");
+  if (resolution.selected === "mcp" && (!existsSync(serverPath) || !existsSync(monitorPath))) {
+    process.stderr.write(`cci --tui with MCP transport requires a build. Run \`npm run build\` in ${root} first.\n`);
+    return 1;
+  }
+  if (options.minimal) {
+    process.stderr.write(resolution.selected === "mcp"
+      ? "cci --tui ignores --minimal: --safe-mode would disable the intercom MCP server and inbox monitor.\n"
+      : "cci --tui ignores --minimal: live native mode runs an ordinary interactive Claude session.\n");
+  }
+
+  const inboxPath = defaultInboxPath(id);
+  if (resolution.selected === "mcp") {
+    rmSync(inboxPath, { force: true }); // fresh session: only surface messages that arrive from now on
+  }
+
+  const args: string[] = ["--append-system-prompt", buildTuiAppendSystemPrompt(name, id, resolution.selected)];
+  if (resolution.selected === "mcp") args.unshift("--plugin-dir", root);
+  const permission = resolveClaudePermissionPolicy(options);
+  if (options.model) args.push("--model", options.model);
+  if (options.effort) args.push("--effort", options.effort);
+  if (permission.dangerouslySkipPermissions) args.push("--dangerously-skip-permissions");
+  else if (permission.permissionMode) args.push("--permission-mode", permission.permissionMode);
+  for (const dir of options.addDirs) args.push("--add-dir", dir);
+
+  process.stderr.write(`cci --tui: live intercom session ${name} (${id}), ${resolution.selected} transport (${resolution.reason})\n`);
+  process.stderr.write(resolution.selected === "native"
+    ? "Inbound intercom messages use Claude's native cross-session channel; answer peers with Claude's built-in SendMessage tool.\n"
+    : "Inbound intercom messages appear in this session automatically; reply with the intercom_reply tool.\n");
+
+  const child = spawn(options.claudeCommand, args, {
+    cwd: options.cwd,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ...scopeEnv,
+      CLAUDE_INTERCOM_NAME: name,
+      CLAUDE_INTERCOM_SESSION_ID: id,
+      ...(options.model ? { CLAUDE_INTERCOM_MODEL: options.model } : {}),
+      ...nativeClaudeFeatureEnv(resolution.selected),
+      ...(resolution.selected === "mcp" ? { CLAUDE_INTERCOM_INBOX: inboxPath } : {}),
+    },
+  });
+  let bridge: NativeClaudeBrokerBridge | undefined;
+  if (resolution.selected === "native") {
+    try {
+      if (!child.pid) throw new Error("Claude started without a process id; native transport cannot attach");
+      const peer = await waitForNativeClaudePeer(child.pid);
+      bridge = new NativeClaudeBrokerBridge({ id, name, cwd: options.cwd, model: options.model }, { scopeId });
+      await bridge.start(peer.socketPath);
+    } catch (error) {
+      child.kill("SIGTERM");
+      await waitForChildExit(child).catch(() => undefined);
+      await bridge?.stop();
+      if (resolution.requested !== "auto") throw error;
+      process.stderr.write(`Native Claude transport did not attach (${error instanceof Error ? error.message : String(error)}); falling back to MCP.\n`);
+      return runCciTui({ ...options, transport: "mcp" }, id, name, scopeId);
+    }
+  }
+  const [code, signal] = await waitForChildExit(child);
+  await bridge?.stop();
+  if (resolution.selected === "mcp") rmSync(inboxPath, { force: true });
+  if (typeof code === "number") return code;
+  return signal === "SIGINT" ? 130 : 1;
+}
+
+export async function runCci(options: CciOptions): Promise<number> {
+  const tuiScopeId = options.tui ? intercomScopeIdFromEnvForRegistration(options.intercomEnv ?? process.env) : undefined;
+  const identity = detectIdentity(options.cwd);
+  const id = sanitizeSegment(options.id ?? identity.id);
+  const name = options.name ?? identity.name;
+
+  if (options.tui) {
+    return runCciTui(options, id, name, tuiScopeId);
+  }
+
+  const statePath = options.statePath ?? DEFAULT_WORKER_STATE_PATH;
+  const resolution = resolveClaudeIntercomTransport({
+    requested: options.transport,
+    claudeCommand: options.claudeCommand,
+  });
+  const mcpConfig = options.mcpConfig ?? (
+    resolution.selected === "mcp" && !options.minimal ? writeDefaultWorkerMcpConfig() : undefined
+  );
+
+  // Minimal mode runs each woken turn with Claude Code's --safe-mode, which
+  // disables CLAUDE.md, skills, plugins, hooks, MCP servers, and *custom* agent
+  // definitions while keeping auth, built-in tools, and permissions working
+  // normally — the focused-worker analog of the Codex minimal profile. The
+  // built-in Task tool is retained, so a minimal worker can still delegate to
+  // general-purpose subagents (matching Codex minimal's multi_agent = true).
+  const claudeArgs = [
+    ...(options.minimal ? ["--safe-mode"] : []),
+    ...(options.effort ? ["--effort", options.effort] : []),
+  ];
+
+  const agent: WorkerAgentConfig = {
+    id,
+    name,
+    cwd: options.cwd,
+    model: options.model,
+    instructions: options.instructions,
+    permissionMode: options.permissionMode,
+    dangerouslySkipPermissions: options.dangerouslySkipPermissions,
+    addDirs: options.addDirs.length ? options.addDirs : undefined,
+    mcpConfig,
+    claudeArgs: claudeArgs.length ? claudeArgs : undefined,
+    transport: resolution.selected,
+  };
+
+  const config: WorkerConfig = {
+    statePath,
+    claudeCommand: options.claudeCommand,
+    agents: [agent],
+  };
+
+  process.stderr.write(`cci intercom worker: ${name} (${id}), ${resolution.selected} transport (${resolution.reason})\n`);
+  process.stderr.write(`Resume this worker's Claude session anytime with: claude --resume <session-id> (see ${statePath} once a turn has run)\n`);
+  if (options.dangerouslySkipPermissions) {
+    process.stderr.write("Running with explicitly requested --dangerously-skip-permissions (yolo).\n");
+  }
+  if (options.minimal) {
+    process.stderr.write("Minimal mode: woken turns run with --safe-mode (no CLAUDE.md, skills, plugins, hooks, or MCP). Built-in tools and subagent delegation (Task tool) are retained.\n");
+  }
+
+  const daemon = new ClaudeWorkerDaemon(config);
+  let cleaned = false;
+  const cleanupOnce = async () => {
+    if (cleaned) return;
+    cleaned = true;
+    await daemon.stop().catch(() => undefined);
+  };
+
+  process.once("SIGINT", () => {
+    void cleanupOnce().finally(() => process.exit(130));
+  });
+  process.once("SIGTERM", () => {
+    void cleanupOnce().finally(() => process.exit(143));
+  });
+
+  await daemon.start();
+  let restoreInput: (() => void) | undefined;
+  if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    let composerOpen = false;
+    const onData = (chunk: Buffer) => {
+      const input = chunk.toString("utf8");
+      if (input === "\u001bi" || input === "\u001bI") {
+        void daemon.copyPrimaryContact().then((status) => process.stderr.write(`${status}\n`));
+      } else if ((input === "\u001bm" || input === "\u001bM") && !composerOpen) {
+        composerOpen = true;
+        process.stdin.off("data", onData);
+        process.stdin.setRawMode(false);
+        void openIntercomComposer(daemon)
+          .catch((error) => process.stderr.write(`Intercom: ${error instanceof Error ? error.message : String(error)}\n`))
+          .finally(() => {
+            composerOpen = false;
+            process.stdin.setRawMode(true);
+            process.stdin.on("data", onData);
+          });
+      } else if (input === "\u0003") {
+        process.emit("SIGINT");
+      }
+    };
+    process.stdin.on("data", onData);
+    restoreInput = () => {
+      process.stdin.off("data", onData);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    };
+    process.stderr.write("Press Alt+M to send an intercom message or Alt+I to copy this worker's contact target.\n");
+  }
+  await Promise.race([once(process, "SIGINT"), once(process, "SIGTERM")]);
+  restoreInput?.();
+  await cleanupOnce();
+  return 0;
+}
+
+async function main(): Promise<void> {
+  const options = parseCciArgs(process.argv.slice(2));
+  const code = await runCci(options);
+  process.exit(code);
+}
+
+// Resolve the invoked path through realpath: when installed as an npm bin,
+// process.argv[1] is the symlink (e.g. .../bin/cci) whose basename lacks the
+// .mjs suffix, so match against the real bundle file (dist/cci.mjs) instead.
+function invokedFileBasename(): string {
+  try {
+    return process.argv[1] ? basename(realpathSync(process.argv[1])) : "";
+  } catch {
+    return process.argv[1] ? basename(process.argv[1]) : "";
+  }
+}
+
+if (invokedFileBasename() === "cci.ts" || invokedFileBasename() === "cci.mjs") {
+  void main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    process.exit(1);
+  });
+}

package/claude/ccim.ts

@@ -0,0 +1,31 @@
+// ccim — the minimal counterpart to cci (like Codex's coim to coi).
+// Identical to `cci` but forces minimal mode (--safe-mode woken turns), which
+// strips CLAUDE.md, skills, plugins, hooks, and MCP while keeping built-in tools
+// and subagent delegation. Everything else (flags, identity, yolo/--safe) is the
+// same as cci; `ccim ...` is exactly `cci --minimal ...`.
+import { realpathSync } from "node:fs";
+import { basename } from "node:path";
+import { parseCciArgs, runCci } from "./cci.ts";
+
+async function main(): Promise<void> {
+  const options = { ...parseCciArgs(process.argv.slice(2)), minimal: true };
+  const code = await runCci(options);
+  process.exit(code);
+}
+
+// See cci.ts: match the real bundle file so the npm-bin symlink (basename
+// "ccim", no extension) still triggers main().
+function invokedFileBasename(): string {
+  try {
+    return process.argv[1] ? basename(realpathSync(process.argv[1])) : "";
+  } catch {
+    return process.argv[1] ? basename(process.argv[1]) : "";
+  }
+}
+
+if (invokedFileBasename() === "ccim.ts" || invokedFileBasename() === "ccim.mjs") {
+  void main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    process.exit(1);
+  });
+}