copilot-reverse 0.0.1

package/dist/tui/report.js

@@ -0,0 +1,35 @@
+// Sentinel for an unconfigured report target. /report refuses to open until this is changed.
+export const PLACEHOLDER_REPO = "OWNER/REPO";
+// A diagnostics-only report. It contains metrics, doctor output, and worker restart reasons —
+// never request/response bodies — so there is no user prompt content to leak.
+export function buildIssueBody(i) {
+    const lines = [
+        "## copilot-reverse diagnostics",
+        "",
+        `- version: ${i.version}`,
+        `- platform: ${i.platform}`,
+        `- worker state: ${i.status.workerState}`,
+        "",
+        "### Health checks",
+        ...i.doctor.map((c) => `- ${c.ok ? "✓" : "✗"} ${c.name}: ${c.detail}`),
+        "",
+        "### Recent request errors",
+        ...(i.errors.length
+            ? i.errors.map((e) => `- \`${e.status}\` ${e.endpoint} ${e.model} — ${e.error ?? "(no message)"}`)
+            : ["- (none)"]),
+    ];
+    if (i.status.restarts.length) {
+        lines.push("", "### Recent worker restarts", ...i.status.restarts.slice(0, 5).map((r) => `- ${new Date(r.ts).toISOString()} ${r.reason} exit=${r.exitCode ?? "-"} ${r.stderrTail.slice(0, 120)}`));
+    }
+    lines.push("", "### What happened", "<!-- describe what you were doing when this occurred -->", "");
+    // Keep well under GitHub's ~8KB URL cap once encoded.
+    return lines.join("\n").slice(0, 5500);
+}
+export function buildIssueTitle(i) {
+    const first = i.errors[0]?.error;
+    return `copilot-reverse report: ${first ? first.slice(0, 70) : i.status.workerState}`;
+}
+export function buildIssueUrl(i) {
+    const q = `title=${encodeURIComponent(buildIssueTitle(i))}&body=${encodeURIComponent(buildIssueBody(i))}`;
+    return `https://github.com/${i.repo}/issues/new?${q}`;
+}

package/dist/tui/screens/config.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { Select } from "../components/select.js";
+import { theme } from "../theme.js";
+export function ConfigScreen({ info, model, clients, onAction }) {
+    const row = (k, v) => (_jsxs(Text, { children: [_jsx(Text, { color: theme.muted, children: k.padEnd(12) }), _jsx(Text, { color: theme.output, children: v })] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.border, paddingX: 1, marginBottom: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: "configuration" }), row("chat model", model), row("OpenAI", info.openai), row("Anthropic", info.anthropic), row("ports", `supervisor ${info.supervisorPort} · worker ${info.workerPort}`), row("clients", `claude ${clients.claude ? "✓" : "○"}  codex ${clients.codex ? "✓" : "○"}`), row("data dir", info.dataDir), _jsx(Text, { children: " " }), _jsx(Select, { items: [
+                    { label: "change chat model", value: "model" },
+                    { label: "configure Claude Code", value: "setup-claude" },
+                    { label: "configure Codex", value: "setup-codex" },
+                    { label: "back", value: "back" },
+                ], onSubmit: (v) => onAction(v.value), onCancel: () => onAction("back") })] }));
+}

package/dist/tui/screens/model.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import { Select } from "../components/select.js";
+import { theme } from "../theme.js";
+import { formatContextWindow } from "../../shared/format.js";
+// Label a model with its context window (e.g. "claude-opus-4-8  · 200K") and a (current) marker.
+export function modelLabel(m, current, limits) {
+    const win = formatContextWindow(limits?.[m]);
+    return `${m}${win ? `  · ${win}` : ""}${m === current ? "  (current)" : ""}`;
+}
+export function ModelScreen({ loadModels, limits, current, onPick, onCancel }) {
+    const [models, setModels] = useState(null);
+    useEffect(() => { loadModels().then(setModels).catch(() => setModels([])); }, []);
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, marginBottom: 1, children: [_jsx(Text, { color: theme.accent, bold: true, children: "select chat model" }), !models ? (_jsx(Text, { color: theme.muted, children: "loading models from Copilot\u2026" })) : (_jsx(Select, { items: models.map((m) => ({ label: modelLabel(m, current, limits), value: m })), onSubmit: (v) => onPick(v.value), onCancel: onCancel }))] }));
+}

