inflight-cli 2.7.0 → 2.9.0

package/dist/index.js

@@ -18,13 +18,24 @@ program
     .description("Get feedback directly on your staging URL")
     .version(version)
     .enablePositionalOptions();
-program.command("setup").description("Set up Inflight in your project").action(setupCommand);
+program
+    .command("setup")
+    .description("Set up Inflight in your project")
+    .option("--json", "Output as JSON (auto-enabled for non-TTY)")
+    .option("--workspace <id>", "Workspace ID (skip selection)")
+    .action((opts) => setupCommand(opts));
 program.command("login").description("Authenticate with your Inflight account").action(loginCommand);
 program
     .command("share")
     .description("Get feedback on your staging URL")
     .option("--url <url>", "Staging URL (skips provider selection)")
-    .option("--json", "Output result as JSON")
+    .option("--json", "Output result as JSON (auto-enabled for non-TTY)")
+    .option("--workspace <id>", "Workspace ID (skip selection)")
+    .option("--project <id>", "Project ID, or 'new' to create")
+    .option("--provider <id>", "Deployment provider: vercel, netlify")
+    .option("--deployment <url>", "Specific deployment URL")
+    .option("--override", "Override latest version instead of creating new")
+    .option("--skip-git-check", "Skip git state check (use after agent handled git)")
     .action((opts) => shareCommand(opts));
 program
     .command("workspace")

package/dist/lib/agent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Agent mode detection and structured JSON output.
+ *
+ * When !process.stdout.isTTY (piped output, agent calling CLI),
+ * all interactive prompts are replaced with auto-resolution or
+ * structured JSON responses the agent can parse and act on.
+ */
+export declare const isAgent: boolean;
+export interface AgentChoice {
+    id: string;
+    label: string;
+    hint?: string;
+}
+export declare function agentSuccess(data: Record<string, unknown>): never;
+export declare function agentActionRequired(opts: {
+    type: string;
+    message: string;
+    choices: AgentChoice[];
+    nextCommand: string;
+    instructions?: Record<string, string>;
+}): never;
+export declare function agentError(opts: {
+    type: string;
+    message: string;
+    suggestion?: string;
+}): never;

package/dist/lib/agent.js

@@ -0,0 +1,32 @@
+/**
+ * Agent mode detection and structured JSON output.
+ *
+ * When !process.stdout.isTTY (piped output, agent calling CLI),
+ * all interactive prompts are replaced with auto-resolution or
+ * structured JSON responses the agent can parse and act on.
+ */
+export const isAgent = !process.stdout.isTTY;
+export function agentSuccess(data) {
+    console.log(JSON.stringify({ status: "success", data }));
+    process.exit(0);
+}
+export function agentActionRequired(opts) {
+    console.log(JSON.stringify({
+        status: "action_required",
+        type: opts.type,
+        message: opts.message,
+        choices: opts.choices,
+        next_command: opts.nextCommand,
+        ...(opts.instructions && { instructions: opts.instructions }),
+    }));
+    process.exit(0);
+}
+export function agentError(opts) {
+    console.log(JSON.stringify({
+        status: "error",
+        type: opts.type,
+        message: opts.message,
+        ...(opts.suggestion && { suggestion: opts.suggestion }),
+    }));
+    process.exit(1);
+}

package/dist/lib/resolve-workspace.d.ts

@@ -0,0 +1,15 @@
+import type { Workspace } from "./api.js";
+/**
+ * Resolves the active workspace ID.
+ *
+ * Resolution order:
+ * 1. Explicit --workspace flag
+ * 2. Saved config from prior session
+ * 3. Single workspace → auto-select
+ * 4. Multiple → action_required (agent) or p.select (human)
+ * 5. Zero → error
+ */
+export declare function resolveWorkspace(workspaces: Workspace[], opts?: {
+    explicitId?: string;
+    commandForNext?: string;
+}): Promise<string>;

package/dist/lib/resolve-workspace.js

