inflight-cli 2.6.0 → 2.8.0

package/dist/lib/vercel.d.ts

@@ -1,5 +1,8 @@
 /** Ensures the Vercel CLI is available — installs globally if missing. */
-export declare function ensureVercelCli(log?: (msg: string) => void): Promise<boolean>;
+export declare function ensureVercelCli(log?: (msg: string) => void): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
 /**
  * Gets a valid Vercel token. Refreshes silently via `vercel whoami` if expired.
  * Does NOT prompt for login — returns null if no valid token available.

package/dist/lib/vercel.js

@@ -18,14 +18,19 @@ function hasVercelCli() {
 /** Ensures the Vercel CLI is available — installs globally if missing. */
 export async function ensureVercelCli(log) {
     if (hasVercelCli())
-        return true;
+        return { ok: true };
     log?.("Installing Vercel CLI...");
     try {
         await execAsync("npm install -g vercel");
-        return true;
+        return { ok: true };
     }
-    catch {
-        return false;
+    catch (e) {
+        const stderr = e && typeof e === "object" && "stderr" in e && typeof e.stderr === "string"
+            ? e.stderr
+            : e instanceof Error
+                ? e.message
+                : "Unknown error";
+        return { ok: false, error: stderr };
     }
 }
 /** Returns the Vercel CLI config directory for the current platform. */

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,18 +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 {
-        spinner.stop("Could not fetch Netlify sites.");
+    catch (e) {
+        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 ---
@@ -56,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,
@@ -65,25 +68,25 @@ 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",
         options: sites.map((s) => ({
             value: s,
-            label: s.account_name
-                ? `${s.name.padEnd(maxName)}  ${pc.dim(`(${s.account_name})`)}`
-                : s.name,
+            label: s.account_name ? `${s.name.padEnd(maxName)}  ${pc.dim(`(${s.account_name})`)}` : s.name,
         })),
     });
     if (p.isCancel(selected)) {
@@ -91,15 +94,23 @@ async function pickFromList(sites) {
         process.exit(0);
     }
     const match = selected;
-    return { siteId: match.id, siteName: match.name, teamSlug: match.account_slug, repoPath: match.build_settings?.repo_path ?? null };
+    return {
+        siteId: match.id,
+        siteName: match.name,
+        teamSlug: match.account_slug,
+        repoPath: match.build_settings?.repo_path ?? null,
+    };
 }
 // --- Manual picker (used by `inflight netlify` command) ---
 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) => ({
@@ -122,14 +133,22 @@ export async function pickNetlifySite(token) {
 }
 // --- Main resolve function ---
 export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
-    const cliOk = await ensureNetlifyCli((msg) => p.log.step(msg));
-    if (!cliOk) {
-        p.log.error("Failed to install Netlify CLI. Install manually: " + pc.cyan("npm install -g netlify-cli"));
-        return null;
+    const cli = await ensureNetlifyCli((msg) => { if (!isAgent)
+        p.log.step(msg); });
+    if (!cli.ok) {
+        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")}.`);
+        }
+        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);
@@ -142,27 +161,27 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
     const repoMatches = site.repoPath && localRepoPath ? site.repoPath.toLowerCase() === localRepoPath : false;
     // Only filter by branch if we're in the matching repo — otherwise show all deploys
     let deploys = await getNetlifyDeploys(token, site.siteId, site.siteName, {
-        branch: repoMatches ? (gitInfo.branch ?? undefined) : undefined,
+        branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
     });
     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();
-        pollSpinner.start("Waiting for Netlify deployment...");
+        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, {
-                branch: repoMatches ? (gitInfo.branch ?? undefined) : undefined,
+                branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
             });
             commitDeploy = deploys.find((d) => d.commitRef === commitSha);
             if (commitDeploy)
                 break;
         }
         if (commitDeploy) {
-            pollSpinner.stop("Netlify deployment found!");
+            pollSpinner?.clear();
         }
         else {
-            pollSpinner.stop("Netlify deployment is still building...");
+            pollSpinner?.stop("No deployment detected yet — Netlify may still be processing.");
         }
     }
     // If we found a commit-specific deployment, handle based on state
