unfold-deploy 0.0.0-stage → 0.2.0

package/dist/commands/replay.js

@@ -0,0 +1,76 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { readRun, runsDir } from '../core/store.js';
+import { providers } from '../providers/index.js';
+import { observe, say } from './observe.js';
+/** Replays a run saved by `unfold vercel` (already-redacted events). */
+export async function runReplay(file, flags, speed) {
+    const path = file ? ((await import('./show.js')).resolveRun(file) ?? file) : latestRun();
+    if (!path) {
+        say(`No saved runs in ${runsDir()}.`);
+        return 1;
+    }
+    const events = readRun(path);
+    const started = events.find((e) => e.type === 'run.started');
+    const ended = events.find((e) => e.type === 'run.ended');
+    const provider = started && providers[started.provider];
+    if (!started || !provider) {
+        say(`${path} is not an Unfold run file.`);
+        return 1;
+    }
+    say(`Replaying ${path}`);
+    return observe({
+        provider,
+        command: started.command,
+        cwd: started.cwd,
+        mode: 'replay',
+        flags,
+        save: false,
+        waitForBrowser: true,
+        run: async (session, term) => {
+            const t0 = started.at;
+            const start = Date.now();
+            const wait = async (at) => {
+                const ms = (at - t0) / speed - (Date.now() - start);
+                if (ms > 0)
+                    await new Promise((r) => setTimeout(r, Math.min(ms, 2000)));
+            };
+            if (provider.createPresenter) {
+                // Structured providers: raw events aren't saved, so replay the recorded events.
+                for (const e of events) {
+                    if (e.type === 'log')
+                        await wait(e.line.at);
+                    session.inject(e);
+                }
+                session.endReplay(ended?.exitCode ?? null, ended?.signal ?? null, ended?.interrupted ?? false);
+                return { exitCode: ended?.exitCode ?? null, signal: ended?.signal ?? null, interrupted: ended?.interrupted ?? false };
+            }
+            // Re-run the original lines through today's parser so parser fixes apply to old runs.
+            for (const e of events) {
+                if (e.type !== 'log')
+                    continue;
+                const wait = (e.line.at - t0) / speed - (Date.now() - start);
+                if (wait > 0)
+                    await new Promise((r) => setTimeout(r, Math.min(wait, 2000)));
+                term.write(e.line.text + '\r\n');
+                session.write(e.line.text + '\n');
+            }
+            return { exitCode: ended?.exitCode ?? null, signal: ended?.signal ?? null, interrupted: ended?.interrupted ?? false };
+        },
+    });
+}
+export function listRuns() {
+    try {
+        const dir = runsDir();
+        return readdirSync(dir)
+            .filter((f) => f.endsWith('.jsonl'))
+            .map((f) => join(dir, f))
+            .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
+    }
+    catch {
+        return [];
+    }
+}
+function latestRun() {
+    return listRuns()[0];
+}

package/dist/commands/run.js

@@ -0,0 +1,24 @@
+import { launch, which } from '../core/launch.js';
+import { redactArgs } from '../core/redact.js';
+import { observe, say } from './observe.js';
+export async function runLive(provider, userArgs, flags) {
+    const cwd = process.cwd();
+    const spec = provider.launch(userArgs);
+    const bin = which(spec.bin);
+    if (!bin) {
+        say(`Could not find "${spec.bin}" on your PATH.${provider.install ? ` ${provider.install}` : ''}`);
+        return 127;
+    }
+    for (const msg of provider.preflight?.(cwd) ?? [])
+        say(msg);
+    say(`Running: ${[spec.bin, ...redactArgs(spec.args)].join(' ')}`);
+    return observe({
+        provider,
+        command: [spec.bin, ...redactArgs(spec.args)],
+        cwd,
+        mode: 'live',
+        flags,
+        save: true,
+        run: (session, term) => launch({ bin, args: spec.args, cwd, term, onOutput: (d) => session.write(d) }),
+    });
+}

