inflight-cli 2.6.0 → 2.8.0

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({
@@ -112,7 +144,12 @@ async function checkAndSyncGit(cwd) {
             return { justPushed: true };
         }
         catch (e) {
-            spinner.stop(`Push failed: ${e.message}`);
+            const stderr = e && typeof e === "object" && "stderr" in e ? String(e.stderr).trim() : "";
+            spinner.stop("Push failed.");
+            if (stderr)
+                p.log.message(pc.dim(stderr));
+            else if (e instanceof Error)
+                p.log.message(pc.dim(e.message));
             p.log.warn("Continuing with existing deployment.");
             return { justPushed: false };
         }
@@ -123,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({
@@ -147,7 +195,12 @@ async function checkAndSyncGit(cwd) {
             return { justPushed: true };
         }
         catch (e) {
-            spinner.stop(`Push failed: ${e.message}`);
+            const stderr = e && typeof e === "object" && "stderr" in e ? String(e.stderr).trim() : "";
+            spinner.stop("Push failed.");
+            if (stderr)
+                p.log.message(pc.dim(stderr));
+            else if (e instanceof Error)
+                p.log.message(pc.dim(e.message));
             p.log.warn("Continuing with existing deployment.");
             return { justPushed: false };
         }
@@ -160,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?",
@@ -179,18 +243,182 @@ async function checkAndSyncGit(cwd) {
             return { justPushed: true };
         }
         catch (e) {
-            spinner.stop(`Push failed: ${e.message}`);
+            const stderr = e && typeof e === "object" && "stderr" in e ? String(e.stderr).trim() : "";
+            spinner.stop("Push failed.");
+            if (stderr)
+                p.log.message(pc.dim(stderr));
+            else if (e instanceof Error)
+                p.log.message(pc.dim(e.message));
             return { justPushed: false };
         }
     }
     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." }));
         }
@@ -202,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 }));
         }
@@ -210,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;
@@ -264,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 }));
             }
@@ -277,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 }));
             }
@@ -286,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 }));
         }
@@ -296,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?",
@@ -366,17 +568,15 @@ export async function shareCommand(opts = {}) {
         const projectChoice = await scrollableSelect({
             message: "Create a new project in Inflight, or update an existing one?",
             maxItems: 5,
+            ...(branchMatch && { initialValue: branchMatch.projectId }),
             options: [
                 { value: "new", label: "Start a new project" },
                 ...sortedProjects.map((proj) => ({
                     value: proj.projectId,
                     label: `"${proj.latestVersion.title}"`,
-                    hint: [
-                        formatRelativeTime(proj.latestVersion.createdAt),
-                        proj.latestVersion.branch === currentBranch ? `← current branch (${currentBranch})` : "",
-                    ]
-                        .filter(Boolean)
-                        .join(" · "),
+                    hint: proj.latestVersion.branch === currentBranch
+                        ? `${formatRelativeTime(proj.latestVersion.createdAt)} · current branch (${currentBranch})`
+                        : formatRelativeTime(proj.latestVersion.createdAt),
                 })),
             ],
         });

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/framework.js

@@ -5,6 +5,7 @@ import { getGitRoot } from "./git.js";
 const CANDIDATE_PATTERNS = [
     "package.json",
     "index.html",
+    "src/index.html",
     "app/layout.tsx",
     "app/layout.jsx",
     "src/app/layout.tsx",
@@ -16,8 +17,13 @@ const CANDIDATE_PATTERNS = [
     "app/root.tsx",
     "app/root.jsx",
     "src/app.html",
+    "src/routes/+layout.svelte",
     "nuxt.config.ts",
     "nuxt.config.js",
+    "app.vue",
+    "layouts/default.vue",
+    "gatsby-ssr.tsx",
+    "gatsby-ssr.jsx",
     "src/layouts/Layout.astro",
     "src/layouts/BaseLayout.astro",
 ];
@@ -55,7 +61,7 @@ export function gatherProjectContext(cwd) {
                 fileTree.push(relative(root, join(dir, entry)));
             }
             // Also list key subdirectories
-            for (const sub of ["app", "src", "src/app", "src/layouts", "pages", "src/pages"]) {
+            for (const sub of ["app", "src", "src/app", "src/layouts", "src/routes", "pages", "src/pages", "layouts"]) {
                 const subDir = join(dir, sub);
                 if (!existsSync(subDir))
                     continue;

package/dist/lib/netlify.d.ts

@@ -1,4 +1,7 @@
-export declare function ensureNetlifyCli(log?: (msg: string) => void): Promise<boolean>;
+export declare function ensureNetlifyCli(log?: (msg: string) => void): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
 /**
  * Gets the Netlify auth token non-interactively.
  * Priority: NETLIFY_AUTH_TOKEN env var → CLI config file.

package/dist/lib/netlify.js

@@ -16,14 +16,19 @@ function hasNetlifyCli() {
 }
 export async function ensureNetlifyCli(log) {
     if (hasNetlifyCli())
-        return true;
+        return { ok: true };
     log?.("Installing Netlify CLI...");
     try {
         await execAsync("npm install -g netlify-cli");
-        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 };
     }
 }
 /**

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;
+}