@asrunjs/asrun 0.0.0-stage → 0.5.2

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

@@ -0,0 +1,408 @@
+const MAX_DETAIL = 180;
+const MAX_ERROR = 300;
+const MAX_REASONING = 2000;
+/** A call's output is a preview, not a transcript: the first few lines say what it did without flooding the log. */
+const PREVIEW_LINES = 6;
+const PREVIEW_LINE = 200;
+const PREVIEW_CHARS = 500;
+const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+const SANDBOX_ERROR = /listen EPERM|outside of the sandbox|sandbox/i;
+/** A saved login is a password (AGENTS.md F5): never copy what a call read from `.auth` into the log. */
+const SECRET_PATH = /(^|[\\/])\.auth([\\/]|$)/;
+const oneLine = (value, max) => {
+    const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+};
+const cap = (text, max) => (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`);
+/** The first thing a piece of code does, for a tool whose only argument is the code (`execute`). */
+function firstStatement(code) {
+    const line = code
+        .split('\n')
+        .map((text) => text.trim())
+        .find((text) => text !== '' && !text.startsWith('//') && !text.startsWith('#'));
+    return line ?? '';
+}
+/** `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 argument that names the thing it touched.
+ * The names differ per CLI and per tool (`file_path` for Claude, `path` for OpenCode; `pattern` for glob and grep;
+ * `code` for a code-mode `execute`), so every one of them is looked at.
+ */
+function describe(input) {
+    if (!input || typeof input !== 'object')
+        return '';
+    const args = input;
+    const key = [
+        'intent',
+        'description',
+        'skill',
+        'name',
+        'command',
+        'path',
+        'file_path',
+        'filePath',
+        'filename',
+        'pattern',
+        'query',
+        'url',
+        'element',
+    ].find((name) => typeof args[name] === 'string' && args[name].trim() !== '');
+    if (key)
+        return oneLine(args[key], MAX_DETAIL);
+    if (typeof args.code === 'string')
+        return oneLine(firstStatement(args.code), MAX_DETAIL);
+    // Nothing known: the longest string still tells more than the bare tool name.
+    const longest = Object.values(args)
+        .filter((value) => typeof value === 'string')
+        .sort((a, b) => b.length - a.length)[0];
+    return longest ? oneLine(longest, MAX_DETAIL) : '';
+}
+const callOf = (name, input) => ({
+    name: toolName(name),
+    detail: describe(input),
+    ok: true,
+    pending: true,
+});
+const labelText = (call) => (call.detail ? `${call.name}: ${call.detail}` : call.name);
+/**
+ * The first lines of what a call returned, with the colors a shell put in it. Long output keeps its head only: the
+ * point is to see what happened, not to copy a file into the log.
+ */
+function previewText(value) {
+    const text = (typeof value === 'string' ? value : value == null ? '' : String(value))
+        .replace(/\r\n?/g, '\n')
+        .replace(/\t/g, '  ')
+        .trim();
+    if (!text)
+        return null;
+    const lines = text.split('\n');
+    const kept = [];
+    let chars = 0;
+    for (const line of lines) {
+        if (kept.length >= PREVIEW_LINES || chars >= PREVIEW_CHARS)
+            break;
+        // A cut line loses its colors, so a half escape sequence cannot bleed into the rest of the block.
+        const shown = line.length > PREVIEW_LINE ? oneLine(line.replace(ANSI, ''), PREVIEW_LINE) : line;
+        kept.push(shown);
+        chars += shown.length;
+    }
+    const rest = lines.length - kept.length;
+    return kept.join('\n') + (rest > 0 ? `\n… (${rest} more line${rest === 1 ? '' : 's'})` : '');
+}
+const HANDOFF_CFG = '__handoffCfg';
+const HANDOFF_CARD = /handoff-card\.js/;
+/** What the card returns when it stops waiting (`{outcome: 'done' | 'skip' | 'condition' | 'timeout'}`). */
+const HANDOFF_RESULT = /\\?"outcome\\?"\s*:\s*\\?"(?:done|skip|condition|timeout)\\?"/;
+/**
+ * Said when a card came back that the UI was never told about: only a call of its own that sets the options lets the
+ * UI know a person is needed, so a card that ran with the options of an earlier handoff (or with the options set inside
+ * the call that runs the card) has no badge and no notification.
+ */
+const MISSED_HANDOFF_HINT = 'HINT: this handoff was not announced: the web UI learns a handoff from the call that sets __handoffCfg, and this ' +
+    'card ran without one (see user-handoff.md, "Two calls, every time"), so there was no "Your turn" badge and no ' +
+    'notification.';
+/** The browser tool a handoff runs through: `browser_run_code`, `browser_run_code_unsafe`, ... */
+const BROWSER_RUN_CODE = /browser_run_code/;
+/**
+ * How long "the options are set" survives calls that are not part of the handoff. The agent sets the options and then
+ * runs the card, and in between it may take a screenshot or read a file; the badge (and a notification) must not blink
+ * off and on for that. Long enough for those gaps, short enough that options never followed by a card do not leave the
+ * badge on.
+ */
+const HANDOFF_CFG_TTL_MS = 300_000;
+/** `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;
+}
+const codeOf = (input) => {
+    if (!input || typeof input !== 'object')
+        return '';
+    const code = input.code;
+    return typeof code === 'string' ? code : '';
+};
+/**
+ * Which handoff call this is, if any. The browser tool is called either directly or from a CLI's code mode: OpenCode's
+ * `execute` tool takes a `code` string that holds `tools["playwright-test"].browser_run_code_unsafe({...})`, so the
+ * nested call is only text inside it and the tool name says nothing about the browser.
+ */
+function handoffCall(name, input) {
+    if (!input || typeof input !== 'object')
+        return null;
+    const args = input;
+    const code = codeOf(input);
+    const filename = typeof args.filename === 'string' ? args.filename : '';
+    // A code-mode call is a handoff only when the browser tool is inside it: it also runs everything else.
+    if (!BROWSER_RUN_CODE.test(name) && !BROWSER_RUN_CODE.test(code))
+        return null;
+    if (HANDOFF_CARD.test(filename) || (HANDOFF_CARD.test(code) && /filename\s*:/.test(code)))
+        return 'card';
+    return code.includes(HANDOFF_CFG) ? 'options' : null;
+}
+export class AiStreamFormatter {
+    tool;
+    buffer = '';
+    pending = new Map();
+    cardCalls = new Set();
+    waitingForUser = null;
+    /** The message of the last options call, kept so a card that runs after unrelated calls still carries it. */
+    lastHandoffMessage = null;
+    lastEventAt = Date.now();
+    lastWaitAt = 0;
+    /** The last call the agent finished, so a quiet spell can say what it is doing instead of only that nothing came. */
+    lastCall = '';
+    sandboxHinted = false;
+    constructor(tool) {
+        this.tool = tool;
+    }
+    /** Blocks 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.flatMap((line) => this.line(line));
+    }
+    /**
+     * 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 a later 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. Returns a line for the
+     * log when a card came back that nobody was told about (`MISSED_HANDOFF_HINT`).
+     */
+    watchHandoff(id, name, input, ended, output) {
+        // The card answers `{outcome: ...}` when it stops waiting: that ends the handoff whatever ran it.
+        if (ended && HANDOFF_RESULT.test(String(output ?? ''))) {
+            const announced = this.waitingForUser !== null;
+            this.waitingForUser = null;
+            return announced ? null : { kind: 'hint', at: Date.now(), data: MISSED_HANDOFF_HINT };
+        }
+        const kind = handoffCall(name, input);
+        if (kind === 'card') {
+            if (ended)
+                this.waitingForUser = null;
+            else {
+                this.cardCalls.add(id);
+                // `??=` on purpose: the options call before it already knows the message and when the wait started.
+                this.waitingForUser ??= { message: handoffMessage(codeOf(input)) ?? this.lastHandoffMessage, since: Date.now() };
+            }
+            return null;
+        }
+        if (kind === 'options') {
+            const message = handoffMessage(codeOf(input));
+            if (message)
+                this.lastHandoffMessage = message;
+            // Keep the start time when the wait is already set: a second report of the same handoff must not announce it twice.
+            const since = this.waitingForUser?.since ?? Date.now();
+            this.waitingForUser = { message: message ?? this.lastHandoffMessage, since };
+            return null;
+        }
+        // Anything else ends the wait, unless it was set too recently to be an abandoned one: the card runs right after it.
+        if (this.waitingForUser && Date.now() - this.waitingForUser.since > HANDOFF_CFG_TTL_MS)
+            this.waitingForUser = null;
+        return null;
+    }
+    /** What is left when the process ends. */
+    end() {
+        const rest = this.buffer;
+        this.buffer = '';
+        return rest.trim() ? this.line(rest) : [];
+    }
+    /**
+     * A block about the oldest tool call that has not returned, when nothing has happened for `quietMs` (and again every
+     * `quietMs` after that). It names the last call that did finish, so a long run never looks stuck.
+     */
+    waiting(quietMs) {
+        const now = Date.now();
+        if (now - Math.max(this.lastEventAt, this.lastWaitAt) < quietMs)
+            return null;
+        this.lastWaitAt = now;
+        const [first] = [...this.pending.values()].sort((a, b) => a.startedAt - b.startedAt);
+        const last = this.lastCall ? ` (last: ${this.lastCall})` : '';
+        const data = first
+            ? `... still waiting for ${labelText(first)} (running ${seconds(now - first.startedAt)})`
+            : `... no output from the agent for ${seconds(now - this.lastEventAt)}${last}`;
+        return { kind: 'meta', at: now, data };
+    }
+    line(raw) {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return [];
+        let event;
+        try {
+            event = JSON.parse(trimmed);
+        }
+        catch {
+            // Not one of the CLI's events: keep the line as it came, it is the only trace of it.
+            return [{ kind: 'meta', at: Date.now(), data: raw.trimEnd() }];
+        }
+        if (!event || typeof event !== 'object' || typeof event.type !== 'string') {
+            return [{ kind: 'meta', at: Date.now(), data: raw.trimEnd() }];
+        }
+        this.lastEventAt = Date.now();
+        return this.tool === 'claude' ? this.claude(event) : this.opencode(event);
+    }
+    /** A call the agent has started and not finished yet (Claude reports both ends). */
+    start(id, call) {
+        const now = Date.now();
+        this.pending.set(id, { name: call.name, detail: call.detail, startedAt: now });
+        return [{ kind: 'tool', at: now, data: `>> ${labelText(call)}`, tool: call }];
+    }
+    /**
+     * The end of a call, plus the first lines of what it returned. `fallback` is for a CLI that reports a call only when
+     * it is over (OpenCode), which still knows when it started.
+     */
+    finishCall(id, ok, output, fallback) {
+        const now = Date.now();
+        const call = this.pending.get(id);
+        this.pending.delete(id);
+        if (this.cardCalls.delete(id))
+            this.waitingForUser = null;
+        const name = call?.name ?? fallback?.name ?? 'tool';
+        const detail = call?.detail ?? fallback?.detail ?? '';
+        const startedAt = call?.startedAt ?? fallback?.startedAt;
+        const took = startedAt ? seconds(now - startedAt) : undefined;
+        const label = labelText({ name, detail });
+        this.lastCall = label;
+        const parts = [
+            {
+                kind: 'tool',
+                at: now,
+                data: `${ok ? 'ok' : 'FAILED'}: ${label}${took ? ` after ${took}` : ''}`,
+                tool: { name, detail, ok, ...(took && { took }) },
+            },
+        ];
+        if (!ok) {
+            const error = oneLine(output, MAX_ERROR);
+            if (error)
+                parts.push({ kind: 'error', at: now, data: error });
+            return parts;
+        }
+        // A saved login is a password: what a call read from `.auth` never goes into the log.
+        const preview = SECRET_PATH.test(detail) ? null : previewText(output);
+        if (preview)
+            parts.push({ kind: 'result', at: now, data: preview });
+        return parts;
+    }
+    /** 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 null;
+        this.sandboxHinted = true;
+        return {
+            kind: 'hint',
+            at: Date.now(),
+            data: "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).',
+        };
+    }
+    claude(event) {
+        const content = event.message?.content;
+        if (event.type === 'assistant' && Array.isArray(content)) {
+            return content.flatMap((block) => {
+                if (block?.type === 'text' && block.text?.trim()) {
+                    return [{ kind: 'markdown', at: Date.now(), data: block.text.trimEnd() }];
+                }
+                // A thinking block: worth reading while it waits, but never mistaken for the answer (see `--thinking`).
+                if (block?.type === 'thinking' && block.thinking?.trim()) {
+                    return [{ kind: 'reasoning', at: Date.now(), data: cap(block.thinking.trim(), MAX_REASONING) }];
+                }
+                if (block?.type === 'tool_use') {
+                    this.watchHandoff(String(block.id), String(block.name), block.input, false);
+                    return this.start(String(block.id), callOf(String(block.name), block.input));
+                }
+                return [];
+            });
+        }
+        if (event.type === 'user' && Array.isArray(content)) {
+            return content
+                .filter((block) => block?.type === 'tool_result')
+                .flatMap((block) => {
+                const body = Array.isArray(block.content)
+                    ? block.content.map((part) => part?.text ?? '').join(' ')
+                    : block.content;
+                const hint = this.sandboxHint(block.is_error, body);
+                return [...this.finishCall(String(block.tool_use_id), !block.is_error, body), ...(hint ? [hint] : [])];
+            });
+        }
+        if (event.type === 'result' && event.is_error) {
+            return [{ kind: 'error', at: Date.now(), data: oneLine(event.result ?? event.subtype, MAX_ERROR) }];
+        }
+        return [];
+    }
+    opencode(event) {
+        const part = event.part ?? {};
+        // The CLI reports a failed turn (bad model, no credentials, a usage limit, a provider outage) as an error event,
+        // not on stderr: without this branch the log of a run that died at once showed nothing but the exit code.
+        if (event.type === 'error')
+            return this.opencodeError(event.error);
+        // `--thinking` is what makes OpenCode ask the model to think; without it these blocks are never sent.
+        if (event.type === 'reasoning' && typeof part.text === 'string' && part.text.trim()) {
+            return [{ kind: 'reasoning', at: Date.now(), data: cap(part.text.trim(), MAX_REASONING) }];
+        }
+        if (event.type === 'text' && typeof part.text === 'string' && part.text.trim()) {
+            return [{ kind: 'markdown', at: Date.now(), data: part.text.trimEnd() }];
+        }
+        if (event.type === 'tool_use') {
+            const state = part.state ?? {};
+            const call = callOf(String(part.tool ?? 'tool'), state.input);
+            const id = String(part.callID ?? part.id ?? labelText(call));
+            const finished = state.status === 'completed' || state.status === 'error';
+            const hint = this.watchHandoff(id, String(part.tool ?? ''), state.input, finished, finished ? (state.error ?? state.output) : undefined);
+            if (finished) {
+                const time = state.time ?? {};
+                const parts = this.finishCall(id, state.status === 'completed', state.error ?? state.output, {
+                    ...call,
+                    ...(typeof time.start === 'number' && { startedAt: time.start }),
+                });
+                return hint ? [...parts, hint] : parts;
+            }
+            const parts = this.start(id, call);
+            return hint ? [...parts, hint] : parts;
+        }
+        return [];
+    }
+    /** `FAILED: <why>`, plus what to do about the two failures users actually hit. */
+    opencodeError(error) {
+        const body = (error ?? {});
+        const now = Date.now();
+        const message = oneLine(body.message ?? body.type ?? 'the agent failed', MAX_ERROR);
+        const type = String(body.type ?? '');
+        const parts = [{ kind: 'error', at: now, data: `FAILED: ${message}` }];
+        if (type === 'provider.free-limit') {
+            const wait = typeof body.retryAfterMs === 'number' ? ` (it comes back in about ${waitFor(body.retryAfterMs)})` : '';
+            parts.push({
+                kind: 'hint',
+                at: now,
+                data: 'HINT: this run used a free OpenCode model, and its free usage limit is spent' +
+                    `${wait}. Pick a model in the top bar (it has to belong to a provider you are signed in to), ` +
+                    'or switch the AI agent to Claude. A model can also be set as "model" in opencode.jsonc.',
+            });
+        }
+        else if (type === 'provider.no-route' || type === 'provider.no-key' || type === 'provider.auth') {
+            parts.push({
+                kind: 'hint',
+                at: now,
+                data: 'HINT: the model is not available to this OpenCode install. Pick another one in the top bar, ' +
+                    'or sign the provider in with "opencode auth login".',
+            });
+        }
+        return parts;
+    }
+}
+/** A retry delay as a person reads it: `40 s`, `12.5 min`, `15.3 h`. */
+function waitFor(ms) {
+    if (ms < 90_000)
+        return `${Math.max(1, Math.round(ms / 1000))} s`;
+    if (ms < 90 * 60_000)
+        return `${(ms / 60_000).toFixed(1)} min`;
+    return `${(ms / 3_600_000).toFixed(1)} h`;
+}

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, "/">;