@@ -0,0 +1,77 @@
+// apps/cli/src/lib/resolve-workspace.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { isAgent, agentActionRequired, agentError } from "./agent.js";
+import { readWorkspaceConfig, writeWorkspaceConfig } from "./config.js";
+/**
+ * Resolves the active workspace ID.
+ *
+ * Resolution order:
+ * 1. Explicit --workspace flag
+ * 2. Saved config from prior session
+ * 3. Single workspace → auto-select
+ * 4. Multiple → action_required (agent) or p.select (human)
+ * 5. Zero → error
+ */
+export async function resolveWorkspace(workspaces, opts = {}) {
+    const { explicitId, commandForNext = "inflight share" } = opts;
+    // Explicit flag
+    if (explicitId) {
+        const match = workspaces.find((w) => w.id === explicitId);
+        if (!match) {
+            if (isAgent) {
+                agentError({
+                    type: "invalid_workspace",
+                    message: `Workspace "${explicitId}" not found.`,
+                    suggestion: `Valid IDs: ${workspaces.map((w) => w.id).join(", ")}`,
+                });
+            }
+            p.log.error(`Workspace "${explicitId}" not found.`);
+            process.exit(1);
+        }
+        writeWorkspaceConfig({ workspaceId: match.id });
+        return match.id;
+    }
+    // Saved config — return silently (avoids duplicate log when setup calls share)
+    const savedConfig = readWorkspaceConfig();
+    const savedWorkspace = savedConfig ? workspaces.find((w) => w.id === savedConfig.workspaceId) : null;
+    if (savedWorkspace) {
+        return savedWorkspace.id;
+    }
+    // Zero
+    if (workspaces.length === 0) {
+        if (isAgent) {
+            agentError({ type: "no_workspaces", message: "No workspaces found. Create one at inflight.co first." });
+        }
+        p.log.error("No workspaces found. Create one at " + pc.cyan("inflight.co") + " first.");
+        process.exit(1);
+    }
+    // Single → auto-select
+    if (workspaces.length === 1) {
+        const ws = workspaces[0];
+        writeWorkspaceConfig({ workspaceId: ws.id });
+        if (!isAgent)
+            p.log.success(`Workspace: ${pc.bold(ws.name)}`);
+        return ws.id;
+    }
+    // Multiple
+    if (isAgent) {
+        agentActionRequired({
+            type: "choose_workspace",
+            message: "Multiple workspaces found. Re-run with --workspace <id>.",
+            choices: workspaces.map((w) => ({ id: w.id, label: w.name })),
+            nextCommand: `${commandForNext} --workspace <ID>`,
+        });
+    }
+    const selected = await p.select({
+        message: "Select a workspace " + pc.dim("(change anytime with inflight workspace)"),
+        options: workspaces.map((w) => ({ value: w.id, label: w.name })),
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    const workspaceId = selected;
+    writeWorkspaceConfig({ workspaceId });
+    return workspaceId;
+}

package/dist/providers/netlify.js

@@ -1,6 +1,7 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { parseGitRepo, getGitRoot } from "../lib/git.js";
+import { isAgent } from "../lib/agent.js";
 import { writeNetlifyConfig } from "../lib/config.js";
 import { ensureNetlifyCli, ensureNetlifyAuth, readLocalNetlifySite, writeLocalNetlifySite, getNetlifySiteById, getNetlifySites, getNetlifyDeploys, matchSitesByRepo, } from "../lib/netlify.js";
 // --- Auto-detection ---
@@ -37,20 +38,20 @@ async function autoDetectSite(cwd, gitInfo, token) {
         }
     }
     // --- Fetch all sites ---
-    const spinner = p.spinner();
-    spinner.start("Detecting Netlify site...");
+    const spinner = !isAgent ? p.spinner() : null;
+    spinner?.start("Detecting Netlify site...");
     let allSites;
     try {
         allSites = await getNetlifySites(token);
     }
     catch (e) {
-        spinner.stop("Could not fetch Netlify sites.");
-        if (e instanceof Error)
+        spinner?.stop("Could not fetch Netlify sites.");
+        if (!isAgent && e instanceof Error)
             p.log.message(pc.dim(e.message));
         return null;
     }
     if (allSites.length === 0) {
-        spinner.stop("No Netlify sites found.");
+        spinner?.stop("No Netlify sites found.");
         return null;
     }
     // --- Try exact match on git remote ---
@@ -58,7 +59,7 @@ async function autoDetectSite(cwd, gitInfo, token) {
     if (gitRepo) {
         const matches = matchSitesByRepo(allSites, gitRepo.owner, gitRepo.name);
         if (matches.length === 1) {
-            spinner.stop(`Detected Netlify site: ${pc.bold(matches[0].name)}`);
+            spinner?.stop(`Detected Netlify site: ${pc.bold(matches[0].name)}`);
             return cacheResult({
                 siteId: matches[0].id,
                 siteName: matches[0].name,
@@ -67,17 +68,19 @@ async function autoDetectSite(cwd, gitInfo, token) {
             });
         }
         if (matches.length > 1) {
-            spinner.stop(`Found ${matches.length} Netlify sites for this repo.`);
+            spinner?.stop(`Found ${matches.length} Netlify sites for this repo.`);
             const picked = await pickFromList(matches);
             return picked ? cacheResult(picked) : null;
         }
     }
     // --- No match ---
-    spinner.stop("Could not auto-detect Netlify site.");
+    spinner?.stop("Could not auto-detect Netlify site.");
     const picked = await pickFromList(allSites);
     return picked ? cacheResult(picked) : null;
 }
 async function pickFromList(sites) {
+    if (isAgent)
+        return null;
     const maxName = Math.max(...sites.map((s) => s.name.length));
     const selected = await p.select({
         message: "Select a Netlify site",
@@ -102,9 +105,12 @@ async function pickFromList(sites) {
 export async function pickNetlifySite(token) {
     const allSites = await getNetlifySites(token);
     if (allSites.length === 0) {
-        p.log.error("No Netlify sites found.");
+        if (!isAgent)
+            p.log.error("No Netlify sites found.");
         return null;
     }
+    if (isAgent)
+        return null;
     const selected = await p.select({
         message: "Select a Netlify site",
         options: allSites.map((s) => ({
@@ -127,18 +133,22 @@ export async function pickNetlifySite(token) {
 }
 // --- Main resolve function ---
 export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
-    const cli = await ensureNetlifyCli((msg) => p.log.step(msg));
+    const cli = await ensureNetlifyCli((msg) => { if (!isAgent)
+        p.log.step(msg); });
     if (!cli.ok) {
-        p.log.error("Could not install the Netlify CLI automatically.");
-        if (cli.error) {
-            p.log.message(pc.dim(cli.error.trim()));
+        if (!isAgent) {
+            p.log.error("Could not install the Netlify CLI automatically.");
+            if (cli.error) {
+                p.log.message(pc.dim(cli.error.trim()));
+            }
+            p.log.info(`Paste the error above into your AI agent — it can fix this for you.\n\nThen re-run ${pc.cyan("inflight share")}.`);
         }
-        p.log.info(`Paste the error above into your AI agent — it can fix this for you.\n\nThen re-run ${pc.cyan("inflight share")}.`);
         process.exit(0);
     }
     const token = await ensureNetlifyAuth();
     if (!token) {
-        p.log.error("Netlify login failed.");
+        if (!isAgent)
+            p.log.error("Netlify login failed.");
         return null;
     }
     const site = await autoDetectSite(cwd, gitInfo, token);
@@ -156,8 +166,8 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
     let commitDeploy = repoMatches ? deploys.find((d) => d.commitRef === commitSha) : undefined;
     // If just pushed, poll until the commit deployment appears
     if (!commitDeploy && repoMatches && opts?.justPushed) {
-        const pollSpinner = p.spinner({ indicator: "timer" });
-        pollSpinner.start("Waiting for Netlify to pick up your push...");
+        const pollSpinner = !isAgent ? p.spinner({ indicator: "timer" }) : null;
+        pollSpinner?.start("Waiting for deploy");
         for (let i = 0; i < 30; i++) {
             await new Promise((r) => setTimeout(r, 2000));
             deploys = await getNetlifyDeploys(token, site.siteId, site.siteName, {
@@ -168,10 +178,10 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
                 break;
         }
         if (commitDeploy) {
-            pollSpinner.clear();
+            pollSpinner?.clear();
         }
         else {
-            pollSpinner.stop("No deployment detected yet — Netlify may still be processing.");
+            pollSpinner?.stop("No deployment detected yet — Netlify may still be processing.");
         }
     }
     // If we found a commit-specific deployment, handle based on state
@@ -181,20 +191,22 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
             ? pc.dim(` — ${truncate(commitDeploy.commitMessage.split("\n")[0], 50)}`)
             : "";
         if (commitDeploy.state === "error") {
-            p.log.error(`Netlify deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
+            if (!isAgent)
+                p.log.error(`Netlify deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
             commitDeploy = undefined;
             // Fall through to the picker
         }
         else if (commitDeploy.state !== "ready") {
             // Any non-ready, non-error state (building, enqueued, uploading, preparing, processing, etc.)
-            p.log.info(`Netlify deployment for ${commitLabel}${message} — ${pc.yellow(commitDeploy.state)}`);
+            if (!isAgent)
+                p.log.info(`Netlify deployment for ${commitLabel}${message} — ${pc.yellow(commitDeploy.state)}`);
             const buildingUrl = commitDeploy.deploySslUrl;
             const startTime = Date.now();
             const maxWaitMs = 120_000;
             const pollIntervalMs = 5_000;
             let resolved = false;
-            const spinner = p.spinner({ indicator: "timer" });
-            spinner.start("Waiting for Netlify to finish building...");
+            const spinner = !isAgent ? p.spinner({ indicator: "timer" }) : null;
+            spinner?.start("Waiting for build");
             try {
                 while (Date.now() - startTime < maxWaitMs) {
                     await new Promise((r) => setTimeout(r, pollIntervalMs));
@@ -205,20 +217,24 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
                     if (!fresh)
                         break;
                     if (fresh.state === "ready") {
-                        spinner.stop("Netlify deployment ready!");
-                        p.log.info(`Netlify deployment for ${commitLabel}${message}:\n  → ${pc.cyan(fresh.deploySslUrl)}`);
+                        spinner?.stop("Netlify deployment ready!");
+                        if (!isAgent)
+                            p.log.info(`Netlify deployment for ${commitLabel}${message}:\n  → ${pc.cyan(fresh.deploySslUrl)}`);
                         return fresh.deploySslUrl;
                     }
                     if (fresh.state === "error") {
-                        spinner.stop(pc.red("Netlify deployment failed."));
-                        p.log.error(`Netlify deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
+                        spinner?.stop(pc.red("Netlify deployment failed."));
+                        if (!isAgent)
+                            p.log.error(`Netlify deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
                         commitDeploy = undefined;
                         resolved = true;
                         break;
                     }
                 }
                 if (!resolved) {
-                    spinner.stop("Still building...");
+                    spinner?.stop("Still building...");
+                    if (isAgent)
+                        return buildingUrl;
                     const action = await p.select({
                         message: "Netlify deployment is still building.",
                         options: [
@@ -239,14 +255,15 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
                 }
             }
             catch (e) {
-                spinner.stop("Error checking deployment status.");
-                if (e instanceof Error)
+                spinner?.stop("Error checking deployment status.");
+                if (!isAgent && e instanceof Error)
                     p.log.message(pc.dim(e.message));
             }
         }
         else {
             // ready — use it
-            p.log.info(`Netlify deployment for ${commitLabel}${message}:\n  → ${pc.cyan(commitDeploy.deploySslUrl)}`);
+            if (!isAgent)
+                p.log.info(`Netlify deployment for ${commitLabel}${message}:\n  → ${pc.cyan(commitDeploy.deploySslUrl)}`);
             return commitDeploy.deploySslUrl;
         }
     }
@@ -256,14 +273,20 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
     });
     // Fallback: no commit deployment — let user pick from recent or paste manually
     if (deploys.length === 0) {
-        p.log.warn("No deployments found. Paste a URL instead.");
+        if (!isAgent)
+            p.log.warn("No deployments found. Paste a URL instead.");
         return null;
     }
     const hasWorkingDeploy = deploys.some((d) => d.state !== "error");
     if (!hasWorkingDeploy) {
-        p.log.warn("All recent deployments failed. Fix the build and push again, or paste a URL.");
+        if (!isAgent)
+            p.log.warn("All recent deployments failed. Fix the build and push again, or paste a URL.");
         return null;
     }
+    if (isAgent) {
+        const ready = deploys.find((d) => d.state === "ready");
+        return ready?.deploySslUrl ?? deploys[0]?.deploySslUrl ?? null;
+    }
     const maxBranch = Math.max(...deploys.map((d) => (d.branch ?? "unknown").length));
     const selected = await p.select({
         message: "No deployment found for current commit. Select one:",
@@ -295,6 +318,8 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
     // Warn if the user picked a failed deployment
     const pickedDeploy = deploys.find((d) => d.deploySslUrl === selected);
     if (pickedDeploy && pickedDeploy.state === "error") {
+        if (isAgent)
+            return null;
         p.log.warn("This deployment failed — the URL may not load.");
         const confirm = await p.confirm({ message: "Use it anyway?" });
         if (p.isCancel(confirm) || !confirm)

package/dist/providers/vercel.js

@@ -2,6 +2,7 @@ import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { execSync } from "child_process";
 import { parseGitRepo, getGitRoot } from "../lib/git.js";
+import { isAgent } from "../lib/agent.js";
 import { ensureVercelCli, ensureVercelAuth, readLocalVercelProject, writeLocalVercelProject, getVercelProjectById, getVercelProjects, matchVercelProjectsByRepo, createVercelProject, getVercelDeployments, } from "../lib/vercel.js";
 // --- Auto-detection ---
 /**
@@ -40,20 +41,21 @@ async function autoDetectProject(cwd, gitInfo, token) {
         }
     }
     // --- Fetch all projects ---
-    const spinner = p.spinner();
-    spinner.start("Detecting Vercel project...");
+    const spinner = !isAgent ? p.spinner() : null;
+    spinner?.start("Detecting Vercel project...");
     let allProjects;
     try {
         allProjects = await getVercelProjects(token);
     }
     catch (e) {
-        spinner.stop("Could not fetch Vercel projects.");
+        spinner?.stop("Could not fetch Vercel projects.");
         if (e instanceof Error)
-            p.log.message(pc.dim(e.message));
+            if (!isAgent)
+                p.log.message(pc.dim(e.message));
         return null;
     }
     if (allProjects.length === 0) {
-        spinner.stop("No Vercel projects found.");
+        spinner?.stop("No Vercel projects found.");
         return null;
     }
     // --- Try exact match on git remote ---
@@ -61,7 +63,7 @@ async function autoDetectProject(cwd, gitInfo, token) {
     if (gitRepo) {
         const matches = matchVercelProjectsByRepo(allProjects, gitRepo.owner, gitRepo.name);
         if (matches.length === 1) {
-            spinner.stop(`Detected Vercel project: ${pc.bold(matches[0].name)}`);
+            spinner?.stop(`Detected Vercel project: ${pc.bold(matches[0].name)}`);
             return cacheResult({
                 teamId: matches[0].teamId,
                 projectId: matches[0].id,
@@ -71,18 +73,20 @@ async function autoDetectProject(cwd, gitInfo, token) {
             });
         }
         if (matches.length > 1) {
-            spinner.stop(`Found ${matches.length} Vercel projects for this repo.`);
+            spinner?.stop(`Found ${matches.length} Vercel projects for this repo.`);
             const picked = await pickFromList(allProjects);
             return picked ? cacheResult(picked) : null;
         }
     }
     // --- No match ---
-    spinner.stop("Could not auto-detect Vercel project.");
+    spinner?.stop("Could not auto-detect Vercel project.");
     const canCreate = gitRepo && gitRepo.provider !== "unknown";
     const picked = await pickFromList(allProjects, canCreate ? { token, gitRepo } : undefined);
     return picked ? cacheResult(picked) : null;
 }
 async function pickFromList(projects, createCtx) {
+    if (isAgent)
+        return null;
     const maxName = Math.max(...projects.map((proj) => proj.name.length));
     const selected = await p.select({
         message: "Select a Vercel project",
@@ -113,6 +117,8 @@ async function pickFromList(projects, createCtx) {
     };
 }
 async function createProjectFlow(projects, ctx) {
+    if (isAgent)
+        return null;
     const { token, gitRepo } = ctx;
     // Pick team from unique teams
     const teams = [...new Map(projects.map((proj) => [proj.teamId, proj.teamName])).entries()];
@@ -184,18 +190,23 @@ async function createProjectFlow(projects, ctx) {
 }
 // --- Main resolve function ---
 export async function resolveVercelUrl(cwd, gitInfo, opts) {
-    const cli = await ensureVercelCli((msg) => p.log.step(msg));
+    const cli = await ensureVercelCli((msg) => { if (!isAgent)
+        p.log.step(msg); });
     if (!cli.ok) {
-        p.log.error("Could not install the Vercel CLI automatically.");
+        if (!isAgent)
+            p.log.error("Could not install the Vercel CLI automatically.");
         if (cli.error) {
-            p.log.message(pc.dim(cli.error.trim()));
+            if (!isAgent)
+                p.log.message(pc.dim(cli.error.trim()));
         }
-        p.log.info(`Paste the error above into your AI agent — it can fix this for you.\n\nThen re-run ${pc.cyan("inflight share")}.`);
+        if (!isAgent)
+            p.log.info(`Paste the error above into your AI agent — it can fix this for you.\n\nThen re-run ${pc.cyan("inflight share")}.`);
         process.exit(0);
     }
     const token = await ensureVercelAuth();
     if (!token) {
-        p.log.error("Vercel login failed.");
+        if (!isAgent)
+            p.log.error("Vercel login failed.");
         return null;
     }
     const project = await autoDetectProject(cwd, gitInfo, token);
@@ -215,8 +226,8 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
     let commitDeploy = repoMatches ? deployments.find((d) => d.commitSha === commitSha) : undefined;
     // If just pushed, poll until the commit deployment appears
     if (!commitDeploy && repoMatches && opts?.justPushed) {
-        const pollSpinner = p.spinner({ indicator: "timer" });
-        pollSpinner.start("Waiting for Vercel to pick up your push");
+        const pollSpinner = !isAgent ? p.spinner({ indicator: "timer" }) : null;
+        pollSpinner?.start("Waiting for deploy");
         for (let i = 0; i < 30; i++) {
             await new Promise((r) => setTimeout(r, 2000));
             deployments = await getVercelDeployments(token, project.teamId, project.projectId, {
@@ -227,10 +238,10 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
                 break;
         }
         if (commitDeploy) {
-            pollSpinner.clear();
+            pollSpinner?.clear();
         }
         else {
-            pollSpinner.stop("No deployment detected yet — Vercel may still be processing.");
+            pollSpinner?.stop("No deployment detected yet — Vercel may still be processing.");
         }
     }
     // If we found a commit-specific deployment, handle based on state
@@ -240,7 +251,8 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
             ? pc.dim(` — ${truncate(commitDeploy.commitMessage.split("\n")[0], 50)}`)
             : "";
         if (commitDeploy.state === "ERROR" || commitDeploy.state === "CANCELED") {
-            p.log.error(`Vercel deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
+            if (!isAgent)
+                p.log.error(`Vercel deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
             commitDeploy = undefined;
             // Fall through to the picker
         }
@@ -248,15 +260,16 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
             commitDeploy.state === "QUEUED" ||
             commitDeploy.state === "INITIALIZING") {
             // Show what we're waiting on
-            p.log.info(`Vercel deployment for ${commitLabel}${message} — ${pc.yellow(commitDeploy.state.toLowerCase())}`);
+            if (!isAgent)
+                p.log.info(`Vercel deployment for ${commitLabel}${message} — ${pc.yellow(commitDeploy.state.toLowerCase())}`);
             // Poll with a ticking timer for up to ~2 minutes
             const buildingUrl = commitDeploy.url;
             const startTime = Date.now();
             const maxWaitMs = 120_000;
             const pollIntervalMs = 3_000;
             let resolved = false;
-            const spinner = p.spinner({ indicator: "timer" });
-            spinner.start("Waiting for Vercel to finish building");
+            const spinner = !isAgent ? p.spinner({ indicator: "timer" }) : null;
+            spinner?.start("Waiting for build");
             try {
                 while (Date.now() - startTime < maxWaitMs) {
                     await new Promise((r) => setTimeout(r, pollIntervalMs));
@@ -267,19 +280,22 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
                     if (!fresh)
                         break;
                     if (fresh.state === "READY") {
-                        spinner.stop("Vercel deployment ready!");
+                        spinner?.stop("Vercel deployment ready!");
                         return fresh.url;
                     }
                     if (fresh.state === "ERROR" || fresh.state === "CANCELED") {
-                        spinner.stop(pc.red("Vercel deployment failed."));
-                        p.log.error(`Vercel deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
+                        spinner?.stop(pc.red("Vercel deployment failed."));
+                        if (!isAgent)
+                            p.log.error(`Vercel deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
                         commitDeploy = undefined;
                         resolved = true;
                         break;
                     }
                 }
                 if (!resolved) {
-                    spinner.stop("Still building...");
+                    if (isAgent)
+                        return buildingUrl;
+                    spinner?.stop("Still building...");
                     const action = await p.select({
                         message: "Vercel deployment is still building.",
                         options: [
@@ -292,7 +308,8 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
                         process.exit(0);
                     }
                     if (action === "continue") {
-                        p.log.info(`Vercel deployment for ${commitLabel}${message}:\n  → ${pc.cyan(buildingUrl)} ${pc.yellow("(building)")}`);
+                        if (!isAgent)
+                            p.log.info(`Vercel deployment for ${commitLabel}${message}:\n  → ${pc.cyan(buildingUrl)} ${pc.yellow("(building)")}`);
                         return buildingUrl;
                     }
                     commitDeploy = undefined;
@@ -300,14 +317,16 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
                 }
             }
             catch (e) {
-                spinner.stop("Error checking deployment status.");
+                spinner?.stop("Error checking deployment status.");
                 if (e instanceof Error)
-                    p.log.message(pc.dim(e.message));
+                    if (!isAgent)
+                        p.log.message(pc.dim(e.message));
             }
         }
         else {
             // READY or any other terminal state — use it
-            p.log.info(`Vercel deployment for ${commitLabel}${message}`);
+            if (!isAgent)
+                p.log.info(`Vercel deployment for ${commitLabel}${message}`);
             return commitDeploy.url;
         }
     }
@@ -317,14 +336,20 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
     });
     // Fallback: no commit deployment found — let user pick from recent or paste manually
     if (deployments.length === 0) {
-        p.log.warn("No deployments found. Paste a URL instead.");
+        if (!isAgent)
+            p.log.warn("No deployments found. Paste a URL instead.");
         return null;
     }
     const hasWorkingDeployment = deployments.some((d) => d.state !== "ERROR" && d.state !== "CANCELED");
     if (!hasWorkingDeployment) {
-        p.log.warn("All recent deployments failed. Fix the build and push again, or paste a URL.");
+        if (!isAgent)
+            p.log.warn("All recent deployments failed. Fix the build and push again, or paste a URL.");
         return null;
     }
+    if (isAgent) {
+        const ready = deployments.find((d) => d.state === "READY");
+        return ready?.url ?? deployments[0]?.url ?? null;
+    }
     const maxBranchPick = Math.max(...deployments.map((d) => (d.branch ?? "unknown").length));
     const selected = await p.select({
         message: "No deployment found for current commit. Select one:",
@@ -356,6 +381,8 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
     // Warn if the user picked a failed deployment
     const pickedDeploy = deployments.find((d) => d.url === selected);
     if (pickedDeploy && (pickedDeploy.state === "ERROR" || pickedDeploy.state === "CANCELED")) {
+        if (isAgent)
+            return null;
         p.log.warn("This deployment failed — the URL may not load.");
         const confirm = await p.confirm({ message: "Use it anyway?" });
         if (p.isCancel(confirm) || !confirm)