@vale-dinap/lucidly 0.0.0-stage → 0.1.0

package/dist/core/events.js

@@ -0,0 +1,5 @@
+/**
+ * Normalized, agent-agnostic events. Adapters produce these; the engine consumes them.
+ * This is the stable contract between "how an agent talks" and "how Lucidly draws it".
+ */
+export {};

package/dist/core/model.js

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

package/dist/core/text.js

@@ -0,0 +1,253 @@
+/** Text heuristics shared by the engine: intent titles, plan extraction, step matching. */
+export function truncate(s, max) {
+    const t = s.replace(/\s+/g, ' ').trim();
+    if (t.length <= max)
+        return t;
+    const cut = t.slice(0, max - 1);
+    const sp = cut.lastIndexOf(' ');
+    return (sp > max * 0.6 ? cut.slice(0, sp) : cut).replace(/[\s,;:.-]+$/, '') + '…';
+}
+export function stripMarkdown(s) {
+    return s
+        .replace(/\[([^\]]*)\]\([^)]*\)/g, '$1')
+        .replace(/[*_`~]+/g, '')
+        .replace(/^#+\s*/, '')
+        .trim();
+}
+function capitalize(s) {
+    return s ? s[0].toUpperCase() + s.slice(1) : s;
+}
+const INTENT_CUE = /\b(?:let me|let's|i'll|i will|i'm going to|i am going to|i need to|i'm now going to|next,? i'll|now i'll|time to)\s+/i;
+/** Split prose into sentences, ignoring code blocks, headings and list items. */
+export function sentences(text) {
+    const noCode = text.replace(/```[\s\S]*?```/g, ' ');
+    const out = [];
+    for (const line of noCode.split(/\n+/)) {
+        const l = line.trim();
+        if (!l || /^(#|\||[-*+]\s|\d+[.)]\s)/.test(l))
+            continue;
+        for (const s of l.split(/(?<=[.!?])\s+(?=[A-Z"'(`*])/)) {
+            const c = stripMarkdown(s).trim();
+            if (c)
+                out.push(c);
+        }
+    }
+    return out;
+}
+/**
+ * Derive a short step title from narration, favouring the sentence that states intent:
+ * "Good. Now let me run the tests." → "Run the tests".
+ */
+export function intentTitle(text, max = 90) {
+    const ss = sentences(text);
+    if (ss.length === 0)
+        return truncate(stripMarkdown(text), max) || 'Working';
+    for (const s of ss) {
+        const m = INTENT_CUE.exec(s);
+        if (m) {
+            const rest = s
+                .slice(m.index + m[0].length)
+                .replace(/^(?:now|first|also|then|quickly|just)\s+/i, '')
+                .replace(/^(?:start|begin) (?:by|with)\s+/i, '')
+                .replace(/[.:!]+$/, '');
+            if (rest.length > 3)
+                return truncate(capitalize(rest), max);
+        }
+    }
+    // A terse opener ("All pass.") followed by more text: the next sentence says more.
+    const pick = ss.length > 1 && ss[0].split(/\s+/).length <= 3 ? ss[1] : ss[0];
+    return truncate(pick.replace(/[.:]+$/, ''), max);
+}
+/** True when the text carries an explicit intent statement. */
+export function hasIntent(text) {
+    return sentences(text).some((s) => INTENT_CUE.test(s));
+}
+const PLAN_CUE = /\b(plan|steps?|order of work|approach|roadmap|todo|to-do|phases?|i'll|i will|going to|let me|let's|first|then|next)\b/i;
+function cleanItem(s) {
+    let t = stripMarkdown(s);
+    if (t.length > 60) {
+        const m = /^(.{6,60}?)(?::\s| — | – | - )/.exec(t);
+        if (m)
+            t = m[1];
+    }
+    return truncate(t.replace(/[.;:]+$/, ''), 90);
+}
+/**
+ * Find a plan-shaped list in narration. Numbered lists (1., 2., ...) qualify on their own;
+ * bulleted lists need a planning cue in the line(s) right before them.
+ * With `requireCue`, numbered lists also need the cue (used for re-planning mid-goal).
+ */
+export function extractPlan(text, requireCue = false) {
+    const lines = text.replace(/```[\s\S]*?```/g, '').split('\n');
+    let best = null;
+    let i = 0;
+    while (i < lines.length) {
+        const num = /^\s{0,3}(\d{1,2})[.)]\s+(.+)$/.exec(lines[i]);
+        const bul = /^\s{0,1}[-*+]\s+(.+)$/.exec(lines[i]);
+        if (!num && !bul) {
+            i++;
+            continue;
+        }
+        const numbered = !!num;
+        const start = i;
+        const items = [];
+        let expect = 1;
+        while (i < lines.length) {
+            const l = lines[i];
+            if (numbered) {
+                const m = /^\s{0,3}(\d{1,2})[.)]\s+(.+)$/.exec(l);
+                if (m && Number(m[1]) === expect) {
+                    items.push(m[2]);
+                    expect++;
+                    i++;
+                    continue;
+                }
+            }
+            else {
+                const m = /^\s{0,1}[-*+]\s+(.+)$/.exec(l);
+                if (m) {
+                    items.push(m[1]);
+                    i++;
+                    continue;
+                }
+            }
+            // allow indented continuation / sub-items and blank lines inside the list
+            if (/^\s{2,}\S/.test(l) || (l.trim() === '' && i + 1 < lines.length && /^\s{0,3}(\d{1,2}[.)]|[-*+])\s/.test(lines[i + 1]))) {
+                i++;
+                continue;
+            }
+            break;
+        }
+        if (i === start)
+            i++;
+        if (numbered && items.length > 0 && !/^\s{0,3}1[.)]/.test(lines[start]))
+            items.length = 0;
+        if (items.length >= 2 && (!best || items.length > best.items.length))
+            best = { start, items, numbered };
+    }
+    if (!best)
+        return null;
+    const before = lines.slice(0, best.start).filter((l) => l.trim());
+    const lead = before.slice(-2).join(' ');
+    const cue = PLAN_CUE.test(lead);
+    if ((!best.numbered || requireCue) && !cue)
+        return null;
+    const items = best.items.map(cleanItem).filter((s) => s.length > 1);
+    if (items.length < 2)
+        return null;
+    if (best.items.some((s) => s.length > 400))
+        return null;
+    return { intro: stripMarkdown(lead), items };
+}
+const STOP = new Set('the and for with that this from into then than them they have has had was were are will would should could can let lets now next also just some more most very what when where which while who why how all any each its it’s it\'s our you your not but out use using about over under after before again first second third step steps i\'ll done make sure need needs check'.split(' '));
+function stem(w) {
+    return w.replace(/(?:ing|ed|es|s)$/, '') || w;
+}
+export function tokens(s) {
+    const out = new Set();
+    for (const w of s.toLowerCase().match(/[a-z0-9][a-z0-9_-]*/g) ?? []) {
+        if (w.length < 3 || STOP.has(w))
+            continue;
+        out.add(stem(w));
+    }
+    return out;
+}
+export function similarity(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let common = 0;
+    for (const t of a)
+        if (b.has(t))
+            common++;
+    return common / Math.sqrt(a.size * b.size);
+}
+/**
+ * Pick which plan step a narration refers to.
+ * Returns an index into `steps`, or -1 when nothing matches well enough.
+ */
+export function matchStep(text, steps, current) {
+    const explicit = /\b(?:step|phase|part)\s+#?(\d{1,2})\b/i.exec(text);
+    if (explicit) {
+        const idx = Number(explicit[1]) - 1;
+        if (idx >= 0 && idx < steps.length)
+            return idx;
+    }
+    // Use the intent sentence(s) rather than the whole message: long messages match everything.
+    const focus = sentences(text).slice(0, 3).join(' ');
+    const t = tokens(focus || text);
+    let best = -1;
+    let bestScore = 0;
+    const from = Math.max(0, current);
+    for (let i = from; i < steps.length; i++) {
+        if (steps[i].done && i !== current)
+            continue;
+        const score = similarity(t, tokens(steps[i].title)) - 0.04 * Math.max(0, i - from - 1);
+        if (score > bestScore) {
+            bestScore = score;
+            best = i;
+        }
+    }
+    return bestScore >= 0.3 ? best : -1;
+}
+const DEVIATION = /\b(fix|fixing|fixed|retry|retrying|try again|instead|workaround|missing|failed|failing|fails|error|errors|broken|doesn't work|didn't work|not found|unexpected|turns out|wrong|bug|investigate|debug|debugging|revert)\b/i;
+export function hasDeviationCue(text) {
+    return DEVIATION.test(sentences(text).slice(0, 2).join(' ') || text);
+}
+/** Is this user message the start of a new task, or a short reply within the current one? */
+const REPLY = /^(yes|yep|yeah|yup|y|no|nope|ok|okay|k|sure|go|go ahead|go on|do it|do so|proceed|continue|carry on|keep going|please do|please|sounds good|looks good|lgtm|agreed|right|correct|exactly|perfect|great|thanks|thank you|both|neither|either|the (first|second|third|last) one|option \w+|\d+)\b/i;
+const HOUSEKEEPING = /^\/(compact|clear|model|config|cost|context|status|help|memory|permissions|login|logout|doctor|resume|fast|effort|theme|usage|statusline)\b/i;
+/**
+ * A short message that answers the agent rather than giving it something new: an approval,
+ * a choice, or anything at all when the agent's last words asked a question.
+ */
+export function isReply(text, agentAsked) {
+    const t = text.trim();
+    // Housekeeping commands never start a task; any other slash command is a new request.
+    if (HOUSEKEEPING.test(t))
+        return true;
+    if (t.startsWith('/'))
+        return false;
+    if (isSubstantivePrompt(t))
+        return false;
+    return agentAsked || REPLY.test(text.trim());
+}
+/** The agent's words end by asking the user something. */
+export function endsWithQuestion(text) {
+    return /\?\s*(\*+|_+|\)|")?\s*$/.test(text.trim());
+}
+export function isSubstantivePrompt(text) {
+    const t = text.trim();
+    const words = t.split(/\s+/).filter(Boolean).length;
+    return words >= 6 || t.length >= 40;
+}
+const ERROR_LINE = /\b(error|exception|failed|failure|fatal|denied|not found|cannot|can't|unable|invalid|refused|timed? ?out|traceback|panic|undefined|missing)\b|✗|✖|FAIL\b/i;
+/**
+ * One-line summary of a failure. Prefers the most telling line (a Python traceback's last line,
+ * an "error:" line) over boilerplate such as "Exit code 1", and keeps the exit code as a prefix.
+ */
+export function issueSummary(output, max = 160) {
+    const lines = output.split('\n').map((l) => l.trim()).filter(Boolean);
+    if (!lines.length)
+        return 'Failed';
+    let exit = '';
+    const m = /^exit code (\d+)$/i.exec(lines[0]);
+    if (m) {
+        const hint = { '124': 'timed out', '126': 'not executable', '127': 'command not found', '130': 'interrupted', '137': 'killed', '143': 'terminated' };
+        exit = `exit ${m[1]}${hint[m[1]] ? ` (${hint[m[1]]})` : ''}`;
+        lines.shift();
+    }
+    if (!lines.length)
+        return exit || 'Failed';
+    const tracebackEnd = lines.some((l) => /^Traceback \(most recent call last\)/.test(l))
+        ? lines.slice().reverse().find((l) => /^[A-Za-z_.]+(Error|Exception|Exit|Interrupt)\b/.test(l))
+        : undefined;
+    // No error-looking line: output usually ends with the failure, not starts with it.
+    const pick = tracebackEnd ??
+        lines.find((l) => ERROR_LINE.test(l) && !/^at\s/.test(l) && !/^Traceback \(most recent/.test(l)) ??
+        lines[lines.length - 1];
+    return truncate(exit ? `${exit} · ${stripMarkdown(pick)}` : pick, max);
+}
+export function firstLine(s, max = 160) {
+    const l = s.split('\n').find((x) => x.trim()) ?? '';
+    return truncate(l, max);
+}

package/dist/outline.js

@@ -0,0 +1,73 @@
+export function filterActions(e, rows, o) {
+    const goalIds = o.goals ? new Set(e.run.goals.slice(-o.goals)) : null;
+    const q = o.grep?.toLowerCase();
+    return rows.filter((r) => (!o.kinds?.length || o.kinds.includes(r.kind)) &&
+        (!o.errorsOnly || r.status === 'failed') &&
+        (!goalIds || (r.goalId && goalIds.has(r.goalId))) &&
+        (!q || [r.title, r.command, r.step, r.input].some((s) => s?.toLowerCase().includes(q))));
+}
+const time = (ts) => (ts ? new Date(ts).toLocaleTimeString([], { hour12: false }) : '--:--:--');
+/** Chronological action list for terminals: one line per action, grouped under its task. */
+export function actionList(e, o = {}) {
+    const rows = filterActions(e, e.actions(o.full ? 1_000_000 : 4000), o);
+    const out = [];
+    let goal;
+    for (const r of rows) {
+        if (r.goalId !== goal) {
+            goal = r.goalId;
+            out.push(`\n■ ${r.goal ?? 'Session'}`);
+        }
+        const mark = r.status === 'failed' ? '✖' : r.status === 'active' ? '▶' : '✔';
+        const what = r.command !== undefined ? `$ ${o.full ? r.command : (r.short ?? firstLineOf(r.command))}` : r.title;
+        const where = [r.subagent ? `subagent: ${r.subagent}` : '', r.step ?? ''].filter(Boolean).join(' › ');
+        out.push(`${time(r.startedAt)}  ${mark}  ${what}${r.retry ? '  (retry)' : ''}${where ? `    [${where}]` : ''}`);
+        if (r.status === 'failed' && r.issue)
+            out.push(`            └ ${r.issue}${r.recovered ? '  (recovered)' : ''}`);
+    }
+    const failed = rows.filter((r) => r.status === 'failed').length;
+    const recovered = rows.filter((r) => r.status === 'failed' && r.recovered).length;
+    out.push(`\n${rows.length} actions${failed - recovered ? `, ${failed - recovered} failed` : ''}${recovered ? `, ${recovered} recovered after failing` : ''}`);
+    return out.join('\n').replace(/^\n/, '');
+}
+function firstLineOf(s) {
+    const lines = s.split('\n');
+    return lines[0] + (lines.length > 1 ? ' …' : '');
+}
+const ICON = {
+    done: '✔',
+    active: '▶',
+    pending: '○',
+    failed: '✖',
+    open: '⛔',
+    resolved: '✓',
+    waiting: '⏸',
+};
+export function outline(e, opts = {}) {
+    const out = [];
+    const r = e.run;
+    out.push(`${r.title ?? 'Run'} — ${r.agent ?? 'agent'} · ${r.status} · ${r.goals.length} goals · ${r.eventCount} events`);
+    const show = (id, depth) => {
+        const n = e.nodes.get(id);
+        if (!n)
+            return;
+        const pad = '  '.repeat(depth);
+        if (n.type === 'activity') {
+            if (opts.activities)
+                out.push(`${pad}${ICON[n.status] ?? '·'} ${n.title}${n.retry ? ' (retry)' : ''}${n.issue ? ` — ${n.issue}` : ''}`);
+            return;
+        }
+        const stats = n.stats && n.type !== 'goal' ? `  [${n.stats.actions} actions${n.stats.errors ? `, ${n.stats.errors} errors` : ''}]` : '';
+        const origin = n.origin && n.origin !== 'inferred' && n.origin !== 'plan' ? ` (${n.origin})` : '';
+        out.push(`${pad}${ICON[n.status] ?? '·'} ${n.type === 'goal' ? 'GOAL ' : n.type === 'step' ? '' : n.type + ': '}${n.title}${origin}${stats}`);
+        if (n.type === 'goal' && n.intent)
+            out.push(`${pad}    intent: ${n.intent}`);
+        for (const c of n.children)
+            show(c, depth + 1);
+        if (n.type === 'goal' && n.outcome)
+            out.push(`${pad}    outcome: ${n.outcome}`);
+    };
+    const goals = opts.goals ? r.goals.slice(-opts.goals) : r.goals;
+    for (const g of goals)
+        show(g, 0);
+    return out.join('\n');
+}

package/dist/server/server.js

@@ -0,0 +1,286 @@
+/**
+ * Local HTTP server: static web UI, JSON API, and Server-Sent Events for live updates.
+ * Binds to 127.0.0.1 only and rejects foreign Host headers (DNS rebinding) and
+ * cross-site writes (POST bodies must be JSON, which forces a CORS preflight we never answer).
+ */
+import { createServer } from 'node:http';
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { extname, normalize, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { RunSession } from "./session.js";
+import { ClaudeSessionSource, findSession, listSessions } from "../sources/claude-sessions.js";
+const WEB_DIR = fileURLToPath(new URL('../../web/', import.meta.url));
+const SRC_DIR = fileURLToPath(new URL('../', import.meta.url));
+const STARTED = Date.now();
+/**
+ * Whether the server's own code changed on disk since it started. The web UI is read from
+ * disk on every request, so a running server can serve a newer page than its engine knows
+ * about: the page says so, rather than quietly missing data.
+ */
+async function codeChangedSince(t) {
+    try {
+        const files = await readdir(SRC_DIR, { recursive: true });
+        for (const f of files) {
+            if (!String(f).endsWith('.ts'))
+                continue;
+            if ((await stat(resolve(SRC_DIR, String(f)))).mtimeMs > t)
+                return true;
+        }
+    }
+    catch {
+        // Installed without sources nearby: nothing to compare.
+    }
+    return false;
+}
+const MAX_BODY = 512 * 1024 * 1024;
+const LIVE_MS = 3 * 60 * 1000;
+const TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.json': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.ico': 'image/x-icon',
+};
+export class LucidlyServer {
+    runs = new Map();
+    byKey = new Map();
+    seq = 0;
+    server = null;
+    port = 0;
+    cwd;
+    wantPort;
+    constructor(opts) {
+        this.wantPort = opts.port;
+        this.cwd = opts.cwd;
+    }
+    get url() {
+        return `http://127.0.0.1:${this.port}/`;
+    }
+    /** Listen on the requested port, or the next free one. */
+    async listen() {
+        for (let p = this.wantPort; p < this.wantPort + 20; p++) {
+            try {
+                await new Promise((ok, fail) => {
+                    const s = createServer((req, res) => void this.handle(req, res));
+                    s.once('error', fail);
+                    s.listen(p, '127.0.0.1', () => {
+                        s.off('error', fail);
+                        this.server = s;
+                        this.port = s.address().port;
+                        ok();
+                    });
+                });
+                return;
+            }
+            catch (e) {
+                if (e?.code !== 'EADDRINUSE' || this.wantPort === 0)
+                    throw e;
+            }
+        }
+        throw new Error(`No free port from ${this.wantPort}`);
+    }
+    async close() {
+        for (const r of this.runs.values())
+            r.close();
+        this.server?.closeAllConnections?.();
+        await new Promise((ok) => (this.server ? this.server.close(() => ok()) : ok()));
+    }
+    /** Open (or reuse) a run for a source. */
+    async open(source) {
+        const existing = this.byKey.get(source.key);
+        if (existing && this.runs.has(existing))
+            return this.runs.get(existing);
+        const run = new RunSession(`r${++this.seq}`, source);
+        this.runs.set(run.id, run);
+        this.byKey.set(run.key, run.id);
+        await run.start();
+        return run;
+    }
+    addRun(make) {
+        const run = make(`r${++this.seq}`);
+        this.runs.set(run.id, run);
+        this.byKey.set(run.key, run.id);
+        return run;
+    }
+    closeRun(id) {
+        const r = this.runs.get(id);
+        if (!r)
+            return false;
+        r.close();
+        this.runs.delete(id);
+        this.byKey.delete(r.key);
+        return true;
+    }
+    // ───────────────────────────── HTTP
+    hostOk(req) {
+        const host = (req.headers.host ?? '').toLowerCase();
+        return [`127.0.0.1:${this.port}`, `localhost:${this.port}`, `[::1]:${this.port}`].includes(host);
+    }
+    async handle(req, res) {
+        try {
+            if (!this.hostOk(req))
+                return send(res, 403, { error: 'forbidden host' });
+            const url = new URL(req.url ?? '/', 'http://localhost');
+            const path = url.pathname;
+            if (req.method === 'POST' || req.method === 'DELETE') {
+                const origin = req.headers.origin;
+                if (origin && origin !== `http://${req.headers.host}`)
+                    return send(res, 403, { error: 'forbidden origin' });
+                if (req.method === 'POST' && !String(req.headers['content-type'] ?? '').startsWith('application/json')) {
+                    return send(res, 415, { error: 'JSON body required' });
+                }
+            }
+            if (path.startsWith('/api/'))
+                return await this.api(req, res, path, url);
+            if (req.method !== 'GET')
+                return send(res, 405, { error: 'method not allowed' });
+            return await this.static(res, path);
+        }
+        catch (e) {
+            if (!res.headersSent)
+                send(res, 500, { error: String(e?.message ?? e) });
+            else
+                res.end();
+        }
+    }
+    async api(req, res, path, url) {
+        const m = /^\/api\/s\/([^/]+)(?:\/([a-z]+)(?:\/([^/]+))?)?$/.exec(path);
+        if (m) {
+            const run = this.runs.get(m[1]);
+            if (!run)
+                return send(res, 404, { error: 'no such run' });
+            const [, , action, arg] = m;
+            if (!action && req.method === 'DELETE')
+                return send(res, 200, { closed: this.closeRun(run.id) });
+            if (action === 'stream')
+                return this.stream(req, res, run);
+            if (action === 'raw' && arg) {
+                if (!run.engine.nodes.has(arg))
+                    return send(res, 404, { error: 'no such node' });
+                return send(res, 200, { node: arg, chunks: run.engine.raw(arg, url.searchParams.get('own') === '1') });
+            }
+            if (action === 'actions') {
+                const cap = Math.min(Number(url.searchParams.get('cap')) || 1200, 20000);
+                return send(res, 200, { actions: run.engine.actions(cap) });
+            }
+            if (action === 'save') {
+                const name = slug(run.engine.run.title ?? run.label) + '.lucidly.json';
+                res.writeHead(200, {
+                    'content-type': 'application/json; charset=utf-8',
+                    'content-disposition': `attachment; filename="${name}"`,
+                    'cache-control': 'no-store',
+                });
+                res.end(JSON.stringify(run.save()));
+                return;
+            }
+            return send(res, 404, { error: 'unknown action' });
+        }
+        if (path === '/api/health' && req.method === 'GET') {
+            return send(res, 200, { startedAt: new Date(STARTED).toISOString(), outdated: await codeChangedSince(STARTED) });
+        }
+        if (path === '/api/runs' && req.method === 'GET') {
+            return send(res, 200, { runs: [...this.runs.values()].map((r) => r.info()) });
+        }
+        if (path === '/api/sessions' && req.method === 'GET') {
+            const all = url.searchParams.get('scope') === 'all';
+            const sessions = await listSessions({ cwd: all ? undefined : this.cwd, limit: all ? 60 : 30 });
+            const now = Date.now();
+            return send(res, 200, {
+                cwd: this.cwd,
+                scope: all ? 'all' : 'project',
+                sessions: sessions.map((s) => ({
+                    ...s,
+                    live: now - s.mtime < LIVE_MS,
+                    run: this.byKey.get(new ClaudeSessionSource(s.path).key),
+                })),
+            });
+        }
+        if (path === '/api/open' && req.method === 'POST') {
+            const body = (await readJson(req));
+            const target = body.path ?? (body.id ? await findSession(body.id) : null);
+            if (!target || !target.endsWith('.jsonl'))
+                return send(res, 400, { error: 'session not found' });
+            try {
+                await stat(target);
+            }
+            catch {
+                return send(res, 404, { error: 'session file not found' });
+            }
+            const run = await this.open(new ClaudeSessionSource(target));
+            return send(res, 200, { run: run.info() });
+        }
+        if (path === '/api/load' && req.method === 'POST') {
+            const data = await readJson(req);
+            try {
+                const run = this.addRun((id) => RunSession.fromSave(id, data));
+                return send(res, 200, { run: run.info() });
+            }
+            catch (e) {
+                return send(res, 400, { error: String(e?.message ?? e) });
+            }
+        }
+        return send(res, 404, { error: 'not found' });
+    }
+    stream(req, res, run) {
+        res.writeHead(200, {
+            'content-type': 'text/event-stream; charset=utf-8',
+            'cache-control': 'no-store',
+            connection: 'keep-alive',
+            'x-accel-buffering': 'no',
+        });
+        res.write('retry: 2000\n\n');
+        const unsubscribe = run.subscribe((event, data) => {
+            res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+        });
+        const ping = setInterval(() => res.write(': ping\n\n'), 15000);
+        req.on('close', () => {
+            clearInterval(ping);
+            unsubscribe();
+        });
+    }
+    async static(res, path) {
+        const rel = path === '/' ? 'index.html' : decodeURIComponent(path).replace(/^\/+/, '');
+        const full = resolve(WEB_DIR, normalize(rel));
+        if (!full.startsWith(resolve(WEB_DIR) + sep) && full !== resolve(WEB_DIR))
+            return send(res, 403, { error: 'forbidden' });
+        let body;
+        try {
+            body = await readFile(full);
+        }
+        catch {
+            return send(res, 404, { error: 'not found' });
+        }
+        res.writeHead(200, {
+            'content-type': TYPES[extname(full)] ?? 'application/octet-stream',
+            'cache-control': 'no-cache',
+            'x-content-type-options': 'nosniff',
+            'content-security-policy': "default-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:",
+        });
+        res.end(body);
+    }
+}
+function send(res, status, body) {
+    res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+    res.end(JSON.stringify(body));
+}
+async function readJson(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const c of req) {
+        size += c.length;
+        if (size > MAX_BODY)
+            throw new Error('body too large');
+        chunks.push(c);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}');
+}
+function slug(s) {
+    return (s
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 60) || 'run');
+}
+export { WEB_DIR };