inflight-cli 1.0.4 → 1.1.0

package/README.md

@@ -1,43 +1,36 @@
 # inflight-cli
 
-The official CLI for [Inflight](https://inflight.co) — create and share design versions from the terminal.
+The official CLI for [Inflight](https://inflight.co).
 
-## Installation
+## Development
+
+### Run locally
 
 ```bash
-npm install -g inflight-cli
+cd apps/cli
+bun run src/index.ts <command>
 ```
 
-## Usage
-
-### Login
-
-Authenticate with your Inflight account:
+### Run against staging
 
 ```bash
-inflight login
+INFLIGHT_API_URL=https://staging-api.inflight.co INFLIGHT_WEB_URL=https://staging.inflight.co bun run src/index.ts <command>
 ```
 
-This opens a browser window to complete authentication. Your credentials are stored in `~/Library/Application Support/co.inflight.cli/auth.json` (macOS) or `~/.local/share/co.inflight.cli/auth.json` (Linux).
-
-### Share a version
+For the `preview` command, also set `INFLIGHT_SHARE_API_URL`.
 
-Share a new design version for the current project:
+### Build
 
 ```bash
-inflight share
+bun run build
 ```
 
-This will:
-1. Detect your git branch and commit info automatically
-2. Ask where your staging URL is hosted (Vercel or paste a URL)
-3. Create a version on Inflight and open it in your browser
-
-On first run, you'll be prompted to link your Vercel project and select a workspace. These are saved locally so subsequent runs are fast.
-
-Git context (branch, commit, diff) is captured automatically and used to generate a version title and feedback questions.
-
-## Requirements
+### Commands
 
-- Node.js 18+
-- A free [Inflight](https://inflight.co) account
+| Command     | Description                              |
+| ----------- | ---------------------------------------- |
+| `login`     | Authenticate with your Inflight account  |
+| `logout`    | Disconnect your Inflight account         |
+| `share`     | Get feedback on your staging URL         |
+| `preview`   | Preview a live component from your code  |
+| `workspace` | Switch the workspace for this project    |

package/dist/commands/login.js

@@ -1,73 +1,68 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import { createServer } from "http";
 import { readGlobalAuth, writeGlobalAuth } from "../lib/config.js";
 import { apiGetMe } from "../lib/api.js";
-const DEFAULT_API_URL = process.env.INFLIGHT_API_URL ?? "https://api.inflight.co";
-const WEB_URL = process.env.INFLIGHT_WEB_URL ?? "https://inflight.co";
+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, existingAuth.apiUrl).catch(() => null);
-        if (me) {
-            spinner.stop(`Already logged in as ${pc.bold(me.name)}`);
+        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("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...");
-    const apiKey = await browserAuth();
-    const apiUrl = DEFAULT_API_URL;
+    p.log.info(`Opening ${pc.cyan(authUrl)}`);
+    const { default: open } = await import("open");
+    await open(authUrl);
     const spinner = p.spinner();
-    spinner.start("Validating...");
-    const me = await apiGetMe(apiKey, apiUrl).catch((e) => {
+    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);
+    }
+    spinner.message("Validating...");
+    const me = await apiGetMe(apiKey).catch((e) => {
         spinner.stop("Validation failed.");
         p.log.error(e.message);
         process.exit(1);
     });
-    spinner.stop(`Authenticated as ${pc.bold(me.name)}`);
-    writeGlobalAuth({ apiKey, apiUrl });
+    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);
+    }
+    spinner.stop(`Authenticated as ${pc.bold(me.email)}`);
+    writeGlobalAuth({ apiKey });
     p.outro(pc.green("✓ Logged in successfully"));
     process.exit(0);
 }
