copilot-reverse 0.0.1

package/dist/supervisor/index.js

@@ -0,0 +1,66 @@
+import { fileURLToPath } from "node:url";
+import { join, dirname } from "node:path";
+import { mkdirSync } from "node:fs";
+import { openDb, recordRestart, recordRequest } from "./db.js";
+import { WorkerMonitor } from "./monitor.js";
+import { EventBus } from "./events.js";
+import { createControlApp } from "./api.js";
+import { defaultConfig } from "../shared/config.js";
+import { dataDir, dbPath } from "../shared/paths.js";
+import { readGhToken } from "../shared/creds.js";
+import { CopilotTokenStore } from "../providers/copilot/token.js";
+export function startSupervisor() {
+    const config = defaultConfig();
+    mkdirSync(dataDir(), { recursive: true });
+    const db = openDb(dbPath());
+    const bus = new EventBus();
+    const workerEntry = join(dirname(fileURLToPath(import.meta.url)), "..", "worker", "index.js");
+    let state = "starting";
+    const monitor = new WorkerMonitor(config, workerEntry, {
+        onStateChange: (s) => { state = s; bus.emit("state", { state: s }); },
+        onCrash: (d, exitCode, stderrTail) => {
+            recordRestart(db, { ts: Date.now(), reason: d.markedUnhealthy ? "unhealthy" : "crash", exitCode, stderrTail, backoffMs: d.backoffMs, markedUnhealthy: d.markedUnhealthy ? 1 : 0 });
+            bus.emit("crash", { exitCode, ...d });
+        },
+        onWorkerMessage: (m) => {
+            if (m.type === "request-metric") {
+                const sample = { ts: Date.now(), endpoint: m.endpoint, model: m.model, status: m.status, latencyMs: m.latencyMs, error: m.error };
+                recordRequest(db, sample);
+                bus.emit("metric", sample);
+            }
+        },
+    });
+    const doctor = async () => {
+        const gh = readGhToken(dataDir());
+        let auth;
+        if (!gh) {
+            auth = { name: "github-auth", ok: false, detail: "not logged in — restart copilot-reverse to log in" };
+        }
+        else {
+            // Validate the token actually exchanges, not just that it exists on disk.
+            try {
+                await new CopilotTokenStore(gh).get();
+                auth = { name: "github-auth", ok: true, detail: "token valid" };
+            }
+            catch (e) {
+                auth = { name: "github-auth", ok: false, detail: e instanceof Error ? e.message : String(e) };
+            }
+        }
+        return [auth, { name: "worker", ok: state === "ready", detail: `worker is ${state}` }];
+    };
+    const app = createControlApp({
+        db, getState: () => state,
+        restart: () => monitor.restartManually(),
+        stop: () => monitor.stop(),
+        start: () => monitor.start(),
+        doctor,
+        subscribe: (send) => bus.subscribe(send),
+    });
+    app.listen(config.supervisorPort, config.bindHost, () => monitor.start());
+    process.on("SIGINT", () => { monitor.stop(); process.exit(0); });
+    process.on("SIGTERM", () => { monitor.stop(); process.exit(0); });
+    return { stop: () => monitor.stop() };
+}
+// Allow `node dist/supervisor/index.js` to boot the daemon directly.
+if (process.argv[1] && process.argv[1].endsWith(join("supervisor", "index.js")))
+    startSupervisor();

package/dist/supervisor/monitor.js