@@ -172,55 +191,50 @@ 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();
-            const updateMessage = () => {
-                const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                spinner.message(`Waiting for Netlify to finish building... (${elapsed}s)`);
-            };
-            spinner.start("Waiting for Netlify to finish building... (0s)");
-            const ticker = setInterval(updateMessage, 1000);
+            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));
-                    updateMessage();
                     const freshDeps = await getNetlifyDeploys(token, site.siteId, site.siteName, {
-                        branch: repoMatches ? (gitInfo.branch ?? undefined) : undefined,
+                        branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
                     });
                     const fresh = freshDeps.find((d) => d.commitRef === commitSha);
                     if (!fresh)
                         break;
                     if (fresh.state === "ready") {
-                        clearInterval(ticker);
-                        const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                        spinner.stop(`Netlify deployment ready! (${elapsed}s)`);
-                        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") {
-                        clearInterval(ticker);
-                        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) {
-                    clearInterval(ticker);
-                    const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                    spinner.stop(`Still building after ${elapsed}s.`);
+                    spinner?.stop("Still building...");
+                    if (isAgent)
+                        return buildingUrl;
                     const action = await p.select({
                         message: "Netlify deployment is still building.",
                         options: [
@@ -240,31 +254,39 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
                     // Fall through to picker
                 }
             }
-            catch {
-                clearInterval(ticker);
-                spinner.stop("Error checking deployment status.");
+            catch (e) {
+                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;
         }
     }
     // Refresh deployments so the picker shows current states
     deploys = await getNetlifyDeploys(token, site.siteId, site.siteName, {
-        branch: repoMatches ? (gitInfo.branch ?? undefined) : undefined,
+        branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
     });
     // 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:",
@@ -296,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,18 +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 {
-        spinner.stop("Could not fetch Vercel projects.");
+    catch (e) {
+        spinner?.stop("Could not fetch Vercel projects.");
+        if (e instanceof Error)
+            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 ---
@@ -59,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,
@@ -69,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",
@@ -111,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()];
@@ -182,14 +190,23 @@ async function createProjectFlow(projects, ctx) {
 }
 // --- Main resolve function ---
 export async function resolveVercelUrl(cwd, gitInfo, opts) {
-    const cliOk = await ensureVercelCli((msg) => p.log.step(msg));
-    if (!cliOk) {
-        p.log.error("Failed to install Vercel CLI. Install manually: " + pc.cyan("npm install -g vercel"));
-        return null;
+    const cli = await ensureVercelCli((msg) => { if (!isAgent)
+        p.log.step(msg); });
+    if (!cli.ok) {
+        if (!isAgent)
+            p.log.error("Could not install the Vercel CLI automatically.");
+        if (cli.error) {
+            if (!isAgent)
+                p.log.message(pc.dim(cli.error.trim()));
+        }
+        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);
@@ -209,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();
-        pollSpinner.start("Waiting for Vercel deployment...");
+        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, {
@@ -221,10 +238,10 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
                 break;
         }
         if (commitDeploy) {
-            pollSpinner.stop("Vercel deployment found!");
+            pollSpinner?.clear();
         }
         else {
-            pollSpinner.stop("Vercel deployment is still building...");
+            pollSpinner?.stop("No deployment detected yet — Vercel may still be processing.");
         }
     }
     // If we found a commit-specific deployment, handle based on state
@@ -234,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
         }
@@ -242,24 +260,19 @@ 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 = 5_000;
+            const pollIntervalMs = 3_000;
             let resolved = false;
-            const spinner = p.spinner();
-            const updateMessage = () => {
-                const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                spinner.message(`Waiting for Vercel to finish building... (${elapsed}s)`);
-            };
-            spinner.start("Waiting for Vercel to finish building... (0s) ");
-            const ticker = setInterval(updateMessage, 1000);
+            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));
-                    updateMessage();
                     const freshDeps = await getVercelDeployments(token, project.teamId, project.projectId, {
                         branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
                     });
@@ -267,25 +280,22 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
                     if (!fresh)
                         break;
                     if (fresh.state === "READY") {
-                        clearInterval(ticker);
-                        const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                        spinner.stop(`Vercel deployment ready! (${elapsed}s)`);
-                        p.log.info(`Vercel deployment for ${commitLabel}${message}:\n  → ${pc.cyan(fresh.url)}`);
+                        spinner?.stop("Vercel deployment ready!");
                         return fresh.url;
                     }
                     if (fresh.state === "ERROR" || fresh.state === "CANCELED") {
-                        clearInterval(ticker);
-                        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) {
-                    clearInterval(ticker);
-                    const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                    spinner.stop(`Still building after ${elapsed}s.`);
+                    if (isAgent)
+                        return buildingUrl;
+                    spinner?.stop("Still building...");
                     const action = await p.select({
                         message: "Vercel deployment is still building.",
                         options: [
@@ -298,21 +308,25 @@ 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;
                     // Fall through to picker
                 }
             }
-            catch {
-                clearInterval(ticker);
-                spinner.stop("Error checking deployment status.");
+            catch (e) {
+                spinner?.stop("Error checking deployment status.");
+                if (e instanceof Error)
+                    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}:\n  → ${pc.cyan(commitDeploy.url)}`);
+            if (!isAgent)
+                p.log.info(`Vercel deployment for ${commitLabel}${message}`);
             return commitDeploy.url;
         }
     }
@@ -322,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:",
@@ -361,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)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "inflight-cli",
-	"version": "2.6.0",
+	"version": "2.8.0",
 	"description": "Get feedback directly on your staging URL",
 	"bin": {
 		"inflight": "dist/index.js",
@@ -19,8 +19,8 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@clack/core": "1.2.0",
-		"@clack/prompts": "1.2.0",
+		"@clack/core": "^1.3.0",
+		"@clack/prompts": "^1.3.0",
 		"commander": "12.1.0",
 		"open": "11.0.0",
 		"picocolors": "1.1.1",