package/dist/tui/setup/apply.js

@@ -0,0 +1,119 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+// The env keys copilot-reverse writes for each client — so reset knows exactly what to remove.
+export const CLAUDE_ENV_KEYS = [
+    "ANTHROPIC_BASE_URL", "ANTHROPIC_API_KEY", "ANTHROPIC_MODEL",
+    "CLAUDE_CODE_AUTO_COMPACT_WINDOW", "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE",
+    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC", "CLAUDE_CODE_ATTRIBUTION_HEADER",
+];
+export const CODEX_ENV_KEYS = ["OPENAI_BASE_URL", "OPENAI_API_KEY", "OPENAI_MODEL"];
+// --- Claude Code: merge into settings.json `env` (non-destructive) ---
+export function claudePath(scope, o) {
+    const home = o.home ?? homedir();
+    const cwd = o.cwd ?? process.cwd();
+    return scope === "global" ? join(home, ".claude", "settings.json") : join(cwd, ".claude", "settings.json");
+}
+export function applyClaude(scope, env, o = {}) {
+    const path = claudePath(scope, o);
+    if (!existsSync(dirname(path)))
+        mkdirSync(dirname(path), { recursive: true });
+    let settings = {};
+    if (existsSync(path)) {
+        try {
+            settings = JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    const envObj = (settings.env && typeof settings.env === "object" ? settings.env : {});
+    const changed = [];
+    for (const [k, v] of Object.entries(env)) {
+        if (envObj[k] !== v) {
+            envObj[k] = v;
+            changed.push(k);
+        }
+    }
+    settings.env = envObj;
+    writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+    return { path, changed };
+}
+// Inverse of applyClaude: drop copilot-reverse's keys from settings.json `env`, keep everything else.
+export function resetClaude(scope, keys, o = {}) {
+    const path = claudePath(scope, o);
+    if (!existsSync(path))
+        return { path, changed: [] };
+    let settings;
+    try {
+        settings = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return { path, changed: [] };
+    }
+    const envObj = (settings.env && typeof settings.env === "object" ? settings.env : {});
+    const changed = [];
+    for (const k of keys) {
+        if (k in envObj) {
+            delete envObj[k];
+            changed.push(k);
+        }
+    }
+    if (Object.keys(envObj).length)
+        settings.env = envObj;
+    else
+        delete settings.env;
+    writeFileSync(path, JSON.stringify(settings, null, 2) + "\n");
+    return { path, changed };
+}
+// --- Codex / OpenAI clients: merge into a .env file (non-destructive, line-wise) ---
+export function codexPath(scope, o) {
+    const home = o.home ?? homedir();
+    const cwd = o.cwd ?? process.cwd();
+    return scope === "global" ? join(home, ".copilot-reverse", "codex.env") : join(cwd, ".env");
+}
+export function applyCodex(scope, env, o = {}) {
+    const path = codexPath(scope, o);
+    if (!existsSync(dirname(path)))
+        mkdirSync(dirname(path), { recursive: true });
+    const lines = existsSync(path) ? readFileSync(path, "utf8").split(/\r?\n/) : [];
+    const changed = [];
+    const seen = new Set();
+    const out = lines.map((line) => {
+        const m = /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(line);
+        if (m && env[m[1]] !== undefined) {
+            seen.add(m[1]);
+            const nv = `${m[1]}=${env[m[1]]}`;
+            if (line !== nv)
+                changed.push(m[1]);
+            return nv;
+        }
+        return line;
+    });
+    for (const [k, v] of Object.entries(env)) {
+        if (!seen.has(k)) {
+            out.push(`${k}=${v}`);
+            changed.push(k);
+        }
+    }
+    writeFileSync(path, out.join("\n").replace(/\n*$/, "\n"));
+    return { path, changed };
+}
+// Inverse of applyCodex: drop copilot-reverse's KEY=value lines, keep every other line.
+export function resetCodex(scope, keys, o = {}) {
+    const path = codexPath(scope, o);
+    if (!existsSync(path))
+        return { path, changed: [] };
+    const set = new Set(keys);
+    const changed = [];
+    const out = readFileSync(path, "utf8").split(/\r?\n/).filter((line) => {
+        const m = /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(line);
+        if (m && set.has(m[1])) {
+            changed.push(m[1]);
+            return false;
+        }
+        return true;
+    });
+    writeFileSync(path, out.join("\n").replace(/\n*$/, "\n"));
+    return { path, changed };
+}

package/dist/tui/setup/clients.js

@@ -0,0 +1,38 @@
+export function claudeCodeConfig(e) {
+    const base = `http://${e.host}:${e.port}`;
+    return {
+        env: { ANTHROPIC_BASE_URL: base, ANTHROPIC_API_KEY: e.apiKey },
+        instructions: `Set these env vars for Claude Code:\n  ANTHROPIC_BASE_URL=${base}\n  ANTHROPIC_API_KEY=${e.apiKey}`,
+    };
+}
+export const ONE_M_SUFFIX = "[1m]";
+// Claude Code switches to its 1M context window only when ANTHROPIC_MODEL ends with `[1m]` — that
+// suffix is its built-in signal for a 1M model. Mirror agent-maestro: append it for models whose
+// window is in the ~1M band (800K..1.5M). Without it Claude Code assumes 200K -> "context 100%"
+// and /compact fails. The proxy strips the suffix again before forwarding to Copilot.
+export function withClaude1mSuffix(model, contextWindow) {
+    return contextWindow && contextWindow > 800_000 && contextWindow < 1_500_000 && !model.endsWith(ONE_M_SUFFIX)
+        ? `${model}${ONE_M_SUFFIX}`
+        : model;
+}
+// The full env copilot-reverse writes into Claude Code's settings.json. Beyond the endpoint, it tells
+// Claude Code the selected model's real context window (via the [1m] model suffix and
+// CLAUDE_CODE_AUTO_COMPACT_WINDOW) so the client stops assuming the default 200K. Mirrors agent-maestro.
+export function claudeCopilotReverseEnv(base, apiKey, model, contextWindow) {
+    return {
+        ANTHROPIC_BASE_URL: base,
+        ANTHROPIC_API_KEY: apiKey,
+        ANTHROPIC_MODEL: withClaude1mSuffix(model, contextWindow),
+        ...(contextWindow ? { CLAUDE_CODE_AUTO_COMPACT_WINDOW: String(contextWindow) } : {}),
+        CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "80",
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+        CLAUDE_CODE_ATTRIBUTION_HEADER: "0", // keep prompt caching working on a non-Anthropic gateway
+    };
+}
+export function codexConfig(e) {
+    const base = `http://${e.host}:${e.port}/v1`;
+    return {
+        env: { OPENAI_BASE_URL: base, OPENAI_API_KEY: e.apiKey },
+        instructions: `Set these env vars for Codex / OpenAI clients:\n  OPENAI_BASE_URL=${base}\n  OPENAI_API_KEY=${e.apiKey}`,
+    };
+}

package/dist/tui/setup/codex-toml.js

@@ -0,0 +1,47 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+// Codex reads ~/.codex/config.toml. copilot-reverse writes a managed provider block there (model,
+// provider, context window) while preserving the user's other top-level keys. Mirrors
+// agent-maestro's `configureCodex`, but uses wire_api="chat" since our proxy is chat/completions.
+export const PROVIDER_ID = "copilot-reverse";
+export function codexTomlPath(home = homedir()) {
+    return join(home, ".codex", "config.toml");
+}
+// The top-level keys we own (so re-applying replaces them instead of duplicating).
+const MANAGED_TOP_KEYS = ["model", "model_provider", "model_context_window"];
+export function applyCodexToml(opts) {
+    const path = codexTomlPath(opts.home);
+    if (!existsSync(dirname(path)))
+        mkdirSync(dirname(path), { recursive: true });
+    // Read existing top-level lines, dropping our managed keys and any prior managed provider table,
+    // but keeping everything else (approval_policy, other providers, etc.) verbatim.
+    const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+    const kept = [];
+    let inOurTable = false;
+    for (const line of existing.split(/\r?\n/)) {
+        const tableMatch = /^\s*\[/.test(line);
+        if (tableMatch)
+            inOurTable = line.trim() === `[model_providers.${PROVIDER_ID}]`;
+        if (inOurTable)
+            continue; // skip our previously-written provider table
+        const keyMatch = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line);
+        if (keyMatch && MANAGED_TOP_KEYS.includes(keyMatch[1]))
+            continue; // skip our managed top keys
+        kept.push(line);
+    }
+    const head = kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    const managed = [
+        `model = "${opts.model}"`,
+        `model_provider = "${PROVIDER_ID}"`,
+        ...(opts.contextWindow ? [`model_context_window = ${opts.contextWindow}`] : []),
+        "",
+        `[model_providers.${PROVIDER_ID}]`,
+        `name = "copilot-reverse"`,
+        `base_url = "${opts.baseUrl}"`,
+        `wire_api = "chat"`,
+    ].join("\n");
+    const body = (head ? `${head}\n\n` : "") + managed + "\n";
+    writeFileSync(path, body);
+    return { path, changed: MANAGED_TOP_KEYS };
+}

package/dist/tui/setup/status.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from "node:fs";
+import { claudePath, codexPath } from "./apply.js";
+// A copilot-reverse-written endpoint always points at the local loopback proxy — this lets us tell our
+// own config apart from a user's pre-existing ANTHROPIC_BASE_URL / OPENAI_BASE_URL.
+const isCopilotReverse = (v) => typeof v === "string" && /127\.0\.0\.1|localhost/.test(v);
+function claudeConfigured(scope, o) {
+    const p = claudePath(scope, o);
+    if (!existsSync(p))
+        return false;
+    try {
+        const s = JSON.parse(readFileSync(p, "utf8"));
+        return isCopilotReverse(s.env?.ANTHROPIC_BASE_URL);
+    }
+    catch {
+        return false;
+    }
+}
+function codexConfigured(scope, o) {
+    const p = codexPath(scope, o);
+    if (!existsSync(p))
+        return false;
+    try {
+        const m = /^OPENAI_BASE_URL=(.*)$/m.exec(readFileSync(p, "utf8"));
+        return !!m && isCopilotReverse(m[1]);
+    }
+    catch {
+        return false;
+    }
+}
+export function readClientStatus(o = {}) {
+    return {
+        claude: { user: claudeConfigured("global", o), project: claudeConfigured("project", o) },
+        codex: { user: codexConfigured("global", o), project: codexConfigured("project", o) },
+    };
+}

package/dist/tui/setup/wizard.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import { Select } from "../components/select.js";
+import { theme } from "../theme.js";
+import { modelLabel } from "../screens/model.js";
+function Dismiss({ onDismiss }) {
+    useInput(() => onDismiss());
+    return _jsx(Text, { color: theme.muted, children: "press any key to continue" });
+}
+export function SetupWizard({ client, loadModels, limits, apply, onDone, onCancel }) {
+    const [step, setStep] = useState("loading");
+    const [models, setModels] = useState([]);
+    const [model, setModel] = useState("");
+    const [result, setResult] = useState(null);
+    const [err, setErr] = useState("");
+    useEffect(() => {
+        loadModels().then((m) => { setModels(m); setStep("model"); }).catch((e) => { setErr(String(e)); setStep("error"); });
+    }, []);
+    async function doApply(scope) {
+        setStep("applying");
+        try {
+            const r = await apply(scope, model);
+            setResult(r);
+            setStep("done");
+        }
+        catch (e) {
+            setErr(e instanceof Error ? e.message : String(e));
+            setStep("error");
+        }
+    }
+    const heading = step === "model" ? "choose a model" : step === "scope" ? "choose scope" : "";
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, marginBottom: 1, children: [_jsxs(Text, { color: theme.accent, bold: true, children: ["setup ", client, heading ? `  ·  ${heading}` : ""] }), step === "loading" && _jsx(Text, { color: theme.muted, children: "loading models from Copilot\u2026" }), step === "model" && (_jsx(Select, { items: models.map((m) => ({ label: modelLabel(m, "", limits), value: m })), onSubmit: (v) => { setModel(v.value); setStep("scope"); }, onCancel: onCancel })), step === "scope" && (_jsx(Select, { items: [
+                    { label: "global   — this machine, all projects", value: "global" },
+                    { label: "project  — current directory only", value: "project" },
+                ], onSubmit: (v) => void doApply(v.value), onCancel: onCancel })), step === "applying" && _jsx(Text, { color: theme.muted, children: "applying\u2026" }), step === "done" && result && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: theme.ready, children: ["\u2713 configured \u00B7 model ", model] }), _jsxs(Text, { color: theme.output, children: ["wrote ", result.path] }), _jsxs(Text, { color: theme.muted, children: ["keys: ", result.changed.join(", ") || "(no change)"] }), _jsx(Dismiss, { onDismiss: () => onDone(result, model) })] })), step === "error" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: theme.error, children: ["failed: ", err] }), _jsx(Dismiss, { onDismiss: onCancel })] }))] }));
+}