@@ -0,0 +1,91 @@
+import { fork } from "node:child_process";
+export class RestartController {
+    policy;
+    now;
+    crashTimes = [];
+    consecutive = 0;
+    constructor(policy, now = () => Date.now()) {
+        this.policy = policy;
+        this.now = now;
+    }
+    onCrash() {
+        const t = this.now();
+        this.crashTimes.push(t);
+        this.crashTimes = this.crashTimes.filter((ct) => t - ct < this.policy.windowMs);
+        this.consecutive += 1;
+        const backoffMs = Math.min(this.policy.baseBackoffMs * 2 ** (this.consecutive - 1), this.policy.maxBackoffMs);
+        return { backoffMs, markedUnhealthy: this.crashTimes.length >= this.policy.maxCrashes, crashesInWindow: this.crashTimes.length };
+    }
+    reset() { this.consecutive = 0; }
+}
+export class WorkerMonitor {
+    config;
+    workerEntry;
+    hooks;
+    child;
+    controller;
+    stderrTail = "";
+    state = "starting";
+    stopped = false;
+    constructor(config, workerEntry, hooks) {
+        this.config = config;
+        this.workerEntry = workerEntry;
+        this.hooks = hooks;
+        this.controller = new RestartController(config.restart);
+    }
+    start() { this.spawn(); }
+    currentState() { return this.state; }
+    set(s) { this.state = s; this.hooks.onStateChange(s); }
+    spawn() {
+        this.set("starting");
+        const child = fork(this.workerEntry, [], {
+            env: { ...process.env, WORKER_PORT: String(this.config.workerPort), BIND_HOST: this.config.bindHost },
+            stdio: ["ignore", "ignore", "pipe", "ipc"],
+        });
+        this.child = child;
+        this.stderrTail = "";
+        child.stderr?.on("data", (d) => { this.stderrTail = (this.stderrTail + d.toString()).slice(-4000); });
+        child.on("message", (m) => {
+            if (m.type === "ready") {
+                this.controller.reset();
+                this.set("ready");
+            }
+            this.hooks.onWorkerMessage(m);
+        });
+        child.on("exit", (code) => {
+            if (this.stopped)
+                return;
+            const d = this.controller.onCrash();
+            this.hooks.onCrash(d, code, this.stderrTail);
+            if (d.markedUnhealthy) {
+                this.set("unhealthy");
+                return;
+            }
+            this.set("crashed");
+            setTimeout(() => this.spawn(), d.backoffMs);
+        });
+    }
+    restartManually() {
+        this.controller.reset();
+        this.stopped = false;
+        if (this.child && !this.child.killed) {
+            this.child.removeAllListeners("exit");
+            this.child.kill();
+        }
+        this.spawn();
+    }
+    stop() {
+        this.stopped = true;
+        const child = this.child;
+        if (!child || child.killed)
+            return;
+        // The IPC channel may already be torn down (e.g. right after a manual restart) — sending then
+        // throws ERR_IPC_CHANNEL_CLOSED. Guard the graceful shutdown and fall back to a hard kill.
+        try {
+            if (child.connected)
+                child.send({ type: "shutdown" });
+        }
+        catch { /* channel already closed */ }
+        child.kill();
+    }
+}

package/dist/tui/app.js