package/dist/commands/show.js

@@ -0,0 +1,44 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { FlowReducer } from '../core/flow.js';
+import { readRun, runsDir } from '../core/store.js';
+import { explore } from '../tui/explore.js';
+import { style } from '../tui/ansi.js';
+import { summary } from '../tui/render.js';
+import { say } from './observe.js';
+import { listRuns, runReplay } from './replay.js';
+/** Resolves a run file from a path, a run id (or its prefix), or the latest run. */
+export function resolveRun(ref) {
+    if (!ref)
+        return listRuns()[0];
+    if (existsSync(ref))
+        return ref;
+    const byId = join(runsDir(), ref.endsWith('.jsonl') ? ref : `${ref}.jsonl`);
+    if (existsSync(byId))
+        return byId;
+    return listRuns().find((p) => p.split('/').pop().startsWith(ref));
+}
+/** `unfold show`: explore a finished run in the terminal (or the browser with --web). */
+export async function runShow(ref, flags) {
+    const path = resolveRun(ref);
+    if (!path) {
+        say(ref ? `No run matching "${ref}" in ${runsDir()}.` : `No saved runs yet in ${runsDir()}. Run \`unfold vercel\` or \`unfold demo\` first.`);
+        return 1;
+    }
+    if (flags.web)
+        return runReplay(path, { ...flags, panel: false }, 1e9);
+    const reducer = new FlowReducer();
+    for (const e of readRun(path))
+        reducer.apply(e);
+    const state = reducer.state;
+    if (!state) {
+        say(`${path} is not an Unfold run file.`);
+        return 1;
+    }
+    const logs = [...reducer.logs.values()];
+    if (process.stdout.isTTY && process.stdin.isTTY)
+        await explore(state, logs);
+    else
+        process.stdout.write(summary(state, logs, { s: style(false) }));
+    return 0;
+}

package/dist/core/errors.js

@@ -0,0 +1,3 @@
+/** A mistake in how Unfold was invoked: printed without a stack trace. */
+export class UsageError extends Error {
+}

package/dist/core/fix-prompt.js

