inflight-cli 1.1.5 → 2.0.0

package/dist/commands/login.js

@@ -6,16 +6,14 @@ import { API_URL, WEB_URL } from "../lib/env.js";
 const POLL_INTERVAL_MS = 2000;
 const POLL_TIMEOUT_MS = 5 * 60 * 1000;
 export async function loginCommand() {
-    p.intro(pc.bgBlue(pc.white(" inflight login ")));
     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(`Already logged in as ${pc.bold(me.email)}`);
-            p.outro(pc.green("✓ You're already logged in"));
-            process.exit(0);
+            spinner.stop(pc.green(`✓ Logged in as ${pc.bold(me.email)}`));
+            return;
         }
         spinner.stop("Session expired — re-authenticating...");
     }
@@ -44,10 +42,8 @@ export async function loginCommand() {
         p.log.error("No email associated with this account. Please sign up at inflight.co first.");
         process.exit(1);
     }
-    spinner.stop(`Authenticated as ${pc.bold(me.email)}`);
     writeGlobalAuth({ apiKey });
-    p.outro(pc.green("✓ Logged in successfully"));
-    process.exit(0);
+    spinner.stop(pc.green(`✓ Logged in as ${pc.bold(me.email)}`));
 }
 async function pollForApiKey(sessionId) {
     const deadline = Date.now() + POLL_TIMEOUT_MS;
@@ -56,11 +52,16 @@ async function pollForApiKey(sessionId) {
             const res = await fetch(`${API_URL}/api/cli/poll?session_id=${sessionId}`);
             if (res.ok) {
                 const { api_key } = (await res.json());
-                return api_key;
+                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 — keep polling
+            // Network error (offline, DNS, etc.) — keep polling
         }
         await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
     }

package/dist/commands/logout.js

@@ -2,7 +2,6 @@ import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { readGlobalAuth, clearGlobalAuth } from "../lib/config.js";
 export async function logoutCommand() {
-    p.intro(pc.bgBlue(pc.white(" inflight logout ")));
     const auth = readGlobalAuth();
     if (!auth) {
         p.outro(pc.yellow("You're not logged in"));

package/dist/commands/preview.js

@@ -8,7 +8,6 @@ import { createProgressHandler } from "../lib/progress.js";
 import { apiGetMe } from "../lib/api.js";
 export async function previewCommand(opts) {
     const cwd = process.cwd();
-    p.intro(pc.bgMagenta(pc.white(" inflight preview ")));
     // ── Step 1: Auth ──
     const auth = readGlobalAuth();
     if (!auth) {
@@ -31,7 +30,7 @@ export async function previewCommand(opts) {
         process.exit(1);
     }
     // ── Step 4: Workspace ──
-    let workspaceId = readWorkspaceConfig(cwd)?.workspaceId;
+    let workspaceId = readWorkspaceConfig()?.workspaceId;
     if (!workspaceId) {
         spinner.start("Loading workspaces...");
         const me = await apiGetMe(auth.apiKey).catch((e) => {
@@ -60,7 +59,7 @@ export async function previewCommand(opts) {
             }
             workspaceId = selected;
         }
-        writeWorkspaceConfig(cwd, { workspaceId });
+        writeWorkspaceConfig({ workspaceId });
     }
     // ── Step 5: Show diff summary and select scope ──
     const baseBranch = getDefaultBranch(cwd);

package/dist/commands/reset.d.ts

@@ -0,0 +1 @@
+export declare function resetCommand(): Promise<void>;

package/dist/commands/reset.js

@@ -0,0 +1,17 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { clearGlobalAuth, clearWorkspaceConfig, clearVercelConfig } from "../lib/config.js";
+export async function resetCommand() {
+    const confirm = await p.confirm({
+        message: "This will clear all Inflight auth and workspace config. Continue?",
+        initialValue: false,
+    });
+    if (p.isCancel(confirm) || !confirm) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    clearGlobalAuth();
+    clearWorkspaceConfig();
+    clearVercelConfig();
+    p.log.success(pc.green("All Inflight config cleared."));
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1 @@
+export declare function setupCommand(): Promise<void>;

package/dist/commands/setup.js

@@ -0,0 +1,168 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { execSync, exec } from "child_process";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+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, hasInflightWidget, insertWidgetScript } from "../lib/framework.js";
+import { isGitRepo } from "../lib/git.js";
+import { installSkill } from "../lib/skill.js";
+async function ensureGlobalInstall() {
+    try {
+        await execAsync("inflight --version");
+    }
+    catch {
+        try {
+            await execAsync("npm install -g inflight-cli");
+        }
+        catch {
+            // Non-fatal — they can still use npx
+        }
+    }
+}
+export async function setupCommand() {
+    const cwd = process.cwd();
+    // ── Step 1: Install CLI globally + agent skill ──
+    p.log.step("Installing Inflight CLI and agent skill...");
+    await Promise.all([ensureGlobalInstall(), installSkill()]);
+    // ── Step 2: Authenticate ──
+    let auth = readGlobalAuth();
+    if (!auth) {
+        await loginCommand();
+        auth = readGlobalAuth();
+        if (!auth) {
+            p.log.error("Login failed.");
+            process.exit(1);
+        }
+    }
+    else {
+        const me = await apiGetMe(auth.apiKey).catch(() => null);
+        if (me?.email) {
+            p.log.success(`Logged in as ${pc.bold(me.email)}`);
+        }
+    }
+    // ── Step 3: Resolve workspace ──
+    const me = await apiGetMe(auth.apiKey).catch((e) => {
+        p.log.error(e.message);
+        process.exit(1);
+    });
+    const workspaces = me.workspaces;
+    let workspaceId;
+    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;
+    }
+    writeWorkspaceConfig({ workspaceId });
+    const widgetId = workspaces.find((w) => w.id === workspaceId)?.widgetId;
+    if (!widgetId) {
+        p.log.error("Could not find widget ID for this workspace.");
+        process.exit(1);
+    }
+    // ── Step 4: Add widget script tag ──
+    if (hasInflightWidget(cwd)) {
+        // Already present — move on silently
+    }
+    else {
+        const spinner = p.spinner();
+        spinner.start("Detecting framework...");
+        const context = gatherProjectContext(cwd);
+        const location = await apiDetectWidgetLocation({
+            apiKey: auth.apiKey,
+            fileTree: context.fileTree,
+            fileContents: context.fileContents,
+        });
+        let inserted = false;
+        if (location.file && location.insertAfter && location.confidence === "high") {
+            const result = insertWidgetScript(cwd, location.file, location.insertAfter, widgetId);
+            if (result) {
+                spinner.stop(`Detected ${pc.bold(location.framework ?? "framework")} — widget script tag added to ${pc.cyan(location.file)}`);
+                inserted = true;
+            }
+        }
+        else {
+            spinner.stop("Could not auto-detect where to add the widget.");
+        }
+        if (!inserted) {
+            p.log.message(`Add this snippet to your root HTML layout, just before ${pc.cyan("</body>")}:\n\n` +
+                pc.dim(`  <script src="https://www.inflight.co/widget.js" data-workspace="${widgetId}" async></script>`));
+            await p.text({
+                message: "Press enter when you've added it",
+                defaultValue: "",
+                placeholder: "",
+            });
+            if (!hasInflightWidget(cwd)) {
+                const skip = await p.confirm({
+                    message: "Widget script not detected. Continue anyway?",
+                    initialValue: false,
+                });
+                if (p.isCancel(skip) || !skip) {
+                    p.cancel("Add the widget script and run setup again.");
+                    process.exit(0);
+                }
+            }
+        }
+    }
+    // ── Step 5: Commit and push (only files containing the widget script) ──
+    if (isGitRepo(cwd)) {
+        const gitRoot = execSync("git rev-parse --show-toplevel", { cwd, encoding: "utf-8" }).trim();
+        let widgetFiles;
+        try {
+            const grepResult = execSync('git diff --name-only | xargs grep -l "inflight.co/widget.js" 2>/dev/null', {
+                cwd: gitRoot,
+                encoding: "utf-8",
+            }).trim();
+            widgetFiles = grepResult ? grepResult.split("\n") : [];
+        }
+        catch {
+            widgetFiles = [];
+        }
+        if (widgetFiles.length > 0) {
+            const fileList = widgetFiles.map((f) => pc.cyan(f)).join(", ");
+            const shouldCommit = await p.confirm({ message: `Commit and push ${fileList}?`, initialValue: true });
+            if (!p.isCancel(shouldCommit) && shouldCommit) {
+                try {
+                    for (const file of widgetFiles) {
+                        execSync(`git add "${file}"`, { cwd: gitRoot, stdio: "pipe" });
+                    }
+                    execSync('git commit -m "Add Inflight feedback widget script tag"', {
+                        cwd: gitRoot,
+                        stdio: "pipe",
+                    });
+                    p.log.success("Changes committed.");
+                    const spinner = p.spinner();
+                    spinner.start("Pushing...");
+                    execSync("git push", { cwd: gitRoot, stdio: "pipe" });
+                    spinner.stop("Pushed. When sharing, pick a deployment that includes the script tag.");
+                }
+                catch {
+                    p.log.warn("Could not push. Push manually before sharing.");
+                }
+            }
+            else {
+                p.log.info("Remember to push your changes. The widget won't show on deployments made before the script tag was added.");
+            }
+        }
+    }
+    // ── Done ──
+    p.log.success(pc.green("Setup complete!") + " Run " + pc.cyan("inflight share") + " anytime to share your staging URL.");
+    // ── Step 6: Share ──
+    await shareCommand({ workspace: workspaceId });
+}

package/dist/commands/share.d.ts

@@ -1 +1,6 @@
-export declare function shareCommand(): Promise<void>;
+export interface ShareOptions {
+    url?: string;
+    workspace?: string;
+    json?: boolean;
+}
+export declare function shareCommand(opts?: ShareOptions): Promise<void>;

package/dist/commands/share.js

@@ -4,23 +4,58 @@ import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../li
 import { getGitInfo } from "../lib/git.js";
 import { providers } from "../providers/index.js";
 import { apiGetMe, apiCreateVersion } from "../lib/api.js";
-export async function shareCommand() {
+export async function shareCommand(opts = {}) {
     const cwd = process.cwd();
     const auth = readGlobalAuth();
     if (!auth) {
-        p.log.error("Not logged in. Run " + pc.cyan("inflight login") + " first.");
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "not_authenticated", message: "Not logged in. Run inflight login first." }));
+        }
+        else {
+            p.log.error("Not logged in. Run " + pc.cyan("inflight login") + " first.");
+        }
         process.exit(1);
     }
-    p.intro(pc.bgBlue(pc.white(" inflight share ")));
-    // Resolve workspace — read from .inflight/workspace.json, prompt if not linked
-    let workspaceId = readWorkspaceConfig(cwd)?.workspaceId;
+    const gitInfo = getGitInfo(cwd);
+    // ── Fast path: all inputs provided (agent / scripting) ──
+    if (opts.url && opts.workspace) {
+        let stagingUrl = opts.url;
+        if (!stagingUrl.startsWith("http")) {
+            stagingUrl = `https://${stagingUrl}`;
+        }
+        const result = await apiCreateVersion({
+            apiKey: auth.apiKey,
+            workspaceId: opts.workspace,
+            stagingUrl,
+            gitInfo,
+        }).catch((e) => {
+            if (opts.json) {
+                console.log(JSON.stringify({ error: "create_failed", message: e.message }));
+            }
+            else {
+                p.log.error(e.message);
+            }
+            process.exit(1);
+        });
+        if (opts.json) {
+            console.log(JSON.stringify({ success: true, stagingUrl, ...result }));
+        }
+        else {
+            p.log.info(`Staging URL: ${pc.cyan(stagingUrl)}`);
+            p.outro(pc.green("✓ Inflight added to your staging URL"));
+        }
+        return;
+    }
+    // ── Interactive path: prompt for missing inputs ──
+    // Resolve workspace
+    let workspaceId = opts.workspace ?? readWorkspaceConfig()?.workspaceId;
     if (!workspaceId) {
         const me = await apiGetMe(auth.apiKey).catch((e) => {
             p.log.error(e.message);
             process.exit(1);
         });
         if (me.workspaces.length === 0) {
-            p.log.error("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);
         }
         else if (me.workspaces.length === 1) {
@@ -38,10 +73,9 @@ export async function shareCommand() {
             }
             workspaceId = selected;
         }
-        writeWorkspaceConfig(cwd, { workspaceId });
+        writeWorkspaceConfig({ workspaceId });
     }
-    const gitInfo = getGitInfo(cwd);
-    // Staging URL — user picks provider
+    // Resolve staging URL
     const providerChoice = await p.select({
         message: "Where is your staging URL hosted?",
         options: [
@@ -53,12 +87,11 @@ export async function shareCommand() {
         p.cancel("Cancelled.");
         process.exit(0);
     }
-    const provider = providers.find((prov) => prov.id === providerChoice);
     let stagingUrl;
+    const provider = providers.find((prov) => prov.id === providerChoice);
     if (provider) {
         stagingUrl = (await provider.resolve(cwd, gitInfo)) ?? undefined;
     }
-    // Manual input (or fallback if provider returned no URL)
     if (!stagingUrl) {
         const input = await p.text({
             message: "Staging URL",
@@ -80,7 +113,6 @@ export async function shareCommand() {
         }
         stagingUrl = input.trim();
     }
-    // Ensure protocol for any source (Vercel returns bare hostnames)
     if (!stagingUrl.startsWith("http")) {
         stagingUrl = `https://${stagingUrl}`;
     }
@@ -97,5 +129,4 @@ export async function shareCommand() {
     p.outro(pc.green("✓ Inflight added to your staging URL") + " — opening in browser...");
     const { default: open } = await import("open");
     await open(stagingUrl);
-    process.exit(0);
 }

package/dist/commands/vercel.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerVercelCommand(program: Command): void;

package/dist/commands/vercel.js

@@ -0,0 +1,169 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { readVercelConfig, writeVercelConfig } from "../lib/config.js";
+import { ensureVercelCli, ensureVercelAuth, getVercelToken, getVercelTeams, getVercelProjects, getRecentDeployments, getBranchAliasUrl, } from "../lib/vercel.js";
+import { pickVercelProject } from "../providers/vercel.js";
+// --- Action handlers ---
+async function vercelSetup(opts) {
+    // Fast path: non-interactive set (for agents)
+    if (opts.team && opts.project) {
+        const token = requireVercelToken();
+        const teams = await getVercelTeams(token);
+        const team = teams.find((t) => t.id === opts.team);
+        if (!team) {
+            const msg = `Team '${opts.team}' not found. Available: ${teams.map((t) => `${t.name} (${t.id})`).join(", ")}`;
+            if (opts.json) {
+                console.log(JSON.stringify({ error: "team_not_found", message: msg }));
+            }
+            else {
+                p.log.error(msg);
+            }
+            process.exit(1);
+        }
+        const projects = await getVercelProjects(token, opts.team);
+        const project = projects.find((proj) => proj.id === opts.project);
+        if (!project) {
+            const msg = `Project '${opts.project}' not found on team '${team.name}'.`;
+            if (opts.json) {
+                console.log(JSON.stringify({ error: "project_not_found", message: msg }));
+            }
+            else {
+                p.log.error(msg);
+            }
+            process.exit(1);
+        }
+        writeVercelConfig({ teamId: team.id, teamName: team.name, projectId: project.id, projectName: project.name });
+        if (opts.json) {
+            console.log(JSON.stringify({
+                saved: true,
+                teamId: team.id,
+                teamName: team.name,
+                projectId: project.id,
+                projectName: project.name,
+            }));
+        }
+        else {
+            p.log.success(`Saved! Using ${pc.bold(project.name)} on ${pc.bold(team.name)}.`);
+        }
+        return;
+    }
+    // Interactive path
+    const cliOk = await ensureVercelCli((msg) => p.log.step(msg));
+    if (!cliOk) {
+        p.log.error("Failed to install Vercel CLI. Install manually: " + pc.cyan("npm install -g vercel"));
+        process.exit(1);
+    }
+    p.log.step("Checking Vercel authentication...");
+    const token = await ensureVercelAuth();
+    if (!token) {
+        p.log.error("Vercel login failed.");
+        process.exit(1);
+    }
+    const current = readVercelConfig();
+    if (current) {
+        p.log.info(`Current: ${pc.bold(current.projectName)} on ${pc.bold(current.teamName)}`);
+    }
+    const config = await pickVercelProject(token);
+    if (!config)
+        process.exit(1);
+    p.log.success(`Saved! ${pc.cyan("inflight share")} will now use ${pc.bold(config.projectName)} on ${pc.bold(config.teamName)}.`);
+}
+async function listTeams() {
+    const token = requireVercelToken();
+    const teams = await getVercelTeams(token);
+    console.log(JSON.stringify(teams));
+}
+async function listProjects(opts) {
+    const token = requireVercelToken();
+    const projects = await getVercelProjects(token, opts.team);
+    console.log(JSON.stringify(projects));
+}
+async function listDeployments(opts) {
+    const token = requireVercelToken();
+    let teamId = opts.team;
+    let projectId = opts.project;
+    if (!teamId || !projectId) {
+        const config = readVercelConfig();
+        if (!config) {
+            console.log(JSON.stringify({
+                error: "vercel_not_configured",
+                message: "No Vercel project configured. Run 'inflight vercel --team=TEAM_ID --project=PROJECT_ID --json' first.",
+            }));
+            process.exit(1);
+        }
+        teamId = teamId ?? config.teamId;
+        projectId = projectId ?? config.projectId;
+    }
+    const deployments = await getRecentDeployments(token, teamId, projectId, {
+        limit: parseInt(opts.limit ?? "10"),
+        branch: opts.branch,
+    });
+    console.log(JSON.stringify(deployments));
+}
+async function branchUrl(opts) {
+    const token = requireVercelToken();
+    let teamId = opts.team;
+    let projectId = opts.project;
+    if (!teamId || !projectId) {
+        const config = readVercelConfig();
+        if (!config) {
+            console.log(JSON.stringify({
+                error: "vercel_not_configured",
+                message: "No Vercel project configured. Run 'inflight vercel --team=TEAM_ID --project=PROJECT_ID --json' first.",
+            }));
+            process.exit(1);
+        }
+        teamId = teamId ?? config.teamId;
+        projectId = projectId ?? config.projectId;
+    }
+    const url = await getBranchAliasUrl(token, teamId, projectId, opts.branch);
+    if (url) {
+        console.log(JSON.stringify({ url, branch: opts.branch }));
+    }
+    else {
+        console.log(JSON.stringify({ url: null, branch: opts.branch, message: "No deployment found for this branch." }));
+    }
+}
+/** Gets token silently, exits with JSON error if unavailable. */
+function requireVercelToken() {
+    const token = getVercelToken();
+    if (!token) {
+        console.log(JSON.stringify({
+            error: "vercel_not_authenticated",
+            message: "Vercel auth expired or missing. Run 'inflight vercel' or 'vercel login' first.",
+        }));
+        process.exit(1);
+    }
+    return token;
+}
+// --- Command registration ---
+export function registerVercelCommand(program) {
+    const vercel = program
+        .command("vercel")
+        .description("Set up or change your Vercel project")
+        .option("--team <id>", "Vercel team ID (non-interactive)")
+        .option("--project <id>", "Vercel project ID (non-interactive)")
+        .option("--json", "Output as JSON (non-interactive)")
+        .action(vercelSetup);
+    vercel.command("teams").description("List Vercel teams (JSON)").action(listTeams);
+    vercel
+        .command("projects")
+        .description("List projects for a Vercel team (JSON)")
+        .requiredOption("--team <id>", "Vercel team ID")
+        .action(listProjects);
+    vercel
+        .command("branch-url")
+        .description("Get the stable branch preview URL (JSON)")
+        .requiredOption("--branch <name>", "Git branch name")
+        .option("--team <id>", "Vercel team ID (reads from saved config if omitted)")
+        .option("--project <id>", "Vercel project ID (reads from saved config if omitted)")
+        .action(branchUrl);
+    vercel
+        .command("deployments")
+        .description("List recent deployments (JSON)")
+        .option("--team <id>", "Vercel team ID (reads from saved config if omitted)")
+        .option("--project <id>", "Vercel project ID (reads from saved config if omitted)")
+        .option("--branch <name>", "Filter by git branch")
+        .option("--limit <n>", "Number of deployments", "10")
+        .action(listDeployments);
+}

package/dist/commands/workspace.js

@@ -3,14 +3,12 @@ import pc from "picocolors";
 import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
 import { apiGetMe } from "../lib/api.js";
 export async function workspaceCommand() {
-    const cwd = process.cwd();
-    p.intro(pc.bgCyan(pc.white(" inflight workspace ")));
     const auth = readGlobalAuth();
     if (!auth) {
         p.log.error("Not logged in. Run " + pc.cyan("inflight login") + " first.");
         process.exit(1);
     }
-    const current = readWorkspaceConfig(cwd);
+    const current = readWorkspaceConfig();
     const spinner = p.spinner();
     spinner.start("Loading workspaces...");
     const me = await apiGetMe(auth.apiKey).catch((e) => {
@@ -44,7 +42,7 @@ export async function workspaceCommand() {
         process.exit(0);
     }
     const workspaceId = selected;
-    writeWorkspaceConfig(cwd, { workspaceId });
+    writeWorkspaceConfig({ workspaceId });
     const name = workspaces.find((w) => w.id === workspaceId)?.name ?? workspaceId;
     p.outro(pc.green(`Workspace set to ${pc.bold(name)}`));
     process.exit(0);

package/dist/commands/workspaces.d.ts

@@ -0,0 +1,4 @@
+export declare function workspacesCommand(opts: {
+    json?: boolean;
+    set?: string;
+}): Promise<void>;

package/dist/commands/workspaces.js

@@ -0,0 +1,81 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
+import { apiGetMe } from "../lib/api.js";
+export async function workspacesCommand(opts) {
+    const auth = readGlobalAuth();
+    if (!auth) {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "not_authenticated", message: "Not logged in. Run inflight login first." }));
+            process.exit(1);
+        }
+        p.log.error("Not logged in. Run " + pc.cyan("inflight login") + " first.");
+        process.exit(1);
+    }
+    // ── Fetch workspaces ──
+    const me = await apiGetMe(auth.apiKey).catch((e) => {
+        if (opts.json) {
+            console.log(JSON.stringify({ error: "api_error", message: e.message }));
+            process.exit(1);
+        }
+        p.log.error(e.message);
+        process.exit(1);
+    });
+    const workspaces = me.workspaces;
+    // ── Set active workspace ──
+    if (opts.set) {
+        const workspace = workspaces.find((w) => w.id === opts.set);
+        if (!workspace) {
+            const msg = `Workspace '${opts.set}' not found.`;
+            if (opts.json) {
+                console.log(JSON.stringify({ error: "workspace_not_found", message: msg, available: workspaces.map((w) => ({ id: w.id, name: w.name })) }));
+            }
+            else {
+                p.log.error(msg);
+            }
+            process.exit(1);
+        }
+        writeWorkspaceConfig({ workspaceId: workspace.id });
+        if (opts.json) {
+            console.log(JSON.stringify({ success: true, active: workspace.id, name: workspace.name }));
+        }
+        else {
+            p.outro(pc.green(`Workspace set to ${pc.bold(workspace.name)}`));
+        }
+        return;
+    }
+    // ── JSON mode: list + active ──
+    if (opts.json) {
+        const active = readWorkspaceConfig()?.workspaceId ?? null;
+        console.log(JSON.stringify({ active, workspaces }));
+        return;
+    }
+    // ── Interactive mode: select workspace ──
+    if (workspaces.length === 0) {
+        p.log.error("No workspaces found. Create one at inflight.co");
+        process.exit(1);
+    }
+    const currentWorkspaceId = readWorkspaceConfig()?.workspaceId;
+    if (currentWorkspaceId) {
+        const currentWs = workspaces.find((w) => w.id === currentWorkspaceId);
+        if (currentWs) {
+            p.log.info(`Current workspace: ${pc.bold(currentWs.name)}`);
+        }
+    }
+    const selected = await p.select({
+        message: "Select a workspace",
+        options: workspaces.map((w) => ({
+            value: w.id,
+            label: w.name,
+            hint: currentWorkspaceId === w.id ? "current" : undefined,
+        })),
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    const workspaceId = selected;
+    writeWorkspaceConfig({ workspaceId });
+    const name = workspaces.find((w) => w.id === workspaceId)?.name ?? workspaceId;
+    p.outro(pc.green(`Workspace set to ${pc.bold(name)}`));
+}