copilot-reverse 0.0.1

package/dist/providers/copilot/adapter.js

@@ -0,0 +1,146 @@
+import { randomUUID } from "node:crypto";
+const CHAT_URL = "https://api.githubcopilot.com/chat/completions";
+// Canonical messages -> OpenAI wire messages (Copilot is OpenAI-shaped).
+function toWireMessages(messages) {
+    const out = [];
+    for (const m of messages) {
+        const toolResults = m.content.filter((b) => b.type === "tool_result");
+        // EACH tool_result becomes its own OpenAI `tool` message. Anthropic packs parallel results
+        // into one user message; emitting only the first (the old bug) left later tool_use ids without
+        // a matching tool_result -> Claude/Copilot 400 "tool_use ids ... without tool_result blocks".
+        if (toolResults.length) {
+            for (const tr of toolResults)
+                out.push({ role: "tool", tool_call_id: tr.toolUseId, content: tr.content });
+            continue;
+        }
+        const text = m.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        const images = m.content.filter((b) => b.type === "image");
+        const toolUses = m.content.filter((b) => b.type === "tool_use");
+        // With images, content becomes an OpenAI multipart array (text part + image_url parts); otherwise a string.
+        let msgContent = text || null;
+        if (images.length) {
+            msgContent = [...(text ? [{ type: "text", text }] : []), ...images.map((img) => ({ type: "image_url", image_url: { url: img.dataUrl } }))];
+        }
+        const msg = { role: m.role, content: msgContent };
+        if (toolUses.length)
+            msg.tool_calls = toolUses.map((t) => ({ id: t.id, type: "function", function: { name: t.name, arguments: JSON.stringify(t.input) } }));
+        out.push(msg);
+    }
+    return out;
+}
+function buildBody(req) {
+    const body = { model: req.model, messages: toWireMessages(req.messages), stream: req.stream, temperature: req.temperature, max_tokens: req.maxTokens };
+    if (req.stream)
+        body.stream_options = { include_usage: true }; // ask Copilot for usage in the final frame
+    if (req.tools?.length)
+        body.tools = req.tools.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
+    return body;
+}
+function headers(token) {
+    return { authorization: `Bearer ${token}`, "content-type": "application/json", "editor-version": "vscode/1.95.0", "copilot-integration-id": "vscode-chat" };
+}
+// Copilot puts the real reason (bad model, oversized prompt, unsupported tool, …) in the body —
+// surface it instead of a bare status code so failures are diagnosable.
+async function errorDetail(res) {
+    try {
+        const t = (await res.text()).trim();
+        return t ? ` — ${t.slice(0, 400)}` : "";
+    }
+    catch {
+        return "";
+    }
+}
+export class CopilotAdapter {
+    tokenStore;
+    fetchFn;
+    name = "copilot";
+    constructor(tokenStore, fetchFn = fetch) {
+        this.tokenStore = tokenStore;
+        this.fetchFn = fetchFn;
+    }
+    async complete(req) {
+        const token = await this.tokenStore.get();
+        const res = await this.fetchFn(CHAT_URL, { method: "POST", headers: headers(token), body: JSON.stringify(buildBody({ ...req, stream: false })) });
+        if (!res.ok)
+            throw new Error(`copilot completion failed: ${res.status}${await errorDetail(res)}`);
+        const data = (await res.json());
+        const choice = data.choices[0];
+        const content = [];
+        if (choice.message.content)
+            content.push({ type: "text", text: choice.message.content });
+        for (const tc of choice.message.tool_calls ?? [])
+            content.push({ type: "tool_use", id: tc.id, name: tc.function.name, input: safeJson(tc.function.arguments) });
+        return {
+            id: data.id ?? `cmpl-${randomUUID().replace(/-/g, "")}`, model: req.model, content,
+            finishReason: choice.finish_reason === "tool_calls" ? "tool_use" : choice.finish_reason === "length" ? "length" : "stop",
+            usage: { promptTokens: data.usage?.prompt_tokens ?? 0, completionTokens: data.usage?.completion_tokens ?? 0 },
+        };
+    }
+    async *stream(req) {
+        const token = await this.tokenStore.get();
+        const res = await this.fetchFn(CHAT_URL, { method: "POST", headers: headers(token), body: JSON.stringify(buildBody({ ...req, stream: true })) });
+        if (!res.ok || !res.body)
+            throw new Error(`copilot stream failed: ${res.status}${await errorDetail(res)}`);
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        const startedTools = new Set();
+        let buffer = "";
+        let finishReason = "stop";
+        let usage;
+        const mapFinish = (f) => f === "tool_calls" ? "tool_use" : f === "length" ? "length" : "stop";
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const events = buffer.split("\n\n");
+            buffer = events.pop() ?? "";
+            for (const evt of events) {
+                const line = evt.split("\n").find((l) => l.startsWith("data: "));
+                if (!line)
+                    continue;
+                const payload = line.slice(6).trim();
+                if (payload === "[DONE]") {
+                    yield { kind: "done", done: true, finishReason, usage };
+                    return;
+                }
+                let json;
+                try {
+                    json = JSON.parse(payload);
+                }
+                catch {
+                    continue;
+                }
+                // Copilot sends a final frame with empty choices carrying usage (stream_options.include_usage).
+                if (json.usage)
+                    usage = { promptTokens: json.usage.prompt_tokens ?? 0, completionTokens: json.usage.completion_tokens ?? 0, cachedTokens: json.usage.prompt_tokens_details?.cached_tokens ?? 0 };
+                const choice = json.choices?.[0];
+                if (!choice)
+                    continue;
+                if (choice.finish_reason)
+                    finishReason = mapFinish(choice.finish_reason);
+                const delta = choice.delta;
+                if (!delta)
+                    continue;
+                if (delta.content)
+                    yield { kind: "text", delta: delta.content, done: false };
+                for (const tc of delta.tool_calls ?? []) {
+                    const idx = tc.index ?? 0;
+                    if (!startedTools.has(idx) && tc.function?.name) {
+                        startedTools.add(idx);
+                        yield { kind: "tool_use_start", index: idx, id: tc.id ?? `call_${idx}`, name: tc.function.name, done: false };
+                    }
+                    if (tc.function?.arguments)
+                        yield { kind: "tool_use_delta", index: idx, argsDelta: tc.function.arguments, done: false };
+                }
+            }
+        }
+        yield { kind: "done", done: true, finishReason, usage };
+    }
+}
+function safeJson(s) { try {
+    return JSON.parse(s);
+}
+catch {
+    return {};
+} }

