@vertaaux/cli 0.3.3 → 0.5.0

package/dist/commands/triage.js

@@ -12,15 +12,15 @@
  *   vertaa triage --job abc123
  *   vertaa triage --file audit.json --verbose
  */
-import chalk from "chalk";
+import { bold, dim, colorize, boldColor, brand, severity as severityPalette, runSteps, createRenderer, renderWarning, renderError, isCI, isTTY, isStdinTTY, ScrollingViewport } from "@vertaaux/tui";
 import { ExitCode } from "../utils/exit-codes.js";
-import { resolveApiBase, getApiKey, apiRequest } from "../utils/client.js";
+import { resolveApiBase, getApiKey, apiRequest, createClient } from "../utils/client.js";
 import { resolveConfig } from "../config/loader.js";
 import { writeJsonOutput, writeOutput } from "../output/envelope.js";
 import { resolveCommandFormat } from "../output/formats.js";
-import { createSpinner, succeedSpinner } from "../ui/spinner.js";
 import { readJsonInput } from "../utils/stdin.js";
-import { handleAiCommandError, AI_TIMEOUT_MS } from "../utils/ai-error.js";
+import { AI_TIMEOUT_MS } from "../utils/ai-error.js";
+import { strings } from "../ui/strings.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -53,21 +53,21 @@ function normalizeIssues(issues) {
 // Formatters
 // ---------------------------------------------------------------------------
 const EFFORT_LABELS = {
-    trivial: chalk.green("trivial"),
-    small: chalk.green("small"),
-    medium: chalk.yellow("medium"),
-    large: chalk.red("large"),
+    trivial: colorize("trivial", brand.lime),
+    small: colorize("small", brand.lime),
+    medium: colorize("medium", severityPalette.warning),
+    large: colorize("large", severityPalette.error),
 };
 function formatEffort(effort) {
-    return EFFORT_LABELS[effort] || chalk.dim(effort);
+    return EFFORT_LABELS[effort] || dim(effort);
 }
 function formatTriageHuman(data, verbose) {
     const lines = [];
     // P0
-    lines.push(chalk.red.bold(`P0 Critical (${data.p0_critical.length})`));
+    lines.push(boldColor(`P0 Critical (${data.p0_critical.length})`, severityPalette.error));
     if (verbose) {
         for (const item of data.p0_critical) {
-            lines.push(`  ${chalk.red(">")} ${chalk.bold(item.title)}${item.id ? chalk.dim(` (${item.id})`) : ""}`);
+            lines.push(`  ${colorize(">", severityPalette.error)} ${bold(item.title)}${item.id ? dim(` (${item.id})`) : ""}`);
             lines.push(`    ${item.reason}`);
             lines.push(`    Effort: ${formatEffort(item.effort)}`);
         }
@@ -77,10 +77,10 @@ function formatTriageHuman(data, verbose) {
     }
     lines.push("");
     // P1
-    lines.push(chalk.yellow.bold(`P1 Important (${data.p1_important.length})`));
+    lines.push(boldColor(`P1 Important (${data.p1_important.length})`, severityPalette.warning));
     if (verbose) {
         for (const item of data.p1_important) {
-            lines.push(`  ${chalk.yellow(">")} ${chalk.bold(item.title)}${item.id ? chalk.dim(` (${item.id})`) : ""}`);
+            lines.push(`  ${colorize(">", severityPalette.warning)} ${bold(item.title)}${item.id ? dim(` (${item.id})`) : ""}`);
             lines.push(`    ${item.reason}`);
             lines.push(`    Effort: ${formatEffort(item.effort)}`);
         }
@@ -90,10 +90,10 @@ function formatTriageHuman(data, verbose) {
     }
     lines.push("");
     // P2
-    lines.push(chalk.cyan.bold(`P2 Nice to Have (${data.p2_nice_to_have.length})`));
+    lines.push(boldColor(`P2 Nice to Have (${data.p2_nice_to_have.length})`, brand.cyan));
     if (verbose) {
         for (const item of data.p2_nice_to_have) {
-            lines.push(`  ${chalk.cyan(">")} ${chalk.bold(item.title)}${item.id ? chalk.dim(` (${item.id})`) : ""}`);
+            lines.push(`  ${colorize(">", brand.cyan)} ${bold(item.title)}${item.id ? dim(` (${item.id})`) : ""}`);
             lines.push(`    ${item.reason}`);
             lines.push(`    Effort: ${formatEffort(item.effort)}`);
         }
@@ -104,14 +104,185 @@ function formatTriageHuman(data, verbose) {
     lines.push("");
     // Quick wins
     if (data.quick_wins.length > 0) {
-        lines.push(chalk.green.bold("Quick Wins (< 5 min each)"));
+        lines.push(boldColor("Quick Wins (< 5 min each)", brand.lime));
         for (const win of data.quick_wins) {
-            lines.push(`  ${chalk.green("*")} ${win}`);
+            lines.push(`  ${colorize("*", brand.lime)} ${win}`);
         }
     }
     return lines.join("\n");
 }
 // ---------------------------------------------------------------------------
+// Viewport helpers
+// ---------------------------------------------------------------------------
+/**
+ * Flatten triage p0/p1/p2 buckets into a ViewportItem array.
+ *
+ * Order: p0_critical → p1_important → p2_nice_to_have (preserves API order within buckets).
+ * Severity mapping: p0 → "critical", p1 → "warning", p2 → "moderate".
+ */
+export function buildViewportItems(data) {
+    const items = [];
+    for (const item of data.p0_critical) {
+        items.push({
+            id: item.id ?? item.title,
+            severity: "critical",
+            title: item.title,
+            effort: item.effort,
+            detail: item.reason,
+        });
+    }
+    for (const item of data.p1_important) {
+        items.push({
+            id: item.id ?? item.title,
+            severity: "warning",
+            title: item.title,
+            effort: item.effort,
+            detail: item.reason,
+        });
+    }
+    for (const item of data.p2_nice_to_have) {
+        items.push({
+            id: item.id ?? item.title,
+            severity: "moderate",
+            title: item.title,
+            effort: item.effort,
+            detail: item.reason,
+        });
+    }
+    return items;
+}
+export async function handleTriage(opts) {
+    const format = resolveCommandFormat("triage", opts.format, opts.machine || false);
+    const verbose = opts.verbose || false;
+    const config = { apiKey: opts.apiKey };
+    // Resolve fail-fast mode: --strict > --continue-on-error > auto-detect
+    let failFast;
+    if (opts.strict && opts.continueOnError) {
+        writeOutput(renderWarning({ message: "--strict and --continue-on-error both set — --strict takes precedence" }));
+        failFast = true;
+    }
+    else if (opts.strict) {
+        failFast = true;
+    }
+    else if (opts.continueOnError) {
+        failFast = false;
+    }
+    else {
+        failFast = isCI() || !isTTY();
+    }
+    // Resolve audit data
+    let auditPayload;
+    if (opts.job) {
+        // Fetch from API using SDK typed client
+        const sdkClient = createClient({ base: opts.base, apiKey: config.apiKey });
+        const result = await sdkClient.audits.retrieve(opts.job);
+        const issues = normalizeIssues(result.issues);
+        auditPayload = {
+            job_id: result.job_id || opts.job,
+            url: result.url || null,
+            scores: result.scores || null,
+            issues,
+        };
+    }
+    else {
+        // Read from stdin or --file
+        const input = await readJsonInput(opts.file);
+        if (!input) {
+            throw new Error("No audit data provided.\nUsage:\n  vertaa audit https://example.com --json | vertaa triage\n  vertaa triage --job <job-id>\n  vertaa triage --file audit.json");
+        }
+        const data = input;
+        const innerData = (data.data && typeof data.data === "object" ? data.data : data);
+        const issues = normalizeIssues(innerData.issues);
+        auditPayload = {
+            job_id: innerData.job_id || null,
+            url: innerData.url || null,
+            scores: innerData.scores || null,
+            issues,
+        };
+    }
+    if (!Array.isArray(auditPayload.issues) ||
+        auditPayload.issues.length === 0) {
+        throw new Error("No issues found in audit data.");
+    }
+    // Auth check
+    const base = resolveApiBase(opts.base);
+    const apiKey = getApiKey(config.apiKey);
+    const ctx = { triageData: null };
+    const renderer = createRenderer("auto");
+    const baseState = {
+        phase: "triage",
+        phaseIndex: 1,
+        phaseTotal: 1,
+        url: auditPayload.url || "",
+        mode: "triage",
+        progress: {},
+        totals: {},
+        issueCount: 0,
+        scorePreview: null,
+        verbose: false,
+        elapsed: 0,
+    };
+    const steps = [
+        {
+            id: "triage",
+            actionText: strings.triage.run.action,
+            summaryText: strings.triage.run.done(0, 0, 0),
+            run: async () => {
+                const response = await Promise.race([
+                    apiRequest(base, "/cli/ai/triage", { method: "POST", body: { audit: auditPayload } }, apiKey),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("LLM request timed out")), AI_TIMEOUT_MS)),
+                ]);
+                ctx.triageData = response.data;
+            },
+        },
+    ];
+    const { success, states } = await runSteps(steps, {
+        failFast,
+        onStateChange: (stepStates) => {
+            renderer.update({ ...baseState, stepStates });
+        },
+    });
+    renderer.finish({
+        url: auditPayload.url || "",
+        mode: "triage",
+        overallScore: success ? 100 : 0,
+        scores: {},
+        issueCount: 0,
+        passed: success,
+        elapsed: 0,
+    });
+    if (!success) {
+        const failedStep = states.find((s) => s.status === "failed");
+        process.stderr.write(renderError({
+            message: strings.triage.errors.triageFailed(failedStep?.failReason ?? "unknown error"),
+            suggestion: "vertaa doctor",
+        }) + "\n");
+        process.exit(ExitCode.ERROR);
+    }
+    const triageData = ctx.triageData;
+    if (!triageData) {
+        process.exit(ExitCode.ERROR);
+    }
+    if (format === "json") {
+        writeJsonOutput(triageData, "triage");
+    }
+    else if (isTTY() && isStdinTTY() && !isCI()) {
+        // Interactive viewport navigation — arrow-key navigable list
+        const viewportItems = buildViewportItems(triageData);
+        if (viewportItems.length > 0) {
+            const viewport = new ScrollingViewport({ items: viewportItems });
+            await viewport.run();
+        }
+        else {
+            writeOutput(formatTriageHuman(triageData, verbose));
+        }
+    }
+    else {
+        // Non-TTY / CI / piped-stdin fallback: current text output
+        writeOutput(formatTriageHuman(triageData, verbose));
+    }
+}
+// ---------------------------------------------------------------------------
 // Command Registration
 // ---------------------------------------------------------------------------
 export function registerTriageCommand(program) {
@@ -121,6 +292,8 @@ export function registerTriageCommand(program) {
         .option("--job <job-id>", "Fetch audit data from a job ID")
         .option("--file <path>", "Load audit JSON from file")
         .option("-f, --format <format>", "Output format: json | human")
+        .option("--strict", "Fail immediately on first step error")
+        .option("--continue-on-error", "Continue on step errors even in CI")
         .addHelpText("after", `
 Examples:
   vertaa audit https://example.com --json | vertaa triage
@@ -133,72 +306,24 @@ Examples:
             const config = await resolveConfig(globalOpts.config);
             const machineMode = globalOpts.machine || false;
             const verbose = globalOpts.verbose || false;
-            const format = resolveCommandFormat("triage", options.format, machineMode);
-            // Resolve audit data
-            let auditPayload;
-            if (options.job) {
-                // Fetch from API
-                const base = resolveApiBase(globalOpts.base);
-                const apiKey = getApiKey(config.apiKey);
-                const result = await apiRequest(base, `/audit/${options.job}`, { method: "GET" }, apiKey);
-                const issues = normalizeIssues(result.issues);
-                auditPayload = {
-                    job_id: result.job_id || options.job,
-                    url: result.url || null,
-                    scores: result.scores || null,
-                    issues,
-                };
-            }
-            else {
-                // Read from stdin or --file
-                const input = await readJsonInput(options.file);
-                if (!input) {
-                    console.error("Error: No audit data provided.");
-                    console.error("Usage:");
-                    console.error("  vertaa audit https://example.com --json | vertaa triage");
-                    console.error("  vertaa triage --job <job-id>");
-                    console.error("  vertaa triage --file audit.json");
-                    process.exit(ExitCode.ERROR);
-                }
-                const data = input;
-                const innerData = (data.data && typeof data.data === "object" ? data.data : data);
-                const issues = normalizeIssues(innerData.issues);
-                auditPayload = {
-                    job_id: innerData.job_id || null,
-                    url: innerData.url || null,
-                    scores: innerData.scores || null,
-                    issues,
-                };
-            }
-            if (!Array.isArray(auditPayload.issues) ||
-                auditPayload.issues.length === 0) {
-                console.error("Error: No issues found in audit data.");
-                process.exit(ExitCode.ERROR);
-            }
-            // Auth check
-            const base = resolveApiBase(globalOpts.base);
-            const apiKey = getApiKey(config.apiKey);
-            // Call LLM triage API
-            const spinner = createSpinner("Triaging findings...");
-            try {
-                const response = await Promise.race([
-                    apiRequest(base, "/cli/ai/triage", { method: "POST", body: { audit: auditPayload } }, apiKey),
-                    new Promise((_, reject) => setTimeout(() => reject(new Error("LLM request timed out")), AI_TIMEOUT_MS)),
-                ]);
-                succeedSpinner(spinner, "Triage complete");
-                if (format === "json") {
-                    writeJsonOutput(response.data, "triage");
-                }
-                else {
-                    writeOutput(formatTriageHuman(response.data, verbose));
-                }
-            }
-            catch (error) {
-                handleAiCommandError(error, "triage", spinner);
-            }
+            await handleTriage({
+                job: options.job,
+                file: options.file,
+                format: options.format,
+                strict: options.strict,
+                continueOnError: options.continueOnError,
+                machine: machineMode,
+                verbose,
+                base: globalOpts.base,
+                apiKey: config.apiKey,
+            });
         }
         catch (error) {
-            console.error("Error:", error instanceof Error ? error.message : String(error));
+            process.stderr.write(renderError({
+                message: error instanceof Error ? error.message : String(error),
+                suggestion: "vertaa doctor",
+                exitCode: ExitCode.ERROR,
+            }) + "\n");
             process.exit(ExitCode.ERROR);
         }
     });

package/dist/commands/upload.d.ts

@@ -5,6 +5,15 @@
  * Enables sharing results across team members and CI runs.
  */
 import { Command } from "commander";
+/**
+ * Handle the upload command.
+ */
+export declare function handleUpload(jobId: string | undefined, options: {
+    baseline?: boolean;
+    project?: string;
+    base?: string;
+    configPath?: string;
+}): Promise<void>;
 /**
  * Register the upload command with the Commander program.
  */

package/dist/commands/upload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/commands/upload.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0LpC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiB5D"}
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/commands/upload.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2CpC;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,OAAO,EAAE;IACP,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GACA,OAAO,CAAC,IAAI,CAAC,CAwKf;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA4B5D"}

package/dist/commands/upload.js

@@ -6,14 +6,15 @@
  */
 import fs from "fs";
 import path from "path";
-import chalk from "chalk";
-import { createSpinner, succeedSpinner, failSpinner } from "../ui/spinner.js";
+import { colorize, brand, renderError, runSteps, createRenderer } from "@vertaaux/tui";
 import { loadToken } from "../auth/token-store.js";
 import { getCIToken } from "../auth/ci-token.js";
-import { resolveApiBase } from "../utils/client.js";
+import { apiRequest, resolveApiBase } from "../utils/client.js";
 import { resolveConfig } from "../config/loader.js";
 import { loadBaseline, DEFAULT_BASELINE_PATH } from "../baseline/manager.js";
 import { ExitCode } from "../utils/exit-codes.js";
+import { writeOutput } from "../output/envelope.js";
+import { strings } from "../ui/strings.js";
 /**
  * Artifacts directory.
  */
@@ -33,113 +34,141 @@ async function getAuthToken() {
 /**
  * Handle the upload command.
  */
-async function handleUpload(jobId, options) {
+export async function handleUpload(jobId, options) {
     // Get auth token
     const token = await getAuthToken();
     if (!token) {
-        console.error(chalk.red("Error: Not authenticated."));
-        console.error("Run `vertaa login` to authenticate or set VERTAAUX_TOKEN environment variable.");
+        process.stderr.write(renderError({
+            message: strings.upload.errors.notAuthenticated,
+            suggestion: "vertaa login",
+            exitCode: ExitCode.ERROR,
+        }) + "\n");
         process.exit(ExitCode.ERROR);
     }
     // Load config for API base (supports --config global option)
-    const config = await resolveConfig(options.configPath);
+    await resolveConfig(options.configPath);
     const apiBase = resolveApiBase(options.base);
-    // Determine what to upload
-    const spinner = createSpinner("Preparing upload...");
-    spinner.start();
-    try {
-        // If no job ID, find the most recent local result
-        let targetJobId = jobId;
-        let localResultPath;
-        if (!targetJobId) {
-            // Look for recent results in artifacts directory
-            const artifactsPath = path.resolve(process.cwd(), ARTIFACTS_DIR);
-            if (fs.existsSync(artifactsPath)) {
-                const dirs = fs.readdirSync(artifactsPath).filter((d) => {
-                    const stat = fs.statSync(path.join(artifactsPath, d));
-                    return stat.isDirectory();
-                });
-                if (dirs.length > 0) {
-                    // Get most recent by mtime
-                    const sorted = dirs
-                        .map((d) => ({
-                        name: d,
-                        mtime: fs.statSync(path.join(artifactsPath, d)).mtime,
-                    }))
-                        .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-                    targetJobId = sorted[0].name;
-                    localResultPath = path.join(artifactsPath, targetJobId);
+    const renderer = createRenderer("auto");
+    const baseState = {
+        phase: "upload",
+        phaseIndex: 1,
+        phaseTotal: 1,
+        url: "",
+        mode: "upload",
+        progress: {},
+        totals: {},
+        issueCount: 0,
+        scorePreview: null,
+        verbose: false,
+        elapsed: 0,
+    };
+    const startTime = Date.now();
+    const ctx = {
+        uploadResult: null,
+        artifactCount: 1,
+    };
+    const steps = [
+        {
+            id: "read",
+            actionText: strings.upload.run.action,
+            summaryText: "File loaded",
+            run: async () => {
+                // If no job ID, find the most recent local result
+                let targetJobId = jobId;
+                let localResultPath;
+                if (!targetJobId) {
+                    // Look for recent results in artifacts directory
+                    const artifactsPath = path.resolve(process.cwd(), ARTIFACTS_DIR);
+                    if (fs.existsSync(artifactsPath)) {
+                        const dirs = fs.readdirSync(artifactsPath).filter((d) => {
+                            const stat = fs.statSync(path.join(artifactsPath, d));
+                            return stat.isDirectory();
+                        });
+                        if (dirs.length > 0) {
+                            // Get most recent by mtime
+                            const sorted = dirs
+                                .map((d) => ({
+                                name: d,
+                                mtime: fs.statSync(path.join(artifactsPath, d)).mtime,
+                            }))
+                                .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+                            targetJobId = sorted[0].name;
+                            localResultPath = path.join(artifactsPath, targetJobId);
+                        }
+                    }
+                    if (!targetJobId) {
+                        throw new Error(strings.upload.noJobId);
+                    }
                 }
-            }
-            if (!targetJobId) {
-                failSpinner(spinner, "No job ID provided and no local results found.");
-                console.error("Run `vertaa audit --save-trace` to save local results first.");
-                process.exit(ExitCode.ERROR);
-            }
-        }
-        spinner.setText(`Uploading audit ${targetJobId}...`);
-        // Prepare upload payload
-        const payload = {
-            job_id: targetJobId,
-            project: options.project || path.basename(process.cwd()),
-        };
-        // Add local results if available
-        if (localResultPath && fs.existsSync(localResultPath)) {
-            const files = fs.readdirSync(localResultPath);
-            const artifacts = {};
-            for (const file of files) {
-                const filePath = path.join(localResultPath, file);
-                const stat = fs.statSync(filePath);
-                // Skip large files (> 10MB)
-                if (stat.size > 10 * 1024 * 1024) {
-                    continue;
+                // Prepare upload payload
+                const payload = {
+                    job_id: targetJobId,
+                    project: options.project || path.basename(process.cwd()),
+                };
+                // Add local results if available
+                if (localResultPath && fs.existsSync(localResultPath)) {
+                    const files = fs.readdirSync(localResultPath);
+                    const artifacts = {};
+                    for (const file of files) {
+                        const filePath = path.join(localResultPath, file);
+                        const stat = fs.statSync(filePath);
+                        // Skip large files (> 10MB)
+                        if (stat.size > 10 * 1024 * 1024) {
+                            continue;
+                        }
+                        // Read file content (base64 for binary)
+                        const content = fs.readFileSync(filePath);
+                        const ext = path.extname(file).toLowerCase();
+                        const isBinary = [".png", ".jpg", ".jpeg", ".gif", ".zip"].includes(ext);
+                        artifacts[file] = isBinary
+                            ? content.toString("base64")
+                            : content.toString("utf-8");
+                    }
+                    payload.artifacts = artifacts;
+                    ctx.artifactCount = Object.keys(artifacts).length;
                 }
-                // Read file content (base64 for binary)
-                const content = fs.readFileSync(filePath);
-                const ext = path.extname(file).toLowerCase();
-                const isBinary = [".png", ".jpg", ".jpeg", ".gif", ".zip"].includes(ext);
-                artifacts[file] = isBinary
-                    ? content.toString("base64")
-                    : content.toString("utf-8");
-            }
-            payload.artifacts = artifacts;
-        }
-        // Upload baseline if requested
-        if (options.baseline) {
-            const baseline = await loadBaseline(DEFAULT_BASELINE_PATH);
-            if (baseline) {
-                payload.baseline = baseline;
-                spinner.setText(`Uploading audit ${targetJobId} with baseline...`);
-            }
-        }
-        // Make API request
-        const response = await fetch(`${apiBase}/sync/upload`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "X-API-Key": token,
+                // Upload baseline if requested
+                if (options.baseline) {
+                    const baseline = await loadBaseline(DEFAULT_BASELINE_PATH);
+                    if (baseline) {
+                        payload.baseline = baseline;
+                    }
+                }
+                // Make API request via apiRequest() — auth header constructed in client.ts only
+                const result = await apiRequest(apiBase, "/sync/upload", { method: "POST", body: payload }, token);
+                if (!result.success) {
+                    throw new Error(result.error?.message || "Upload failed");
+                }
+                ctx.uploadResult = result;
             },
-            body: JSON.stringify(payload),
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({ error: { message: response.statusText } }));
-            throw new Error(error.error?.message || `HTTP ${response.status}`);
-        }
-        const result = (await response.json());
-        if (!result.success) {
-            throw new Error(result.error?.message || "Upload failed");
-        }
-        succeedSpinner(spinner, "Upload complete!");
-        console.error("");
-        console.error(`  Job ID: ${result.job_id}`);
-        console.error(`  URL:    ${chalk.cyan(result.url)}`);
-        console.error("");
-        console.error("Share this URL with your team to view the results.");
+        },
+    ];
+    const { success, states } = await runSteps(steps, {
+        failFast: true,
+        onStateChange: (stepStates) => {
+            renderer.update({ ...baseState, stepStates, elapsed: Date.now() - startTime });
+        },
+    });
+    renderer.finish({ url: "", mode: "upload", overallScore: 0, scores: {}, issueCount: 0, passed: success, elapsed: Date.now() - startTime });
+    if (!success) {
+        const failed = states.find(s => s.status === "failed");
+        process.stderr.write(renderError({
+            message: failed?.failReason || "Command failed",
+            suggestion: "vertaa doctor",
+        }) + "\n");
+        process.exitCode = ExitCode.ERROR;
     }
-    catch (error) {
-        failSpinner(spinner, "Upload failed");
-        console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
-        process.exit(ExitCode.ERROR);
+    const { uploadResult, artifactCount } = ctx;
+    if (uploadResult) {
+        const lines = [
+            strings.upload.run.done(artifactCount),
+            "",
+            `  Job ID: ${uploadResult.job_id}`,
+            `  URL:    ${colorize(uploadResult.url, brand.cyan)}`,
+            "",
+            strings.upload.shareUrl,
+        ];
+        writeOutput(lines.join("\n"));
     }
 }
 /**
@@ -153,7 +182,17 @@ export function registerUploadCommand(program) {
         .option("--project <name>", "Cloud project name (default: current directory name)")
         .option("-b, --base <url>", "API base URL")
         .action(async (jobId, options, command) => {
-        const globalOpts = command.optsWithGlobals();
-        await handleUpload(jobId, { ...options, configPath: globalOpts.config });
+        try {
+            const globalOpts = command.optsWithGlobals();
+            await handleUpload(jobId, { ...options, configPath: globalOpts.config });
+        }
+        catch (error) {
+            process.stderr.write(renderError({
+                message: error instanceof Error ? error.message : String(error),
+                suggestion: "vertaa doctor",
+                exitCode: ExitCode.ERROR,
+            }) + "\n");
+            process.exit(ExitCode.ERROR);
+        }
     });
 }