@@ -0,0 +1,85 @@
+import { homedir } from 'node:os';
+export const AGENTS = ['claude', 'codex'];
+const MAX_EXCERPT = 40;
+const STAMP = /^\d{4}-\d{2}-\d{2}T[\d:.]+Z {0,2}/;
+// path/to/file.ext:line[:col], as printed by compilers, bundlers and linters
+const FILE_REF = /(?:^|[\s(])((?:\.{0,2}\/)?[\w@.-]+(?:\/[\w@.[\]-]+)*\.[A-Za-z]{1,5}):(\d+)(?::(\d+))?/g;
+/** Most specific cause first, then by position in the output. */
+export function rankCauses(state) {
+    const fatal = state.errors.find((e) => e.severity === 'fatal');
+    return state.errors
+        .filter((e) => e.severity === 'cause' && e.message !== fatal?.message)
+        .sort((a, b) => (b.priority ?? 1) - (a.priority ?? 1) || a.seq - b.seq);
+}
+function fileRefs(lines) {
+    const refs = new Set();
+    for (const line of lines) {
+        for (const m of line.replace(STAMP, '').matchAll(FILE_REF)) {
+            if (/^https?:/.test(m[1]) || m[1].includes('node_modules'))
+                continue;
+            refs.add(`${m[1]}:${m[2]}${m[3] ? `:${m[3]}` : ''}`);
+        }
+    }
+    return [...refs].slice(0, 8);
+}
+function excerpt(state, logs, anchor) {
+    const sorted = [...logs].sort((a, b) => a.seq - b.seq);
+    if (!sorted.length)
+        return { from: 0, to: 0, lines: [] };
+    const fatal = state.errors.find((e) => e.severity === 'fatal');
+    const end = fatal?.seq ?? sorted.at(-1).seq;
+    const start = anchor ? Math.max(anchor.seq - 12, end - MAX_EXCERPT + 1) : end - 30;
+    const lines = sorted.filter((l) => l.seq >= start && l.seq <= end).slice(-MAX_EXCERPT);
+    while (lines.length && lines[0].text.replace(STAMP, '').trim() === '')
+        lines.shift();
+    return { from: lines[0]?.seq ?? 0, to: lines.at(-1)?.seq ?? 0, lines };
+}
+const fence = (body) => '```\n' + body.replace(/```/g, '`​``') + '\n```';
+/**
+ * Builds a prompt for a coding agent from a failed run. Uses only the already
+ * redacted log lines and parsed facts, so it contains nothing that isn't on the page.
+ */
+export function buildFixPrompt(state, logs, hints = []) {
+    if (state.outcome !== 'failure')
+        return undefined;
+    const stage = (id) => state.stages.find((s) => s.id === id)?.title;
+    const fatal = state.errors.find((e) => e.severity === 'fatal');
+    const causes = rankCauses(state);
+    const top = causes[0];
+    const ex = excerpt(state, logs, top);
+    const refs = fileRefs([...causes.map((c) => c.message), ...ex.lines.map((l) => l.text)]);
+    const facts = state.facts.filter((f) => !['inspectUrl', 'deploymentUrl', 'cliVersion', 'duration', 'region', 'machine'].includes(f.key));
+    const failedStage = stage(state.failedStage) ?? 'an unknown stage';
+    const out = [];
+    out.push(`# Fix a failed ${state.title.toLowerCase()}`, '');
+    out.push(`I ran \`${state.command.join(' ')}\` in \`${state.cwd}\` and it failed during the **${failedStage}** stage` +
+        (state.lastConfirmed ? `. The last stage that completed was **${stage(state.lastConfirmed)}**.` : ', before any stage completed.') +
+        ` It exited with ${state.exitCode !== null ? `code ${state.exitCode}` : (state.exitSignal ?? 'an unknown status')}.`);
+    out.push('', '## Error', fence(fatal?.message ?? 'The command failed without printing a recognizable error. See the log excerpt.'));
+    if (causes.length) {
+        out.push('', '## Most relevant output', fence(causes.slice(0, 4).map((c) => c.message).join('\n')));
+    }
+    if (ex.lines.length) {
+        out.push('', `## Log excerpt (lines ${ex.from}–${ex.to})`, fence(ex.lines.map((l) => l.text.replace(STAMP, '')).join('\n')));
+    }
+    const context = [
+        ...facts.map((f) => `- ${f.label}: ${f.value}`),
+        ...(refs.length ? [`- Files mentioned in the output: ${refs.map((r) => `\`${r}\``).join(', ')}`] : []),
+    ];
+    if (context.length)
+        out.push('', '## Context', ...context);
+    if (hints.length)
+        out.push('', '## Things to know about this failure', ...hints.map((h) => `- ${h}`));
+    out.push('', '## What I want', `1. Find the root cause in this repository${refs.length ? ', starting with the files mentioned above' : ''}.`, '2. Make the smallest change that fixes it, then reproduce the failing step locally to confirm the fix.', "3. Don't deploy, and don't change hosting settings or environment variables. If the fix needs that, tell me exactly what to change instead.", '4. Summarize what was wrong and what you changed.', '', 'Values shown as [REDACTED] were removed on purpose; don\'t try to recover them.');
+    return out.join('\n') + '\n';
+}
+const shQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+/** One-line shell commands that start each agent with the saved prompt. */
+export function agentCommands(promptPath, home = homedir()) {
+    // `~/…` is shorter to read and copy; only used when no quoting is needed.
+    const safe = /^[\w./-]+$/;
+    const rest = promptPath.startsWith(home + '/') ? promptPath.slice(home.length) : undefined;
+    const ref = rest && safe.test(home) && safe.test(rest) ? `~${rest}` : shQuote(promptPath);
+    const arg = `"$(cat ${ref})"`;
+    return { claude: `claude ${arg}`, codex: `codex ${arg}` };
+}

package/dist/core/flow.js

@@ -0,0 +1,211 @@
+const MAX_EVIDENCE = 40;
+const DEFAULT_NOTES = {
+    interrupted: 'You pressed Ctrl+C while this stage was in progress, so its outcome was never reported.',
+    unverified: "This run's output never confirmed this stage.",
+};
+/**
+ * Pure reducer from RunEvents to FlowState plus the log. Rules:
+ * - Stages only move forward on explicit signals from the provider parser; a later
+ *   stage starting never implies an earlier one finished.
+ * - When the run ends, anything not confirmed becomes `unverified` (or `failed` for
+ *   the stage the failure is attributed to).
+ */
+export class FlowReducer {
+    state;
+    logs = new Map();
+    notes = DEFAULT_NOTES;
+    apply(event) {
+        if (event.type === 'run.started') {
+            this.notes = { ...DEFAULT_NOTES, ...event.notes };
+            this.logs.clear();
+            this.state = {
+                runId: event.runId,
+                provider: event.provider,
+                title: event.title,
+                command: event.command,
+                cwd: event.cwd,
+                mode: event.mode,
+                startedAt: event.at,
+                outcome: 'running',
+                exitCode: null,
+                exitSignal: null,
+                stages: event.stages.map((d) => ({ ...d, status: 'pending', evidence: [] })),
+                notes: event.notes,
+                facts: [],
+                errors: [],
+                lineCount: 0,
+            };
+            return;
+        }
+        const s = this.state;
+        if (!s)
+            return;
+        switch (event.type) {
+            case 'log':
+                this.logs.set(event.line.seq, event.line);
+                s.lineCount = this.logs.size;
+                return;
+            case 'signal':
+                this.signal(s, event);
+                return;
+            case 'run.ended':
+                this.end(s, event);
+                return;
+            case 'fix.ready':
+                s.fix = event.fix;
+                return;
+        }
+    }
+    stage(s, id) {
+        return id ? s.stages.find((st) => st.id === id) : undefined;
+    }
+    addEvidence(st, seq, at, note) {
+        const text = this.logs.get(seq)?.text ?? '';
+        const existing = st.evidence.find((e) => e.seq === seq);
+        if (existing) {
+            // Same line redrawn (e.g. a progress bar): keep the latest version.
+            existing.text = text;
+            existing.note = note;
+            existing.at = at;
+            return;
+        }
+        st.evidence.push({ seq, at, text, note });
+        if (st.evidence.length > MAX_EVIDENCE)
+            st.evidence.splice(1, 1); // keep the first line
+    }
+    signal(s, e) {
+        const sig = e.signal;
+        switch (sig.kind) {
+            case 'stage': {
+                const st = this.stage(s, sig.stage);
+                if (!st)
+                    return;
+                if (sig.status === 'active') {
+                    if (st.status === 'pending' || st.status === 'active') {
+                        st.status = 'active';
+                        st.startedAt ??= e.at;
+                        st.note = sig.note;
+                    }
+                }
+                else if (sig.status === 'confirmed') {
+                    if (st.status !== 'failed') {
+                        st.status = 'confirmed';
+                        st.startedAt ??= e.at;
+                        st.endedAt = e.at;
+                        st.note = sig.note;
+                    }
+                }
+                else if (sig.status === 'unverified') {
+                    // A parser saying "this happened but didn't succeed" (e.g. checks ran and failed).
+                    if (st.status === 'pending' || st.status === 'active') {
+                        st.status = 'unverified';
+                        st.note = sig.note;
+                    }
+                }
+                else if (st.status !== 'confirmed') {
+                    st.status = 'failed';
+                    st.endedAt = e.at;
+                    st.note = sig.note;
+                    s.failedStage = st.id;
+                }
+                this.addEvidence(st, e.seq, e.at, sig.note);
+                this.updateLastConfirmed(s);
+                return;
+            }
+            case 'evidence': {
+                const st = this.stage(s, sig.stage);
+                if (st)
+                    this.addEvidence(st, e.seq, e.at, sig.note);
+                return;
+            }
+            case 'fact': {
+                const existing = s.facts.find((f) => f.key === sig.key);
+                const fact = { key: sig.key, label: sig.label, value: sig.value, stage: sig.stage, href: sig.href, seq: e.seq };
+                if (existing)
+                    Object.assign(existing, fact);
+                else
+                    s.facts.push(fact);
+                return;
+            }
+            case 'error': {
+                const info = { severity: sig.severity, priority: sig.priority, stage: sig.stage, message: sig.message, seq: e.seq, at: e.at };
+                if (!s.errors.some((x) => x.seq === e.seq && x.message === sig.message))
+                    s.errors.push(info);
+                if (sig.severity === 'fatal') {
+                    const st = this.stage(s, sig.stage) ?? this.currentStage(s);
+                    if (st && st.status !== 'confirmed') {
+                        // Keep a note the parser already gave the failure (e.g. "Creating Revision failed.");
+                        // the full message is shown as the error.
+                        if (st.status !== 'failed' || !st.note)
+                            st.note = sig.message;
+                        st.status = 'failed';
+                        st.endedAt = e.at;
+                        s.failedStage = st.id;
+                        info.stage = st.id;
+                        this.addEvidence(st, e.seq, e.at, 'Error reported here');
+                    }
+                }
+                return;
+            }
+        }
+    }
+    /** The stage work is most plausibly happening in right now. */
+    currentStage(s) {
+        const active = [...s.stages].reverse().find((st) => st.status === 'active');
+        if (active)
+            return active;
+        const lastIdx = s.stages.findLastIndex((st) => st.status === 'confirmed');
+        return s.stages[lastIdx + 1] ?? s.stages[lastIdx];
+    }
+    updateLastConfirmed(s) {
+        const idx = s.stages.findLastIndex((st) => st.status === 'confirmed');
+        s.lastConfirmed = idx >= 0 ? s.stages[idx].id : undefined;
+    }
+    end(s, e) {
+        s.endedAt = e.at;
+        s.exitCode = e.exitCode;
+        s.exitSignal = e.signal;
+        const failed = e.exitCode !== 0 || e.signal !== null;
+        const finished = s.stages.at(-1)?.status === 'confirmed';
+        // Ctrl+C after the workflow already finished successfully does not change the outcome.
+        if (e.interrupted && (failed || !finished)) {
+            s.outcome = 'interrupted';
+        }
+        else if (failed) {
+            s.outcome = 'failure';
+            if (!s.failedStage) {
+                const st = this.stage(s, s.errors.find((x) => x.severity === 'fatal')?.stage) ?? this.currentStage(s);
+                if (st && st.status !== 'confirmed') {
+                    st.status = 'failed';
+                    st.endedAt = e.at;
+                    st.note ??= `The command exited with code ${e.exitCode ?? e.signal} during this stage.`;
+                    s.failedStage = st.id;
+                }
+            }
+        }
+        else {
+            s.outcome = 'success';
+        }
+        // Index of the furthest stage the run is known to have reached.
+        const reached = s.stages.findLastIndex((st) => st.status !== 'pending');
+        s.stages.forEach((st, i) => {
+            if (st.status === 'active') {
+                st.status = 'unverified';
+                st.note = s.outcome === 'interrupted' ? this.notes.interrupted : this.notes.unverified;
+            }
+            else if (st.status === 'pending') {
+                st.status = 'unverified';
+                // A stage skipped over by later ones: prefer the parser's own explanation, if it gave one.
+                if (i < reached)
+                    st.note = st.evidence.at(-1)?.note ?? this.notes.unverified;
+                else if (s.outcome === 'interrupted')
+                    st.note = 'The run stopped before this stage was observed.';
+                else if (s.outcome === 'failure')
+                    st.note = 'Not reached: the run failed before this stage.';
+                else
+                    st.note = this.notes.unverified;
+            }
+        });
+        this.updateLastConfirmed(s);
+    }
+}

package/dist/core/launch.js

@@ -0,0 +1,196 @@
+import { spawn } from 'node:child_process';
+import { chmodSync, existsSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { delimiter, dirname, isAbsolute, join } from 'node:path';
+import { onRestore } from '../tui/restore.js';
+const require = createRequire(import.meta.url);
+/** Finds an executable on PATH without running a shell. */
+export function which(bin) {
+    if (isAbsolute(bin) || bin.includes('/'))
+        return existsSync(bin) ? bin : undefined;
+    const exts = process.platform === 'win32' ? ['.cmd', '.exe', ''] : [''];
+    for (const dir of (process.env.PATH ?? '').split(delimiter)) {
+        for (const ext of exts) {
+            const p = join(dir, bin + ext);
+            try {
+                if (statSync(p).isFile())
+                    return p;
+            }
+            catch {
+                // not here
+            }
+        }
+    }
+    return undefined;
+}
+/** `UNFOLD_TERMINAL=script|pipe` forces a fallback (for troubleshooting and tests). */
+const forced = () => process.env.UNFOLD_TERMINAL;
+function loadPty() {
+    if (forced() === 'script' || forced() === 'pipe')
+        return undefined;
+    try {
+        const pty = require('node-pty');
+        // node-pty 1.1.0 prebuilds can ship spawn-helper without its execute bit.
+        const root = dirname(require.resolve('node-pty/package.json'));
+        const helper = join(root, 'prebuilds', `${process.platform}-${process.arch}`, 'spawn-helper');
+        if (existsSync(helper) && !(statSync(helper).mode & 0o111))
+            chmodSync(helper, 0o755);
+        return pty;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Runs the command attached to the user's terminal. With node-pty the child sees a
+ * real TTY, so prompts, colors and spinners behave exactly as they would without
+ * Unfold; all keystrokes (including Ctrl+C) are forwarded to it.
+ *
+ * The child inherits the environment so it can use the existing login and project
+ * config. Unfold never records the environment.
+ */
+export function launch(opts) {
+    const pty = loadPty();
+    if (pty)
+        return launchPty(pty, opts);
+    if (terminalMode() === 'script')
+        return launchScript(opts);
+    return launchPiped(opts);
+}
+/**
+ * How the wrapped command will be attached to the terminal:
+ * - `pty`: node-pty, full control (live panel supported)
+ * - `script`: the system `script` command gives the child a real TTY; used when node-pty
+ *   isn't installed (e.g. Linux without build tools). The panel is off because the child
+ *   sizes itself to the whole terminal.
+ * - `pipe`: no TTY for the child; prompts and spinners may behave differently.
+ */
+export function terminalMode() {
+    if (loadPty())
+        return 'pty';
+    if (forced() !== 'pipe' && process.platform !== 'win32' && process.stdin.isTTY && which('script'))
+        return 'script';
+    return 'pipe';
+}
+const shQuote = (s) => (/^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`);
+function launchScript({ bin, args, cwd, term: io, onOutput }) {
+    // BSD/macOS: script -q file cmd args…   util-linux: script -qefc "cmd args…" file
+    const scriptArgs = process.platform === 'darwin' || process.platform.endsWith('bsd')
+        ? ['-q', '/dev/null', bin, ...args]
+        : ['-qefc', [bin, ...args].map(shQuote).join(' '), '/dev/null'];
+    const child = spawn('script', scriptArgs, { cwd, env: process.env, stdio: ['inherit', 'pipe', 'inherit'] });
+    let interrupted = false;
+    const onSignal = (sig) => {
+        interrupted = true;
+        child.kill(sig);
+    };
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    // `script` puts the terminal in raw mode itself; make sure it's undone if we die first.
+    const release = onRestore(() => process.stdin.isTTY && process.stdin.setRawMode(false));
+    child.stdout.on('data', (d) => {
+        const text = d.toString('utf8');
+        io.write(text);
+        onOutput(text);
+    });
+    return new Promise((resolve) => {
+        child.on('error', (err) => onOutput(`Error: ${err.message}\n`));
+        child.on('close', (code, signal) => {
+            release();
+            process.off('SIGINT', onSignal);
+            process.off('SIGTERM', onSignal);
+            // Ctrl+C reaches the child through the TTY, so infer it from the exit status.
+            resolve({ exitCode: code, signal, interrupted: interrupted || code === 130 || signal === 'SIGINT' });
+        });
+    });
+}
+function launchPty(pty, { bin, args, cwd, term: io, onOutput }) {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    const term = pty.spawn(bin, args, {
+        name: process.env.TERM || 'xterm-256color',
+        cols: stdout.columns || 100,
+        rows: io.rows(),
+        cwd,
+        env: process.env,
+    });
+    let interrupted = false;
+    const onInput = (data) => {
+        if (data.includes(0x03))
+            interrupted = true;
+        term.write(data.toString('utf8'));
+    };
+    let alive = true;
+    const onResize = () => alive && term.resize(stdout.columns || 100, io.rows());
+    io.onRowsChange(onResize);
+    // Signals that reach Unfold directly (not via the TTY) are passed on.
+    const onSignal = (sig) => {
+        interrupted = true;
+        try {
+            term.kill(sig);
+        }
+        catch {
+            // already gone
+        }
+    };
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    const release = onRestore(() => stdin.isTTY && stdin.setRawMode(false));
+    stdin.resume();
+    stdin.on('data', onInput);
+    stdout.on('resize', onResize);
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    term.onData((d) => {
+        io.write(d);
+        onOutput(d);
+    });
+    return new Promise((resolve) => {
+        term.onExit(({ exitCode, signal }) => {
+            alive = false;
+            release();
+            stdin.off('data', onInput);
+            if (stdin.isTTY)
+                stdin.setRawMode(false);
+            stdin.pause();
+            stdout.off('resize', onResize);
+            process.off('SIGINT', onSignal);
+            process.off('SIGTERM', onSignal);
+            const sig = signal ? signalName(signal) : null;
+            resolve({ exitCode: sig ? null : exitCode, signal: sig, interrupted });
+        });
+    });
+}
+function launchPiped({ bin, args, cwd, term: io, onOutput }) {
+    process.stderr.write('[unfold] No pseudo-terminal available (node-pty is not installed); prompts and spinners may look different.\n');
+    const child = spawn(bin, args, { cwd, env: process.env, stdio: ['inherit', 'pipe', 'pipe'] });
+    let interrupted = false;
+    const onSignal = (sig) => {
+        interrupted = true;
+        child.kill(sig);
+    };
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    child.stdout.on('data', (d) => {
+        io.write(d.toString('utf8'));
+        onOutput(d.toString('utf8'));
+    });
+    child.stderr.on('data', (d) => {
+        process.stderr.write(d);
+        onOutput(d.toString('utf8'));
+    });
+    return new Promise((resolve) => {
+        child.on('error', (err) => {
+            onOutput(`Error: ${err.message}\n`);
+        });
+        child.on('close', (code, signal) => {
+            process.off('SIGINT', onSignal);
+            process.off('SIGTERM', onSignal);
+            resolve({ exitCode: code, signal, interrupted });
+        });
+    });
+}
+function signalName(n) {
+    const names = { 1: 'SIGHUP', 2: 'SIGINT', 9: 'SIGKILL', 15: 'SIGTERM' };
+    return names[n] ?? `signal ${n}`;
+}

package/dist/core/model.js

@@ -0,0 +1,3 @@
+// Shared, provider-agnostic event model. Providers (vercel today, gcloud later)
+// only produce `Signal`s from log lines; everything else lives here.
+export {};