package/dist/tui/slash/commands.js

@@ -0,0 +1,68 @@
+import { Registry } from "./registry.js";
+import { claudeCodeConfig, codexConfig } from "../setup/clients.js";
+import { aggregate, recentErrors } from "../panels/metrics-agg.js";
+import { openUrl as defaultOpenUrl } from "../../shared/open-url.js";
+import { buildIssueUrl, PLACEHOLDER_REPO } from "../report.js";
+export function buildRegistry(ctx, endpoint, opts = {}) {
+    const reg = new Registry(ctx);
+    const openUrl = opts.openUrl ?? defaultOpenUrl;
+    reg.add({ name: "/status", describe: "show worker status + restart history", run: async (_a, c) => {
+            const s = await c.client.status();
+            const lines = [`worker: ${s.workerState}`];
+            for (const r of s.restarts.slice(0, 5))
+                lines.push(`  ${r.reason} exit=${r.exitCode ?? "-"} ${r.stderrTail.slice(0, 60)}`);
+            return lines;
+        } });
+    reg.add({ name: "/doctor", describe: "run health checks", run: async (_a, c) => (await c.client.doctor()).map((x) => `${x.ok ? "OK " : "FAIL"} ${x.name}: ${x.detail}`) });
+    reg.add({ name: "/restart", describe: "restart the worker", run: async (_a, c) => { await c.client.restart(); return ["restart requested"]; } });
+    reg.add({ name: "/stop", describe: "stop the worker", run: async (_a, c) => { await c.client.stop(); return ["worker stopped"]; } });
+    reg.add({ name: "/start", describe: "start the worker", run: async (_a, c) => { await c.client.start(); return ["worker started"]; } });
+    reg.add({ name: "/logs", describe: "recent request errors (what failed & why)", run: async (_a, c) => {
+            const errs = recentErrors(await c.client.requests(), 20);
+            if (!errs.length)
+                return ["no request errors logged — everything's green ✓"];
+            return errs.map((e) => `${new Date(e.ts).toISOString()} ${e.status} ${e.endpoint} ${e.model} — ${e.error ?? "(no message)"}`);
+        } });
+    reg.add({ name: "/metrics", describe: "request metrics + recent errors", run: async (_a, c) => {
+            const reqs = await c.client.requests();
+            const a = aggregate(reqs);
+            if (!a.total)
+                return ["no requests yet"];
+            const lines = [`requests: ${a.total}  errors: ${a.errors}`, ...a.byModel.map((r) => `  ${r.model.padEnd(20)} n=${r.count} avg=${r.avgMs}ms`)];
+            const errs = recentErrors(reqs, 5);
+            if (errs.length) {
+                lines.push("recent errors:");
+                for (const e of errs)
+                    lines.push(`  ${e.status} ${e.model} — ${(e.error ?? "(no message)").slice(0, 80)}`);
+            }
+            return lines;
+        } });
+    reg.add({ name: "/setup-claude", describe: "print Claude Code config", run: async () => claudeCodeConfig(endpoint).instructions.split("\n") });
+    reg.add({ name: "/setup-codex", describe: "print Codex/OpenAI config", run: async () => codexConfig(endpoint).instructions.split("\n") });
+    reg.add({ name: "/setup-status", describe: "show configured endpoints", run: async () => [`OpenAI: http://${endpoint.host}:${endpoint.port}/v1`, `Anthropic: http://${endpoint.host}:${endpoint.port}`] });
+    reg.add({ name: "/reset-claude", describe: "restore Claude Code config (remove copilot-reverse's keys)", run: async () => opts.resetClient ? opts.resetClient("claude") : ["reset not available"] });
+    reg.add({ name: "/reset-codex", describe: "restore Codex/OpenAI config (remove copilot-reverse's keys)", run: async () => opts.resetClient ? opts.resetClient("codex") : ["reset not available"] });
+    reg.add({ name: "/model", describe: "switch the chat model", run: async () => ["opening model picker…"] });
+    reg.add({ name: "/config", describe: "view & change configuration", run: async () => ["opening config panel…"] });
+    reg.add({ name: "/dashboard", describe: "open the web dashboard in your browser", run: async () => {
+            if (!opts.dashboardUrl)
+                return ["dashboard URL not available"];
+            openUrl(opts.dashboardUrl);
+            return [`opening dashboard: ${opts.dashboardUrl}`];
+        } });
+    reg.add({ name: "/report", describe: "open a pre-filled GitHub issue with diagnostics", run: async (_a, c) => {
+            const repo = opts.reportRepo;
+            if (!repo || repo === PLACEHOLDER_REPO)
+                return ["set reportRepo (owner/repo) in config to enable /report"];
+            const [status, doctor, reqs] = await Promise.all([c.client.status(), c.client.doctor(), c.client.requests()]);
+            const url = buildIssueUrl({
+                repo, version: opts.appVersion ?? "0.0.0", platform: opts.platform ?? process.platform,
+                status, doctor, errors: recentErrors(reqs, 10),
+            });
+            openUrl(url);
+            return [`opening a pre-filled GitHub issue for ${repo} in your browser…`];
+        } });
+    reg.add({ name: "/quit", describe: "exit copilot-reverse", run: async (_a, c) => { c.quit(); return ["bye"]; } });
+    reg.add({ name: "/help", describe: "list commands", run: async () => reg.list().map((c) => `${c.name.padEnd(14)} ${c.describe}`) });
+    return reg;
+}

