inflight-cli 2.7.0 → 2.9.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,21 @@ 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" },
+                ],
+                instructions: {
+                    commit_push: "Stage the changes, commit with a descriptive message, and push. Then re-run with the next_command.",
+                    continue: "Re-run with the next_command 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 +164,21 @@ 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" },
+                ],
+                instructions: {
+                    push: "Run `git push` to push the commits. Then re-run with the next_command.",
+                    continue: "Re-run with the next_command 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 +221,21 @@ 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" },
+                ],
+                instructions: {
+                    push: "Run `git push -u origin ${branch}` to push the branch. Then re-run with the next_command.",
+                    continue: "Re-run with the next_command 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 +266,174 @@ 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>",
+            });
+        }
+    }
+    // At this point stagingUrl is guaranteed set — provider.resolve returned a value or agentError exited
+    const resolvedUrl = stagingUrl;
+    // ── 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 ${resolvedUrl} --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(resolvedUrl).hostname}`,
+                    },
+                    {
+                        id: "new_version",
+                        label: "Add a new version",
+                        hint: "keep both in version history",
+                    },
+                ],
+                nextCommand: `inflight share --skip-git-check --deployment ${resolvedUrl} --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: resolvedUrl,
+        gitInfo,
+        ...(selectedProjectId && { projectId: selectedProjectId }),
+        ...(overrideVersionId && { overrideVersionId }),
+    }).catch((e) => {
+        agentError({ type: "create_failed", message: e.message });
+    });
+    await open(resolvedUrl);
+    agentSuccess({
+        stagingUrl: resolvedUrl,
+        ...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 +445,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 +455,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 +469,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 +484,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 +496,10 @@ export async function shareCommand(opts = {}) {
             }
             process.exit(1);
         });
+        if (isAgent) {
+            await open(stagingUrl);
+            agentSuccess({ stagingUrl, ...result });
+        }
         if (opts.json) {
             console.log(JSON.stringify({ success: true, stagingUrl, ...result }));
         }
@@ -311,6 +510,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?",