inflight-cli 2.7.0 → 2.8.0

package/dist/commands/login.js

@@ -3,47 +3,74 @@ import pc from "picocolors";
 import { readGlobalAuth, writeGlobalAuth } from "../lib/config.js";
 import { apiGetMe } from "../lib/api.js";
 import { API_URL, WEB_URL } from "../lib/env.js";
+import { isAgent, agentError } from "../lib/agent.js";
 const POLL_INTERVAL_MS = 2000;
 const POLL_TIMEOUT_MS = 5 * 60 * 1000;
 export async function loginCommand() {
     const existingAuth = readGlobalAuth();
     if (existingAuth) {
-        const spinner = p.spinner();
-        spinner.start("Checking existing session...");
-        const me = await apiGetMe(existingAuth.apiKey).catch(() => null);
-        if (me?.email) {
-            spinner.stop(pc.green(`✓ Logged in as ${pc.bold(me.email)}`));
-            return;
+        if (!isAgent) {
+            const spinner = p.spinner();
+            spinner.start("Checking existing session...");
+            const me = await apiGetMe(existingAuth.apiKey).catch(() => null);
+            if (me?.email) {
+                spinner.stop(pc.green(`✓ Logged in as ${pc.bold(me.email)}`));
+                return;
+            }
+            spinner.stop("Session expired — re-authenticating...");
+        }
+        else {
+            const me = await apiGetMe(existingAuth.apiKey).catch(() => null);
+            if (me?.email)
+                return;
         }
-        spinner.stop("Session expired — re-authenticating...");
     }
     const sessionId = crypto.randomUUID();
     const authUrl = `${WEB_URL}/cli/connect?session_id=${sessionId}`;
-    p.log.info("Opening browser to authenticate with Inflight...");
-    p.log.info(`Opening ${pc.cyan(authUrl)}`);
+    if (!isAgent) {
+        p.log.info("Opening browser to authenticate with Inflight...");
+        p.log.info(`Opening ${pc.cyan(authUrl)}`);
+    }
     const { default: open } = await import("open");
     await open(authUrl);
-    const spinner = p.spinner();
-    spinner.start("Waiting for browser authentication...");
-    const apiKey = await pollForApiKey(sessionId);
-    if (!apiKey) {
-        spinner.stop("Authentication timed out.");
-        p.log.error("No response after 5 minutes. Please try again.");
-        process.exit(1);
+    if (!isAgent) {
+        const spinner = p.spinner();
+        spinner.start("Waiting for login");
+        const apiKey = await pollForApiKey(sessionId);
+        if (!apiKey) {
+            spinner.stop("Authentication timed out.");
+            p.log.error("No response after 5 minutes. Please try again.");
+            process.exit(1);
+        }
+        spinner.message("Validating...");
+        const me = await apiGetMe(apiKey).catch((e) => {
+            spinner.stop("Validation failed.");
+            p.log.error(e.message);
+            process.exit(1);
+        });
+        if (!me.email) {
+            spinner.stop("Validation failed.");
+            p.log.error("No email associated with this account.");
+            process.exit(1);
+        }
+        writeGlobalAuth({ apiKey });
+        spinner.stop(pc.green(`✓ Logged in as ${pc.bold(me.email)}`));
     }
-    spinner.message("Validating...");
-    const me = await apiGetMe(apiKey).catch((e) => {
-        spinner.stop("Validation failed.");
-        p.log.error(e.message);
-        process.exit(1);
-    });
-    if (!me.email) {
-        spinner.stop("Validation failed.");
-        p.log.error("No email associated with this account. Please sign up at inflight.co first.");
-        process.exit(1);
+    else {
+        const apiKey = await pollForApiKey(sessionId);
+        if (!apiKey) {
+            agentError({
+                type: "auth_timeout",
+                message: "Authentication timed out. Approve the browser prompt and try again.",
+                suggestion: "inflight login",
+            });
+        }
+        const me = await apiGetMe(apiKey).catch(() => null);
+        if (!me?.email) {
+            agentError({ type: "auth_failed", message: "Could not validate account." });
+        }
+        writeGlobalAuth({ apiKey });
     }
-    writeGlobalAuth({ apiKey });
-    spinner.stop(pc.green(`✓ Logged in as ${pc.bold(me.email)}`));
 }
 async function pollForApiKey(sessionId) {
     const deadline = Date.now() + POLL_TIMEOUT_MS;
@@ -55,14 +82,10 @@ async function pollForApiKey(sessionId) {
                 if (api_key)
                     return api_key;
             }
-            // 404 = not ready yet, keep polling
-            // 500+ = server error, stop
             if (res.status >= 500)
                 return null;
         }
-        catch {
-            // Network error (offline, DNS, etc.) — keep polling
-        }
+        catch { }
         await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
     }
     return null;

package/dist/commands/setup.d.ts

@@ -1 +1,5 @@
-export declare function setupCommand(): Promise<void>;
+export interface SetupOptions {
+    json?: boolean;
+    workspace?: string;
+}
+export declare function setupCommand(opts?: SetupOptions): Promise<void>;

package/dist/commands/setup.js

@@ -1,12 +1,14 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { execSync } from "child_process";
-import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
+import { readGlobalAuth, writeWorkspaceConfig } from "../lib/config.js";
 import { apiGetMe, apiDetectWidgetLocation } from "../lib/api.js";
 import { loginCommand } from "./login.js";
 import { shareCommand } from "./share.js";
 import { gatherProjectContext, insertWidgetScript } from "../lib/framework.js";
 import { isGitRepo } from "../lib/git.js";
+import { isAgent, agentSuccess, agentError } from "../lib/agent.js";
+import { resolveWorkspace } from "../lib/resolve-workspace.js";
 function execSyncErrorDetail(err) {
     if (err !== null && typeof err === "object" && "stderr" in err) {
         const b = err.stderr;
@@ -21,10 +23,10 @@ function execSyncErrorDetail(err) {
     }
     return "";
 }
-export async function setupCommand() {
+export async function setupCommand(opts = {}) {
     const cwd = process.cwd();
     // ── Pre-flight: warn if not a git repo ──
-    if (!isGitRepo(cwd)) {
+    if (!isGitRepo(cwd) && !isAgent) {
         p.log.warn("This directory is not a git repository.\n" +
             "  Inflight works best inside a git repo so it can track branches and commits.");
     }
@@ -35,52 +37,61 @@ export async function setupCommand() {
         await loginCommand();
         auth = readGlobalAuth();
         if (!auth) {
+            if (isAgent)
+                agentError({ type: "auth_failed", message: "Login failed." });
             p.log.error("Login failed.");
             process.exit(1);
         }
     }
     // ── Step 3: Resolve workspace ──
     const me = await apiGetMe(auth.apiKey).catch((e) => {
+        if (isAgent)
+            agentError({ type: "api_error", message: e.message });
         p.log.error(e.message);
         process.exit(1);
     });
-    if (alreadyLoggedIn && me.email) {
+    if (!isAgent && alreadyLoggedIn && me.email) {
         p.log.success(`Logged in as ${pc.bold(me.email)}`);
     }
-    const workspaces = me.workspaces;
-    let workspaceId;
-    // Check if a workspace is already configured and still valid
-    const existingConfig = readWorkspaceConfig();
-    const existingWorkspace = existingConfig ? workspaces.find((w) => w.id === existingConfig.workspaceId) : null;
-    if (existingWorkspace) {
-        workspaceId = existingWorkspace.id;
-        p.log.success(`Workspace: ${pc.bold(existingWorkspace.name)} ${pc.dim("(change anytime with inflight workspace)")}`);
-    }
-    else if (workspaces.length === 0) {
-        p.log.error("No workspaces found. Create one at " + pc.cyan("inflight.co") + " first.");
-        process.exit(1);
-    }
-    else if (workspaces.length === 1) {
-        workspaceId = workspaces[0].id;
-        p.log.success(`Workspace: ${pc.bold(workspaces[0].name)}`);
-    }
-    else {
-        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);
-        }
-        workspaceId = selected;
-    }
+    const workspaceId = await resolveWorkspace(me.workspaces, {
+        explicitId: opts.workspace,
+        commandForNext: "inflight setup",
+    });
     writeWorkspaceConfig({ workspaceId });
-    const widgetId = workspaces.find((w) => w.id === workspaceId)?.widgetId;
+    if (!isAgent) {
+        const wsName = me.workspaces.find((w) => w.id === workspaceId)?.name;
+        if (wsName)
+            p.log.success(`Workspace: ${pc.bold(wsName)} ${pc.dim("(change anytime with inflight workspace)")}`);
+    }
+    const widgetId = me.workspaces.find((w) => w.id === workspaceId)?.widgetId;
     if (!widgetId) {
+        if (isAgent)
+            agentError({ type: "no_widget_id", message: "Could not find widget ID for this workspace." });
         p.log.error("Could not find widget ID for this workspace.");
         process.exit(1);
     }
+    // ── Agent mode: return JSON with instructions and exit ──
+    if (isAgent) {
+        const context = gatherProjectContext(cwd);
+        const alreadyHasWidget = Object.values(context.fileContents).some((c) => c.includes("inflight.co/widget.js"));
+        const scriptTag = `<script src="https://www.inflight.co/widget.js" data-workspace="${widgetId}" async></script>`;
+        const nextSteps = alreadyHasWidget
+            ? ["Widget already installed. Run `inflight share` to share your staging URL."]
+            : [
+                "Insert the scriptTag into the project's root layout file, just before </body> (or as the last child of <body> in JSX/TSX files).",
+                "Common locations: app/layout.tsx (Next.js), index.html (Vite/CRA), app/root.tsx (Remix), src/app.html (SvelteKit).",
+                "Commit and push the change so it's included in the next deployment.",
+                "Then run `inflight share` to share the staging URL for feedback.",
+            ];
+        agentSuccess({
+            workspaceId,
+            workspaceName: me.workspaces.find((w) => w.id === workspaceId)?.name ?? null,
+            widgetId,
+            scriptTag,
+            alreadyInstalled: alreadyHasWidget,
+            nextSteps,
+        });
+    }
     // ── Step 4: Add widget script tag ──
     const hasWidget = (fileContents) => Object.values(fileContents).some((c) => c.includes("inflight.co/widget.js"));
     const context = gatherProjectContext(cwd);

package/dist/commands/share.d.ts

@@ -1,5 +1,11 @@
 export interface ShareOptions {
     url?: string;
     json?: boolean;
+    workspace?: string;
+    project?: string;
+    provider?: string;
+    deployment?: string;
+    override?: boolean;
+    skipGitCheck?: boolean;
 }
 export declare function shareCommand(opts?: ShareOptions): Promise<void>;

package/dist/commands/share.js

@@ -1,11 +1,15 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
-import { getGitInfo, getGitSyncState, generateCommitMessage, commitAndPush, pushBranch, hasCommitsAhead, } from "../lib/git.js";
+import { readGlobalAuth } from "../lib/config.js";
+import { getGitInfo, getGitSyncState, generateCommitMessage, commitAndPush, pushBranch, hasCommitsAhead, getGitRoot, } from "../lib/git.js";
 import open from "open";
 import { providers } from "../providers/index.js";
 import { apiGetMe, apiCreateVersion, apiGetRecentProjects } from "../lib/api.js";
 import { scrollableSelect } from "../lib/scrollable-select.js";
+import { isAgent, agentSuccess, agentActionRequired, agentError } from "../lib/agent.js";
+import { resolveWorkspace } from "../lib/resolve-workspace.js";
+import { readLocalVercelProject } from "../lib/vercel.js";
+import { readLocalNetlifySite } from "../lib/netlify.js";
 function formatRelativeTime(timestampMs) {
     const seconds = Math.floor((Date.now() - timestampMs) / 1000);
     if (seconds < 60)
@@ -32,12 +36,29 @@ function isValidHostedUrl(url) {
         return false;
     }
 }
+/**
+ * Builds a next_command string carrying forward relevant opts from the current run.
+ */
+function buildNextCommand(base, opts) {
+    const parts = [base];
+    if (opts.workspace)
+        parts.push(`--workspace ${opts.workspace}`);
+    if (opts.provider)
+        parts.push(`--provider ${opts.provider}`);
+    if (opts.deployment)
+        parts.push(`--deployment ${opts.deployment}`);
+    if (opts.project)
+        parts.push(`--project ${opts.project}`);
+    if (opts.override)
+        parts.push("--override");
+    return parts.join(" ");
+}
 /**
  * Checks local git state and prompts the user to commit/push if needed.
  * Returns { justPushed: true } if changes were pushed, { justPushed: false } otherwise.
  * Provider-agnostic — works for Vercel, Netlify, or any future provider.
  */
-async function checkAndSyncGit(cwd) {
+async function checkAndSyncGit(cwd, opts = {}) {
     const state = getGitSyncState(cwd);
     if (state.status === "clean" || state.status === "detached") {
         return { justPushed: false };
@@ -74,6 +95,17 @@ async function checkAndSyncGit(cwd) {
         if (state.changedFiles.length > maxFiles) {
             lines.push(`  ${pc.dim(`... and ${state.changedFiles.length - maxFiles} more`)}`);
         }
+        if (isAgent) {
+            agentActionRequired({
+                type: "git_uncommitted",
+                message: "You have uncommitted changes. Your deployment won't include them.",
+                choices: [
+                    { id: "commit_push", label: "Commit and push these changes" },
+                    { id: "continue", label: "Continue without committing" },
+                ],
+                nextCommand: buildNextCommand("inflight share --skip-git-check", opts),
+            });
+        }
         lines.push("", pc.yellow("Your deployment won't include these changes."));
         p.log.warn("You have uncommitted changes:\n" + lines.join("\n"));
         const action = await p.select({
@@ -128,6 +160,17 @@ async function checkAndSyncGit(cwd) {
         if (state.unpushedCommits.length > 5) {
             commitLines.push(`  ${pc.dim(`... and ${state.unpushedCommits.length - 5} more`)}`);
         }
+        if (isAgent) {
+            agentActionRequired({
+                type: "git_unpushed",
+                message: "You have unpushed commits. Your deployment won't include them.",
+                choices: [
+                    { id: "push", label: "Push these commits" },
+                    { id: "continue", label: "Continue without pushing" },
+                ],
+                nextCommand: buildNextCommand("inflight share --skip-git-check", opts),
+            });
+        }
         commitLines.push("", pc.yellow("Your deployment won't include these commits."));
         p.log.warn("You have unpushed commits:\n" + commitLines.join("\n"));
         const action = await p.select({
@@ -170,6 +213,17 @@ async function checkAndSyncGit(cwd) {
             p.log.info(`Branch ${pc.bold(branch)} has no new commits — using existing deployments.`);
             return { justPushed: false };
         }
+        if (isAgent) {
+            agentActionRequired({
+                type: "git_no_remote",
+                message: `Branch "${branch}" hasn't been pushed yet — no deployment exists.`,
+                choices: [
+                    { id: "push", label: "Push to create a deployment" },
+                    { id: "continue", label: "Continue without pushing" },
+                ],
+                nextCommand: buildNextCommand("inflight share --skip-git-check", opts),
+            });
+        }
         p.log.warn(`Branch ${pc.bold(branch)} hasn't been pushed yet — no deployment exists.`);
         const confirm = await p.confirm({
             message: "Push to create a deployment?",
@@ -200,12 +254,171 @@ async function checkAndSyncGit(cwd) {
     }
     return { justPushed: false };
 }
+/**
+ * Agent mode share flow.
+ * Mirrors every human prompt with action_required JSON.
+ * Polling runs normally (no spinners).
+ * Git is NOT touched — if there's dirty state, action_required is returned
+ * and the agent handles git itself, then re-runs with --skip-git-check.
+ */
+async function agentShareFlow(cwd, apiKey, workspaceId, opts) {
+    // ── Git sync — report state, don't touch git ──
+    if (!opts.skipGitCheck) {
+        // checkAndSyncGit will call agentActionRequired and exit if git is dirty
+        await checkAndSyncGit(cwd, opts);
+        // If we reach here, git is clean
+    }
+    const gitInfo = getGitInfo(cwd);
+    // ── Resolve staging URL ──
+    let stagingUrl;
+    if (opts.deployment) {
+        // --deployment flag provided
+        stagingUrl = opts.deployment;
+        if (!stagingUrl.startsWith("http"))
+            stagingUrl = `https://${stagingUrl}`;
+    }
+    else {
+        // Determine provider
+        let providerId = opts.provider;
+        if (!providerId) {
+            // Auto-detect from local config files
+            const gitRoot = getGitRoot(cwd);
+            if (gitRoot && readLocalVercelProject(gitRoot)) {
+                providerId = "vercel";
+            }
+            else if (gitRoot && readLocalNetlifySite(gitRoot)) {
+                providerId = "netlify";
+            }
+            else {
+                agentActionRequired({
+                    type: "choose_provider",
+                    message: "Could not auto-detect deployment provider.",
+                    choices: [
+                        { id: "vercel", label: "Vercel" },
+                        { id: "netlify", label: "Netlify" },
+                    ],
+                    nextCommand: "inflight share --skip-git-check --provider <ID>",
+                });
+            }
+        }
+        const provider = providers.find((prov) => prov.id === providerId);
+        if (!provider) {
+            agentError({
+                type: "invalid_provider",
+                message: `Unknown provider "${providerId}". Use "vercel" or "netlify".`,
+            });
+        }
+        stagingUrl = (await provider.resolve(cwd, gitInfo, {})) ?? undefined;
+        if (stagingUrl && !stagingUrl.startsWith("http")) {
+            stagingUrl = `https://${stagingUrl}`;
+        }
+        if (!stagingUrl) {
+            agentError({
+                type: "no_deployment",
+                message: "Could not find a deployment URL. Provide one with --url.",
+                suggestion: "inflight share --url <staging-url>",
+            });
+        }
+    }
+    // ── Resolve project ──
+    let selectedProjectId;
+    let overrideVersionId;
+    if (opts.project) {
+        if (opts.project !== "new") {
+            selectedProjectId = opts.project;
+        }
+    }
+    else {
+        const { projects } = await apiGetRecentProjects(apiKey, workspaceId, 20).catch(() => ({
+            projects: [],
+        }));
+        if (projects.length > 0) {
+            const currentBranch = gitInfo.branch;
+            agentActionRequired({
+                type: "choose_project",
+                message: "Select a project or create new.",
+                choices: [
+                    { id: "new", label: "Start a new project" },
+                    ...projects.map((proj) => ({
+                        id: proj.projectId,
+                        label: proj.latestVersion.title,
+                        hint: [
+                            proj.latestVersion.branch === currentBranch ? "current branch" : proj.latestVersion.branch,
+                            proj.latestVersion.branch === currentBranch ? "(recommended)" : undefined,
+                        ]
+                            .filter(Boolean)
+                            .join(" ") || undefined,
+                    })),
+                ],
+                nextCommand: `inflight share --skip-git-check --deployment ${stagingUrl} --project <ID>`,
+            });
+        }
+    }
+    // ── Resolve override vs new version ──
+    if (selectedProjectId && !opts.override) {
+        const { projects } = await apiGetRecentProjects(apiKey, workspaceId, 20).catch(() => ({
+            projects: [],
+        }));
+        const selectedProject = projects.find((proj) => proj.projectId === selectedProjectId);
+        if (selectedProject && selectedProject.latestVersion.commentCount === 0) {
+            agentActionRequired({
+                type: "choose_override",
+                message: `"${selectedProject.latestVersion.title}" has no feedback yet.`,
+                choices: [
+                    {
+                        id: "override",
+                        label: "Update its staging URL",
+                        hint: `replace with ${new URL(stagingUrl).hostname}`,
+                    },
+                    {
+                        id: "new_version",
+                        label: "Add a new version",
+                        hint: "keep both in version history",
+                    },
+                ],
+                nextCommand: `inflight share --skip-git-check --deployment ${stagingUrl} --project ${selectedProjectId} --override`,
+            });
+        }
+    }
+    if (opts.override && selectedProjectId) {
+        const { projects } = await apiGetRecentProjects(apiKey, workspaceId, 20).catch(() => ({
+            projects: [],
+        }));
+        const selectedProject = projects.find((proj) => proj.projectId === selectedProjectId);
+        if (selectedProject) {
+            overrideVersionId = selectedProject.latestVersion.id;
+        }
+    }
+    // ── Create version ──
+    const result = await apiCreateVersion({
+        apiKey,
+        workspaceId,
+        stagingUrl: stagingUrl,
+        gitInfo,
+        ...(selectedProjectId && { projectId: selectedProjectId }),
+        ...(overrideVersionId && { overrideVersionId }),
+    }).catch((e) => {
+        agentError({ type: "create_failed", message: e.message });
+    });
+    agentSuccess({
+        stagingUrl,
+        ...result,
+        isOverride: !!overrideVersionId,
+    });
+}
 export async function shareCommand(opts = {}) {
     const cwd = process.cwd();
     // TODO: Add a step to login if not authenticated
     // ── Step 1: Auth ──
     const auth = readGlobalAuth();
     if (!auth) {
+        if (isAgent) {
+            agentError({
+                type: "not_authenticated",
+                message: "Not logged in. Run inflight setup first.",
+                suggestion: "inflight setup",
+            });
+        }
         if (opts.json) {
             console.log(JSON.stringify({ error: "not_authenticated", message: "Not logged in. Run inflight setup first." }));
         }
@@ -217,6 +430,8 @@ export async function shareCommand(opts = {}) {
     let gitInfo = getGitInfo(cwd);
     // ── Step 2: Resolve workspace ──
     const me = await apiGetMe(auth.apiKey).catch((e) => {
+        if (isAgent)
+            agentError({ type: "api_error", message: e.message });
         if (opts.json) {
             console.log(JSON.stringify({ error: "api_error", message: e.message }));
         }
@@ -225,50 +440,10 @@ export async function shareCommand(opts = {}) {
         }
         process.exit(1);
     });
-    const workspaces = me.workspaces;
-    let workspaceId;
-    const savedConfig = readWorkspaceConfig();
-    const savedWorkspace = savedConfig ? workspaces.find((w) => w.id === savedConfig.workspaceId) : null;
-    if (savedWorkspace) {
-        workspaceId = savedWorkspace.id;
-    }
-    else if (workspaces.length === 0) {
-        if (opts.json) {
-            console.log(JSON.stringify({
-                error: "no_workspaces",
-                message: "No workspaces found. Create one at inflight.co first.",
-            }));
-        }
-        else {
-            p.log.error("No workspaces found. Create one at " + pc.cyan("inflight.co") + " first.");
-        }
-        process.exit(1);
-    }
-    else if (workspaces.length === 1) {
-        workspaceId = workspaces[0].id;
-        if (!opts.json)
-            p.log.success(`Workspace: ${pc.bold(workspaces[0].name)}`);
-    }
-    else {
-        if (opts.json) {
-            console.log(JSON.stringify({
-                error: "no_workspace_set",
-                message: "Multiple workspaces found. Run 'inflight workspace --set=ID' first.",
-                workspaces: workspaces.map((w) => ({ id: w.id, name: w.name })),
-            }));
-            process.exit(1);
-        }
-        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);
-        }
-        workspaceId = selected;
-    }
-    writeWorkspaceConfig({ workspaceId });
+    const workspaceId = await resolveWorkspace(me.workspaces, {
+        explicitId: opts.workspace,
+        commandForNext: "inflight share",
+    });
     // ── Fast path: URL provided (agent / scripting) ──
     if (opts.url) {
         let stagingUrl = opts.url;
@@ -279,6 +454,8 @@ export async function shareCommand(opts = {}) {
             const message = stagingUrl.includes("localhost")
                 ? "Inflight needs a hosted URL — localhost isn't accessible to your team. Deploy to Vercel, Netlify, or another hosting provider first."
                 : "Must be a hosted URL with a domain (e.g., my-branch.vercel.app)";
+            if (isAgent)
+                agentError({ type: "invalid_url", message });
             if (opts.json) {
                 console.log(JSON.stringify({ error: "invalid_url", message }));
             }
@@ -292,7 +469,10 @@ export async function shareCommand(opts = {}) {
             workspaceId,
             stagingUrl,
             gitInfo,
+            ...(opts.project && opts.project !== "new" && { projectId: opts.project }),
         }).catch((e) => {
+            if (isAgent)
+                agentError({ type: "create_failed", message: e.message });
             if (opts.json) {
                 console.log(JSON.stringify({ error: "create_failed", message: e.message }));
             }
@@ -301,6 +481,8 @@ export async function shareCommand(opts = {}) {
             }
             process.exit(1);
         });
+        if (isAgent)
+            agentSuccess({ stagingUrl, ...result });
         if (opts.json) {
             console.log(JSON.stringify({ success: true, stagingUrl, ...result }));
         }
@@ -311,6 +493,11 @@ export async function shareCommand(opts = {}) {
         await open(stagingUrl);
         return;
     }
+    // ── Agent mode: structured flow with action_required for every choice ──
+    if (isAgent) {
+        await agentShareFlow(cwd, auth.apiKey, workspaceId, opts);
+        return;
+    }
     // Resolve staging URL
     const providerChoice = await p.select({
         message: "Where is your staging URL hosted?",

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,25 @@
+/**
+ * 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;
+}): never;
+export declare function agentError(opts: {
+    type: string;
+    message: string;
+    suggestion?: string;
+}): never;

package/dist/lib/agent.js

@@ -0,0 +1,31 @@
+/**
+ * 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,
+    }));
+    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)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "inflight-cli",
-	"version": "2.7.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",