package/dist/tui/slash/registry.js

@@ -0,0 +1,16 @@
+export class Registry {
+    ctx;
+    cmds = new Map();
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    add(cmd) { this.cmds.set(cmd.name, cmd); return this; }
+    list() { return [...this.cmds.values()]; }
+    async run(line) {
+        const [name, ...args] = line.trim().split(/\s+/);
+        const cmd = this.cmds.get(name);
+        if (!cmd)
+            return [`unknown command: ${name} (try /help)`];
+        return cmd.run(args, this.ctx);
+    }
+}

package/dist/tui/theme.js

@@ -0,0 +1,16 @@
+// Claude-Code-inspired palette. Warm coral accent, muted secondary text, clear state colors.
+// Named colors keep broad terminal compatibility; the accent uses hex (truecolor terminals).
+export const theme = {
+    accent: "#cc785c", // Claude clay/coral
+    prompt: "#cc785c",
+    user: "white",
+    assistant: "white",
+    output: "gray",
+    muted: "gray",
+    border: "gray",
+    ready: "green",
+    starting: "yellow",
+    crashed: "redBright",
+    unhealthy: "red",
+    error: "red",
+};

package/dist/worker/anthropic-server.js

@@ -0,0 +1,108 @@
+import { randomUUID } from "node:crypto";
+import { anthropicRequestToCanonical, canonicalToAnthropicResponse } from "../core/anthropic-inbound.js";
+import { estimateTokens } from "../core/tokens.js";
+import { errorHint } from "./errors.js";
+import { CopilotAuthError } from "../providers/copilot/token.js";
+const frame = (event, data) => `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+export function mountAnthropic(app, router, onMetric) {
+    // Anthropic clients (Claude Code) call this to size the prompt and decide when to auto-compact.
+    app.post("/v1/messages/count_tokens", (req, res) => {
+        res.json({ input_tokens: estimateTokens(anthropicRequestToCanonical(req.body)) });
+    });
+    app.post("/v1/messages", async (req, res) => {
+        const start = Date.now();
+        const canon = anthropicRequestToCanonical(req.body);
+        canon.model = router.resolveModel(canon.model);
+        const provider = router.pick(canon.model);
+        const metric = (status, error) => onMetric({ endpoint: "/v1/messages", model: canon.model, status, latencyMs: Date.now() - start, error });
+        try {
+            if (canon.stream) {
+                res.setHeader("content-type", "text/event-stream");
+                res.setHeader("cache-control", "no-cache");
+                // MUST be unique per message — Anthropic ids are unique and clients (Claude Code) key
+                // their message store on it. A constant id made every answer overwrite/dedupe to the
+                // first one, so different questions appeared to return the same content.
+                const id = `msg_${randomUUID().replace(/-/g, "")}`;
+                // Claude Code reads input_tokens from message_start to size the context bar, but the real
+                // usage only arrives in the final frame. Seed message_start with an ESTIMATE so the bar
+                // isn't stuck at 0%; the terminal message_delta then reports the exact count.
+                const estInput = estimateTokens(canon);
+                res.write(frame("message_start", { type: "message_start", message: { id, type: "message", role: "assistant", model: canon.model, content: [], stop_reason: null, usage: { input_tokens: estInput, output_tokens: 0, cache_read_input_tokens: 0 } } }));
+                // D3 (interface-freeze §5.4) + mixed text+tool fix (architect, 2026-06-17): the endpoint owns
+                // open/stop bookkeeping with DYNAMIC SEQUENTIAL allocation. We do NOT pre-open an index-0 text block,
+                // and we do NOT map the Copilot tool index straight to the Anthropic block index (that collides with a
+                // text preamble on a mixed turn). Instead, whichever block opens FIRST claims Anthropic index 0, the
+                // next claims 1, etc. This keeps indices contiguous-from-0 in all three cases: pure-text (text@0),
+                // pure-tool (tool@0), and mixed preamble+tool (text@0, tool@1).
+                let next = 0;
+                let textIndex; // Anthropic index of the (single) text block, once opened
+                const toolIndex = new Map(); // Copilot tool index -> Anthropic block index
+                const openedOrder = []; // Anthropic indices in allocation order
+                let stopReason = "stop";
+                let usage;
+                for await (const chunk of provider.stream(canon)) {
+                    if (chunk.done) {
+                        stopReason = chunk.finishReason ?? "stop";
+                        usage = chunk.usage;
+                        break;
+                    }
+                    if (chunk.kind === "text") {
+                        if (textIndex === undefined) {
+                            textIndex = next++;
+                            openedOrder.push(textIndex);
+                            res.write(frame("content_block_start", { type: "content_block_start", index: textIndex, content_block: { type: "text", text: "" } }));
+                        }
+                        res.write(frame("content_block_delta", { type: "content_block_delta", index: textIndex, delta: { type: "text_delta", text: chunk.delta } }));
+                    }
+                    else if (chunk.kind === "tool_use_start") {
+                        if (!toolIndex.has(chunk.index)) {
+                            const index = next++;
+                            toolIndex.set(chunk.index, index);
+                            openedOrder.push(index);
+                            res.write(frame("content_block_start", { type: "content_block_start", index, content_block: { type: "tool_use", id: chunk.id, name: chunk.name, input: {} } }));
+                        }
+                    }
+                    else if (chunk.kind === "tool_use_delta") {
+                        const index = toolIndex.get(chunk.index);
+                        if (index !== undefined)
+                            res.write(frame("content_block_delta", { type: "content_block_delta", index, delta: { type: "input_json_delta", partial_json: chunk.argsDelta } }));
+                    }
+                }
+                // Close every opened block (ascending Anthropic index) before the terminal frames.
+                for (const index of [...openedOrder].sort((a, b) => a - b))
+                    res.write(frame("content_block_stop", { type: "content_block_stop", index }));
+                // Report real usage (agent-maestro shape): split cached tokens out of input so Claude Code's
+                // context bar is accurate. Falls back to zeros if Copilot didn't return usage.
+                const cached = usage?.cachedTokens ?? 0;
+                const inputTokens = Math.max(0, (usage?.promptTokens ?? estInput) - cached); // fall back to the estimate
+                const deltaUsage = { input_tokens: inputTokens, output_tokens: usage?.completionTokens ?? 0, cache_read_input_tokens: cached };
+                res.write(frame("message_delta", { type: "message_delta", delta: { stop_reason: stopReason === "tool_use" ? "tool_use" : stopReason === "length" ? "max_tokens" : "end_turn" }, usage: deltaUsage }));
+                res.write(frame("message_stop", { type: "message_stop" }));
+                res.end();
+                metric(200);
+            }
+            else {
+                res.json(canonicalToAnthropicResponse(await provider.complete(canon)));
+                metric(200);
+            }
+        }
+        catch (err) {
+            const raw = err instanceof Error ? err.message : String(err);
+            const hint = errorHint(raw);
+            const message = hint ? `${raw}\n${hint}` : raw;
+            const status = err instanceof CopilotAuthError ? 401 : 502;
+            const errorType = status === 401 ? "authentication_error" : "api_error";
+            if (!res.headersSent) {
+                res.status(status).json({ type: "error", error: { type: errorType, message } });
+            }
+            else {
+                // The stream already opened (message_start sent), so we can't set a status code.
+                // Emit an Anthropic `error` SSE event before closing so the client renders the
+                // failure instead of seeing a silently truncated response.
+                res.write(frame("error", { type: "error", error: { type: errorType, message } }));
+                res.end();
+            }
+            metric(status, message);
+        }
+    });
+}

package/dist/worker/errors.js

@@ -0,0 +1,12 @@
+// Turn a raw upstream error message into an actionable hint (agent-maestro v2.8.1/v2.6.0:
+// structured context-window-exceeded + model_not_supported guidance instead of a bare 400).
+export function errorHint(message) {
+    const m = message.toLowerCase();
+    if (/context_length_exceeded|prompt is too long|maximum context|too many tokens|context window/.test(m)) {
+        return "context window exceeded — the conversation is too long; /compact or switch to a larger-context model";
+    }
+    if (/not supported|unknown model|invalid model|model_not_found|does not support/.test(m)) {
+        return "model not supported — run /model to pick an available one";
+    }
+    return "";
+}

package/dist/worker/index.js

@@ -0,0 +1,30 @@
+import { createWorkerApp } from "./server.js";
+import { Router } from "./router.js";
+import { CopilotAdapter } from "../providers/copilot/adapter.js";
+import { CopilotTokenStore } from "../providers/copilot/token.js";
+import { fetchCopilotModels } from "../providers/copilot/models.js";
+import { readGhToken } from "../shared/creds.js";
+import { dataDir } from "../shared/paths.js";
+import { defaultConfig } from "../shared/config.js";
+function send(msg) { if (process.send)
+    process.send(msg); }
+const cfg = defaultConfig();
+const port = Number(process.env.WORKER_PORT ?? cfg.workerPort);
+const host = process.env.BIND_HOST ?? cfg.bindHost;
+const gh = readGhToken(dataDir());
+if (!gh) {
+    send({ type: "error", message: "no GitHub token; run `copilot-reverse` and /login first" });
+    process.exit(1);
+}
+const tokenStore = new CopilotTokenStore(gh);
+const router = new Router([new CopilotAdapter(tokenStore)], cfg.modelMap);
+// Load the live model list so the router can fuzzy-match near-miss ids (e.g. dated Anthropic ids).
+void tokenStore.get().then((t) => fetchCopilotModels(t)).then((ids) => router.setAvailableModels(ids)).catch(() => { });
+const app = createWorkerApp(router, (m) => send({ type: "request-metric", ...m }));
+const server = app.listen(port, host, () => send({ type: "ready", port }));
+const hb = setInterval(() => send({ type: "heartbeat", ts: Date.now() }), 5_000);
+process.on("message", (m) => { if (m?.type === "shutdown") {
+    clearInterval(hb);
+    server.close(() => process.exit(0));
+} });
+process.on("uncaughtException", (e) => { send({ type: "error", message: e.message, stack: e.stack }); process.exit(1); });