aiki-cli 0.3.2 → 0.3.5

package/dist/serve/server.js

@@ -0,0 +1,219 @@
+// `aiki serve` HTTP server (plan §3.1). Native node:http, static files + JSON API + (HD3) SSE.
+// Zero new dependencies. Security posture (kept from the v1 rules):
+//   - binds 127.0.0.1 only (never a public interface);
+//   - Host header must be localhost/127.0.0.1 (blocks DNS-rebinding);
+//   - a per-boot random deckToken is injected into the shell and required on every mutating POST/PATCH;
+//   - one active run at a time — a second Convene returns 409 (HD3 sets the lock).
+// Nothing path-bearing is ever serialized out: every response body is a projections.ts view.
+import { createServer as createHttpServer } from 'node:http';
+import { randomBytes } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { extname, join, normalize } from 'node:path';
+import { z, ZodError } from 'zod';
+import { ConfigError } from '../config/config.js';
+import { DeckAction, SendInput, SettingsPatch } from './projections.js';
+import { DeckError } from './flight-deck.js';
+import { encodeSse } from './frames.js';
+const DEFAULT_PORT = 4173;
+const PORT_SCAN_END = 4183;
+const HOST = '127.0.0.1';
+const MIME = {
+    '.html': 'text/html; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+};
+/** Build the request handler around a FlightDeck. Exported for tests (drive it without a socket). */
+export function createHandler(opts) {
+    const { flightDeck, staticDir, deckToken, port } = opts;
+    return async (req, res) => {
+        try {
+            if (!hostAllowed(req, port))
+                return send(res, 403, { error: 'forbidden host' });
+            const url = new URL(req.url ?? '/', `http://${HOST}`);
+            const path = url.pathname;
+            const method = req.method ?? 'GET';
+            // Mutating requests must carry the per-boot deck token (same-origin CSRF guard).
+            if (method === 'POST' || method === 'PATCH') {
+                if (req.headers['x-deck-token'] !== deckToken)
+                    return send(res, 403, { error: 'bad deck token' });
+            }
+            if (method === 'GET' && (path === '/' || path === '/index.html')) {
+                return await sendShell(res, staticDir, deckToken);
+            }
+            if (method === 'GET' && path === '/api/bootstrap') {
+                return send(res, 200, await flightDeck.bootstrap());
+            }
+            if (method === 'GET' && path === '/api/settings') {
+                return send(res, 200, await flightDeck.settings());
+            }
+            if (method === 'PATCH' && path === '/api/settings') {
+                return send(res, 200, await flightDeck.updateSettings(SettingsPatch.parse(await readJson(req))));
+            }
+            if (method === 'GET' && path.startsWith('/api/threads/')) {
+                const id = decodeURIComponent(path.slice('/api/threads/'.length));
+                const detail = await flightDeck.thread(id);
+                return detail ? send(res, 200, detail) : send(res, 404, { error: 'no such thread' });
+            }
+            if (method === 'POST' && path === '/api/providers/check') {
+                const { fresh } = z.object({ fresh: z.boolean() }).strict().parse(await readJson(req));
+                return send(res, 200, await flightDeck.checkProviders(fresh));
+            }
+            if (method === 'POST' && path === '/api/messages') {
+                return send(res, 202, await flightDeck.send(SendInput.parse(await readJson(req))));
+            }
+            const runRoute = path.match(/^\/api\/runs\/([^/]+)\/(events|actions|report)$/);
+            if (runRoute) {
+                const runId = decodeURIComponent(runRoute[1]);
+                const route = runRoute[2];
+                if (method === 'GET' && route === 'events')
+                    return await sendEvents(req, res, flightDeck, runId);
+                if (method === 'POST' && route === 'actions') {
+                    const outcome = await flightDeck.act(runId, DeckAction.parse(await readJson(req)));
+                    return send(res, 200, outcome ?? { ok: true });
+                }
+                if (method === 'GET' && route === 'report')
+                    return send(res, 200, await flightDeck.report(runId));
+                return send(res, 405, { error: 'method not allowed' });
+            }
+            if (path.startsWith('/api/'))
+                return send(res, 404, { error: 'not found' });
+            // Static asset (css/js/png) from the serve-ui dir.
+            if (method === 'GET')
+                return await sendStatic(res, staticDir, path);
+            return send(res, 405, { error: 'method not allowed' });
+        }
+        catch (e) {
+            if (e instanceof DeckError)
+                return send(res, e.status, { error: e.message });
+            if (e instanceof ConfigError)
+                return send(res, 409, { error: 'Existing config is invalid. Fix it before saving settings.' });
+            if (e instanceof ZodError)
+                return send(res, 400, { error: 'invalid request' });
+            send(res, 500, { error: 'internal error' });
+        }
+    };
+}
+/** Start listening on 127.0.0.1. Explicit port that is busy fails loud; otherwise scan 4173–4183. */
+export async function startServer(opts) {
+    const deckToken = randomBytes(16).toString('hex');
+    const host = opts.host ?? HOST;
+    const handler = (port) => createHandler({ flightDeck: opts.flightDeck, staticDir: opts.staticDir, deckToken, port });
+    const tryPort = (port) => new Promise((resolve, reject) => {
+        const server = createHttpServer(handler(port));
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE')
+                resolve(null);
+            else
+                reject(err);
+        });
+        server.listen(port, host, () => resolve(server));
+    });
+    if (opts.port !== undefined) {
+        const server = await tryPort(opts.port);
+        if (!server)
+            throw new Error(`port ${opts.port} is already in use`);
+        return running(server, opts.port, deckToken, opts.flightDeck);
+    }
+    for (let port = DEFAULT_PORT; port <= PORT_SCAN_END; port++) {
+        const server = await tryPort(port);
+        if (server)
+            return running(server, port, deckToken, opts.flightDeck);
+    }
+    throw new Error(`no free port in ${DEFAULT_PORT}–${PORT_SCAN_END}`);
+}
+function running(server, port, deckToken, flightDeck) {
+    return {
+        port,
+        deckToken,
+        close: async () => {
+            await flightDeck.close();
+            await new Promise((resolve) => server.close(() => resolve()));
+        },
+    };
+}
+// ── helpers ──────────────────────────────────────────────────────────────
+/** Host allowlist: localhost / 127.0.0.1, with or without the served port. Blocks DNS-rebinding. */
+export function hostAllowed(req, port) {
+    const host = req.headers.host;
+    if (!host)
+        return false;
+    const ok = new Set([`127.0.0.1:${port}`, `localhost:${port}`, '127.0.0.1', 'localhost']);
+    return ok.has(host);
+}
+function send(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'x-content-type-options': 'nosniff' });
+    res.end(payload);
+}
+async function sendShell(res, staticDir, deckToken) {
+    let html;
+    try {
+        html = await readFile(join(staticDir, 'index.html'), 'utf8');
+    }
+    catch {
+        return send(res, 500, { error: 'serve-ui not built (run npm run build)' });
+    }
+    const injected = html.replace('__DECK_TOKEN__', deckToken);
+    res.writeHead(200, { 'content-type': MIME['.html'], 'x-content-type-options': 'nosniff' });
+    res.end(injected);
+}
+async function sendStatic(res, staticDir, path) {
+    // Contain the read inside staticDir (no traversal out via ../).
+    const rel = normalize(path).replace(/^(\.\.[/\\])+/, '');
+    const file = join(staticDir, rel);
+    if (!file.startsWith(staticDir))
+        return send(res, 403, { error: 'forbidden path' });
+    let data;
+    try {
+        data = await readFile(file);
+    }
+    catch {
+        return send(res, 404, { error: 'not found' });
+    }
+    res.writeHead(200, { 'content-type': MIME[extname(file)] ?? 'application/octet-stream', 'x-content-type-options': 'nosniff' });
+    res.end(data);
+}
+async function readJson(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const part = chunk;
+        size += part.length;
+        if (size > 1_000_000)
+            throw new DeckError(413, 'request body too large');
+        chunks.push(part);
+    }
+    if (!chunks.length)
+        return null;
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new DeckError(400, 'invalid JSON');
+    }
+}
+async function sendEvents(req, res, flightDeck, runId) {
+    const raw = req.headers['last-event-id'];
+    const parsed = Number.parseInt(Array.isArray(raw) ? raw[0] ?? '0' : raw ?? '0', 10);
+    const after = Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+    const abort = new AbortController();
+    const frames = flightDeck.frames(runId, after, abort.signal);
+    const first = await frames.next(); // surface an unknown run before committing a 200 SSE response
+    res.once('close', () => abort.abort());
+    res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-cache, no-transform',
+        connection: 'keep-alive',
+        'x-content-type-options': 'nosniff',
+    });
+    res.flushHeaders?.();
+    if (!first.done)
+        res.write(encodeSse(first.value));
+    for await (const frame of frames)
+        res.write(encodeSse(frame));
+    res.end();
+}