package/dist/providers/copilot/auth.js

@@ -0,0 +1,30 @@
+// Community-documented GitHub Copilot OAuth (unofficial; may change).
+const CLIENT_ID = "Iv1.b507a08c87ecfe98";
+const DEVICE_CODE_URL = "https://github.com/login/device/code";
+const ACCESS_TOKEN_URL = "https://github.com/login/oauth/access_token";
+export async function requestDeviceCode(fetchFn = fetch) {
+    const res = await fetchFn(DEVICE_CODE_URL, {
+        method: "POST",
+        headers: { accept: "application/json", "content-type": "application/json" },
+        body: JSON.stringify({ client_id: CLIENT_ID, scope: "read:user" }),
+    });
+    if (!res.ok)
+        throw new Error(`device code request failed: ${res.status}`);
+    return (await res.json());
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function pollForToken(deviceCode, intervalMs, fetchFn = fetch) {
+    for (;;) {
+        const res = await fetchFn(ACCESS_TOKEN_URL, {
+            method: "POST",
+            headers: { accept: "application/json", "content-type": "application/json" },
+            body: JSON.stringify({ client_id: CLIENT_ID, device_code: deviceCode, grant_type: "urn:ietf:params:oauth:grant-type:device_code" }),
+        });
+        const data = (await res.json());
+        if (data.access_token)
+            return data.access_token;
+        if (data.error && data.error !== "authorization_pending" && data.error !== "slow_down")
+            throw new Error(`authorization failed: ${data.error}`);
+        await sleep(intervalMs);
+    }
+}

package/dist/providers/copilot/models.js

@@ -0,0 +1,49 @@
+// Live model list from Copilot. Falls back to a curated list if the endpoint is unavailable.
+const MODELS_URL = "https://api.githubcopilot.com/models";
+const FALLBACK = ["gpt-4o", "gpt-4o-mini", "claude-sonnet-4-6", "claude-opus-4-8", "o3-mini"];
+const HEADERS = (token) => ({
+    authorization: `Bearer ${token}`,
+    "content-type": "application/json",
+    "editor-version": "vscode/1.95.0",
+    "copilot-integration-id": "vscode-chat",
+});
+const DEFAULT_TIMEOUT_MS = 8000;
+// A stalled Copilot endpoint must never hang the model picker forever — abort after timeoutMs.
+async function getModels(token, fetchFn, timeoutMs) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+        const res = await fetchFn(MODELS_URL, { headers: HEADERS(token), signal: ctrl.signal });
+        if (!res.ok)
+            return null;
+        return (await res.json()).data ?? [];
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function fetchCopilotModels(token, fetchFn = fetch, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const data = await getModels(token, fetchFn, timeoutMs);
+    if (!data)
+        return FALLBACK;
+    const ids = [...new Set(data.map((m) => m.id).filter((x) => Boolean(x)))];
+    return ids.length ? ids : FALLBACK;
+}
+// Map of model id -> its real input/context window, used to size auto-compaction per model and
+// to show the window in the picker. Returns {} on failure/timeout so callers fall back gracefully.
+export async function fetchModelLimits(token, fetchFn = fetch, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const data = await getModels(token, fetchFn, timeoutMs);
+    if (!data)
+        return {};
+    const out = {};
+    for (const m of data) {
+        // Prefer the headline context window (so a 1M model shows as 1M); fall back to the prompt budget.
+        const limit = m.capabilities?.limits?.max_context_window_tokens ?? m.capabilities?.limits?.max_prompt_tokens;
+        if (m.id && typeof limit === "number")
+            out[m.id] = limit;
+    }
+    return out;
+}

package/dist/providers/copilot/token.js

@@ -0,0 +1,53 @@
+const COPILOT_TOKEN_URL = "https://api.github.com/copilot_internal/v2/token";
+// Thrown when the stored GitHub token can no longer be exchanged for a Copilot token
+// (expired / revoked login). Carries an actionable message.
+export class CopilotAuthError extends Error {
+    status;
+    constructor(status) {
+        super(status === 401 || status === 403
+            ? "GitHub login expired — restart copilot-reverse (or run `copilot-reverse login`) to re-authenticate"
+            : `copilot token exchange failed: ${status}`);
+        this.status = status;
+        this.name = "CopilotAuthError";
+    }
+}
+export class CopilotTokenStore {
+    ghToken;
+    fetchFn;
+    nowMs;
+    cached;
+    constructor(ghToken, fetchFn = fetch, nowMs = () => Date.now()) {
+        this.ghToken = ghToken;
+        this.fetchFn = fetchFn;
+        this.nowMs = nowMs;
+    }
+    async get() {
+        const skewMs = 60_000;
+        if (this.cached && this.cached.expiresAtMs - skewMs > this.nowMs())
+            return this.cached.token;
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 8000);
+        let res;
+        try {
+            res = await this.fetchFn(COPILOT_TOKEN_URL, { headers: { authorization: `token ${this.ghToken}`, accept: "application/json" }, signal: ctrl.signal });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (!res.ok)
+            throw new CopilotAuthError(res.status);
+        const data = (await res.json());
+        this.cached = { token: data.token, expiresAtMs: data.expires_at * 1000 };
+        return data.token;
+    }
+}
+// True if the stored GitHub token still exchanges for a Copilot token.
+export async function isCopilotTokenValid(ghToken, fetchFn = fetch) {
+    try {
+        await new CopilotTokenStore(ghToken, fetchFn).get();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/client-setup.js

@@ -0,0 +1,19 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const file = (dir) => join(dir, "clients.json");
+export function readClientSetup(dir) {
+    if (!existsSync(file(dir)))
+        return { claude: false, codex: false };
+    try {
+        const d = JSON.parse(readFileSync(file(dir), "utf8"));
+        return { claude: Boolean(d.claude), codex: Boolean(d.codex) };
+    }
+    catch {
+        return { claude: false, codex: false };
+    }
+}
+export function writeClientSetup(dir, state) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(file(dir), JSON.stringify(state));
+}

package/dist/shared/config.js

@@ -0,0 +1,20 @@
+export function defaultConfig() {
+    return {
+        bindHost: "127.0.0.1",
+        supervisorPort: 7890,
+        workerPort: 7891,
+        restart: { maxCrashes: 5, windowMs: 60_000, baseBackoffMs: 500, maxBackoffMs: 8_000 },
+        // Empty = pass the requested model straight through to Copilot. Add entries (or "*") to remap.
+        modelMap: {},
+        // Set MAESTRO_REPORT_REPO=owner/repo to override where /report files diagnostics issues.
+        reportRepo: process.env.MAESTRO_REPORT_REPO ?? "wangcansunking/copilot-reverse",
+    };
+}
+export function mergeConfig(base, o) {
+    return {
+        ...base,
+        ...o,
+        restart: { ...base.restart, ...(o.restart ?? {}) },
+        modelMap: { ...base.modelMap, ...(o.modelMap ?? {}) },
+    };
+}

package/dist/shared/control-types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/creds.js

@@ -0,0 +1,14 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+// M1: plaintext token in the data dir (0600). Encryption-at-rest is M2.
+const file = (dir) => join(dir, "creds.json");
+export function writeGhToken(token, dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(file(dir), JSON.stringify({ ghToken: token }), { mode: 0o600 });
+}
+export function readGhToken(dir) {
+    if (!existsSync(file(dir)))
+        return null;
+    return JSON.parse(readFileSync(file(dir), "utf8")).ghToken ?? null;
+}

package/dist/shared/format.js

@@ -0,0 +1,28 @@
+// Whimsical loading verbs, à la Claude Code — rotated every ~3s based on elapsed time so the
+// label changes as you wait. Deterministic per time-bucket (no per-render flicker).
+export const LOADING_VERBS = [
+    "Orchestrating", "Cogitating", "Pondering", "Noodling", "Conjuring", "Percolating",
+    "Ruminating", "Synthesizing", "Marshalling", "Untangling", "Wrangling", "Spelunking",
+];
+export function loadingVerb(elapsedMs) {
+    return LOADING_VERBS[Math.floor(Math.max(0, elapsedMs) / 3000) % LOADING_VERBS.length];
+}
+// Human-readable context window, e.g. 1_000_000 -> "1M", 200_000 -> "200K". Empty when unknown.
+export function formatContextWindow(n) {
+    if (!n || n <= 0)
+        return "";
+    if (n >= 1_000_000)
+        return `${+(n / 1_000_000).toFixed(n % 1_000_000 ? 1 : 0)}M`;
+    if (n >= 1000)
+        return `${Math.round(n / 1000)}K`;
+    return String(n);
+}
+// Bulleted model list with context windows — used by the assistant's list_models tool.
+export function formatModelList(ids, limits) {
+    if (!ids.length)
+        return "(no models found)";
+    return ids.map((id) => {
+        const w = formatContextWindow(limits?.[id]);
+        return `- ${id}${w ? ` (${w})` : ""}`;
+    }).join("\n");
+}

package/dist/shared/ipc.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/open-url.js

@@ -0,0 +1,17 @@
+import { spawn } from "node:child_process";
+// The platform's URL-opening command. Pure + exported so it can be asserted without spawning.
+export function openCommandFor(url, platform = process.platform) {
+    if (platform === "win32")
+        return { command: "cmd", args: ["/c", "start", "", url] };
+    if (platform === "darwin")
+        return { command: "open", args: [url] };
+    return { command: "xdg-open", args: [url] };
+}
+// Best-effort: open the URL in the user's default browser. Never throws — if no opener
+// exists (headless box), the caller's printed URL is the fallback.
+export function openUrl(url, platform = process.platform) {
+    const { command, args } = openCommandFor(url, platform);
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", () => { });
+    child.unref();
+}

package/dist/shared/paths.js

@@ -0,0 +1,11 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function dataDir(home = homedir()) {
+    return join(home, ".copilot-reverse");
+}
+export function dbPath(home) {
+    return join(dataDir(home), "copilot-reverse.db");
+}
+export function configPath(home) {
+    return join(dataDir(home), "config.json");
+}

package/dist/shared/prefs.js

@@ -0,0 +1,28 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+// Small user-preferences store (e.g. the chosen chat model), persisted across launches.
+const file = (dir) => join(dir, "prefs.json");
+export function readChatModel(dir) {
+    if (!existsSync(file(dir)))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file(dir), "utf8")).chatModel ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeChatModel(dir, model) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    let cur = {};
+    if (existsSync(file(dir))) {
+        try {
+            cur = JSON.parse(readFileSync(file(dir), "utf8"));
+        }
+        catch {
+            cur = {};
+        }
+    }
+    writeFileSync(file(dir), JSON.stringify({ ...cur, chatModel: model }));
+}