-function browserAuth() {
-    return new Promise((resolve, reject) => {
-        const server = createServer((req, res) => {
-            const url = new URL(req.url ?? "/", "http://localhost");
-            const key = url.searchParams.get("api_key");
-            res.writeHead(200, { "Content-Type": "text/html" });
-            res.end(`
-				<html><body style="font-family:sans-serif;text-align:center;padding:60px">
-					<h2>Authenticated!</h2>
-					<p>You can close this tab and return to the terminal.</p>
-					<script>window.close()</script>
-				</body></html>
-			`);
-            server.close();
-            if (key) {
-                resolve(key);
+async function pollForApiKey(sessionId) {
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(`${API_URL}/api/cli/poll?session_id=${sessionId}`);
+            if (res.ok) {
+                const { api_key } = (await res.json());
+                return api_key;
             }
-            else {
-                reject(new Error("No API key received from browser"));
-            }
-        });
-        server.listen(0, "127.0.0.1").unref();
-        server.once("listening", async () => {
-            const port = server.address().port;
-            const callbackUrl = `http://127.0.0.1:${port}`;
-            const authUrl = `${WEB_URL}/cli/connect?callback=${encodeURIComponent(callbackUrl)}`;
-            p.log.info(`Opening ${pc.cyan(authUrl)}`);
-            const { default: open } = await import("open");
-            await open(authUrl);
-        });
-        const timeoutId = setTimeout(() => {
-            server.close();
-            reject(new Error("Authentication timed out after 5 minutes"));
-        }, 5 * 60 * 1000);
-        server.once("close", () => clearTimeout(timeoutId));
-    });
+        }
+        catch {
+            // Network error — keep polling
+        }
+        await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+    }
+    return null;
 }

package/dist/commands/logout.d.ts

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

package/dist/commands/logout.js

@@ -0,0 +1,14 @@
+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"));
+        process.exit(0);
+    }
+    clearGlobalAuth();
+    p.outro(pc.green("✓ Logged out successfully"));
+    process.exit(0);
+}

package/dist/commands/preview.d.ts

@@ -0,0 +1,7 @@
+interface ShareOptions {
+    message?: string;
+    scope?: string;
+    open?: boolean;
+}
+export declare function previewCommand(opts: ShareOptions): Promise<void>;
+export {};

package/dist/commands/preview.js