@@ -0,0 +1,184 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { loadingVerb } from "../shared/format.js";
+import { Repl } from "./repl.js";
+import { SetupWizard } from "./setup/wizard.js";
+import { ModelScreen } from "./screens/model.js";
+import { ConfigScreen } from "./screens/config.js";
+import { theme } from "./theme.js";
+const stateColor = {
+    ready: theme.ready, starting: theme.starting, crashed: theme.crashed, unhealthy: theme.unhealthy,
+};
+const EMPTY_STATUS = { claude: { user: false, project: false }, codex: { user: false, project: false } };
+const SPINNER = ["✶", "✸", "✹", "✺", "✹", "✷"];
+const fmtElapsed = (ms) => {
+    const s = Math.floor(ms / 1000);
+    return s >= 60 ? `${Math.floor(s / 60)}m ${s % 60}s` : `${s}s`;
+};
+const fmtTokens = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`);
+function OutputCard({ title, lines, tone }) {
+    const border = tone === "error" ? theme.error : tone === "ok" ? theme.ready : theme.border;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: border, paddingX: 1, marginBottom: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: title }), lines.map((l, i) => {
+                const m = /^(OK|FAIL)\s+(.*)$/.exec(l);
+                if (m) {
+                    const ok = m[1] === "OK";
+                    return (_jsxs(Text, { children: [_jsx(Text, { color: ok ? theme.ready : theme.error, children: ok ? "✓ " : "✗ " }), _jsx(Text, { color: theme.output, children: m[2] })] }, i));
+                }
+                return _jsx(Text, { color: theme.output, children: l }, i);
+            })] }));
+}
+function HelpCard({ commands }) {
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.border, paddingX: 1, marginBottom: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: "Commands" }), commands.map((c) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.prompt, children: c.name.padEnd(16) }), _jsx(Text, { color: theme.muted, children: c.describe })] }, c.name))), _jsx(Text, { color: theme.muted, children: "tip: type / to autocomplete \u00B7 plain text talks to the assistant" })] }));
+}
+// HUD client cell: shows configured scopes read from the real config files.
+function ClientBadge({ name, status }) {
+    const cell = (label, on) => (_jsxs(Text, { color: on ? theme.ready : theme.muted, children: [label, ":", on ? "✓" : "○"] }));
+    return (_jsxs(Text, { color: theme.muted, children: [name, " ", cell("u", status.user), " ", cell("p", status.project)] }));
+}
+export function App({ registry, title, workerState = "starting", initialModel = "—", statusSource, readStatus, modelLimits, onChat, loadModels, setup, info, onModelChange, pickModelOnStart, }) {
+    const cmds = registry.list().map((c) => ({ name: c.name, describe: c.describe }));
+    const [entries, setEntries] = useState([
+        { type: "system", text: "Type a message to chat with the assistant, or /help for commands." },
+    ]);
+    const [state, setState] = useState(workerState);
+    const [status, setStatus] = useState(() => readStatus?.() ?? EMPTY_STATUS);
+    const [model, setModel] = useState(initialModel);
+    const [screen, setScreen] = useState(pickModelOnStart && loadModels ? { kind: "model" } : null);
+    const [, setNow] = useState(0); // ticks the live loading line while the assistant streams
+    const abortRef = useRef(null); // current turn's interrupt handle
+    const add = (e) => setEntries((p) => [...p, e].slice(-100));
+    const refreshStatus = () => { if (readStatus)
+        setStatus(readStatus()); };
+    // esc interrupts an in-flight assistant turn (the Repl doesn't use esc, so this is unambiguous).
+    useInput((_input, key) => { if (key.escape)
+        abortRef.current?.abort(); });
+    useEffect(() => {
+        if (!statusSource && !readStatus)
+            return;
+        let alive = true;
+        const tick = async () => {
+            try {
+                const s = await statusSource?.();
+                if (alive && s)
+                    setState(s.workerState);
+            }
+            catch { /* daemon momentarily down */ }
+            if (alive)
+                refreshStatus(); // HUD reflects the real config files, even if edited externally
+        };
+        void tick();
+        const id = setInterval(tick, 2000);
+        return () => { alive = false; clearInterval(id); };
+    }, [statusSource]);
+    const streaming = entries.some((e) => e.type === "assistant" && e.streaming);
+    useEffect(() => {
+        if (!streaming)
+            return;
+        const id = setInterval(() => setNow((n) => n + 1), 200);
+        return () => clearInterval(id);
+    }, [streaming]);
+    function pickModel(m) {
+        setModel(m);
+        onModelChange?.(m);
+        setScreen(null);
+        add({ type: "card", title: "model", tone: "ok", lines: [`✓ chat model set to ${m}`] });
+    }
+    async function handle(line) {
+        add({ type: "user", text: `› ${line}` });
+        const t = line.trim();
+        if (t === "/model" && loadModels) {
+            setScreen({ kind: "model" });
+            return;
+        }
+        if (t === "/config" && info) {
+            setScreen({ kind: "config" });
+            return;
+        }
+        if (setup && loadModels && (t === "/setup-claude" || t === "/setup-codex")) {
+            setScreen({ kind: "setup", client: t === "/setup-claude" ? "claude" : "codex" });
+            return;
+        }
+        if (line.startsWith("/")) {
+            if (t === "/help") {
+                add({ type: "help", commands: cmds });
+                return;
+            }
+            const out = await registry.run(line);
+            const tone = out.some((l) => /fail|error|unknown/i.test(l)) ? "error" : out.some((l) => /^OK /.test(l)) ? "ok" : "info";
+            add({ type: "card", title: t, tone, lines: out });
+            if (t === "/reset-claude" || t === "/reset-codex")
+                refreshStatus(); // HUD follows the files
+        }
+        else if (onChat) {
+            // Open one streaming bubble immediately (shows the live loading line), then append each
+            // delta into it in place rather than spawning a new line per chunk.
+            add({ type: "assistant", text: "", streaming: true, startedAt: Date.now() });
+            const append = (chunk) => setEntries((p) => {
+                const copy = [...p];
+                for (let i = copy.length - 1; i >= 0; i--) {
+                    const e = copy[i];
+                    if (e.type === "assistant" && e.streaming) {
+                        copy[i] = { ...e, text: e.text + chunk };
+                        break;
+                    }
+                }
+                return copy;
+            });
+            const ctrl = new AbortController();
+            abortRef.current = ctrl;
+            try {
+                await onChat(line, append, model, ctrl);
+            }
+            finally {
+                abortRef.current = null;
+                setEntries((p) => p.map((e) => (e.type === "assistant" && e.streaming ? { ...e, streaming: false } : e)));
+            }
+        }
+        else {
+            add({ type: "system", text: "(assistant not available — use /help)" });
+        }
+    }
+    const configured = (s) => s.user || s.project;
+    let body;
+    if (screen?.kind === "model" && loadModels) {
+        body = _jsx(ModelScreen, { loadModels: loadModels, limits: modelLimits, current: model, onPick: pickModel, onCancel: () => setScreen(null) });
+    }
+    else if (screen?.kind === "setup" && setup && loadModels) {
+        const client = screen.client;
+        body = (_jsx(SetupWizard, { client: client, loadModels: loadModels, limits: modelLimits, apply: (scope, m) => setup.apply(client, scope, m), onDone: (result, m) => {
+                refreshStatus();
+                setScreen(null);
+                add({ type: "card", title: `setup ${client}`, tone: "ok", lines: [`✓ model ${m}`, `wrote ${result.path}`, `keys: ${result.changed.join(", ") || "(no change)"}`] });
+            }, onCancel: () => { setScreen(null); add({ type: "system", text: "setup cancelled" }); } }));
+    }
+    else if (screen?.kind === "config" && info) {
+        body = (_jsx(ConfigScreen, { info: info, model: model, clients: { claude: configured(status.claude), codex: configured(status.codex) }, onAction: (a) => {
+                if (a === "model")
+                    setScreen({ kind: "model" });
+                else if (a === "setup-claude")
+                    setScreen({ kind: "setup", client: "claude" });
+                else if (a === "setup-codex")
+                    setScreen({ kind: "setup", client: "codex" });
+                else
+                    setScreen(null);
+            } }));
+    }
+    else {
+        body = _jsx(Repl, { onSubmit: handle, commands: cmds });
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { justifyContent: "space-between", paddingX: 1, children: [_jsxs(Text, { color: theme.accent, bold: true, children: ["\u2733 ", title] }), _jsxs(Text, { color: theme.muted, children: ["worker: ", _jsx(Text, { color: stateColor[state], children: state })] })] }), _jsx(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, children: entries.map((e, i) => {
+                    if (e.type === "card")
+                        return _jsx(OutputCard, { title: e.title, lines: e.lines, tone: e.tone }, i);
+                    if (e.type === "help")
+                        return _jsx(HelpCard, { commands: e.commands }, i);
+                    const color = e.type === "user" ? theme.user : e.type === "assistant" ? theme.assistant : theme.muted;
+                    if (e.type === "assistant" && e.streaming) {
+                        const elapsed = e.startedAt ? Date.now() - e.startedAt : 0;
+                        const frame = SPINNER[Math.floor(Date.now() / 200) % SPINNER.length];
+                        const tokens = Math.ceil(e.text.length / 4);
+                        return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: theme.accent, children: ["\u273D ", _jsxs(Text, { color: theme.muted, children: [frame, " ", loadingVerb(elapsed), "\u2026 (esc to interrupt \u00B7 ", fmtElapsed(elapsed), " \u00B7 \u2193 ", fmtTokens(tokens), " tokens \u00B7 thinking)"] })] }), e.text ? _jsx(Text, { color: color, children: e.text }) : null] }, i));
+                    }
+                    return _jsx(Text, { color: color, children: e.text }, i);
+                }) }), body, _jsxs(Box, { paddingX: 1, children: [_jsx(Text, { color: theme.muted, children: "model " }), _jsx(Text, { color: theme.accent, children: model }), _jsx(Text, { color: theme.muted, children: "  \u00B7  daemon " }), _jsx(Text, { color: stateColor[state], children: state }), _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), _jsx(ClientBadge, { name: "claude", status: status.claude }), _jsx(Text, { color: theme.muted, children: "  " }), _jsx(ClientBadge, { name: "codex", status: status.codex }), _jsx(Text, { color: theme.muted, children: "  \u00B7  /help" })] })] }));
+}

package/dist/tui/assistant/on-chat.js

@@ -0,0 +1,25 @@
+const DEFAULT_TURN_TIMEOUT_MS = 120_000; // 2 minutes — a turn that hasn't replied by then is given up on
+export function makeOnChat(cfg, runner, timeoutMs = DEFAULT_TURN_TIMEOUT_MS) {
+    return async (text, print, model, abort) => {
+        const ctrl = abort ?? new AbortController();
+        let timedOut = false;
+        // Race the turn against a hard timeout so a hung SDK/upstream can never block the UI forever.
+        // We also abort the controller to try to stop the underlying work.
+        const timeout = new Promise((_, reject) => setTimeout(() => { timedOut = true; ctrl.abort(); reject(new Error("turn timeout")); }, timeoutMs));
+        try {
+            await Promise.race([runner(model ? { ...cfg, model } : cfg, text, print, ctrl), timeout]);
+        }
+        catch (err) {
+            if (timedOut) {
+                print(`⎿ no response after ${Math.round(timeoutMs / 1000)}s — gave up (try again or pick a different model)`);
+                return;
+            }
+            if (ctrl.signal.aborted) {
+                print("⎿ interrupted");
+                return;
+            }
+            print(`assistant error: ${err instanceof Error ? err.message : String(err)}`);
+            print("\n  ↳ next: retry · /model to switch model · /doctor to check health · /report to file it");
+        }
+    };
+}

package/dist/tui/assistant/runtime.js

@@ -0,0 +1,104 @@
+import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import { buildActions } from "./tools.js";
+import { formatModelList } from "../../shared/format.js";
+const empty = z.object({});
+const setupShape = z.object({
+    scope: z.enum(["global", "project"]).optional(),
+    model: z.string().optional(),
+}).shape;
+function sdkTools(actions, cfg) {
+    const tools = [
+        tool("get_status", "Get the proxy worker status and restart history", empty.shape, async () => ({ content: [{ type: "text", text: await actions.get_status({}) }] })),
+        tool("restart_worker", "Restart the proxy worker", empty.shape, async () => ({ content: [{ type: "text", text: await actions.restart_worker({}) }] })),
+        tool("run_doctor", "Run copilot-reverse health checks", empty.shape, async () => ({ content: [{ type: "text", text: await actions.run_doctor({}) }] })),
+        tool("recent_requests", "List recent proxied requests", empty.shape, async () => ({ content: [{ type: "text", text: await actions.recent_requests({}) }] })),
+    ];
+    const listModels = cfg.listModels;
+    if (listModels) {
+        tools.push(tool("list_models", "List the Copilot models available through the proxy, with their context windows", empty.shape, async () => ({
+            content: [{ type: "text", text: formatModelList(await listModels(), cfg.modelLimits) }],
+        })));
+    }
+    const setupClient = cfg.setupClient;
+    if (setupClient) {
+        for (const client of ["claude", "codex"]) {
+            const label = client === "claude" ? "Claude Code" : "Codex";
+            tools.push(tool(`setup_${client}`, `Configure ${label} to use the copilot-reverse proxy (writes its config). scope defaults to "global" (all projects); model defaults to the current chat model.`, setupShape, async (args) => {
+                const scope = args.scope ?? "global";
+                const model = args.model ?? cfg.model;
+                const r = await setupClient(client, scope, model);
+                return { content: [{ type: "text", text: `configured ${label} (${scope}) with model ${model} — wrote ${r.path}; keys: ${r.changed.join(", ") || "(no change)"}` }] };
+            }));
+        }
+    }
+    return tools;
+}
+// Runs one assistant turn, streaming assistant text to `print`. Pass an AbortController to make
+// the turn interruptible (esc) — aborting ends the stream.
+export async function runAssistantTurn(cfg, prompt, print, queryFn = query, abortController) {
+    // Dogfood: route the agent SDK through copilot-reverse's own Anthropic endpoint -> Copilot.
+    process.env.ANTHROPIC_BASE_URL = cfg.workerBaseUrl;
+    process.env.ANTHROPIC_API_KEY = cfg.apiKey;
+    // The bundled Claude Code engine assumes a ~200K window and only auto-compacts near it,
+    // but the routed Copilot model's real window is often far smaller -> a single turn can
+    // overflow and the upstream rejects with context_length_exceeded. Mirror agent-maestro:
+    // size auto-compaction to the model's real window, compact early, and drop the billing
+    // attribution header that breaks prompt caching on a non-Anthropic gateway.
+    const contextWindow = cfg.modelLimits?.[cfg.model] ?? cfg.maxInputTokens;
+    if (contextWindow)
+        process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW = String(contextWindow);
+    // 80% keeps the compaction trigger under the model's input budget even when the window above is
+    // the full context window (e.g. 1M ctx vs ~936K prompt budget on the 1M Claude models).
+    process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE ?? "80";
+    process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
+    process.env.CLAUDE_CODE_ATTRIBUTION_HEADER = "0";
+    const actions = buildActions(cfg.client);
+    const mcp = createSdkMcpServer({ name: "copilotReverse", tools: sdkTools(actions, cfg) });
+    const response = queryFn({
+        prompt,
+        options: {
+            model: cfg.model,
+            mcpServers: { copilotReverse: mcp },
+            // Keep the request small so a single turn never overflows a modest Copilot window:
+            //  - tools: [] -> disable ALL built-in Claude Code tools (Bash/Task/Read/Edit/…), whose huge
+            //    descriptions otherwise bloat every request and overflow the model -> Copilot 400. The
+            //    copilot-reverse MCP tools (via mcpServers) remain available. (`allowedTools` only gates
+            //    permission; `tools` is what actually removes them from the request.)
+            //  - settingSources: [] -> do NOT load the cwd's CLAUDE.md / project memory / settings.
+            tools: [],
+            settingSources: [],
+            systemPrompt: "You are copilot-reverse's built-in assistant for the local Copilot proxy. Be concise. " +
+                "When the user expresses an intent you have a tool for, CALL THE TOOL instead of explaining. " +
+                "Tools: get_status, restart_worker, run_doctor, recent_requests, list_models (show available " +
+                "models + context windows), setup_claude / setup_codex (configure those clients to use the proxy). " +
+                "E.g. 'list models' -> call list_models; 'set up claude' -> call setup_claude.",
+            permissionMode: "bypassPermissions",
+            includePartialMessages: true,
+            ...(abortController ? { abortController } : {}),
+        },
+    });
+    // Stream token-by-token from partial-message events for a live, SSE-like feel. Once any
+    // delta has streamed, skip the final complete text block so the answer isn't printed twice.
+    // If partial events never arrive (e.g. a stubbed transport), fall back to the full block.
+    let streamed = false;
+    for await (const message of response) {
+        if (message.type === "stream_event") {
+            const ev = message.event;
+            if (ev.type === "content_block_delta" && ev.delta.type === "text_delta") {
+                streamed = true;
+                print(ev.delta.text);
+            }
+        }
+        else if (message.type === "assistant") {
+            for (const block of message.message.content) {
+                if (block.type === "text" && !streamed)
+                    print(block.text);
+            }
+        }
+        else if (message.type === "result" && message.subtype !== "success") {
+            // Don't swallow a failed turn: surface the SDK's terminal error subtype.
+            print(`assistant error: ${message.subtype}`);
+        }
+    }
+}

package/dist/tui/assistant/tools.js

@@ -0,0 +1,24 @@
+// Plain action handlers — wrapped as SDK tools in runtime.ts.
+// Each takes a parsed-args object and returns a short text result for the model.
+export function buildActions(client) {
+    return {
+        async get_status(_args) {
+            const s = await client.status();
+            return `worker is ${s.workerState}; ${s.restarts.length} restart event(s) recorded`;
+        },
+        async restart_worker(_args) {
+            await client.restart();
+            return "restart requested; worker is restarting";
+        },
+        async run_doctor(_args) {
+            const checks = await client.doctor();
+            return checks.map((c) => `${c.ok ? "OK" : "FAIL"} ${c.name}: ${c.detail}`).join("; ");
+        },
+        async recent_requests(_args) {
+            const reqs = await client.requests();
+            if (!reqs.length)
+                return "no requests logged yet";
+            return reqs.slice(0, 10).map((r) => `${r.endpoint} ${r.model} ${r.status} ${r.latencyMs}ms`).join("; ");
+        },
+    };
+}

package/dist/tui/components/select.js

@@ -0,0 +1,30 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { theme } from "../theme.js";
+// Arrow-navigable single-select list with a bounded, scrolling window so long lists
+// (e.g. the full Copilot model list) never overflow the terminal — the highlight stays
+// visible as you navigate. Only one Select should be mounted at a time.
+export function Select({ items, onSubmit, onCancel, windowSize = 8 }) {
+    const [idx, setIdx] = useState(0);
+    useInput((_input, key) => {
+        if (key.upArrow)
+            setIdx((i) => (i - 1 + items.length) % items.length);
+        else if (key.downArrow)
+            setIdx((i) => (i + 1) % items.length);
+        else if (key.return)
+            onSubmit(items[idx]);
+        else if (key.escape)
+            onCancel?.();
+    });
+    const n = items.length;
+    const w = Math.min(windowSize, n);
+    // keep the selected row inside the window
+    const start = Math.max(0, Math.min(idx - Math.floor(w / 2), n - w));
+    const visible = items.slice(start, start + w);
+    return (_jsxs(Box, { flexDirection: "column", children: [start > 0 && _jsxs(Text, { color: theme.muted, children: ["  \u2191 ", start, " more"] }), visible.map((it, i) => {
+                const real = start + i;
+                const sel = real === idx;
+                return (_jsxs(Text, { color: sel ? theme.accent : theme.output, bold: sel, children: [sel ? "❯ " : "  ", it.label] }, it.value));
+            }), start + w < n && _jsxs(Text, { color: theme.muted, children: ["  \u2193 ", n - start - w, " more"] }), _jsxs(Text, { color: theme.muted, children: ["\u2191\u2193 select \u00B7 enter confirm \u00B7 esc cancel  (", idx + 1, "/", n, ")"] })] }));
+}

package/dist/tui/daemon-client.js

@@ -0,0 +1,16 @@
+export class DaemonClient {
+    base;
+    fetchFn;
+    constructor(base, fetchFn = fetch) {
+        this.base = base;
+        this.fetchFn = fetchFn;
+    }
+    async post(path) { await this.fetchFn(`${this.base}${path}`, { method: "POST" }); }
+    async status() { return (await (await this.fetchFn(`${this.base}/api/status`)).json()); }
+    async restart() { return this.post("/api/restart"); }
+    async stop() { return this.post("/api/stop"); }
+    async start() { return this.post("/api/start"); }
+    async doctor() { return (await (await this.fetchFn(`${this.base}/api/doctor`)).json()).checks; }
+    async requests() { return (await (await this.fetchFn(`${this.base}/api/requests`)).json()).requests; }
+    eventsUrl() { return `${this.base}/api/events`; }
+}

package/dist/tui/panels/metrics-agg.js

@@ -0,0 +1,22 @@
+export function aggregate(samples) {
+    const map = new Map();
+    let errors = 0;
+    for (const s of samples) {
+        if (s.status >= 400)
+            errors++;
+        const m = map.get(s.model) ?? { count: 0, sum: 0 };
+        m.count++;
+        m.sum += s.latencyMs;
+        map.set(s.model, m);
+    }
+    return {
+        total: samples.length,
+        errors,
+        byModel: [...map.entries()].map(([model, v]) => ({ model, count: v.count, avgMs: Math.round(v.sum / v.count) })),
+    };
+}
+// The failed requests (status >= 400), in the order given (callers pass newest-first), capped at `limit`.
+// This is the actually-useful "log" — what failed and why — as opposed to worker restart events.
+export function recentErrors(samples, limit) {
+    return samples.filter((s) => s.status >= 400).slice(0, limit);
+}

package/dist/tui/panels/metrics.js

@@ -0,0 +1,7 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { aggregate } from "./metrics-agg.js";
+export function MetricsPanel({ samples }) {
+    const a = aggregate(samples);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["requests: ", a.total, "  errors: ", a.errors] }), a.byModel.map((r) => (_jsxs(Text, { children: ["  ", r.model.padEnd(20), " n=", r.count, " avg=", r.avgMs, "ms"] }, r.model)))] }));
+}

package/dist/tui/repl.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { theme } from "./theme.js";
+// Input with a Claude-Code-style slash-command autocomplete dropdown.
+// Editing is end-of-line (append/backspace) for reliability; arrows navigate the
+// suggestion list, Tab completes the highlighted command, Enter submits.
+export function Repl({ onSubmit, commands = [] }) {
+    const [value, setValue] = useState("");
+    const [sel, setSel] = useState(0);
+    const typingCommand = value.startsWith("/") && !value.includes(" ");
+    const matches = typingCommand ? commands.filter((c) => c.name.startsWith(value)).slice(0, 8) : [];
+    const selIdx = matches.length ? ((sel % matches.length) + matches.length) % matches.length : 0;
+    useInput((input, key) => {
+        if (key.return) {
+            // If the suggestion popup is open, Enter runs the highlighted command (Claude-Code style),
+            // not the raw prefix the user typed.
+            const line = matches.length ? matches[selIdx].name : value;
+            setValue("");
+            setSel(0);
+            if (line.trim())
+                onSubmit(line);
+            return;
+        }
+        if (key.tab && matches.length) {
+            setValue(matches[selIdx].name + " ");
+            setSel(0);
+            return;
+        }
+        if (matches.length && (key.upArrow || key.downArrow)) {
+            setSel((s) => s + (key.upArrow ? -1 : 1));
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setValue((v) => v.slice(0, -1));
+            setSel(0);
+            return;
+        }
+        if (input && !key.ctrl && !key.meta) {
+            setValue((v) => v + input);
+            setSel(0);
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { borderStyle: "round", borderColor: theme.border, paddingX: 1, children: [_jsx(Text, { color: theme.prompt, children: "› " }), _jsx(Text, { children: value }), _jsx(Text, { inverse: true, children: " " }), value.length === 0 && _jsx(Text, { color: theme.muted, children: " type a message \u00B7 / for commands" })] }), matches.length > 0 && (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [matches.map((c, i) => (_jsxs(Text, { children: [_jsx(Text, { color: i === selIdx ? theme.accent : theme.muted, children: i === selIdx ? "❯ " : "  " }), _jsx(Text, { color: i === selIdx ? theme.accent : theme.output, bold: i === selIdx, children: c.name.padEnd(16) }), _jsx(Text, { color: theme.muted, children: c.describe })] }, c.name))), _jsx(Text, { color: theme.muted, children: "  \u2191\u2193 navigate \u00B7 tab complete \u00B7 enter run" })] }))] }));
+}