package/dist/supervisor/api.js

@@ -0,0 +1,24 @@
+import express from "express";
+import { listRestarts, recentRequests } from "./db.js";
+import { dashboardHtml } from "./dashboard.js";
+export function createControlApp(deps) {
+    const app = express();
+    app.use(express.json());
+    app.get("/", (_req, res) => res.type("html").send(dashboardHtml()));
+    app.get("/api/status", (_req, res) => res.json({ workerState: deps.getState(), restarts: listRestarts(deps.db, 50) }));
+    app.post("/api/restart", (_req, res) => { deps.restart(); res.json({ ok: true }); });
+    app.post("/api/stop", (_req, res) => { deps.stop(); res.json({ ok: true }); });
+    app.post("/api/start", (_req, res) => { deps.start(); res.json({ ok: true }); });
+    app.get("/api/doctor", async (_req, res) => res.json({ checks: await deps.doctor() }));
+    app.get("/api/requests", (_req, res) => res.json({ requests: recentRequests(deps.db, 100) }));
+    app.get("/api/events", (req, res) => {
+        res.setHeader("content-type", "text/event-stream");
+        res.setHeader("cache-control", "no-cache");
+        res.flushHeaders?.();
+        const send = (event, data) => res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+        send("hello", { state: deps.getState() });
+        const off = deps.subscribe(send);
+        req.on("close", off);
+    });
+    return app;
+}

