@asrunjs/asrun 0.0.0-stage → 0.2.0

package/dist/ui/server/ai-stream.js

@@ -0,0 +1,202 @@
+const MAX_DETAIL = 180;
+const MAX_ERROR = 300;
+const SANDBOX_ERROR = /listen EPERM|outside of the sandbox|sandbox/i;
+const clock = (at = Date.now()) => new Date(at).toTimeString().slice(0, 8);
+const oneLine = (value, max) => {
+    const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+};
+const seconds = (ms) => (ms < 90_000 ? `${Math.round(ms / 1000)} s` : `${(ms / 60_000).toFixed(1)} min`);
+/** `mcp__playwright-test__browser_click` -> `browser_click`. */
+const toolName = (name) => name.replace(/^mcp__[^_]+(?:-[^_]+)*__/, '');
+/** What the call is about, in a few words: the intent the agent gave, or the most telling argument. */
+function describe(input) {
+    if (!input || typeof input !== 'object')
+        return '';
+    const args = input;
+    const key = ['intent', 'description', 'skill', 'command', 'file_path', 'filename', 'url', 'element', 'query'].find((name) => typeof args[name] === 'string' && args[name]);
+    return key ? oneLine(args[key], MAX_DETAIL) : '';
+}
+const callLabel = (name, input) => {
+    const detail = describe(input);
+    return detail ? `${toolName(name)}: ${detail}` : toolName(name);
+};
+const HANDOFF_CFG = '__handoffCfg';
+const HANDOFF_CARD = /handoff-card\.js$/;
+/** `message: '...'` of the options call that comes right before the card. */
+function handoffMessage(code) {
+    const match = /message\s*:\s*(['"`])((?:\\.|(?!\1)[^\\])*)\1/.exec(code);
+    return match ? match[2].replace(/\\(['"`\\])/g, '$1').trim() || null : null;
+}
+function handoffCall(name, input) {
+    if (!name.includes('browser_run_code') || !input || typeof input !== 'object')
+        return null;
+    const args = input;
+    if (typeof args.code === 'string' && args.code.includes(HANDOFF_CFG))
+        return 'options';
+    if (typeof args.filename === 'string' && HANDOFF_CARD.test(args.filename))
+        return 'card';
+    return null;
+}
+export class AiStreamFormatter {
+    tool;
+    buffer = '';
+    pending = new Map();
+    cardCalls = new Set();
+    waitingForUser = null;
+    lastEventAt = Date.now();
+    lastWaitAt = 0;
+    sandboxHinted = false;
+    constructor(tool) {
+        this.tool = tool;
+    }
+    /** Lines for a piece of stdout. Incomplete trailing lines wait for the next piece. */
+    feed(text) {
+        this.buffer += text;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() ?? '';
+        return lines.map((line) => this.line(line)).join('');
+    }
+    /**
+     * Set while a handoff card waits for the person. OpenCode reports a tool call only when it has finished, so the card
+     * call itself is not visible while it waits: the options call before it (`__handoffCfg`) starts the state and the end
+     * of the card call, or any other call, ends it. The object changes on every new handoff, so `===` detects a change.
+     */
+    get awaiting() {
+        return this.waitingForUser;
+    }
+    /** Called once for every tool call the agent makes, with the id the end of that call will carry. */
+    watchHandoff(id, name, input, ended) {
+        const kind = handoffCall(name, input);
+        if (kind === 'options') {
+            const code = String(input.code);
+            this.waitingForUser = { message: handoffMessage(code), since: Date.now() };
+        }
+        else if (kind === 'card') {
+            if (ended)
+                this.waitingForUser = null;
+            else {
+                this.cardCalls.add(id);
+                this.waitingForUser ??= { message: null, since: Date.now() };
+            }
+        }
+        else {
+            this.waitingForUser = null;
+        }
+    }
+    /** What is left when the process ends. */
+    end() {
+        const rest = this.buffer;
+        this.buffer = '';
+        return rest.trim() ? this.line(rest) : '';
+    }
+    /**
+     * A line about the oldest tool call that has not returned, when nothing has happened for `quietMs` (and again every
+     * `quietMs` after that).
+     */
+    waiting(quietMs) {
+        const now = Date.now();
+        if (now - Math.max(this.lastEventAt, this.lastWaitAt) < quietMs)
+            return '';
+        this.lastWaitAt = now;
+        const [first] = [...this.pending.values()].sort((a, b) => a.startedAt - b.startedAt);
+        const quiet = seconds(now - this.lastEventAt);
+        return first
+            ? `[${clock(now)}] ... still waiting for ${first.label} (running ${seconds(now - first.startedAt)})\n`
+            : `[${clock(now)}] ... no output from the agent for ${quiet}\n`;
+    }
+    line(raw) {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return '';
+        let event;
+        try {
+            event = JSON.parse(trimmed);
+        }
+        catch {
+            return `${raw}\n`;
+        }
+        if (!event || typeof event !== 'object' || typeof event.type !== 'string')
+            return `${raw}\n`;
+        this.lastEventAt = Date.now();
+        return this.tool === 'claude' ? this.claude(event) : this.opencode(event);
+    }
+    start(id, label) {
+        const now = Date.now();
+        this.pending.set(id, { label, startedAt: now });
+        return `[${clock(now)}] >> ${label}\n`;
+    }
+    end1(id, ok, error, fallbackLabel) {
+        const now = Date.now();
+        const call = this.pending.get(id);
+        this.pending.delete(id);
+        if (this.cardCalls.delete(id))
+            this.waitingForUser = null;
+        const label = call?.label ?? fallbackLabel ?? 'tool call';
+        const took = call ? ` after ${seconds(now - call.startedAt)}` : '';
+        const head = `[${clock(now)}] ${ok ? 'ok' : 'FAILED'}: ${label}${took}\n`;
+        return !ok && error ? `${head}    ${oneLine(error, MAX_ERROR)}\n` : head;
+    }
+    /** Said once per run, after the first tool call that Claude Code's sandbox refused (nobody is there to approve it). */
+    sandboxHint(isError, body) {
+        if (this.sandboxHinted || !isError || !SANDBOX_ERROR.test(String(body ?? '')))
+            return '';
+        this.sandboxHinted = true;
+        return (`[${clock()}] HINT: Claude Code's sandbox blocked a command and a one-shot run cannot approve it. Options:\n` +
+            '    - Switch the AI agent to OpenCode in the top bar and run again (it does not use this sandbox).\n' +
+            '    - Or run the command yourself in a terminal and paste the output into the agent.\n' +
+            '    - Or check that the command matches "sandbox.excludedCommands" in .claude/settings.json (every command of a chained call must match).\n');
+    }
+    claude(event) {
+        const content = event.message?.content;
+        if (event.type === 'assistant' && Array.isArray(content)) {
+            return content
+                .map((block) => {
+                if (block?.type === 'text' && block.text?.trim())
+                    return `${block.text.trimEnd()}\n`;
+                if (block?.type === 'tool_use') {
+                    this.watchHandoff(String(block.id), String(block.name), block.input, false);
+                    return this.start(String(block.id), callLabel(String(block.name), block.input));
+                }
+                return '';
+            })
+                .join('');
+        }
+        if (event.type === 'user' && Array.isArray(content)) {
+            return content
+                .filter((block) => block?.type === 'tool_result')
+                .map((block) => {
+                const body = Array.isArray(block.content)
+                    ? block.content.map((part) => part?.text ?? '').join(' ')
+                    : block.content;
+                return this.end1(String(block.tool_use_id), !block.is_error, body) + this.sandboxHint(block.is_error, body);
+            })
+                .join('');
+        }
+        if (event.type === 'result' && event.is_error) {
+            return `[${clock()}] FAILED: ${oneLine(event.result ?? event.subtype, MAX_ERROR)}\n`;
+        }
+        return '';
+    }
+    opencode(event) {
+        const part = event.part ?? {};
+        if (event.type === 'text' && typeof part.text === 'string' && part.text.trim())
+            return `${part.text.trimEnd()}\n`;
+        if (event.type === 'tool_use') {
+            const state = part.state ?? {};
+            const label = callLabel(String(part.tool ?? 'tool'), state.input);
+            const id = String(part.callID ?? part.id ?? label);
+            const finished = state.status === 'completed' || state.status === 'error';
+            this.watchHandoff(id, String(part.tool ?? ''), state.input, finished);
+            if (finished) {
+                const time = state.time ?? {};
+                if (!this.pending.has(id) && typeof time.start === 'number') {
+                    this.pending.set(id, { label, startedAt: time.start });
+                }
+                return this.end1(id, state.status === 'completed', state.error ?? state.output, label);
+            }
+            return this.start(id, label);
+        }
+        return '';
+    }
+}

package/dist/ui/server/app.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+export declare function createApp({ port }: {
+    port: number;
+}): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/ui/server/app.js

@@ -0,0 +1,333 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { z } from 'zod';
+import { listBaselines, snapshotsDir } from '../../lib/baselines.js';
+import { listEnvs } from '../../lib/profiles.js';
+import { listSuites } from '../../lib/cases.js';
+import { FRAMEWORK_ROOT, ROOT } from '../../lib/paths.js';
+import { ActionError, buildJobSpec, planRunCases, previewRun, previewSchema, startJobSchema } from './actions.js';
+import { addProfile, listProfileRows, ProfileError, verifyProfiles } from './profiles.js';
+import { CaseError, caseImpact, createCase, deleteCase, isValidCaseId, listCaseIds, listCases, openSpec, readCase, readSpec, renameCase, writeCase, writeSpec, } from './cases.js';
+import { resolveInside, sendFile } from './files.js';
+import { JobConflictError, jobs } from './jobs.js';
+import { fileEvents } from './watch-files.js';
+const REPORTS_DIR = path.join(ROOT, 'reports');
+// Built by `prepack` and shipped with the package; the framework repository builds it with `pnpm ui`.
+const WEB_DIST = path.join(FRAMEWORK_ROOT, 'ui', 'dist');
+// `2026-10-27T16-47-54` (before environments existed, always production) or `2026-10-27T16-47-54-staging`.
+const REPORT_ID = /^(latest|\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}(-[a-z0-9]+(-[a-z0-9]+)*)?)$/;
+const BASELINE_FILE = /^[\w.@-]+\.png$/i;
+const CSRF_HEADER = 'x-asrun-ui';
+function readSummary(id) {
+    const file = resolveInside(REPORTS_DIR, path.join(id, 'summary.json'));
+    if (!file)
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function createApp({ port }) {
+    const app = new Hono();
+    const allowedHosts = new Set([`127.0.0.1:${port}`, `localhost:${port}`]);
+    const allowedOrigins = new Set([...allowedHosts].map((host) => `http://${host}`));
+    // Vite dev server proxies /api to us and keeps its own origin.
+    const devOrigin = process.env.ASRUN_UI_DEV_ORIGIN;
+    if (devOrigin)
+        allowedOrigins.add(devOrigin);
+    // This server can start local processes, so only accept requests that really come from our own pages.
+    app.use('*', async (c, next) => {
+        const host = c.req.header('host') ?? '';
+        if (!allowedHosts.has(host) && !(devOrigin && new URL(devOrigin).host === host)) {
+            return c.text('Forbidden host', 403);
+        }
+        const origin = c.req.header('origin');
+        if (origin && !allowedOrigins.has(origin))
+            return c.text('Forbidden origin', 403);
+        if (!['GET', 'HEAD'].includes(c.req.method)) {
+            if (c.req.header(CSRF_HEADER) !== '1')
+                return c.text('Missing CSRF header', 403);
+        }
+        await next();
+    });
+    app.onError((error, c) => {
+        if (error instanceof ActionError)
+            return c.json({ error: error.message }, 400);
+        if (error instanceof JobConflictError)
+            return c.json({ error: error.message }, 409);
+        if (error instanceof ProfileError)
+            return c.json({ error: error.message }, error.status);
+        if (error instanceof CaseError)
+            return c.json({ error: error.message }, error.status);
+        if (error instanceof z.ZodError)
+            return c.json({ error: 'Invalid request body.' }, 400);
+        console.error(error);
+        return c.json({ error: error instanceof Error ? error.message : 'Internal error' }, 500);
+    });
+    const api = new Hono();
+    api.get('/info', (c) => {
+        let suites = [];
+        try {
+            suites = listSuites();
+        }
+        catch {
+            // A case with broken front matter; the cases page shows it.
+        }
+        return c.json({ root: ROOT, envs: listEnvs(), suites, caseIds: listCaseIds() });
+    });
+    api.get('/profiles', (c) => c.json(listProfileRows()));
+    api.post('/profiles', async (c) => {
+        const body = z
+            .object({
+            id: z.string().max(60),
+            name: z.string().max(100),
+            env: z.string().max(40),
+            baseURL: z.string().max(200),
+            account: z.string().max(200).optional(),
+            tags: z.array(z.string().max(40)).max(20).optional(),
+            sessionCheckPath: z.string().max(200).optional(),
+            email: z.boolean().optional(),
+        })
+            .parse(await c.req.json());
+        return c.json(addProfile(body), 201);
+    });
+    api.post('/profiles/verify', async (c) => {
+        const body = z
+            .object({ profile: z.string().optional(), env: z.string().optional() })
+            .parse(await c.req.json().catch(() => ({})));
+        void verifyProfiles({ ids: body.profile ? [body.profile] : undefined, env: body.env });
+        // Give verifyProfiles a tick to mark the profiles as "verifying".
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        return c.json(listProfileRows());
+    });
+    api.get('/cases', (c) => c.json(listCases()));
+    api.post('/cases', async (c) => {
+        const { id } = z.object({ id: z.string() }).parse(await c.req.json());
+        return c.json(await createCase(id), 201);
+    });
+    // A case id may contain one `/` (`documents/landing-page`), so the id is the whole rest of the path.
+    api.get('/case-impact/:id{.+}', (c) => c.json(caseImpact(c.req.param('id'))));
+    // Moving or deleting files under a running agent or test run would break it.
+    const assertNoRunningWork = () => {
+        const busy = jobs.list().find((job) => job.status === 'running' && (job.kind === 'ai' || job.kind === 'run'));
+        if (busy)
+            throw new CaseError(`Wait for "${busy.command}" to finish first.`, 409);
+    };
+    api.post('/case-rename', async (c) => {
+        const body = z.object({ id: z.string().max(200), to: z.string().max(200) }).parse(await c.req.json());
+        assertNoRunningWork();
+        return c.json(renameCase(body.id, body.to));
+    });
+    api.get('/specs/:id{.+}', (c) => c.json(readSpec(c.req.param('id'))));
+    api.put('/specs/:id{.+}', async (c) => {
+        const body = z.object({ content: z.string(), mtimeMs: z.number() }).parse(await c.req.json());
+        return c.json(writeSpec(c.req.param('id'), body.content, body.mtimeMs));
+    });
+    // Only the spec of a known case, never a path from the browser.
+    api.post('/spec-open', async (c) => {
+        const { id } = z.object({ id: z.string().max(200) }).parse(await c.req.json());
+        await openSpec(id);
+        return c.json({ ok: true });
+    });
+    api.get('/cases/:id{.+}', (c) => c.json(readCase(c.req.param('id'))));
+    api.put('/cases/:id{.+}', async (c) => {
+        const body = z.object({ content: z.string(), mtimeMs: z.number() }).parse(await c.req.json());
+        return c.json(writeCase(c.req.param('id'), body.content, body.mtimeMs));
+    });
+    api.delete('/cases/:id{.+}', (c) => {
+        assertNoRunningWork();
+        return c.json(deleteCase(c.req.param('id')));
+    });
+    // The screenshot baselines of one case, with what each must show. Read-only.
+    api.get('/baselines', (c) => {
+        const caseId = c.req.query('case') ?? '';
+        if (!isValidCaseId(caseId) || !listCaseIds().includes(caseId))
+            return c.json({ error: 'Unknown case.' }, 404);
+        const items = listBaselines([caseId]).map(({ caseId, file, profile, env, changed, mtimeMs, targetId, card, problem }) => ({
+            caseId,
+            file,
+            profile,
+            env,
+            changed,
+            mtimeMs,
+            targetId,
+            card,
+            problem,
+        }));
+        return c.json(items);
+    });
+    // One baseline image. Only a .png that sits directly in the snapshot folder of a known case.
+    app.get('/baseline-files', (c) => {
+        const caseId = c.req.query('case') ?? '';
+        const file = c.req.query('file') ?? '';
+        if (!isValidCaseId(caseId) || !listCaseIds().includes(caseId) || !BASELINE_FILE.test(file))
+            return c.notFound();
+        const dir = snapshotsDir(caseId);
+        if (!fs.existsSync(dir))
+            return c.notFound();
+        const image = resolveInside(dir, file);
+        return image ? sendFile(c, image) : c.notFound();
+    });
+    api.get('/reports', (c) => {
+        if (!fs.existsSync(REPORTS_DIR))
+            return c.json([]);
+        const latestTarget = resolveInside(REPORTS_DIR, 'latest');
+        const reports = fs
+            .readdirSync(REPORTS_DIR)
+            .filter((name) => REPORT_ID.test(name) && name !== 'latest')
+            .filter((name) => fs.existsSync(path.join(REPORTS_DIR, name, 'html', 'index.html')))
+            .sort()
+            .reverse()
+            .map((id) => {
+            const summary = readSummary(id);
+            return {
+                id,
+                // Runs from before environments existed have no env in the id or the summary; they all ran against production.
+                env: summary?.env ?? /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)$/.exec(id)?.[1] ?? null,
+                createdAt: new Date(id.slice(0, 10) + 'T' + id.slice(11, 19).replace(/-/g, ':') + 'Z').toISOString(),
+                isLatest: latestTarget === path.join(fs.realpathSync(REPORTS_DIR), id),
+                counts: summary?.counts ?? null,
+            };
+        });
+        return c.json(reports);
+    });
+    // Per-test results with the error already split into a headline and technical details.
+    api.get('/reports/:id/summary', (c) => {
+        const id = c.req.param('id');
+        if (!REPORT_ID.test(id))
+            return c.json({ error: 'Unknown report.' }, 404);
+        const summary = readSummary(id);
+        return summary ? c.json(summary) : c.json({ error: 'This run has no summary.' }, 404);
+    });
+    api.post('/runs/preview', async (c) => c.json(previewRun(previewSchema.parse(await c.req.json()))));
+    api.post('/runs/plan', async (c) => c.json(await planRunCases(previewSchema.parse(await c.req.json()))));
+    api.get('/jobs', (c) => c.json(jobs.list()));
+    api.post('/jobs', async (c) => {
+        const request = startJobSchema.parse(await c.req.json());
+        return c.json(jobs.start(buildJobSpec(request)), 201);
+    });
+    api.post('/jobs/:id/input', async (c) => {
+        const { text } = z.object({ text: z.string().max(100) }).parse(await c.req.json());
+        return c.json({ ok: jobs.write(c.req.param('id'), text) });
+    });
+    api.post('/jobs/:id/cancel', (c) => c.json({ ok: jobs.cancel(c.req.param('id')) }));
+    // Status changes of any job, so every open page can refresh what depends on them.
+    api.get('/events', (c) => streamSSE(c, async (stream) => {
+        let open = true;
+        const listener = (info) => {
+            if (open)
+                void stream.writeSSE({ event: 'job', data: JSON.stringify(info) }).catch(() => { });
+        };
+        const filesListener = (change) => {
+            if (open)
+                void stream.writeSSE({ event: 'files', data: JSON.stringify(change) }).catch(() => { });
+        };
+        jobs.events.on('job', listener);
+        fileEvents.on('files', filesListener);
+        stream.onAbort(() => {
+            open = false;
+            jobs.events.off('job', listener);
+            fileEvents.off('files', filesListener);
+        });
+        while (open) {
+            await stream.writeSSE({ event: 'ping', data: '' });
+            await stream.sleep(15_000);
+        }
+    }));
+    // Output of one job. Reconnecting with Last-Event-ID replays only what was missed.
+    api.get('/jobs/:id/events', (c) => {
+        const record = jobs.get(c.req.param('id'));
+        if (!record)
+            return c.json({ error: 'Unknown job.' }, 404);
+        const lastId = Number(c.req.header('last-event-id') ?? c.req.query('after') ?? -1);
+        return streamSSE(c, async (stream) => {
+            const queue = [];
+            let wake = null;
+            let aborted = false;
+            const notify = () => wake?.();
+            const onChunk = (chunk) => {
+                queue.push({ event: 'chunk', id: String(chunk.seq), data: JSON.stringify(chunk) });
+                notify();
+            };
+            const onStatus = (info) => {
+                queue.push({ event: 'status', data: JSON.stringify(info) });
+                notify();
+            };
+            // Replay and subscribe in one synchronous step so no chunk can fall in between.
+            for (const chunk of record.chunks)
+                if (chunk.seq > lastId)
+                    onChunk(chunk);
+            record.emitter.on('chunk', onChunk);
+            record.emitter.on('status', onStatus);
+            if (record.info.status !== 'running')
+                onStatus(record.info);
+            stream.onAbort(() => {
+                aborted = true;
+                notify();
+            });
+            try {
+                let done = false;
+                while (!aborted && !done) {
+                    while (queue.length > 0) {
+                        const message = queue.shift();
+                        await stream.writeSSE(message);
+                        if (message.event === 'status' && JSON.parse(message.data).status !== 'running')
+                            done = true;
+                    }
+                    if (done || aborted)
+                        break;
+                    await new Promise((resolve) => {
+                        wake = resolve;
+                        setTimeout(resolve, 15_000);
+                    });
+                    wake = null;
+                }
+            }
+            finally {
+                record.emitter.off('chunk', onChunk);
+                record.emitter.off('status', onStatus);
+            }
+        });
+    });
+    api.all('*', (c) => c.json({ error: 'Not found' }, 404));
+    app.route('/api', api);
+    // The Playwright HTML report, same origin so it can be embedded in an iframe.
+    app.get('/report-files/:id', (c) => c.redirect(`/report-files/${c.req.param('id')}/`));
+    app.get('/report-files/:id/*', (c) => {
+        const id = c.req.param('id');
+        if (!REPORT_ID.test(id))
+            return c.notFound();
+        const prefix = `/report-files/${id}/`;
+        const relative = decodeURIComponent(c.req.path.slice(prefix.length)) || 'index.html';
+        const htmlDir = path.join(REPORTS_DIR, id, 'html');
+        if (!fs.existsSync(htmlDir))
+            return c.notFound();
+        // Joined videos live next to the HTML report (it owns its folder), but are served under the same prefix.
+        const videosDir = path.join(REPORTS_DIR, id, 'videos');
+        if (relative.startsWith('videos/') && fs.existsSync(videosDir)) {
+            const video = resolveInside(videosDir, relative.slice('videos/'.length));
+            return video ? sendFile(c, video) : c.notFound();
+        }
+        let file = resolveInside(htmlDir, relative);
+        if (file && fs.statSync(file).isDirectory())
+            file = resolveInside(htmlDir, path.join(relative, 'index.html'));
+        return file ? sendFile(c, file) : c.notFound();
+    });
+    // The static Inkstone theme guide, linked from the top bar of the UI.
+    app.get('/docs/theme-guide.html', (c) => sendFile(c, path.join(FRAMEWORK_ROOT, 'docs', 'theme-guide.html')));
+    // Built web app (production mode). In dev, Vite serves it and proxies /api here.
+    if (fs.existsSync(WEB_DIST)) {
+        app.get('*', (c) => {
+            const relative = decodeURIComponent(c.req.path).replace(/^\/+/, '') || 'index.html';
+            const file = resolveInside(WEB_DIST, relative);
+            if (file && fs.statSync(file).isFile())
+                return sendFile(c, file);
+            return sendFile(c, path.join(WEB_DIST, 'index.html'));
+        });
+    }
+    return app;
+}

package/dist/ui/server/cases.d.ts

@@ -0,0 +1,23 @@
+import { isValidCaseId } from '../../lib/case-id.js';
+import { CaseError } from '../../lib/case-ops.js';
+import { listCaseFileIds } from '../../lib/cases.js';
+import type { CaseDetail, CaseImpact, CaseSummary, SpecDetail } from '../shared/types.js';
+export { CaseError, isValidCaseId };
+export declare const listCaseIds: typeof listCaseFileIds;
+export declare function listCases(): CaseSummary[];
+export declare function readCase(id: string): CaseDetail;
+export declare function readSpec(id: string): SpecDetail;
+/** Writes only if the file is unchanged since the editor loaded it (an agent or an external editor may change it too). */
+export declare function writeSpec(id: string, content: string, expectedMtimeMs: number): SpecDetail;
+/**
+ * Opens the spec of a case in the default application of the system. Resolves once the opener has handed the file over
+ * (or is still running after a moment, as `xdg-open` can be); rejects when there is no opener or it fails.
+ */
+export declare function openSpec(id: string): Promise<void>;
+/** Writes only if the file is unchanged since the editor loaded it (an agent may be editing it too). */
+export declare function writeCase(id: string, content: string, expectedMtimeMs: number): CaseDetail;
+/** Reuses `pnpm case:new` so the template stays in one place. */
+export declare function createCase(id: string): Promise<CaseDetail>;
+export declare const caseImpact: (id: string) => CaseImpact;
+export declare const renameCase: (id: string, to: string) => CaseDetail;
+export declare const deleteCase: (id: string) => CaseImpact;