@@ -0,0 +1,256 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
+import { isGitRepo, getGitDiffResult, getDefaultBranch, getRemoteUrl, parseDiffStat } from "../lib/git.js";
+import { readProjectFiles, calculateTotalSize, getFileCount, formatSize, needsChunkedUpload } from "../lib/files.js";
+import { shareProject, shareChunked, lookupExistingProject, shareApiHealthCheck } from "../lib/share-api.js";
+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) {
+        p.log.error("Not logged in. Run " + pc.cyan("inflight login") + " first.");
+        process.exit(1);
+    }
+    // ── Step 2: Health check ──
+    const spinner = p.spinner();
+    spinner.start("Connecting to Inflight...");
+    const healthy = await shareApiHealthCheck();
+    if (!healthy) {
+        spinner.stop("Connection failed.");
+        p.log.error("Couldn't reach Inflight servers. Check your internet connection and try again.");
+        process.exit(1);
+    }
+    spinner.stop("Connected to Inflight.");
+    // ── Step 3: Git check ──
+    if (!isGitRepo(cwd)) {
+        p.log.error("This folder isn't a git repo. Make sure you're in the right project directory.");
+        process.exit(1);
+    }
+    // ── Step 4: Workspace ──
+    let workspaceId = readWorkspaceConfig(cwd)?.workspaceId;
+    if (!workspaceId) {
+        spinner.start("Loading workspaces...");
+        const me = await apiGetMe(auth.apiKey).catch((e) => {
+            spinner.stop("Failed.");
+            p.log.error(e.message);
+            process.exit(1);
+        });
+        spinner.stop("");
+        const workspaces = me.workspaces;
+        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.info(`Workspace: ${pc.bold(workspaces[0].name)}`);
+        }
+        else {
+            const selected = await p.select({
+                message: "Select a workspace",
+                options: workspaces.map((w) => ({ value: w.id, label: w.name })),
+            });
+            if (p.isCancel(selected)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            workspaceId = selected;
+        }
+        writeWorkspaceConfig(cwd, { workspaceId });
+    }
+    // ── Step 5: Show diff summary and select scope ──
+    const baseBranch = getDefaultBranch(cwd);
+    const branchDiff = getGitDiffResult(cwd, { mode: "branch" });
+    if (branchDiff) {
+        const fileChanges = parseDiffStat(branchDiff.diffStat);
+        const fileCount = fileChanges.length;
+        p.log.info(`Found ${pc.bold(String(fileCount))} changed file${fileCount !== 1 ? "s" : ""} on ${pc.cyan(branchDiff.currentBranch)} (vs ${baseBranch}):`);
+        for (const { file, insertions, deletions } of fileChanges.slice(0, 15)) {
+            const parts = [];
+            if (insertions > 0)
+                parts.push(pc.green(`+${insertions}`));
+            if (deletions > 0)
+                parts.push(pc.red(`-${deletions}`));
+            p.log.message(`  ${file}  ${parts.join(", ")}`);
+        }
+        if (fileChanges.length > 15) {
+            p.log.message(pc.dim(`  ... and ${fileChanges.length - 15} more`));
+        }
+    }
+    else {
+        p.log.warning("No branch diff found against " + pc.cyan(baseBranch) + ". You may want to share uncommitted changes.");
+    }
+    // Scope selection
+    let scope;
+    const VALID_MODES = ["branch", "uncommitted", "staged", "commits", "files"];
+    if (opts.scope) {
+        if (!VALID_MODES.includes(opts.scope)) {
+            p.log.error(`Invalid scope "${opts.scope}". Valid options: ${VALID_MODES.join(", ")}`);
+            process.exit(1);
+        }
+        scope = { mode: opts.scope };
+    }
+    else {
+        const scopeChoice = await p.select({
+            message: "What would you like to share?",
+            options: [
+                { value: "branch", label: `All branch changes${branchDiff ? ` (${parseDiffStat(branchDiff.diffStat).length} files)` : ""}` },
+                { value: "uncommitted", label: "Only uncommitted changes" },
+                { value: "staged", label: "Only staged changes" },
+                { value: "commits", label: "Last N commits" },
+                { value: "files", label: "Pick specific files" },
+            ],
+        });
+        if (p.isCancel(scopeChoice)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        scope = { mode: scopeChoice };
+        // Follow-up prompts for commits and files modes
+        if (scope.mode === "commits") {
+            const count = await p.text({
+                message: "How many commits?",
+                placeholder: "1",
+                validate: (v) => {
+                    const n = parseInt(v, 10);
+                    if (isNaN(n) || n < 1)
+                        return "Enter a positive number";
+                },
+            });
+            if (p.isCancel(count)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            scope.commitCount = parseInt(count, 10);
+        }
+        if (scope.mode === "files" && branchDiff) {
+            const fileChanges = parseDiffStat(branchDiff.diffStat);
+            if (fileChanges.length === 0) {
+                p.log.warning("No changed files found. Falling back to full branch diff.");
+                scope = { mode: "branch" };
+            }
+            else {
+                const selectedFiles = await p.multiselect({
+                    message: "Select files to share",
+                    options: fileChanges.map(({ file, insertions, deletions }) => {
+                        const parts = [];
+                        if (insertions > 0)
+                            parts.push(pc.green(`+${insertions}`));
+                        if (deletions > 0)
+                            parts.push(pc.red(`-${deletions}`));
+                        return { value: file, label: `${file}  ${parts.join(", ")}` };
+                    }),
+                    required: true,
+                });
+                if (p.isCancel(selectedFiles)) {
+                    p.cancel("Cancelled.");
+                    process.exit(0);
+                }
+                scope.paths = selectedFiles;
+            }
+        }
+    }
+    // Get the actual diff for the selected scope
+    const diffResult = getGitDiffResult(cwd, scope);
+    // ── Step 6: Existing project check ──
+    const remoteUrl = getRemoteUrl(cwd);
+    let existingProjectId;
+    if (remoteUrl) {
+        spinner.start("Checking for existing shares...");
+        const existing = await lookupExistingProject(auth.apiKey, remoteUrl, workspaceId);
+        spinner.stop("");
+        if (existing) {
+            const nextVersion = existing.versionCount + 1;
+            const choice = await p.select({
+                message: `This repo was shared before as "${pc.bold(existing.name)}" (${existing.versionCount} version${existing.versionCount !== 1 ? "s" : ""}).`,
+                options: [
+                    { value: "add", label: `Add as V${nextVersion} to "${existing.name}"` },
+                    { value: "new", label: "Create a new project" },
+                ],
+            });
+            if (p.isCancel(choice)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            if (choice === "add") {
+                existingProjectId = existing.id;
+            }
+        }
+    }
+    // ── Step 7: User intent ──
+    let userIntent = opts.message;
+    if (!userIntent) {
+        const intentInput = await p.text({
+            message: "Describe what you're sharing (optional, press Enter to skip)",
+            placeholder: "e.g. the new header on the landing page",
+        });
+        if (p.isCancel(intentInput)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        const trimmed = String(intentInput ?? "").trim();
+        if (trimmed)
+            userIntent = trimmed;
+    }
+    // ── Step 8: File collection ──
+    spinner.start("Reading project files...");
+    const files = readProjectFiles(cwd);
+    const fileCount = getFileCount(files);
+    const totalSize = calculateTotalSize(files);
+    spinner.stop(`Read ${pc.bold(String(fileCount))} files (${formatSize(totalSize)})`);
+    // ── Step 9: Upload + SSE progress ──
+    const toFriendlyMessage = createProgressHandler();
+    const shareSpinner = p.spinner();
+    shareSpinner.start("Uploading to Inflight...");
+    const request = {
+        files,
+        gitDiff: diffResult ?? {
+            diff: "",
+            diffStat: "",
+            baseBranch,
+            currentBranch: branchDiff?.currentBranch ?? "unknown",
+        },
+        workspaceId,
+        existingProjectId,
+        gitUrl: remoteUrl ?? undefined,
+        userIntent,
+    };
+    const onProgress = (percentage, step) => {
+        const friendly = toFriendlyMessage(percentage, step);
+        if (friendly) {
+            shareSpinner.message(friendly);
+        }
+    };
+    try {
+        const chunked = needsChunkedUpload(files);
+        const result = chunked
+            ? await shareChunked(request, auth.apiKey, onProgress)
+            : await shareProject(request, auth.apiKey, onProgress);
+        shareSpinner.stop(pc.green("Share complete!"));
+        // ── Step 10: Result ──
+        const lines = [
+            `${pc.bold("Preview:")}  ${pc.cyan(result.previewUrl)}`,
+            `${pc.bold("Inflight:")} ${pc.cyan(result.inflightUrl)}`,
+        ];
+        p.note(lines.join("\n"), "Your share is live");
+        if (result.diffSummary?.summary) {
+            p.log.info(pc.dim(result.diffSummary.summary));
+        }
+        p.outro(pc.green("Done!") + " — opening in browser...");
+        if (opts.open !== false) {
+            const { default: open } = await import("open");
+            await open(result.inflightUrl);
+        }
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        shareSpinner.stop("Failed.");
+        p.log.error(`Something went wrong: ${message}`);
+        process.exit(1);
+    }
+    process.exit(0);
+}

package/dist/commands/share.js

@@ -1,7 +1,7 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
-import { getGitInfo, isGitRepo } from "../lib/git.js";
+import { getGitInfo } from "../lib/git.js";
 import { providers } from "../providers/index.js";
 import { apiGetMe, apiCreateVersion } from "../lib/api.js";
 export async function shareCommand() {
@@ -15,14 +15,10 @@ export async function shareCommand() {
     // Resolve workspace — read from .inflight/workspace.json, prompt if not linked
     let workspaceId = readWorkspaceConfig(cwd)?.workspaceId;
     if (!workspaceId) {
-        const spinner = p.spinner();
-        spinner.start("Loading workspaces...");
-        const me = await apiGetMe(auth.apiKey, auth.apiUrl).catch((e) => {
-            spinner.stop("Failed.");
+        const me = await apiGetMe(auth.apiKey).catch((e) => {
             p.log.error(e.message);
             process.exit(1);
         });
-        spinner.stop("");
         if (me.workspaces.length === 0) {
             p.log.error("No workspaces found. Create one at inflight.co first.");
             process.exit(1);
@@ -44,10 +40,7 @@ export async function shareCommand() {
         }
         writeWorkspaceConfig(cwd, { workspaceId });
     }
-    // Git info
-    const gitInfo = isGitRepo(cwd)
-        ? getGitInfo(cwd)
-        : { branch: null, commitShort: null, commitFull: null, commitMessage: null, remoteUrl: null, isDirty: false, diff: null };
+    const gitInfo = getGitInfo(cwd);
     // Staging URL — user picks provider
     const providerChoice = await p.select({
         message: "Where is your staging URL hosted?",
@@ -60,25 +53,24 @@ export async function shareCommand() {
         p.cancel("Cancelled.");
         process.exit(0);
     }
-    const providerSpinner = p.spinner();
     const provider = providers.find((prov) => prov.id === providerChoice);
     let stagingUrl;
     if (provider) {
-        stagingUrl = (await provider.resolve(cwd, gitInfo, providerSpinner)) ?? undefined;
+        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",
-            placeholder: "https://my-branch.vercel.app",
+            placeholder: "my-branch.vercel.app",
             validate: (v) => {
                 if (!v)
                     return "Staging URL is required";
                 try {
-                    new URL(v);
+                    new URL(v.startsWith("http") ? v : `https://${v}`);
                 }
                 catch {
-                    return "Must be a valid URL (include https://)";
+                    return "Must be a valid URL";
                 }
             },
         });
@@ -86,11 +78,14 @@ export async function shareCommand() {
             p.cancel("Cancelled.");
             process.exit(0);
         }
-        stagingUrl = input;
+        stagingUrl = input.trim();
+    }
+    // Ensure protocol for any source (Vercel returns bare hostnames)
+    if (!stagingUrl.startsWith("http")) {
+        stagingUrl = `https://${stagingUrl}`;
     }
     const result = await apiCreateVersion({
         apiKey: auth.apiKey,
-        apiUrl: auth.apiUrl,
         workspaceId,
         stagingUrl,
         gitInfo,
@@ -98,8 +93,8 @@ export async function shareCommand() {
         p.log.error(e.message);
         process.exit(1);
     });
-    p.note(result.inflightUrl, "Your Inflight version");
-    p.outro(pc.green("✓ Done") + " — opening staging URL...");
+    p.log.info(`Staging URL: ${pc.cyan(stagingUrl)}`);
+    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/workspace.d.ts

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

package/dist/commands/workspace.js

@@ -0,0 +1,51 @@
+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 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 spinner = p.spinner();
+    spinner.start("Loading workspaces...");
+    const me = await apiGetMe(auth.apiKey).catch((e) => {
+        spinner.stop("Failed.");
+        p.log.error(e.message);
+        process.exit(1);
+    });
+    spinner.stop("");
+    const workspaces = me.workspaces;
+    if (workspaces.length === 0) {
+        p.log.error("No workspaces found. Create one at " + pc.cyan("inflight.co") + " first.");
+        process.exit(1);
+    }
+    // Show current workspace if set
+    if (current) {
+        const currentWs = workspaces.find((w) => w.id === current.workspaceId);
+        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: current?.workspaceId === w.id ? "current" : undefined,
+        })),
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    const workspaceId = selected;
+    writeWorkspaceConfig(cwd, { 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/index.js

@@ -2,19 +2,21 @@
 import { Command } from "commander";
 import { loginCommand } from "./commands/login.js";
 import { shareCommand } from "./commands/share.js";
+import { workspaceCommand } from "./commands/workspace.js";
+import { logoutCommand } from "./commands/logout.js";
 import pkg from "../package.json" with { type: "json" };
 const { version } = pkg;
 const program = new Command();
-program
-    .name("inflight")
-    .description("Get feedback directly on your staging URL")
-    .version(version);
-program
-    .command("login")
-    .description("Authenticate with your Inflight account")
-    .action(loginCommand);
-program
-    .command("share")
-    .description("Share a new version for this project")
-    .action(() => shareCommand());
+program.name("inflight").description("Get feedback directly on your staging URL").version(version);
+program.command("login").description("Authenticate with your Inflight account").action(loginCommand);
+program.command("share").description("Get feedback on your staging URL").action(shareCommand);
+// program
+// 	.command("preview")
+// 	.description("Preview a live component from your code")
+// 	.option("-m, --message <message>", "Pre-fill the intent prompt")
+// 	.option("--scope <mode>", "Skip scope prompt: branch, uncommitted, staged")
+// 	.option("--no-open", "Don't open result in browser")
+// 	.action((opts) => previewCommand(opts));
+program.command("workspace").description("Switch the active inflight workspace").action(workspaceCommand);
+program.command("logout").description("Disconnect your Inflight account").action(logoutCommand);
 program.parse();

package/dist/lib/api.d.ts

@@ -8,13 +8,13 @@ export interface CreateVersionResult {
     versionId: string;
     inflightUrl: string;
 }
-export declare function apiGetMe(apiKey: string, apiUrl: string): Promise<{
-    name: string;
+export declare function apiGetMe(apiKey: string): Promise<{
+    name: string | null;
+    email: string | null;
     workspaces: Workspace[];
 }>;
 export declare function apiCreateVersion(opts: {
     apiKey: string;
-    apiUrl: string;
     workspaceId: string;
     stagingUrl: string;
     gitInfo: GitInfo;