package/dist/supervisor/dashboard.js

@@ -0,0 +1,110 @@
+// A self-contained, dependency-free dashboard page served at GET /. It polls the existing
+// control API (/api/status, /api/requests, /api/doctor) every 2s and renders worker health,
+// request metrics, and — most usefully — recent request errors with their messages.
+export function dashboardHtml() {
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>copilot-reverse dashboard</title>
+<style>
+  :root { color-scheme: dark; }
+  body { margin: 0; font: 14px/1.5 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; background: #0b0e14; color: #c7d0e0; }
+  header { display: flex; align-items: baseline; gap: 12px; padding: 16px 20px; border-bottom: 1px solid #1c2230; }
+  h1 { font-size: 16px; margin: 0; color: #8ab4f8; }
+  .muted { color: #6b7689; }
+  main { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; padding: 20px; }
+  section { background: #11151f; border: 1px solid #1c2230; border-radius: 8px; padding: 14px 16px; }
+  section.wide { grid-column: 1 / -1; }
+  h2 { font-size: 13px; margin: 0 0 10px; color: #9aa7bd; text-transform: uppercase; letter-spacing: .04em; }
+  table { width: 100%; border-collapse: collapse; }
+  th, td { text-align: left; padding: 4px 8px; border-bottom: 1px solid #161b27; vertical-align: top; }
+  th { color: #6b7689; font-weight: 600; }
+  .badge { padding: 1px 8px; border-radius: 999px; font-size: 12px; }
+  .ok { color: #6ee7b7; } .bad { color: #f87171; } .warn { color: #fbbf24; }
+  .err { color: #f87171; white-space: pre-wrap; word-break: break-word; }
+  .pill-ready { background: #064e3b; color: #6ee7b7; }
+  .pill-bad { background: #4c1d24; color: #f87171; }
+  .empty { color: #6b7689; font-style: italic; }
+</style>
+</head>
+<body>
+<header>
+  <h1>✳ copilot-reverse</h1>
+  <span class="muted">worker <span id="state" class="badge">…</span></span>
+  <span class="muted" id="updated"></span>
+</header>
+<main>
+  <section>
+    <h2>Health</h2>
+    <div id="doctor"><span class="empty">loading…</span></div>
+  </section>
+  <section>
+    <h2>Requests</h2>
+    <div id="metrics"><span class="empty">loading…</span></div>
+  </section>
+  <section class="wide">
+    <h2>Recent errors</h2>
+    <div id="errors"><span class="empty">loading…</span></div>
+  </section>
+  <section class="wide">
+    <h2>Recent requests</h2>
+    <div id="requests"><span class="empty">loading…</span></div>
+  </section>
+</main>
+<script>
+const esc = (s) => String(s ?? "").replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" }[c]));
+const fmt = (ts) => new Date(ts).toLocaleTimeString();
+async function getJson(p) { const r = await fetch(p); if (!r.ok) throw new Error(p + " -> " + r.status); return r.json(); }
+
+function renderState(s) {
+  const el = document.getElementById("state");
+  el.textContent = s;
+  el.className = "badge " + (s === "ready" ? "pill-ready" : "pill-bad");
+}
+function renderDoctor(checks) {
+  const el = document.getElementById("doctor");
+  if (!checks.length) { el.innerHTML = '<span class="empty">no checks</span>'; return; }
+  el.innerHTML = "<table>" + checks.map((c) =>
+    '<tr><td class="' + (c.ok ? "ok" : "bad") + '">' + (c.ok ? "✓" : "✗") + "</td><td>" + esc(c.name) + '</td><td class="muted">' + esc(c.detail) + "</td></tr>"
+  ).join("") + "</table>";
+}
+function renderRequests(reqs) {
+  const total = reqs.length, errors = reqs.filter((r) => r.status >= 400).length;
+  document.getElementById("metrics").innerHTML =
+    '<div>total <b>' + total + '</b> &nbsp; errors <b class="' + (errors ? "bad" : "ok") + '">' + errors + "</b></div>";
+
+  const errs = reqs.filter((r) => r.status >= 400).slice(0, 30);
+  document.getElementById("errors").innerHTML = errs.length
+    ? "<table><tr><th>time</th><th>status</th><th>endpoint</th><th>model</th><th>error</th></tr>" + errs.map((r) =>
+        "<tr><td>" + fmt(r.ts) + '</td><td class="bad">' + r.status + "</td><td>" + esc(r.endpoint) + "</td><td>" + esc(r.model) + '</td><td class="err">' + esc(r.error || "(no message)") + "</td></tr>"
+      ).join("") + "</table>"
+    : '<span class="empty">no request errors — everything\\'s green ✓</span>';
+
+  const recent = reqs.slice(0, 30);
+  document.getElementById("requests").innerHTML = recent.length
+    ? "<table><tr><th>time</th><th>status</th><th>endpoint</th><th>model</th><th>ms</th></tr>" + recent.map((r) =>
+        "<tr><td>" + fmt(r.ts) + '</td><td class="' + (r.status >= 400 ? "bad" : "ok") + '">' + r.status + "</td><td>" + esc(r.endpoint) + "</td><td>" + esc(r.model) + "</td><td>" + r.latencyMs + "</td></tr>"
+      ).join("") + "</table>"
+    : '<span class="empty">no requests yet</span>';
+}
+async function tick() {
+  try {
+    const [status, reqs, doctor] = await Promise.all([
+      getJson("/api/status"), getJson("/api/requests"), getJson("/api/doctor"),
+    ]);
+    renderState(status.workerState);
+    renderDoctor(doctor.checks || []);
+    renderRequests(reqs.requests || []);
+    document.getElementById("updated").textContent = "updated " + new Date().toLocaleTimeString();
+  } catch (e) {
+    document.getElementById("updated").textContent = "control API unreachable: " + e.message;
+  }
+}
+tick();
+setInterval(tick, 2000);
+</script>
+</body>
+</html>`;
+}

package/dist/supervisor/db.js

@@ -0,0 +1,35 @@
+import Database from "better-sqlite3";
+export function openDb(file) {
+    const db = new Database(file);
+    db.pragma("journal_mode = WAL");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+    CREATE TABLE IF NOT EXISTS restart_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, ts INTEGER NOT NULL, reason TEXT NOT NULL,
+      exit_code INTEGER, stderr_tail TEXT NOT NULL, backoff_ms INTEGER NOT NULL, marked_unhealthy INTEGER NOT NULL DEFAULT 0);
+    CREATE TABLE IF NOT EXISTS request_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, ts INTEGER NOT NULL, endpoint TEXT NOT NULL,
+      model TEXT NOT NULL, status INTEGER NOT NULL, latency_ms INTEGER NOT NULL, error TEXT);
+  `);
+    // Migrate request_log tables created before the error column existed.
+    const cols = db.prepare(`PRAGMA table_info(request_log)`).all();
+    if (!cols.some((c) => c.name === "error"))
+        db.exec(`ALTER TABLE request_log ADD COLUMN error TEXT`);
+    return db;
+}
+export function recordRestart(db, e) {
+    db.prepare(`INSERT INTO restart_events (ts, reason, exit_code, stderr_tail, backoff_ms, marked_unhealthy)
+    VALUES (@ts, @reason, @exitCode, @stderrTail, @backoffMs, @markedUnhealthy)`).run(e);
+}
+export function listRestarts(db, limit) {
+    return db.prepare(`SELECT ts, reason, exit_code as exitCode, stderr_tail as stderrTail, marked_unhealthy as markedUnhealthy
+    FROM restart_events ORDER BY ts DESC LIMIT ?`).all(limit);
+}
+export function recordRequest(db, m) {
+    db.prepare(`INSERT INTO request_log (ts, endpoint, model, status, latency_ms, error) VALUES (@ts, @endpoint, @model, @status, @latencyMs, @error)`)
+        .run({ error: null, ...m });
+}
+export function recentRequests(db, limit) {
+    return db.prepare(`SELECT ts, endpoint, model, status, latency_ms as latencyMs, error FROM request_log ORDER BY ts DESC LIMIT ?`).all(limit)
+        .map(({ error, ...r }) => (error == null ? r : { ...r, error }));
+}

package/dist/supervisor/events.js

@@ -0,0 +1,6 @@
+export class EventBus {
+    listeners = new Set();
+    subscribe(fn) { this.listeners.add(fn); return () => this.listeners.delete(fn); }
+    emit(event, data) { for (const fn of this.listeners)
+        fn(event, data); }
+}