unfold-deploy 0.1.0 → 0.2.0

package/dist/providers/agents/shared.js

@@ -0,0 +1,119 @@
+export function agentStages(agent, docsUrl, permissions) {
+    return [
+        {
+            id: 'start',
+            title: 'Start',
+            summary: `${agent} starts a session with its model, settings and the tools it may use.`,
+            explanation: [
+                `Unfold runs ${agent} in its non-interactive mode, which reports every step as a structured event instead of drawing a full-screen interface.`,
+                `In this mode ${agent} cannot stop to ask you for permission, so it can only do what your settings and flags allow. ${permissions}`,
+            ],
+            confirmedBy: 'The session start event.',
+            docsUrl,
+        },
+        {
+            id: 'explore',
+            title: 'Explore',
+            summary: 'It reads files and searches the code to understand the task.',
+            explanation: [
+                'Agents usually start by looking around: listing folders, reading files, searching for symbols and running read-only commands such as `git status`.',
+            ],
+            confirmedBy: 'A successful read, search or read-only command.',
+            docsUrl,
+        },
+        {
+            id: 'change',
+            title: 'Change',
+            summary: 'It edits or creates files to carry out the task.',
+            explanation: [
+                'Edits are written straight to your working tree. Review them with `git diff` before committing.',
+                'If it is not allowed to edit, its attempts are denied and the task cannot be completed.',
+            ],
+            confirmedBy: 'A successful file edit or write.',
+            docsUrl,
+        },
+        {
+            id: 'verify',
+            title: 'Verify',
+            summary: 'It runs checks such as tests, a type check, a linter or a build.',
+            explanation: [
+                'Unfold counts a command as a check when it looks like one, for example `npm test`, `pytest`, `tsc`, `eslint`, `cargo build` or `make`.',
+                'If the agent never runs a check, this stays unverified: the change may still be right, but nothing in the run showed it working.',
+            ],
+            confirmedBy: 'A check command that exits successfully.',
+            docsUrl,
+        },
+        {
+            id: 'done',
+            title: 'Done',
+            summary: 'It reports its final answer and the session ends.',
+            explanation: ['The final event says whether the session succeeded and, depending on the agent, how long it took, how many turns it used and what it cost.'],
+            confirmedBy: 'The final result event, with no error.',
+            docsUrl,
+        },
+    ];
+}
+export const AGENT_NOTES = {
+    success: 'Done',
+    successHeadline: 'The agent finished',
+    docsLabel: 'Docs',
+    highlights: ['answer', 'filesChanged', 'denied', 'cost', 'tokens'],
+    interrupted: 'You pressed Ctrl+C while this was in progress. Changes the agent already wrote stay on disk; review them with `git diff`.',
+    unverified: "This run's output never showed this step.",
+};
+const VERIFY = /(^|[\s;&|(])((npm|pnpm|yarn|bun)( run)? (test|build|lint|typecheck|check)\b|npx (tsc|vitest|jest|eslint|playwright)|\b(tsc|vitest|jest|mocha|pytest|tox|ruff|mypy|eslint|phpunit|rspec|playwright)\b|go (test|build|vet)|cargo (test|build|check|clippy)|\bmake\b|gradle|mvn|dotnet (test|build)|swift (test|build))/;
+const CHANGE = /(^|[\s;&|(])(sed -i|perl -pi|tee |mv |rm |cp |mkdir |touch |chmod |apply_patch|git (commit|apply|checkout|restore|reset|stash|add)|(npm|pnpm|yarn|bun) (i|install|add|remove|uninstall)\b|pip install)|[^2&]>{1,2}\s*(?!\/dev\/null)[\w./]/;
+/** Rough classification of a shell command by what it does. */
+export function classifyCommand(cmd) {
+    if (VERIFY.test(cmd))
+        return 'verify';
+    if (CHANGE.test(cmd))
+        return 'change';
+    return 'explore';
+}
+/** `/bin/zsh -lc "npm test"` → `npm test` (Codex wraps commands in a login shell). */
+export function unwrapShell(cmd) {
+    const m = /^\S*\/(?:ba|z)?sh -l?c (['"])([\s\S]*)\1$/.exec(cmd.trim()) ?? /^\S*\/(?:ba|z)?sh -l?c (\S+)$/.exec(cmd.trim());
+    if (!m)
+        return cmd;
+    const inner = m.length === 3 ? m[2] : m[1];
+    return m[1] === "'" ? inner.replace(/'\\''/g, "'").replace(/'"'"'/g, "'") : inner.replace(/\\"/g, '"');
+}
+/** Shows paths relative to the session's folder when possible. */
+export function relPath(path, cwd) {
+    if (cwd && path.startsWith(cwd.replace(/\/$/, '') + '/'))
+        return path.slice(cwd.replace(/\/$/, '').length + 1);
+    return path;
+}
+export const oneLine = (s, max = 160) => {
+    const t = s.replace(/\s+/g, ' ').trim();
+    return t.length > max ? t.slice(0, max - 1) + '…' : t;
+};
+/** Tracks checks across a run so the end of the run can say how they went. */
+export class CheckTracker {
+    last;
+    changed = new Set();
+    record(cmd, ok) {
+        this.last = { cmd, ok };
+    }
+    finish() {
+        const out = [];
+        if (this.changed.size) {
+            const files = [...this.changed];
+            out.push({ kind: 'fact', key: 'filesChanged', label: 'Files changed', value: `${files.slice(0, 8).join(', ')}${files.length > 8 ? ` and ${files.length - 8} more` : ''}`, stage: 'change' });
+        }
+        if (this.last && !this.last.ok) {
+            out.push({ kind: 'stage', stage: 'verify', status: 'unverified', note: `Checks ran, but the last one failed: ${oneLine(this.last.cmd, 80)}` });
+        }
+        return out;
+    }
+}
+/** Hints for the fix prompt when an agent run fails. */
+export function agentFixHints(state, allowHint) {
+    const hints = [];
+    const denied = state.facts.find((f) => f.key === 'denied');
+    if (denied)
+        hints.push(`The agent was denied permission for: ${denied.value}. ${allowHint}`);
+    hints.push('Review what the agent already changed with `git diff` before running it again.');
+    return hints;
+}

package/dist/providers/gcloud/index.js

@@ -0,0 +1,39 @@
+import { GcloudParser } from './parser.js';
+import { GCLOUD_NOTES, GCLOUD_STAGES } from './stages.js';
+export const gcloud = {
+    id: 'gcloud',
+    title: 'Cloud Run deploy',
+    stages: GCLOUD_STAGES,
+    notes: GCLOUD_NOTES,
+    install: 'Install the Google Cloud CLI (https://cloud.google.com/sdk/docs/install), then run `gcloud auth login`.',
+    launch(userArgs) {
+        const args = [...userArgs];
+        // `unfold gcloud …` means `gcloud run deploy …`; accept the full form too.
+        if (args[0] === 'run' && args[1] === 'deploy')
+            args.splice(0, 2);
+        return { bin: process.env.UNFOLD_GCLOUD_BIN || 'gcloud', args: ['run', 'deploy', ...args] };
+    },
+    createParser: () => new GcloudParser(),
+    fixHints(state) {
+        const fact = (k) => state.facts.find((f) => f.key === k)?.value;
+        switch (state.failedStage) {
+            case 'prepare':
+                return [
+                    'This failed before anything was built. Account, project, billing and disabled-API problems are fixed with gcloud commands, not code: `gcloud auth login`, `gcloud config set project <id>`, and `gcloud services enable run.googleapis.com cloudbuild.googleapis.com artifactregistry.googleapis.com`. If that is the cause, say so and stop.',
+                ];
+            case 'build':
+                return [
+                    `The container was built by Cloud Build, not locally.${fact('logsUrl') ? ` The full build log is at ${fact('logsUrl')}.` : ''}`,
+                    `It was built with ${fact('buildType') ?? 'a Dockerfile or buildpacks'}. Reproduce it locally with \`docker build .\` (Dockerfile) or \`pack build\` (buildpacks) before and after the fix.`,
+                    'For buildpacks, check that the project declares how to start (for example a `start` script in package.json, or a Procfile).',
+                ];
+            case 'deploy':
+                return [
+                    'The image built, but the new revision did not become healthy. The most common cause: the container must listen on 0.0.0.0 at the port in the PORT environment variable (8080 by default).',
+                    `Check start-up errors with \`gcloud run services logs read ${fact('service') ?? '<service>'}${fact('region') ? ` --region ${fact('region')}` : ''}\`. Crashes on start, missing environment variables and memory limits show up there.`,
+                ];
+            default:
+                return [];
+        }
+    },
+};

package/dist/providers/gcloud/parser.js

@@ -0,0 +1,149 @@
+const START = /^(?:(Building using (\S+) and deploying)|Deploying(?: new)?)\s+(?:container|sources|locally-built source)?\s*to Cloud Run (service|job|worker pool) \[(.+?)\] in project \[(.+?)\](?: region \[(.+?)\])?/;
+const STEP = /^(✓|OK|X|-|\.)?\s*(Creating Container Repository|Validating configuration|Uploading sources|Building Container|Creating Revision(?: in region: \S+)?|Routing traffic|Splitting instances|Setting IAM Policy|Enabling IAP)(?:\.\.\.)?\s*(.*)$/u;
+const SERVED = /Service \[(.+?)\] revision \[(.+?)\] has been deployed and is serving (\d+) percent of traffic/;
+const ERROR = /^ERROR: \((gcloud[\w.-]*)\) (.+)$/;
+const PROMPT = /\((?:y\/N|Y\/n)\)\??\s*$|^Please (?:specify|enter)|^Service name|^Source code location|^Do you want to continue/;
+const LOGS = /Logs are available at \[\s*(https?:\/\/\S+?)\s*\]/;
+const CAUSE = /failed to start|listen on the port|PORT=\d+|HealthCheckContainerError|Container import failed|exited with|\berror\b|failed|denied|not found|quota/i;
+const STEP_STAGE = {
+    'Creating Container Repository': 'prepare',
+    'Validating configuration': 'prepare',
+    'Uploading sources': 'build',
+    'Building Container': 'build',
+    'Creating Revision': 'deploy',
+    'Routing traffic': 'deploy',
+    'Splitting instances': 'deploy',
+    'Setting IAM Policy': 'deploy',
+    'Enabling IAP': 'deploy',
+};
+export class GcloudParser {
+    phase = 'start';
+    /** gcloud sometimes prints an HTML error page after "ERROR: … HTTPError". */
+    inHtmlError = false;
+    sawBuild = false;
+    prebuiltImage = false;
+    feed(line) {
+        const text = line.text.trim();
+        if (!text)
+            return [];
+        let m;
+        if ((m = START.exec(text))) {
+            this.phase = 'prepare';
+            this.prebuiltImage = !m[1] && /container to/.test(text);
+            const out = [
+                { kind: 'fact', key: 'service', label: 'Service', value: m[4], stage: 'prepare' },
+                { kind: 'fact', key: 'project', label: 'Project', value: m[5], stage: 'prepare' },
+                { kind: 'stage', stage: 'prepare', status: 'confirmed', note: `Deploying ${m[3]} ${m[4]} in project ${m[5]}${m[6] ? `, region ${m[6]}` : ''}.` },
+            ];
+            if (m[6])
+                out.push({ kind: 'fact', key: 'region', label: 'Region', value: m[6], stage: 'prepare' });
+            if (m[2])
+                out.push({ kind: 'fact', key: 'buildType', label: 'Build with', value: m[2], stage: 'build' });
+            if (this.prebuiltImage)
+                out.push({ kind: 'evidence', stage: 'build', note: 'Deploying a prebuilt container image, so there is nothing to build.' });
+            return out;
+        }
+        if (PROMPT.test(text))
+            return [{ kind: 'evidence', stage: 'prepare', note: 'gcloud asked a question in your terminal.' }];
+        if ((m = STEP.exec(text))) {
+            const label = m[2].replace(/ in region: .*/, '');
+            const stage = STEP_STAGE[label];
+            const mark = m[1];
+            const rest = m[3] ?? '';
+            const out = [];
+            const logs = LOGS.exec(rest);
+            if (logs)
+                out.push({ kind: 'fact', key: 'logsUrl', label: 'Build logs', value: logs[1], href: logs[1], stage: 'build' });
+            if (stage === 'build')
+                this.sawBuild = true;
+            if (stage !== 'prepare' && this.rank(stage) > this.rank(this.phase))
+                this.phase = stage;
+            if (mark === '✓' || mark === 'OK') {
+                // A finished build step only confirms the stage once the container is built;
+                // a finished revision step only once traffic is routed (or the IAM policy set).
+                if (label === 'Building Container' || label === 'Routing traffic' || label === 'Splitting instances')
+                    out.push({ kind: 'stage', stage, status: 'confirmed', note: `${label} finished.` });
+                else
+                    out.push({ kind: 'evidence', stage, note: `${label} finished.` });
+            }
+            else if (mark === 'X') {
+                out.push({ kind: 'stage', stage, status: 'failed', note: `${label} failed.${rest && !logs ? ` ${rest}` : ''}` });
+                if (rest && !logs)
+                    out.push({ kind: 'error', severity: 'cause', stage, message: rest, priority: 2 });
+            }
+            else if (mark === '-') {
+                out.push({ kind: 'evidence', stage, note: `${label} was interrupted.` });
+            }
+            else if (mark !== '.') {
+                out.push({ kind: 'stage', stage, status: 'active', note: `${label}…` });
+            }
+            return out;
+        }
+        if ((m = SERVED.exec(text))) {
+            this.phase = 'live';
+            const percent = Number(m[3]);
+            return [
+                { kind: 'fact', key: 'revision', label: 'Revision', value: m[2], stage: 'deploy' },
+                { kind: 'fact', key: 'traffic', label: 'Traffic', value: `${percent}%`, stage: 'live' },
+                { kind: 'stage', stage: 'deploy', status: 'confirmed', note: `Revision ${m[2]} is ready.` },
+                percent > 0
+                    ? { kind: 'stage', stage: 'live', status: 'confirmed', note: `Serving ${percent} percent of traffic.` }
+                    : { kind: 'stage', stage: 'live', status: 'unverified', note: 'The revision is deployed but receives no traffic (deployed with --no-traffic).' },
+            ];
+        }
+        if ((m = /^For more troubleshooting guidance, see (https?:\/\/\S+)/.exec(text))) {
+            return [{ kind: 'fact', key: 'troubleshooting', label: 'Troubleshooting', value: m[1], href: m[1], stage: this.currentStage() }];
+        }
+        if ((m = /^Logs URL:\s*(https?:\/\/\S+)/.exec(text))) {
+            return [{ kind: 'fact', key: 'logsUrl', label: 'Logs', value: m[1], href: m[1], stage: this.currentStage() }];
+        }
+        if ((m = /^Service URL:\s*(https?:\/\/\S+)/.exec(text))) {
+            return [{ kind: 'fact', key: 'deploymentUrl', label: 'Service URL', value: m[1], href: m[1], stage: 'live' }];
+        }
+        if ((m = ERROR.exec(text))) {
+            const html = /<!DOCTYPE|<html/i.test(m[2]);
+            this.inHtmlError = html;
+            const message = html ? m[2].replace(/<!DOCTYPE[\s\S]*$|<html[\s\S]*$/i, '').replace(/:\s*$/, '').trim() : m[2];
+            return [{ kind: 'error', severity: 'fatal', stage: this.stageForError(message), message }];
+        }
+        if (this.inHtmlError) {
+            // Keep only the readable sentences of the error page, e.g. "The requested URL … was not found".
+            if (/<\/html>/i.test(text))
+                this.inHtmlError = false;
+            if (/<title>|<style|<meta/i.test(text))
+                return [];
+            const plain = text
+                .replace(/<[^>]*>/g, ' ')
+                .replace(/That[’']s (all we know|an error)\.?/gi, '')
+                .replace(/\s+/g, ' ')
+                .trim();
+            if (/[a-z]{3,} [a-z]{3,}/i.test(plain) && !/[{}]|^[\w-]+:/.test(plain)) {
+                return [{ kind: 'error', severity: 'cause', stage: this.currentStage(), message: plain, priority: 3 }];
+            }
+            return [];
+        }
+        if (/^(Deployment failed|Failed\.|Local build failed)/.test(text)) {
+            return [{ kind: 'evidence', stage: this.currentStage(), note: 'gcloud reported the deployment failed.' }];
+        }
+        // Revision start-up and build errors printed as plain lines.
+        if (this.phase !== 'start' && CAUSE.test(text) && !/^(Done|OK)\b/.test(text)) {
+            return [{ kind: 'error', severity: 'cause', stage: this.currentStage(), message: text, priority: /failed to start|listen on the port|PORT=/.test(text) ? 3 : 1 }];
+        }
+        return [];
+    }
+    rank(p) {
+        return ['start', 'prepare', 'build', 'deploy', 'live'].indexOf(p);
+    }
+    currentStage() {
+        return this.phase === 'start' ? 'prepare' : this.phase;
+    }
+    stageForError(message) {
+        if (/build/i.test(message) && !/revision/i.test(message))
+            return 'build';
+        if (/revision|container failed|failed to start|PORT|health ?check/i.test(message))
+            return 'deploy';
+        if (/permission|denied|not authenticated|auth|project|api .*(not|has not) been (used|enabled)|billing/i.test(message) && this.phase !== 'deploy')
+            return this.phase === 'build' ? 'build' : 'prepare';
+        return this.currentStage();
+    }
+}

package/dist/providers/gcloud/stages.js

@@ -0,0 +1,55 @@
+// General explanations of `gcloud run deploy`. Nothing here is evidence from a run.
+export const GCLOUD_STAGES = [
+    {
+        id: 'prepare',
+        title: 'Prepare',
+        summary: 'gcloud works out which project, region and service to deploy to.',
+        explanation: [
+            'gcloud uses the account you logged in with (`gcloud auth login`) and your configured project and region. Anything missing, such as the service name or region, it asks for in the terminal.',
+            'With `--source`, it also decides how to build: from your Dockerfile if there is one, otherwise with Google Cloud buildpacks.',
+        ],
+        confirmedBy: 'The "Deploying … to Cloud Run service [name] in project [id] region [region]" line, printed once the target is resolved.',
+        docsUrl: 'https://cloud.google.com/sdk/gcloud/reference/run/deploy',
+    },
+    {
+        id: 'build',
+        title: 'Build',
+        summary: 'Your source is uploaded and built into a container image by Cloud Build.',
+        explanation: [
+            'For source deploys, gcloud uploads your code and Cloud Build turns it into a container image, stored in Artifact Registry. The build runs on Google Cloud, not on your machine; the full log is in the Cloud Build link.',
+            'If you deploy a prebuilt image with `--image`, there is nothing to build and this stage is skipped.',
+        ],
+        confirmedBy: 'A "✓ Building Container..." step.',
+        docsUrl: 'https://cloud.google.com/run/docs/deploying-source-code',
+    },
+    {
+        id: 'deploy',
+        title: 'Deploy',
+        summary: 'Cloud Run creates a new revision from the image and starts it.',
+        explanation: [
+            'Each deploy creates an immutable revision. Cloud Run starts a container from the image and waits for it to listen on the port in the PORT environment variable (8080 by default). A container that crashes or listens on the wrong port fails here.',
+            'Once the revision is healthy, traffic is routed to it, and with `--allow-unauthenticated` the public access policy is set.',
+        ],
+        confirmedBy: 'A "✓ Creating Revision..." step, followed by "✓ Routing traffic...".',
+        docsUrl: 'https://cloud.google.com/run/docs/troubleshooting',
+    },
+    {
+        id: 'live',
+        title: 'Live',
+        summary: 'The new revision serves traffic at the service URL.',
+        explanation: [
+            'When the deploy finishes, the new revision receives its share of traffic (normally 100 percent) at the service URL. Older revisions stay available for rollback.',
+            'Whether anyone on the internet can open the URL depends on the service’s authentication setting.',
+        ],
+        confirmedBy: 'The "Service [name] revision [id] has been deployed and is serving … percent of traffic." message.',
+        docsUrl: 'https://cloud.google.com/run/docs/managing/revisions',
+    },
+];
+export const GCLOUD_NOTES = {
+    success: 'Deployed',
+    successHeadline: 'Service is live',
+    docsLabel: 'Cloud Run docs',
+    highlights: ['revision', 'troubleshooting'],
+    interrupted: 'You pressed Ctrl+C while this stage was in progress. That stops gcloud, but Cloud Build or Cloud Run may finish the operation anyway. Check the Cloud Console.',
+    unverified: "This run's output never confirmed this stage, so Unfold does not claim it happened.",
+};

package/dist/providers/index.js

@@ -1,2 +1,5 @@
+import { claude } from './agents/claude.js';
+import { codex } from './agents/codex.js';
+import { gcloud } from './gcloud/index.js';
 import { vercel } from './vercel/index.js';
-export const providers = { vercel };
+export const providers = { vercel, gcloud, claude, codex };

package/dist/providers/vercel/index.js

@@ -8,6 +8,7 @@ export const vercel = {
     title: 'Vercel preview deploy',
     stages: VERCEL_STAGES,
     notes: VERCEL_NOTES,
+    install: 'Install it with `npm i -g vercel`, then run `vercel login`.',
     launch(userArgs) {
         const args = [...userArgs];
         if (!SUBCOMMANDS.has(args[0] ?? ''))

package/dist/providers/vercel/stages.js

@@ -46,6 +46,9 @@ export const VERCEL_STAGES = [
     },
 ];
 export const VERCEL_NOTES = {
+    success: 'Deployed',
+    successHeadline: 'Preview is ready',
+    docsLabel: 'Vercel docs',
     interrupted: 'You pressed Ctrl+C while this stage was in progress. That stops the CLI, but if the deployment had already been created, Vercel may keep building it. Check the Inspect URL.',
     unverified: "This run's output never confirmed this stage, so Unfold does not claim it happened.",
 };

package/dist/tui/render.js

@@ -23,11 +23,11 @@ export function glyph(st, s, frame = 0) {
             return s.dim('○');
     }
 }
-const OUTCOME = { running: 'Running', success: 'Deployed', failure: 'Failed', interrupted: 'Stopped' };
+const OUTCOME = { running: 'Running', success: 'Done', failure: 'Failed', interrupted: 'Stopped' };
 export function outcomeLabel(state, s) {
     if (state.outcome === 'success' && state.stages.at(-1)?.status !== 'confirmed')
         return s.yellow('Exited 0, not confirmed');
-    const word = OUTCOME[state.outcome];
+    const word = state.outcome === 'success' ? (state.notes?.success ?? OUTCOME.success) : OUTCOME[state.outcome];
     return state.outcome === 'success' ? s.green(word) : state.outcome === 'failure' ? s.red(word) : state.outcome === 'interrupted' ? s.yellow(word) : s.cyan(word);
 }
 export function elapsed(state, now = Date.now()) {
@@ -102,16 +102,23 @@ export function summary(state, logs, opts = {}) {
     }
     if (state.outcome === 'interrupted') {
         line();
-        line(`  ${s.yellow('Stopped')} ${state.facts.some((f) => f.key === 'inspectUrl') ? 'The deployment had already been created, so Vercel may still finish it.' : 'No deployment had been created yet.'}`);
+        block(s.yellow('Stopped'), focusStage(state).note ?? 'Ctrl+C stopped the command before it finished.');
+    }
+    const highlights = (state.notes?.highlights ?? []).map((k) => state.facts.find((f) => f.key === k)).filter((f) => !!f);
+    if (highlights.length) {
+        line();
+        const kw = Math.max(...highlights.map((f) => f.label.length)) + 2;
+        for (const f of highlights)
+            wrapText(f.value, Math.max(20, cols - kw - 2)).forEach((l, n) => out.push(`  ${n === 0 ? s.dim(f.label) + ' '.repeat(kw - f.label.length) : ' '.repeat(kw)}${l}`));
     }
     const url = state.facts.find((f) => f.key === 'alias') ?? state.facts.find((f) => f.key === 'deploymentUrl');
-    const inspect = state.facts.find((f) => f.key === 'inspectUrl');
+    const inspect = state.facts.find((f) => f.key === 'inspectUrl' || f.key === 'logsUrl');
     if (url || inspect)
         line();
     if (url && state.outcome === 'success')
         line(`  ${s.dim('URL'.padEnd(8))}${s.cyan(url.value)}`);
     if (inspect)
-        line(`  ${s.dim('Inspect'.padEnd(8))}${inspect.value}`);
+        out.push(`  ${s.dim((inspect.key === 'logsUrl' ? 'Logs' : 'Inspect').padEnd(8))}${inspect.value}`);
     if (state.fix?.commands) {
         line();
         line(`  ${s.bold('Fix it with an agent')} ${s.dim('(prompt built from this run)')}`);
@@ -121,9 +128,9 @@ export function summary(state, logs, opts = {}) {
     }
     // Output but nothing recognized: likely a CLI format Unfold doesn't know yet.
     if (state.endedAt && state.lineCount > 3 && state.stages.every((x) => x.status === 'unverified' || x.status === 'pending')) {
-        const version = state.facts.find((f) => f.key === 'cliVersion')?.value;
+        const version = state.facts.find((f) => f.key === 'cliVersion');
         line();
-        for (const l of wrapText(`Unfold didn't recognize any of this output${version ? ` (Vercel CLI ${version})` : ''}, so no stage is confirmed. If this was a normal deploy, please report it at https://github.com/faizm10/unfold/issues.`, cols - 4))
+        for (const l of wrapText(`Unfold didn't recognize any of this output${version ? ` (${version.label} ${version.value})` : ''}, so no stage is confirmed. If this was a normal run, please report it at https://github.com/faizm10/unfold/issues.`, cols - 4))
             out.push(`  ${s.yellow(l)}`);
     }
     const unverified = state.stages.filter((x) => x.status === 'unverified').length;

package/dist/ui/app.js

@@ -88,7 +88,7 @@ function renderHeader(s) {
     mode.className = `badge ${s.mode}`;
     const status = $('status');
     status.className = `pill ${s.outcome}`;
-    status.textContent = { running: 'Running', success: s.stages.at(-1)?.status === 'confirmed' ? 'Deployed' : 'Exited 0', failure: 'Failed', interrupted: 'Stopped' }[s.outcome];
+    status.textContent = { running: 'Running', success: s.stages.at(-1)?.status === 'confirmed' ? (s.notes?.success ?? 'Done') : 'Exited 0', failure: 'Failed', interrupted: 'Stopped' }[s.outcome];
     $('saved').replaceChildren(...(s.savedTo ? ['Saved to ', h('code', {}, s.savedTo)] : s.mode === 'demo' ? ['Demo data: recorded output, nothing is sent anywhere.'] : []));
     document.title = `${status.textContent} · Unfold`;
 }
@@ -121,7 +121,7 @@ function extLink(href, label) {
 function renderBanner(s) {
     const el = $('banner');
     const title = (id) => s.stages.find((st) => st.id === id)?.title ?? 'none';
-    const inspect = fact(s, 'inspectUrl');
+    const inspect = fact(s, 'inspectUrl') ?? fact(s, 'logsUrl');
     if (s.outcome === 'running') {
         el.hidden = true;
         return;
@@ -131,15 +131,15 @@ function renderBanner(s) {
     if (s.outcome === 'failure') {
         const err = primaryError(s);
         const cause = causes(s)[0];
-        fill(el, h('h2', {}, `Deploy failed during ${title(s.failedStage)}`), h('p', {}, `Last confirmed stage: ${title(s.lastConfirmed)}. Exit code ${s.exitCode ?? s.exitSignal ?? 'unknown'}.`), err ? h('div', { class: 'err' }, err.message) : h('p', {}, 'The command failed without printing a recognizable error. Check the logs.'), cause ? h('p', {}, 'Most relevant output: ', h('code', {}, cause.message)) : null, h('div', { class: 'actions' }, h('button', { class: 'btn primary', onclick: () => jumpTo((cause ?? err)?.seq) }, 'Jump to the error in the logs'), h('button', { class: 'btn', onclick: () => select(s.failedStage) }, `Open the ${title(s.failedStage)} stage`), inspect && inspect.href ? extLink(inspect.href, 'Full logs on Vercel') : null), s.fix ? fixPanel(s) : null);
+        fill(el, h('h2', {}, `Failed during ${title(s.failedStage)}`), h('p', {}, `Last confirmed stage: ${title(s.lastConfirmed)}. Exit code ${s.exitCode ?? s.exitSignal ?? 'unknown'}.`), err ? h('div', { class: 'err' }, err.message) : h('p', {}, 'The command failed without printing a recognizable error. Check the logs.'), cause ? h('p', {}, 'Most relevant output: ', h('code', {}, cause.message)) : null, h('div', { class: 'actions' }, h('button', { class: 'btn primary', onclick: () => jumpTo((cause ?? err)?.seq) }, 'Jump to the error in the logs'), h('button', { class: 'btn', onclick: () => select(s.failedStage) }, `Open the ${title(s.failedStage)} stage`), inspect && inspect.href ? extLink(inspect.href, `Open ${inspect.label}`) : null), s.fix ? fixPanel(s) : null);
     }
     else if (s.outcome === 'success') {
         const url = fact(s, 'alias') ?? fact(s, 'deploymentUrl');
         const live = s.stages.at(-1)?.status === 'confirmed';
-        fill(el, h('h2', {}, live ? 'Preview is ready' : 'Command finished, deploy not confirmed'), live ? null : h('p', {}, "The command exited with code 0, but its output never confirmed the deployment went live."), url?.href ? h('a', { class: 'live-url', href: url.href, target: '_blank', rel: 'noreferrer noopener' }, url.value) : h('p', {}, 'The command succeeded.'), fact(s, 'protection') ? h('p', {}, 'Deployment Protection is on, so visitors may need to sign in to Vercel.') : null, h('div', { class: 'actions' }, url?.value ? h('button', { class: 'btn', onclick: (e) => copy(url.value, e.currentTarget) }, 'Copy URL') : null, inspect?.href ? extLink(inspect.href, 'Inspect on Vercel') : null));
+        fill(el, h('h2', {}, live ? (s.notes?.successHeadline ?? 'Finished') : 'Command finished, but its output never confirmed the last stage'), live ? null : h('p', {}, "The command exited with code 0, but its output never confirmed the deployment went live."), url?.href ? h('a', { class: 'live-url', href: url.href, target: '_blank', rel: 'noreferrer noopener' }, url.value) : h('p', {}, 'The command succeeded.'), fact(s, 'protection') ? h('p', {}, 'Deployment Protection is on, so visitors may need to sign in to Vercel.') : null, h('div', { class: 'actions' }, url?.value ? h('button', { class: 'btn', onclick: (e) => copy(url.value, e.currentTarget) }, 'Copy URL') : null, inspect?.href ? extLink(inspect.href, `Open ${inspect.label}`) : null));
     }
     else {
-        fill(el, h('h2', {}, 'Stopped with Ctrl+C'), h('p', {}, `Last confirmed stage: ${title(s.lastConfirmed)}. ${inspect ? 'The deployment had already been created, so Vercel may still finish building it.' : 'No deployment had been created yet.'}`), h('div', { class: 'actions' }, inspect?.href ? extLink(inspect.href, 'Check it on Vercel') : null, h('button', { class: 'btn', onclick: () => openLogs(true) }, 'View logs')));
+        fill(el, h('h2', {}, 'Stopped with Ctrl+C'), h('p', {}, `Last confirmed stage: ${title(s.lastConfirmed)}. ${s.stages.find((st) => st.status === 'unverified' && st.note)?.note ?? ''}`), h('div', { class: 'actions' }, inspect?.href ? extLink(inspect.href, `Open ${inspect.label}`) : null, h('button', { class: 'btn', onclick: () => openLogs(true) }, 'View logs')));
     }
 }
 /** A ready-made prompt so a coding agent can pick up the failure. */
@@ -186,7 +186,7 @@ function renderDetail(s) {
         : null, st.evidence.length
         ? h('ul', { class: 'evidence' }, ...st.evidence.map((e) => evidenceItem(e.seq, e.at, e.note, logs.get(e.seq)?.text ?? e.text)))
         : h('p', { class: 'empty' }, 'No output from this run relates to this stage.'));
-    const explain = h('div', { class: 'card explain' }, h('div', { class: 'kicker' }, icon(ICONS.book), 'How this stage works · general, not from this run'), h('p', { class: 'summary' }, st.summary), ...st.explanation.map((p) => h('p', {}, p)), h('p', { class: 'confirm' }, h('b', {}, 'What would confirm it: '), st.confirmedBy), st.docsUrl ? h('a', { href: st.docsUrl, target: '_blank', rel: 'noreferrer noopener' }, 'Vercel docs') : null);
+    const explain = h('div', { class: 'card explain' }, h('div', { class: 'kicker' }, icon(ICONS.book), 'How this stage works · general, not from this run'), h('p', { class: 'summary' }, st.summary), ...st.explanation.map((p) => h('p', {}, p)), h('p', { class: 'confirm' }, h('b', {}, 'What would confirm it: '), st.confirmedBy), st.docsUrl ? h('a', { href: st.docsUrl, target: '_blank', rel: 'noreferrer noopener' }, s.notes?.docsLabel ?? 'Docs') : null);
     $('detail').setAttribute('aria-labelledby', `tab-${st.id}`);
     $('detail').replaceChildren(observed, explain);
 }

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "unfold-deploy",
-  "version": "0.1.0",
-  "description": "Watch what happens after you hit Enter: a live, explained flow of your Vercel deploys in the terminal.",
+  "version": "0.2.0",
+  "description": "Watch what happens after you hit Enter: live, explained flows for Vercel and Cloud Run deploys and Claude Code / Codex tasks, in your terminal.",
   "keywords": [
-    "vercel",
-    "deploy",
+    "ai-agents",
+    "build-logs",
+    "claude-code",
     "cli",
-    "terminal",
-    "preview",
+    "cloud-run",
+    "codex",
+    "deploy",
     "devtools",
-    "build-logs"
+    "gcloud",
+    "preview",
+    "terminal",
+    "vercel"
   ],
   "homepage": "https://github.com/faizm10/unfold#readme",
   "bugs": {