package/dist/serve/threads.js

@@ -0,0 +1,145 @@
+// Conversation threads for `aiki serve` (plan §1.2). A thread is a titled sequence of turns that
+// starts from a decision run. Two append-only files, same last-line-wins pattern as sessions.jsonl:
+//   <root>/threads.jsonl        — the registry (one ThreadEntry line per update)
+//   <root>/threads/<id>.jsonl   — the per-thread turn log
+// Old sessions.jsonl runs are projected read-only as single-run "legacy" threads so existing users
+// see their history on first launch (HD2). New live threads land in HD3.
+import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { readSessions } from '../storage/sessions.js';
+import { readFinalReport } from '../storage/runs-read.js';
+import { runDir } from '../storage/runs-read.js';
+import { sanitizeLocalPaths } from '../orchestration/sanitize-paths.js';
+import { threadTitle } from './projections.js';
+export const ThreadStatus = z.enum(['idle', 'running', 'failed', 'cancelled']);
+export const ThreadEntry = z
+    .object({
+    id: z.string().min(1),
+    title: z.string(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    status: ThreadStatus,
+    run_ids: z.array(z.string()),
+})
+    .strict();
+/** Per-thread turn log (append-only). */
+export const ThreadTurn = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('user_message'), text: z.string(), attachments: z.array(z.string()), mode: z.string() }).strict(),
+    z.object({ kind: z.literal('run_ref'), run_id: z.string(), mode: z.string() }).strict(),
+    z.object({ kind: z.literal('followup'), question: z.string(), provider: z.enum(['claude', 'codex', 'agy']), answer: z.string(), call_ms: z.number().nonnegative() }).strict(),
+    z.object({ kind: z.literal('gate_receipt'), gate_kind: z.string(), summary: z.string(), decision: z.string() }).strict(),
+    z.object({ kind: z.literal('error'), message: z.string() }).strict(),
+]);
+function registryPath(root) {
+    return join(root, 'threads.jsonl');
+}
+function threadLogPath(root, id) {
+    return join(root, 'threads', `${id}.jsonl`);
+}
+export async function readThreads(root) {
+    let raw;
+    try {
+        raw = await readFile(registryPath(root), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const byId = new Map();
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = ThreadEntry.parse(JSON.parse(line));
+            byId.set(e.id, e);
+        }
+        catch {
+            /* skip a malformed/legacy line */
+        }
+    }
+    return [...byId.values()].sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+}
+export async function appendThread(root, entry) {
+    await mkdir(root, { recursive: true });
+    await appendFile(registryPath(root), `${JSON.stringify(ThreadEntry.parse(entry))}\n`);
+}
+export async function appendTurn(root, id, turn) {
+    await mkdir(join(root, 'threads'), { recursive: true });
+    await appendFile(threadLogPath(root, id), `${JSON.stringify(ThreadTurn.parse(turn))}\n`);
+}
+export async function readTurns(root, id) {
+    let raw;
+    try {
+        raw = await readFile(threadLogPath(root, id), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const turns = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            turns.push(ThreadTurn.parse(JSON.parse(line)));
+        }
+        catch {
+            /* skip a malformed line */
+        }
+    }
+    return turns;
+}
+const SESSION_TO_THREAD_STATUS = {
+    running: 'running',
+    ok: 'complete',
+    failed: 'failed',
+    aborted: 'cancelled',
+};
+/** Project the legacy sessions.jsonl into read-only single-run thread rows. Titles come from the
+ *  run's own input (idea text) when available; code-review runs (a diff) get a synthesized label. */
+export async function legacyThreads() {
+    const sessions = await readSessions();
+    return Promise.all(sessions.map(sessionToThreadItem));
+}
+async function sessionToThreadItem(s) {
+    return {
+        id: s.id,
+        title: await legacyTitle(s),
+        updatedAt: s.startedAt,
+        status: SESSION_TO_THREAD_STATUS[s.status],
+        mode: null,
+        legacy: true,
+    };
+}
+async function legacyTitle(s) {
+    if (s.workflow === 'code-review')
+        return `Code review · ${s.startedAt.slice(0, 10)}`;
+    try {
+        const dir = runDir(s.id, s.runsRoot);
+        const original = await readFile(join(dir, '00-original.md'), 'utf8');
+        const firstLine = original.split('\n').find((l) => l.trim()) ?? '';
+        return threadTitle(firstLine) || `${s.workflow} · ${s.startedAt.slice(0, 10)}`;
+    }
+    catch {
+        return `${s.workflow} · ${s.startedAt.slice(0, 10)}`;
+    }
+}
+/** Read-only detail for a legacy thread: the run's final report, path-sanitized. Returns null when
+ *  the run id isn't a known legacy session. Live threads (HD3) render from their turn log instead. */
+export async function legacyThreadDetail(id) {
+    const sessions = await readSessions();
+    const s = sessions.find((x) => x.id === id);
+    if (!s)
+        return null;
+    const dir = runDir(s.id, s.runsRoot);
+    const report = await readFinalReport(dir);
+    const title = await legacyTitle(s);
+    return {
+        id: s.id,
+        title,
+        legacy: true,
+        resumeRunId: null,
+        turns: report
+            ? [{ kind: 'report_md', markdown: sanitizeLocalPaths(report) }]
+            : [{ kind: 'note', text: 'This run left no final report (it did not complete).' }],
+    };
+}