@standardagents/code 0.0.2-dev.51cdb4c → 0.1.0

package/src/index.ts

@@ -1,1152 +0,0 @@
-/**
- * Standard Code CLI entry point.
- *
- * Pre-flight (plain readline): resolve the instance endpoint, OAuth-login if
- * needed, then offer to resume a thread tagged for this project+machine or start
- * a new one. Then hand off to the interactive TUI which streams the agent and
- * forwards its tools to this host.
- */
-import os from "node:os";
-import fs from "node:fs";
-import path from "node:path";
-import readline from "node:readline/promises";
-import { spawn } from "node:child_process";
-import { stdin as input, stdout as output } from "node:process";
-import { ApiClient } from "./api.ts";
-import { Bridge } from "./bridge.ts";
-import { HostTools } from "./host-tools.ts";
-import { MessageStream } from "./stream.ts";
-import { SystemEvents, type ThreadEntry } from "./events-stream.ts";
-import { Tui } from "./tui.ts";
-import { renderMarkdown } from "./markdown.ts";
-import { ProcessRegistry } from "./process-registry.ts";
-import { McpManager } from "./mcp.ts";
-import {
-  listMcpServers,
-  saveMcpServer,
-  removeMcpServer,
-  setMcpServerEnabled,
-  parseServerSpec,
-  type McpServerConfig,
-} from "./mcp-config.ts";
-import {
-  getCredential,
-  saveCredential,
-  defaultEndpoint,
-  normalizeEndpoint,
-} from "./credentials.ts";
-import { LEVELS, levelLabel, type Level, type ThreadSummary } from "./types.ts";
-import type { PermissionState } from "./permissions.ts";
-import { loadApprovals, saveApprovals } from "./approvals.ts";
-
-const AGENT_ID = "standard_code_agent";
-
-const c = {
-  reset: "\x1b[0m",
-  dim: "\x1b[2m",
-  bold: "\x1b[1m",
-  white: "\x1b[97m",
-  cyan: "\x1b[36m",
-  green: "\x1b[32m",
-  gray: "\x1b[90m",
-  magenta: "\x1b[35m",
-  yellow: "\x1b[33m",
-  red: "\x1b[31m",
-  teal: "\x1b[38;5;37m", // brand teal (matches the marketing site's teal accent)
-};
-
-/**
- * The Standard Agents logomark — two interlocking squares crossed by a diagonal
- * lens — rendered in full block characters. Printed at the left of the startup
- * banner with the session details aligned to its right.
- */
-const LOGO_MARK = [
-  "     █████████████",
-  "     ███        ██",
-  "     ██          █",
-  "████ ████████   ██",
-  "███  ████████  ███",
-  "██   ████████ ████",
-  "█          ██",
-  "██        ███",
-  "█████████████",
-];
-
-/**
- * Print an assistant reply: light Markdown formatting, padded with a blank line
- * above and below so successive messages don't run together.
- */
-function printAssistant(tui: Tui, text: string): void {
-  const cols = Math.max(20, (process.stdout.columns || 80) - 1); // -1 cushion to avoid edge-wrap
-  tui.print("");
-  for (const line of renderMarkdown(text, cols)) tui.print(line);
-  tui.print("");
-}
-
-/** A calm, branded goodbye printed on a graceful shutdown. */
-function farewell(): void {
-  output.write(`\n${c.teal}◇${c.reset} ${c.dim}Standard Code — see you soon.${c.reset}\n`);
-}
-
-/** Whether a hostname is a local/private dev address (loopback, .local, RFC-1918). */
-function isLocalHost(host: string): boolean {
-  return (
-    host === "localhost" ||
-    host === "127.0.0.1" ||
-    host === "::1" ||
-    host.endsWith(".local") ||
-    host.endsWith(".localhost") ||
-    /^10\./.test(host) ||
-    /^192\.168\./.test(host) ||
-    /^172\.(1[6-9]|2\d|3[01])\./.test(host)
-  );
-}
-
-/**
- * Relax TLS verification for local/private endpoints only. OrbStack (and other
- * local dev setups) serve HTTPS with a CA installed in the system keychain —
- * which curl and browsers trust, but Node's `fetch`/`WebSocket` do not, so they
- * fail with SELF_SIGNED_CERT_IN_CHAIN and every token "doesn't work". For a
- * loopback/`.local`/RFC-1918 host we disable verification (covering fetch and
- * the bridge/stream WebSockets); public endpoints keep full verification.
- * Returns true when verification was relaxed.
- */
-function relaxTlsForLocalEndpoint(endpoint: string): boolean {
-  let host = "";
-  try {
-    host = new URL(endpoint).hostname;
-  } catch {
-    return false;
-  }
-  if (!endpoint.startsWith("https:") || !isLocalHost(host)) return false;
-  // Filter out Node's global "insecure TLS" warning; we surface our own note.
-  const origEmit = process.emitWarning.bind(process);
-  process.emitWarning = ((warning: string | Error, ...args: unknown[]) => {
-    const msg = typeof warning === "string" ? warning : warning?.message ?? "";
-    if (msg.includes("NODE_TLS_REJECT_UNAUTHORIZED")) return;
-    return (origEmit as (...a: unknown[]) => void)(warning, ...args);
-  }) as typeof process.emitWarning;
-  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
-  return true;
-}
-
-/** Read this package's version from package.json (best effort). */
-function readVersion(): string {
-  try {
-    const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-    return typeof pkg.version === "string" ? pkg.version : "";
-  } catch {
-    return "";
-  }
-}
-
-/**
- * Print the startup welcome: the logomark, then the product name, version, the
- * connected instance, and the working directory stacked beneath it — a calm,
- * branded header before the session begins.
- */
-function printWelcome(endpoint: string, projectDir: string): void {
-  const home = os.homedir();
-  const dir = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
-  const host = endpoint.replace(/^https?:\/\//, "").replace(/\/$/, "");
-  const version = readVersion();
-  const pad = "  ";
-  // Session details, placed to the right of the mark and vertically centered.
-  const meta = [
-    `${c.bold}${c.white}Standard Code${c.reset}${version ? `  ${c.dim}v${version}${c.reset}` : ""}`,
-    `${c.dim}terminal coding agent${c.reset}`,
-    `${c.teal}${host}${c.reset}`,
-    `${c.dim}${dir}${c.reset}`,
-  ];
-  const markWidth = Math.max(...LOGO_MARK.map((l) => [...l].length));
-  const metaTop = Math.floor((LOGO_MARK.length - meta.length) / 2);
-  output.write("\n");
-  for (let i = 0; i < LOGO_MARK.length; i++) {
-    const glyph = LOGO_MARK[i].padEnd(markWidth); // logo in default text color
-    const line = meta[i - metaTop];
-    output.write(`${pad}${glyph}${line ? `   ${line}` : ""}\n`);
-  }
-  output.write("\n");
-}
-
-/**
- * Colour a tool-activity line for readable contrast: a bright status glyph
- * (green ✓, red ✗, yellow ⛔) with the action text at full contrast and only the
- * trailing parenthetical detail dimmed. Replaces the old wrap-everything-in-gray.
- */
-function colorActivity(line: string): string {
-  const m = line.match(/^(\s*)([✓✗⛔])\s?([\s\S]*)$/);
-  if (!m) return `${c.dim}${line}${c.reset}`;
-  const [, indent, glyph, rest] = m;
-  if (glyph === "✓") {
-    const body = rest.replace(/\s(\([^()]*\))\s*$/, ` ${c.dim}$1${c.reset}`);
-    return `${indent}${c.green}✓${c.reset} ${body}`;
-  }
-  if (glyph === "✗") return `${indent}${c.red}✗${c.reset} ${rest}`;
-  return `${indent}${c.yellow}⛔ ${rest}${c.reset}`;
-}
-
-async function main(): Promise<void> {
-  const args = process.argv.slice(2);
-  let endpointArg: string | undefined;
-  let dirArg: string | undefined;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--endpoint" || args[i] === "-e") endpointArg = args[++i];
-    else if (!args[i].startsWith("-")) dirArg = args[i];
-  }
-
-  const projectDir = path.resolve(dirArg || process.cwd());
-  const machine = os.hostname();
-
-  // Create the line reader lazily so it never eagerly consumes stdin (which
-  // would swallow a message the user pre-types before the interactive prompt).
-  // A `SIGINT` listener implements double-press-to-quit during these pre-flight
-  // prompts — without it, ctrl-c rejects `question()` with an AbortError and
-  // crashes the process with a stack trace.
-  const reader: { rl: readline.Interface | null } = { rl: null };
-  let handoffClosing = false; // set when we intentionally close the reader for the TUI handoff
-  let preflightArmed = false;
-  let preflightTimer: ReturnType<typeof setTimeout> | null = null;
-  const onPreflightSigint = () => {
-    if (preflightArmed) {
-      if (preflightTimer) clearTimeout(preflightTimer);
-      reader.rl?.close();
-      farewell();
-      process.exit(0);
-    }
-    preflightArmed = true;
-    output.write(`\n${c.dim}Press Control-C again to exit${c.reset}\n`);
-    preflightTimer = setTimeout(() => {
-      preflightArmed = false;
-      preflightTimer = null;
-    }, 2000);
-  };
-  const ask = async (question: string): Promise<string> => {
-    if (!reader.rl) {
-      reader.rl = readline.createInterface({ input, output });
-      reader.rl.on("SIGINT", onPreflightSigint);
-      // EOF (ctrl-d / closed stdin) ends the reader — exit gracefully instead of
-      // looping into an ERR_USE_AFTER_CLOSE on the next prompt.
-      reader.rl.on("close", () => {
-        if (handoffClosing) return; // our own handoff close, not the user leaving
-        farewell();
-        process.exit(0);
-      });
-    }
-    return reader.rl.question(question);
-  };
-  // Cover the cooked-mode gaps too (e.g. while resolving threads before the TUI
-  // grabs the keyboard) so a stray ctrl-c there also takes two presses and exits
-  // gracefully rather than killing the process. Once the TUI enables raw mode,
-  // ctrl-c arrives as a keypress and this never fires.
-  process.on("SIGINT", onPreflightSigint);
-
-  // 1. Resolve endpoint.
-  let endpoint = endpointArg || defaultEndpoint() || "";
-  if (!endpoint) {
-    const answer = await ask(
-      `${c.cyan}Standard Agents instance URL${c.reset} (e.g. http://localhost:5178): `
-    );
-    endpoint = answer.trim();
-  }
-  endpoint = normalizeEndpoint(endpoint);
-
-  // Local dev instances (OrbStack, etc.) use a CA Node won't trust by default —
-  // relax TLS for loopback/.local/private hosts so the CLI can actually connect.
-  const tlsRelaxed = relaxTlsForLocalEndpoint(endpoint);
-
-  // Welcome banner — printed once the destination instance is known, before any
-  // auth prompt, so the session opens with a calm, branded header.
-  printWelcome(endpoint, projectDir);
-  if (tlsRelaxed) {
-    output.write(`${c.dim}  TLS verification relaxed for local endpoint.${c.reset}\n\n`);
-  }
-
-  // 2. Resolve credentials. Use a stored API token if it still works, otherwise
-  //    ask for one (create it in your Standard Agents instance settings).
-  const stored = getCredential(endpoint);
-  let api = stored ? new ApiClient(endpoint, stored.access_token) : null;
-  if (!api || !(await api.verify())) {
-    const host = endpoint.replace(/^https?:\/\//, "").replace(/\/$/, "");
-    output.write(
-      `${c.bold}${c.white}Sign in${c.reset} ${c.dim}— paste an API token to connect to${c.reset} ${c.teal}${host}${c.reset}\n`
-    );
-    output.write(`${c.dim}Create one in your instance settings under API tokens.${c.reset}\n\n`);
-    for (;;) {
-      const token = (await ask(`${c.teal}❯${c.reset} ${c.dim}token${c.reset} `)).trim();
-      if (!token) {
-        output.write(`${c.dim}A token is required.${c.reset}\n`);
-        continue;
-      }
-      api = new ApiClient(endpoint, token);
-      if (await api.verify()) {
-        saveCredential({ endpoint, access_token: token, token_type: "Bearer", saved_at: Date.now() });
-        output.write(`${c.green}✓${c.reset} Connected to ${c.teal}${host}${c.reset}\n`);
-        break;
-      }
-      output.write(`${c.red}✗${c.reset} ${c.dim}That token didn't work. Try again.${c.reset}\n`);
-    }
-  }
-
-  if (!api) process.exit(1);
-  handoffClosing = true;
-  reader.rl?.close();
-
-  // 3. Offer to resume a session for this project+machine, or start new.
-  const tags = [`path:${projectDir}`, `machine:${machine}`];
-  let existing: ThreadSummary[] = [];
-  try {
-    existing = await api.listThreads(AGENT_ID, tags);
-  } catch {
-    existing = [];
-  }
-
-  const tui = new Tui(1); // auto-accept level 1 by default (asks on anything riskier than a read)
-
-  let threadId: string;
-  let resumed = false;
-  if (existing.length > 0) {
-    const summaries = await summarizeThreads(api, existing.slice(0, 8));
-    const items: { label: string; hint?: string; value: string | null }[] = summaries.map((s) => ({
-      label: s.label,
-      hint: s.hint,
-      value: s.id,
-    }));
-    items.push({ label: "＋ Start a new session", value: null });
-    const home = os.homedir();
-    const tilde = projectDir.startsWith(home) ? "~" + projectDir.slice(home.length) : projectDir;
-    const shortDir = tilde.length > 38 ? "…" + tilde.slice(-37) : tilde;
-    const picked = await tui.select(
-      `${c.bold}${c.magenta}Resume a session${c.reset}  ${c.gray}${shortDir}${c.reset}  ${c.dim}↑↓ · enter · esc to cancel${c.reset}`,
-      items
-    );
-    if (typeof picked === "string") {
-      threadId = picked;
-      resumed = true;
-    } else {
-      threadId = await api.createThread(AGENT_ID, tags);
-    }
-  } else {
-    threadId = await api.createThread(AGENT_ID, tags);
-  }
-
-  await runInteractive(tui, api, threadId, projectDir, machine, resumed);
-}
-
-/** Build a one-line preview (first user message) + timestamp for each thread. */
-async function summarizeThreads(
-  api: ApiClient,
-  threads: ThreadSummary[]
-): Promise<{ id: string; label: string; hint: string }[]> {
-  return Promise.all(
-    threads.map(async (t) => {
-      let preview = "";
-      try {
-        const msgs = await api.getMessages(t.id, 30);
-        const users = msgs
-          .filter((m: any) => m.role === "user" && typeof m.content === "string" && m.content.trim())
-          .sort((a: any, b: any) => (a.created_at ?? 0) - (b.created_at ?? 0));
-        if (users[0]) preview = String(users[0].content).replace(/\s+/g, " ").trim();
-      } catch {
-        // ignore; show a placeholder
-      }
-      const label = preview
-        ? preview.length > 64
-          ? preview.slice(0, 63) + "…"
-          : preview
-        : "(empty session)";
-      const when = t.created_at ? relativeTime(t.created_at) : "";
-      const hint = [t.id.slice(0, 8), when].filter(Boolean).join(" · ");
-      return { id: t.id, label, hint };
-    })
-  );
-}
-
-/**
- * A human-readable label for a subagent's child thread: prefer its instance name
- * tag (`name:<x>`), else a title-cased form of the agent name (`research_agent`
- * → "Research Agent").
- */
-function subagentLabel(t: ThreadEntry, titles: Map<string, string>): string {
-  // Prefer the agent's display title (e.g. "Research Assistant"); a per-instance
-  // name tag refines it ("Research Assistant · auth-flow") when present.
-  const agentName = (t.agent_name || "").trim();
-  const title =
-    titles.get(agentName) ||
-    (agentName ? agentName.replace(/[_-]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()) : "Subagent");
-  const nameTag = (t.tags || []).find((tag) => tag.startsWith("name:"));
-  const tagged = nameTag?.slice("name:".length).trim();
-  return tagged ? `${title} · ${tagged}` : title;
-}
-
-/** Open a URL in the system browser (best effort). */
-function openUrl(url: string): void {
-  const platform = process.platform;
-  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
-  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
-  try {
-    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
-    child.unref();
-  } catch {
-    // ignore — the URL is also printed for manual opening
-  }
-}
-
-/** Compact relative time from a unix-seconds timestamp. */
-function relativeTime(unixSeconds: number): string {
-  const diff = Date.now() / 1000 - unixSeconds;
-  if (diff < 60) return "just now";
-  if (diff < 3600) return `${Math.floor(diff / 60)}m ago`;
-  if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`;
-  return `${Math.floor(diff / 86400)}d ago`;
-}
-
-/**
- * Whether a message carries tool calls. The API serializes `tool_calls` as a
- * JSON STRING (not an array), so `Array.isArray` is never true — checking only
- * that would treat a tool-call assistant message (which can also have narration
- * content) as a final answer, completing the turn while a tool/approval is still
- * pending. Handle both shapes.
- */
-function hasToolCalls(m: any): boolean {
-  const tc = m?.tool_calls;
-  if (Array.isArray(tc)) return tc.length > 0;
-  if (typeof tc === "string") {
-    const s = tc.trim();
-    return s.length > 0 && s !== "null" && s !== "[]";
-  }
-  return false;
-}
-
-/** Extract plain text from a message's content (string or content-block array). */
-function messageText(content: unknown): string {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content
-      .map((b: any) => (typeof b === "string" ? b : typeof b?.text === "string" ? b.text : ""))
-      .join("");
-  }
-  return "";
-}
-
-/** Whether the thread is currently working (a turn active or queued work pending). */
-function threadBusy(msgs: any[]): boolean {
-  if (!msgs.length) return false;
-  if (msgs.some((m) => m.status === "pending")) return true;
-  const last = [...msgs].sort((a, b) => (b.created_at ?? 0) - (a.created_at ?? 0))[0];
-  if (!last) return false;
-  if (last.role === "user" || last.role === "tool") return true; // turn about to run / mid-turn
-  if (last.role === "assistant") return hasToolCalls(last); // tool-call message = still going
-  return false; // a final assistant text, or a system/stop message → idle
-}
-
-/** Replay a resumed thread's conversation so it feels like picking up mid-session. */
-async function printHistory(api: ApiClient, threadId: string, tui: Tui): Promise<void> {
-  let msgs: any[];
-  try {
-    msgs = await api.getMessages(threadId, 200);
-  } catch {
-    return;
-  }
-  const convo = msgs
-    .filter((m) => m.role === "user" || (m.role === "assistant" && messageText(m.content).trim()))
-    .sort((a, b) => (a.created_at ?? 0) - (b.created_at ?? 0));
-  if (!convo.length) return;
-  const shown = convo.slice(-24);
-  tui.print(`${c.dim}── resuming session · ${convo.length} message${convo.length === 1 ? "" : "s"} ──${c.reset}`);
-  if (shown.length < convo.length) tui.print(`${c.dim}   … earlier messages omitted${c.reset}`);
-  for (const m of shown) {
-    const text = messageText(m.content).trim();
-    if (!text) continue;
-    if (m.role === "user") tui.printUserMessage(text);
-    else printAssistant(tui, text);
-  }
-  tui.print(`${c.dim}────────────────${c.reset}`);
-}
-
-async function runInteractive(
-  tui: Tui,
-  api: ApiClient,
-  threadId: string,
-  projectDir: string,
-  machine: string,
-  resumed: boolean
-): Promise<void> {
-  // Background-process metadata lives in the thread's KV (server-side), so the
-  // list resumes from any machine; nothing about it is stored on this client.
-  const registry = new ProcessRegistry(api, threadId, machine);
-  // MCP host: the CLI negotiates with locally-launched MCP servers and forwards
-  // the agent's `mcp` tool calls to them. The discovered tool catalog is mirrored
-  // into the thread KV so a context hook can show the agent what's available.
-  const mcp = new McpManager(projectDir);
-  const publishMcpCatalog = () => void api.kvSet(threadId, "mcp_catalog", mcp.catalog()).catch(() => {});
-  const host = new HostTools(projectDir, registry, threadId, machine, mcp, publishMcpCatalog);
-  const refreshBgCount = () => {
-    void registry.runningCount().then((n) => tui.setBackgroundCount(n)).catch(() => {});
-  };
-  const perm: PermissionState = { level: tui.level, alwaysAllow: new Set(), allowRisk: new Set() };
-  // Restore this session's saved approvals (auto-accept level + pre-approved
-  // tools and risk levels) from the thread KV, so they resume with the session.
-  const savedApprovals = await loadApprovals(api, threadId);
-  for (const t of savedApprovals.allowTools) perm.alwaysAllow.add(t);
-  for (const r of savedApprovals.allowRisk) perm.allowRisk.add(r);
-  if (savedApprovals.level) {
-    perm.level = savedApprovals.level;
-    tui.setLevel(savedApprovals.level);
-  }
-  tui.onLevelChange((l: Level) => {
-    perm.level = l;
-    saveApprovals(api, threadId, perm);
-  });
-
-  // ── state ────────────────────────────────────────────────────────────────
-  let busy = false; // is the agent currently working
-  // Set when the user hits esc to interrupt: clears the working indicator
-  // immediately and suppresses the poller from re-showing it until the backend
-  // confirms the turn actually stopped (otherwise "Working" lingers a poll or two).
-  let interrupting = false;
-  const queued: string[] = []; // messages typed while busy, held to send next
-  let editingQueued = false; // input currently holds a pulled queued message
-  const shownIds = new Set<string>(); // message ids already printed to the transcript
-
-  // ── token feed ──────────────────────────────────────────────────────────
-  // Cumulative tokens are authoritative from logs (one row per completed LLM
-  // call); a live estimate from streamed content ticks the output count up
-  // between log updates so a long generation isn't silent.
-  let tokensIn = 0;
-  let tokensOut = 0;
-  let liveOut = 0; // output tokens for the in-progress response (from `generation` events)
-  const countedLogs = new Set<string>();
-
-  // ── step indicator (what the agent is doing right now) ────────────────────
-  // Driven by tool_call_started / tool_call_done events. Most recently started
-  // active tool wins; cleared when the turn goes idle.
-  const activeSteps = new Map<string, string>(); // tool call id -> label
-
-  // Push the current totals + step to the prompt. Output total folds in the
-  // live in-progress count; the step's own output is the live count.
-  const refreshStatus = () => {
-    tui.setTokens(tokensIn, tokensOut + liveOut);
-    let label: string | null = null;
-    for (const v of activeSteps.values()) label = v; // last (most recent) entry
-    tui.setStep(label, liveOut);
-  };
-
-  const bridge = new Bridge(api, threadId, host, perm, {
-    onActivity: (line) => {
-      tui.print(colorActivity(line));
-      refreshBgCount();
-    },
-    onStatus: () => {}, // the working indicator is driven by the busy poller
-    onConnection: (state, attempt) => {
-      // Brief drops are normal (a permission wait, a dev-server reload) and the
-      // bridge reconnects on its own — stay quiet unless reconnection is actually
-      // struggling (several seconds of failed attempts). The disconnect shows as a
-      // TRANSIENT notice line in the bottom region that clears itself the moment we
-      // reconnect, so nothing about it lingers in the transcript.
-      if (state === "reconnecting") {
-        if (attempt >= 4) tui.setConnected(false);
-      } else {
-        tui.setConnected(true);
-      }
-    },
-    requestApproval: (req, summary, risk) =>
-      tui.approval(
-        `${summary}${req.requestPermission ? `\n${c.dim}why: ${req.requestPermission}${c.reset}` : ""}`,
-        risk
-      ),
-  });
-
-  // The message stream drives two live signals (the transcript itself is
-  // rendered from polling for robustness):
-  //  - `generation` events → the live output-token count (moves during ALL
-  //    generation, including big tool arguments like file content).
-  //  - `tool_call_started` / `tool_call_done` → the current step label.
-  const stream = new MessageStream(api, threadId, {
-    onChunk: () => {},
-    onAssistantText: () => {},
-    onEvent: (eventType, data) => {
-      if (eventType === "generation" && typeof data?.outputTokens === "number") {
-        liveOut = data.outputTokens;
-        refreshStatus();
-      } else if (eventType === "tool_call_started" && data?.id) {
-        activeSteps.set(data.id, data.progress || data.name || "working");
-        refreshStatus();
-      } else if (eventType === "tool_call_done" && data?.id) {
-        activeSteps.delete(data.id);
-        refreshStatus();
-      }
-    },
-    onError: () => {},
-  });
-
-  // ── subagent tracking ──────────────────────────────────────────────────────
-  // A subagent runs in its own child thread, so the live signal that one is
-  // working is its child thread appearing on the system-events channel with our
-  // thread as `parent` (and terminating when it finishes). One line per active
-  // subagent shows in the TUI.
-  const activeSubagents = new Map<string, string>(); // child threadId -> label
-  // Agent name → title, loaded once so subagent lines read "Research Assistant"
-  // rather than the raw agent name. Best effort; falls back to a prettified name.
-  const agentTitles = new Map<string, string>();
-  void api
-    .listAgents()
-    .then((list) => list.forEach((a) => agentTitles.set(a.name, a.title)))
-    .catch(() => {});
-  const pushSubagents = () => tui.setSubagents([...activeSubagents.values()]);
-  const events = new SystemEvents(api, {
-    onThreadCreated: (t) => {
-      if (t.parent === threadId && !t.terminated) {
-        activeSubagents.set(t.id, subagentLabel(t, agentTitles));
-        pushSubagents();
-      }
-    },
-    onThreadUpdated: (t) => {
-      if (t.parent !== threadId) return;
-      if (t.terminated) activeSubagents.delete(t.id);
-      else activeSubagents.set(t.id, subagentLabel(t, agentTitles));
-      pushSubagents();
-    },
-    onThreadDeleted: (id) => {
-      if (activeSubagents.delete(id)) pushSubagents();
-    },
-  });
-
-  const quit = () => {
-    tui.end();
-    bridge.close();
-    stream.close();
-    events.close();
-    mcp.closeAll();
-    farewell();
-    process.exit(0);
-  };
-  tui.setQuitHandler(quit);
-
-  const viewThread = () => {
-    const url = `${api.origin}/threads/${threadId}`;
-    openUrl(url);
-    tui.print(`${c.gray}opened ${c.cyan}${url}${c.reset}`);
-  };
-  const bgMgr: BgManager = {
-    list: () => registry.list(),
-    stop: async (id: string) => {
-      await host.execute("background_process", { action: "stop", id });
-      refreshBgCount();
-    },
-  };
-
-  // ── MCP control surface (for the /mcp command + slash menu) ────────────────
-  const mcpCtl: McpController = {
-    configured: () => listMcpServers(),
-    connectedNames: () => mcp.connectedNames(),
-    catalog: () => mcp.catalog(),
-    connect: async (cfg) => {
-      try {
-        const client = await mcp.connect(cfg);
-        publishMcpCatalog();
-        return { ok: true, tools: client.tools.length };
-      } catch (e) {
-        publishMcpCatalog();
-        return { ok: false, error: e instanceof Error ? e.message : String(e) };
-      }
-    },
-    disconnect: (name) => {
-      mcp.disconnect(name);
-      publishMcpCatalog();
-    },
-    add: async (cfg) => {
-      saveMcpServer(cfg);
-      return mcpCtl.connect(cfg);
-    },
-    // Seed the request into the main chat — the agent researches + installs it
-    // there (using research_agent + install_mcp), visible in the transcript.
-    requestInstall: (query) => {
-      void sendNow(
-        `Install an MCP server for me: ${query}. Research the best one and its exact launch command, then install it.`
-      );
-    },
-    remove: (name) => {
-      mcp.disconnect(name);
-      removeMcpServer(name);
-      publishMcpCatalog();
-    },
-    setEnabled: (name, enabled) => setMcpServerEnabled(name, enabled),
-  };
-
-  // ── submit / queue / steer ─────────────────────────────────────────────────
-  const sendNow = async (text: string) => {
-    tui.printUserMessage(text);
-    try {
-      await api.sendMessage(threadId, text);
-    } catch (e) {
-      tui.print(`${c.dim}failed to send: ${e instanceof Error ? e.message : String(e)}${c.reset}`);
-      return;
-    }
-    interrupting = false; // a fresh turn — let the working indicator show again
-    busy = true;
-    tui.setWorking(true);
-  };
-  const flushQueued = async () => {
-    if (!queued.length) return;
-    const toSend = queued.splice(0);
-    tui.setQueuedCount(0);
-    for (const t of toSend) await sendNow(t);
-  };
-
-  // Manually request a background compaction. Writes a request marker to thread
-  // KV; the agent-side prefilter hook honours it on the next step — spawning the
-  // non-blocking compaction subagent regardless of the auto-trigger threshold —
-  // then clears the marker. Cheap and idempotent.
-  const requestCompaction = async () => {
-    try {
-      await api.kvSet(threadId, "compaction_request", { requestedAt: Date.now() });
-      tui.print(
-        `${c.cyan}⟳${c.reset} compacting the conversation in the background — recent messages stay live.`
-      );
-    } catch (err) {
-      tui.print(`${c.red}✗${c.reset} couldn't request compaction: ${(err as Error).message}`);
-    }
-  };
-
-  // Slash-command palette: typing "/" filters this list inline above the prompt.
-  // Each command is individually addressable (/compact, /mcp, …). Hints are
-  // functions so live state (context %, level, counts) stays fresh as it redraws.
-  tui.setCommands([
-    {
-      name: "compact",
-      label: "Compact conversation now",
-      hint: () => tui.contextPctLabel() || "free up context",
-      run: requestCompaction,
-    },
-    { name: "level", label: "Auto-accept level", hint: () => `level ${tui.level}`, run: () => runLevelMenu(tui, perm) },
-    {
-      name: "permissions",
-      label: "Approved commands",
-      hint: () => {
-        const n = perm.alwaysAllow.size + perm.allowRisk.size;
-        return n ? `${n} approved` : "none";
-      },
-      run: () => runApprovalsMenu(tui, perm, () => saveApprovals(api, threadId, perm)),
-    },
-    {
-      name: "mcp",
-      label: "MCP servers",
-      hint: () => {
-        const n = mcpCtl.connectedNames().length;
-        return n ? `${n} connected` : "none";
-      },
-      run: () => runMcpMenu(tui, mcpCtl),
-    },
-    { name: "background", label: "Background processes", hint: "list / stop", run: () => runProcessMenu(tui, bgMgr) },
-    { name: "view", label: "View thread in AgentBuilder", run: () => viewThread() },
-    { name: "keybindings", label: "Keyboard shortcuts", run: () => showKeybindings(tui) },
-    { name: "quit", label: "Quit", run: () => quit() },
-  ]);
-
-  tui.onSubmit = (text) => {
-    if (editingQueued) {
-      editingQueued = false;
-      queued.push(text);
-      tui.setQueuedCount(queued.length);
-      tui.print(`${c.gray}⏳ queued:${c.reset} ${text}`);
-      return;
-    }
-    if (busy) {
-      queued.push(text);
-      tui.setQueuedCount(queued.length);
-      tui.print(`${c.gray}⏳ queued:${c.reset} ${text}  ${c.dim}(esc to steer now)${c.reset}`);
-    } else {
-      void sendNow(text);
-    }
-  };
-
-  tui.onInterrupt = () => {
-    if (queued.length > 0) {
-      tui.print(`${c.yellow}↪ steering — stopping current work and sending your message…${c.reset}`);
-      void api
-        .stop(threadId)
-        .catch(() => {})
-        .then(() => flushQueued());
-    } else if (busy) {
-      // Optimistically stop the working indicator so esc feels immediate.
-      interrupting = true;
-      busy = false;
-      activeSteps.clear();
-      liveOut = 0;
-      tui.setWorking(false);
-      refreshStatus();
-      tui.print(`${c.yellow}[interrupted by user]${c.reset}`);
-      void api.stop(threadId).catch(() => {});
-    }
-  };
-
-  tui.onUpArrow = () => {
-    if (tui.getInput().trim() || queued.length === 0) return;
-    const text = queued.pop()!;
-    tui.setQueuedCount(queued.length);
-    editingQueued = true;
-    tui.setInput(text);
-  };
-
-  events.connect();
-  await Promise.all([bridge.connect(), stream.connect()]);
-
-  tui.banner([
-    `${c.bold}${c.magenta}Standard Code${c.reset} ${c.dim}— coding agent${c.reset}`,
-    `${c.gray}project:${c.reset} ${projectDir}`,
-    `${c.gray}machine:${c.reset} ${machine}   ${c.gray}thread:${c.reset} ${threadId.slice(0, 8)}`,
-    `${c.dim}type anytime · shift-tab cycles auto-accept level · / for options · esc interrupts/steers · ctrl-c quits${c.reset}`,
-  ]);
-
-  if (resumed) await printHistory(api, threadId, tui);
-
-  // Seed shown-ids so the poller doesn't re-print existing history.
-  try {
-    (await api.getMessages(threadId, 200)).forEach((m: any) => shownIds.add(m.id));
-  } catch {
-    // ignore
-  }
-
-  const runningProcs = (await registry.list()).filter((p) => p.status === "running");
-  if (runningProcs.length) {
-    tui.print(
-      `${c.cyan}⚙ ${runningProcs.length} background process${runningProcs.length === 1 ? "" : "es"} running:${c.reset}`
-    );
-    for (const p of runningProcs) tui.print(`${c.gray}  ${p.id}  ${p.description || p.command}${c.reset}`);
-  }
-  refreshBgCount();
-
-  // Connect every enabled MCP server, then publish the catalog so the agent sees
-  // the tools on its very first step. (The CLI is the MCP host; this is the real
-  // initialize/tools-list handshake with each local server.)
-  const enabledServers = listMcpServers().filter((s) => s.enabled);
-  for (const s of enabledServers) {
-    const res = await mcpCtl.connect(s);
-    if (res.ok) {
-      tui.print(`${c.cyan}⚡ MCP "${s.name}" connected${c.reset} ${c.gray}(${res.tools} tool${res.tools === 1 ? "" : "s"})${c.reset}`);
-    } else {
-      tui.print(`${c.red}⚠ MCP "${s.name}" failed:${c.reset} ${c.gray}${res.error}${c.reset}`);
-    }
-  }
-  publishMcpCatalog();
-
-  tui.start(); // begin the persistent input line
-
-  // ── poller: display new messages, drive the working indicator, flush queue ──
-  const poll = async () => {
-    let msgs: any[];
-    try {
-      msgs = await api.getMessages(threadId, 60);
-    } catch {
-      return;
-    }
-    const sorted = [...msgs].sort((a, b) => (a.created_at ?? 0) - (b.created_at ?? 0));
-    for (const m of sorted) {
-      if (shownIds.has(m.id) || m.status === "pending") continue;
-      shownIds.add(m.id);
-      const text = messageText(m.content).trim();
-      if (m.role === "assistant" && text) printAssistant(tui, text);
-      else if (m.role === "system" && text) tui.print(`${c.dim}${text}${c.reset}`);
-    }
-    const polledBusy = threadBusy(msgs);
-    // While interrupting, keep the indicator off until the backend has actually
-    // gone idle — then clear the latch so future turns show "Working" again.
-    if (interrupting) {
-      if (!polledBusy) interrupting = false;
-      busy = false;
-    } else {
-      busy = polledBusy;
-    }
-    tui.setWorking(busy);
-    if (!busy) {
-      // Turn finished — clear any stale step + in-progress live count.
-      if (activeSteps.size) activeSteps.clear();
-      liveOut = 0;
-      refreshStatus();
-      if (queued.length > 0 && !editingQueued) await flushQueued();
-    }
-    refreshBgCount();
-
-    // Authoritative token totals from completed LLM-call logs.
-    try {
-      const logs = await api.getLogs(threadId, 100);
-      let landed = 0;
-      for (const l of logs) {
-        // Skip until the call is finalized — an in-progress log has null tokens,
-        // and counting it early would mark its id seen before the real counts land.
-        if (!l.is_complete) continue;
-        const id = l.id ?? `${l.created_at}:${l.total_tokens}`;
-        if (countedLogs.has(id)) continue;
-        countedLogs.add(id);
-        const inT = Number(l.input_tokens) || 0;
-        const outT = Number(l.output_tokens) || 0;
-        tokensIn += inT;
-        tokensOut += outT;
-        landed += outT;
-      }
-      if (landed > 0) liveOut = 0; // a real count arrived; drop the live estimate
-      refreshStatus();
-    } catch {
-      // ignore — token feed is best-effort
-    }
-
-    // Context-window gauge: the runtime records the latest request's input tokens
-    // (the true serialized context size) and the model's window to thread KV.
-    try {
-      const cu = (await api.kvGet(threadId, "context_usage")) as
-        | { inputTokens?: number; maxContextTokens?: number }
-        | null;
-      const used = Number(cu?.inputTokens) || 0;
-      const max = Number(cu?.maxContextTokens) || 0;
-      tui.setContextPct(max > 0 && used > 0 ? (used / max) * 100 : null);
-    } catch {
-      // ignore — gauge is best-effort
-    }
-  };
-  setInterval(() => void poll().catch(() => {}), 1200);
-
-  // Event-driven from here; keep the process alive.
-  await new Promise<void>(() => {});
-}
-
-interface BgManager {
-  list: () => Promise<{ id: string; command: string; description?: string; status: string; pid: number; exitCode?: number | null }[]>;
-  stop: (id: string) => Promise<void>;
-}
-
-interface McpController {
-  configured: () => McpServerConfig[];
-  connectedNames: () => string[];
-  catalog: () => { servers: { name: string; status: string; tools: { name: string; description?: string }[]; resources: { uri: string }[]; error?: string }[] };
-  connect: (cfg: McpServerConfig) => Promise<{ ok: boolean; tools?: number; error?: string }>;
-  disconnect: (name: string) => void;
-  add: (cfg: McpServerConfig) => Promise<{ ok: boolean; tools?: number; error?: string }>;
-  remove: (name: string) => void;
-  setEnabled: (name: string, enabled: boolean) => void;
-  /** Seed an install request into the main chat for the agent to research + install. */
-  requestInstall: (query: string) => void;
-}
-
-/** The `/` configuration menu: permission mode, approvals, processes, view thread, shortcuts, quit. */
-/** The auto-accept level submenu (reached via `/level`). */
-async function runLevelMenu(tui: Tui, perm: PermissionState): Promise<void> {
-  const picked = await tui.select(
-    `${c.bold}Auto-accept level${c.reset}  ${c.dim}(↑/↓ · enter · shift-tab cycles)${c.reset}`,
-    LEVELS.map((l) => ({
-      label: levelLabel(l),
-      hint: l === tui.level ? "current" : "",
-      value: l,
-    }))
-  );
-  if (picked) {
-    tui.setLevel(picked);
-    perm.level = picked;
-  }
-}
-
-/** Print the keyboard-shortcut reference (reached via `/keybindings`). */
-function showKeybindings(tui: Tui): void {
-  tui.print(`${c.gray}shortcuts:${c.reset}`);
-  tui.print(`${c.gray}  shift-tab${c.reset}  cycle auto-accept level (1–5)`);
-  tui.print(`${c.gray}  /${c.reset}          open the command palette (type to filter)`);
-  tui.print(`${c.gray}  ctrl-c${c.reset}     quit`);
-}
-
-/** Submenu listing tracked background processes; lets you stop a running one. */
-async function runProcessMenu(tui: Tui, bg: BgManager): Promise<void> {
-  const procs = await bg.list();
-  if (!procs.length) {
-    tui.print(`${c.gray}No background processes for this session.${c.reset}`);
-    return;
-  }
-  const items = procs.map((p) => {
-    const status =
-      p.status === "running"
-        ? `${c.green}running${c.reset}`
-        : `${c.gray}${p.status}${typeof p.exitCode === "number" ? ` (exit ${p.exitCode})` : ""}${c.reset}`;
-    return {
-      label: `${p.description || p.command}`,
-      hint: `${p.id} · ${status}`,
-      value: p.id,
-    };
-  });
-  const picked = await tui.select(
-    `${c.bold}Background processes${c.reset}  ${c.dim}(↑/↓ · enter to manage · esc to close)${c.reset}`,
-    items
-  );
-  if (!picked) return;
-  const proc = procs.find((p) => p.id === picked);
-  if (!proc || proc.status !== "running") {
-    tui.print(`${c.gray}${picked} is not running.${c.reset}`);
-    return;
-  }
-  const action = await tui.select(`${c.bold}${proc.description || proc.command}${c.reset}`, [
-    { label: "Stop this process", value: "stop" as const },
-    { label: "Leave it running", value: "leave" as const },
-  ]);
-  if (action === "stop") {
-    await bg.stop(picked);
-    tui.print(`${c.gray}stopped ${picked}${c.reset}`);
-  }
-}
-
-/** Submenu showing the session's pre-approved tools/risk levels; pick one to revoke. */
-async function runApprovalsMenu(tui: Tui, perm: PermissionState, save: () => void): Promise<void> {
-  const tools = Array.from(perm.alwaysAllow).sort();
-  const risks = Array.from(perm.allowRisk).sort((a, b) => a - b);
-  if (!tools.length && !risks.length) {
-    tui.print(
-      `${c.gray}No pre-approved commands. At a permission prompt, choose "Always allow this tool" or "Allow all level N" to add some.${c.reset}`
-    );
-    return;
-  }
-  const items = [
-    ...tools.map((t) => ({ label: `Tool: ${t}`, hint: "always allowed", value: `tool:${t}` })),
-    ...risks.map((r) => ({ label: `All level ${r} risk`, hint: "always allowed", value: `risk:${r}` })),
-    { label: "Clear all approvals", hint: "", value: "clear" },
-  ];
-  const picked = await tui.select(
-    `${c.bold}Approved commands${c.reset}  ${c.dim}(enter to revoke · esc to close)${c.reset}`,
-    items
-  );
-  if (!picked) return;
-  if (picked === "clear") {
-    perm.alwaysAllow.clear();
-    perm.allowRisk.clear();
-    tui.print(`${c.gray}cleared all approvals${c.reset}`);
-  } else if (picked.startsWith("tool:")) {
-    const t = picked.slice(5);
-    perm.alwaysAllow.delete(t);
-    tui.print(`${c.gray}revoked tool ${t}${c.reset}`);
-  } else if (picked.startsWith("risk:")) {
-    const r = Number(picked.slice(5));
-    perm.allowRisk.delete(r);
-    tui.print(`${c.gray}revoked level ${r}${c.reset}`);
-  }
-  save();
-}
-
-/**
- * Interactive MCP control surface (reached via `/` → "MCP servers"). Lists
- * configured servers with status, and lets you add (free-text command), view
- * tools, connect/disconnect, enable/disable, and remove — all menu-driven.
- */
-async function runMcpMenu(tui: Tui, mcp: McpController): Promise<void> {
-  const configured = mcp.configured();
-  const connected = new Set(mcp.connectedNames());
-  const cat = mcp.catalog();
-
-  const INSTALL = "__install__";
-  const ADD_MANUAL = "__manual__";
-  const items = configured.map((s) => {
-    const entry = cat.servers.find((e) => e.name === s.name);
-    const status = !s.enabled
-      ? "disabled"
-      : connected.has(s.name)
-        ? `connected · ${entry?.tools.length ?? 0} tools`
-        : entry?.error
-          ? "error"
-          : "disconnected";
-    return { label: s.name, hint: status, value: s.name };
-  });
-  items.push({ label: "＋ Install a new MCP server…", hint: "find & install", value: INSTALL });
-  items.push({ label: "Add manually (name: command)…", hint: "advanced", value: ADD_MANUAL });
-
-  const picked = await tui.select(
-    `${c.bold}MCP servers${c.reset}  ${c.dim}(↑/↓ · enter · esc to close)${c.reset}`,
-    items
-  );
-  if (!picked) return;
-
-  if (picked === INSTALL) {
-    await installMcpServerFlow(tui, mcp);
-    return;
-  }
-  if (picked === ADD_MANUAL) {
-    await addMcpServer(tui, mcp);
-    return;
-  }
-
-  const server = configured.find((s) => s.name === picked)!;
-  const isConnected = connected.has(picked);
-
-  const action = await tui.select(`${c.bold}${picked}${c.reset}`, [
-    { label: "View tools", value: "tools" as const },
-    isConnected
-      ? { label: "Disconnect", value: "disconnect" as const }
-      : { label: "Connect", value: "connect" as const },
-    server.enabled
-      ? { label: "Disable (don't auto-connect)", value: "disable" as const }
-      : { label: "Enable (auto-connect on start)", value: "enable" as const },
-    { label: "Remove this server", value: "remove" as const },
-    { label: "Back", value: "back" as const },
-  ]);
-
-  if (action === "tools") {
-    const entry = mcp.catalog().servers.find((e) => e.name === picked);
-    if (!entry || entry.status !== "connected") {
-      tui.print(`${c.gray}${picked} is not connected — connect it to list tools.${c.reset}`);
-      return;
-    }
-    if (!entry.tools.length) tui.print(`${c.gray}${picked} exposes no tools.${c.reset}`);
-    for (const t of entry.tools) tui.print(`  ${c.cyan}${t.name}${c.reset}${t.description ? ` ${c.gray}— ${t.description}${c.reset}` : ""}`);
-    if (entry.resources.length) tui.print(`  ${c.gray}${entry.resources.length} resource(s)${c.reset}`);
-  } else if (action === "connect") {
-    const res = await mcp.connect(server);
-    tui.print(res.ok ? `${c.cyan}⚡ connected (${res.tools} tools)${c.reset}` : `${c.red}⚠ ${res.error}${c.reset}`);
-  } else if (action === "disconnect") {
-    mcp.disconnect(picked);
-    tui.print(`${c.gray}disconnected ${picked}${c.reset}`);
-  } else if (action === "enable") {
-    mcp.setEnabled(picked, true);
-    const res = await mcp.connect(server);
-    tui.print(res.ok ? `${c.cyan}⚡ enabled + connected (${res.tools} tools)${c.reset}` : `${c.red}⚠ enabled but failed: ${res.error}${c.reset}`);
-  } else if (action === "disable") {
-    mcp.setEnabled(picked, false);
-    mcp.disconnect(picked);
-    tui.print(`${c.gray}disabled + disconnected ${picked}${c.reset}`);
-  } else if (action === "remove") {
-    mcp.remove(picked);
-    tui.print(`${c.gray}removed ${picked}${c.reset}`);
-  }
-}
-
-/** Prompt for a new MCP server (`name: command args`), then save + connect it. */
-async function addMcpServer(tui: Tui, mcp: McpController): Promise<void> {
-  const spec = await tui.prompt(
-    "Add an MCP server — enter  name: command [args…]",
-    "fs: npx -y @modelcontextprotocol/server-filesystem ."
-  );
-  if (!spec) return;
-  const cfg = parseServerSpec(spec);
-  if (!cfg) {
-    tui.print(`${c.yellow}couldn't parse that. Use  name: command [args]${c.reset}`);
-    return;
-  }
-  tui.print(`${c.gray}connecting MCP "${cfg.name}" (${cfg.command} ${cfg.args.join(" ")})…${c.reset}`);
-  const res = await mcp.add(cfg);
-  if (res.ok) tui.print(`${c.cyan}⚡ MCP "${cfg.name}" connected${c.reset} ${c.gray}(${res.tools} tool${res.tools === 1 ? "" : "s"})${c.reset}`);
-  else tui.print(`${c.red}⚠ MCP "${cfg.name}" failed:${c.reset} ${c.gray}${res.error}${c.reset} ${c.dim}(saved; retry from the MCP menu)${c.reset}`);
-}
-
-/**
- * The "Install a new MCP server" flow: ask what the user wants, then seed that
- * request into the main chat. The agent researches the right server (via
- * research_agent) and installs it (via install_mcp) right there in the
- * transcript — so the same thing happens whether you use this menu or just ask
- * in chat. We land straight back in the conversation.
- */
-async function installMcpServerFlow(tui: Tui, mcp: McpController): Promise<void> {
-  const query = await tui.prompt(
-    "What MCP server do you want to install?",
-    "the best computer-use mcp server for mac"
-  );
-  if (!query) return;
-  mcp.requestInstall(query);
-}
-
-main().catch((err) => {
-  process.stderr.write(`\n${err instanceof Error ? err.stack || err.message : String(err)}\n`);
-  process.exit(1);
-});