inflight-cli 2.0.9 → 2.1.0

package/dist/commands/setup.js

@@ -8,6 +8,20 @@ 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";
+function execSyncErrorDetail(err) {
+    if (err !== null && typeof err === "object" && "stderr" in err) {
+        const b = err.stderr;
+        if (Buffer.isBuffer(b) && b.length > 0) {
+            const text = b.toString("utf-8").trim();
+            if (text)
+                return text;
+        }
+    }
+    if (err instanceof Error && err.message) {
+        return err.message.trim();
+    }
+    return "";
+}
 export async function setupCommand() {
     const cwd = process.cwd();
     // ── Step 1: Install agent skill ──
@@ -75,31 +89,43 @@ export async function setupCommand() {
     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;
+        try {
+            const context = gatherProjectContext(cwd);
+            const location = await apiDetectWidgetLocation({
+                apiKey: auth.apiKey,
+                fileTree: context.fileTree,
+                fileContents: context.fileContents,
+            });
+            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 update the detected file. Add the snippet manually below.");
+                }
+            }
+            else {
+                spinner.stop("Could not auto-detect where to add the widget.");
             }
         }
-        else {
-            spinner.stop("Could not auto-detect where to add the widget.");
+        catch {
+            spinner.stop("Could not analyze your project.");
         }
         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({
+            const waited = await p.text({
                 message: "Press enter when you've added it",
                 defaultValue: "",
                 placeholder: "",
             });
+            if (p.isCancel(waited)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
             if (!hasInflightWidget(cwd)) {
                 const skip = await p.confirm({
                     message: "Widget script not detected. Continue anyway?",
@@ -138,14 +164,14 @@ export async function setupCommand() {
                         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.");
+                    p.log.success("Pushed. When sharing, pick a deployment that includes the script tag.");
                 }
-                catch {
-                    p.log.warn("Could not push. Push manually before sharing.");
+                catch (err) {
+                    const detail = execSyncErrorDetail(err);
+                    p.log.warn(detail
+                        ? `Commit or push failed:\n${pc.dim(detail)}\n\nPush manually before sharing.`
+                        : "Commit or push failed. Push manually before sharing.");
                 }
             }
             else {

package/dist/commands/share.js

@@ -77,6 +77,10 @@ export async function shareCommand(opts = {}) {
         }
         writeWorkspaceConfig({ workspaceId });
     }
+    if (!workspaceId) {
+        p.log.error("No workspace configured. Run " + pc.cyan("inflight workspaces") + " or " + pc.cyan("inflight setup") + ".");
+        process.exit(1);
+    }
     // Resolve staging URL
     const providerChoice = await p.select({
         message: "Where is your staging URL hosted?",
@@ -118,7 +122,7 @@ export async function shareCommand(opts = {}) {
     if (!stagingUrl.startsWith("http")) {
         stagingUrl = `https://${stagingUrl}`;
     }
-    const result = await apiCreateVersion({
+    await apiCreateVersion({
         apiKey: auth.apiKey,
         workspaceId,
         stagingUrl,

package/dist/commands/vercel.js

@@ -1,7 +1,7 @@
 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 { ensureVercelCli, ensureVercelAuth, getVercelToken, getVercelTeams, getVercelProjects, getRecentDeployments, getBranchAlias, } from "../lib/vercel.js";
 import { pickVercelProject } from "../providers/vercel.js";
 // --- Action handlers ---
 async function vercelSetup(opts) {
@@ -116,9 +116,9 @@ async function branchUrl(opts) {
         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 }));
+    const alias = await getBranchAlias(token, teamId, projectId, opts.branch);
+    if (alias) {
+        console.log(JSON.stringify({ url: alias.url, state: alias.state, branch: opts.branch }));
     }
     else {
         console.log(JSON.stringify({ url: null, branch: opts.branch, message: "No deployment found for this branch." }));

package/dist/lib/git.d.ts

@@ -20,6 +20,12 @@ export interface GitDiffResult {
 }
 export declare function getDefaultBranch(cwd: string): string;
 export declare function getRemoteUrl(cwd: string): string | null;
+export interface GitRepo {
+    owner: string;
+    name: string;
+    provider: "github" | "gitlab" | "bitbucket" | "unknown";
+}
+export declare function parseGitRepo(remoteUrl: string): GitRepo | null;
 /**
  * Get a structured diff result for the share API, supporting multiple scope modes.
  */
@@ -34,3 +40,5 @@ export declare function parseDiffStat(diffStat: string): Array<{
 }>;
 export declare function getGitInfo(cwd: string): GitInfo;
 export declare function isGitRepo(cwd: string): boolean;
+/** Returns the root directory of the git repo, or null if not in one. */
+export declare function getGitRoot(cwd: string): string | null;

package/dist/lib/git.js

@@ -85,6 +85,38 @@ export function getDefaultBranch(cwd) {
 export function getRemoteUrl(cwd) {
     return run("git remote get-url origin", cwd);
 }
+export function parseGitRepo(remoteUrl) {
+    let host = null;
+    let path = null;
+    const sshMatch = remoteUrl.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+    if (sshMatch) {
+        host = sshMatch[1];
+        path = sshMatch[2];
+    }
+    if (!path) {
+        try {
+            const url = new URL(remoteUrl);
+            host = url.hostname;
+            path = url.pathname.replace(/^\//, "").replace(/\.git$/, "");
+        }
+        catch { }
+    }
+    if (!host || !path)
+        return null;
+    const parts = path.split("/");
+    if (parts.length < 2)
+        return null;
+    const owner = parts[0];
+    const name = parts[1];
+    let provider = "unknown";
+    if (host.includes("github"))
+        provider = "github";
+    else if (host.includes("gitlab"))
+        provider = "gitlab";
+    else if (host.includes("bitbucket"))
+        provider = "bitbucket";
+    return { owner, name, provider };
+}
 /**
  * Get a structured diff result for the share API, supporting multiple scope modes.
  */
@@ -215,3 +247,7 @@ export function getGitInfo(cwd) {
 export function isGitRepo(cwd) {
     return run("git rev-parse --git-dir", cwd) !== null;
 }
+/** Returns the root directory of the git repo, or null if not in one. */
+export function getGitRoot(cwd) {
+    return run("git rev-parse --show-toplevel", cwd);
+}

package/dist/lib/vercel.d.ts

@@ -11,6 +11,19 @@ export declare function getVercelToken(): string | null;
  * For interactive commands only.
  */
 export declare function ensureVercelAuth(): Promise<string | null>;
+interface LocalVercelProject {
+    orgId: string;
+    projectId: string;
+}
+/**
+ * Reads `.vercel/project.json` from the given root directory.
+ * Created by `vercel link` or `vercel deploy`.
+ */
+export declare function readLocalVercelProject(root: string): LocalVercelProject | null;
+/**
+ * Writes `.vercel/project.json` at the given root directory and ensures `.vercel` is gitignored.
+ */
+export declare function writeLocalVercelProject(root: string, orgId: string, projectId: string): void;
 export interface VercelTeam {
     id: string;
     name: string;
@@ -22,6 +35,7 @@ export interface VercelProject {
 }
 export interface VercelDeployment {
     url: string;
+    state: string;
     branch: string | null;
     commitSha: string | null;
     commitMessage: string | null;
@@ -29,11 +43,45 @@ export interface VercelDeployment {
 }
 export declare function getVercelTeams(token: string): Promise<VercelTeam[]>;
 export declare function getVercelProjects(token: string, teamId: string): Promise<VercelProject[]>;
+/**
+ * Fetches details for a single Vercel project by ID.
+ */
+export declare function getVercelProjectDetail(token: string, projectId: string, teamId: string): Promise<VercelProject | null>;
+export interface VercelProjectWithLink {
+    id: string;
+    name: string;
+    teamId: string;
+    teamName: string;
+    link?: {
+        org?: string;
+        repo?: string;
+        repoId?: number;
+        type?: string;
+    };
+}
+/**
+ * Fetches all projects across all teams with their link info.
+ * Used for client-side repo matching.
+ */
+export declare function fetchAllProjectsWithLinks(token: string): Promise<VercelProjectWithLink[]>;
+/**
+ * Matches Vercel projects against a git remote's owner/repo.
+ * Exact match on link.org and link.repo.
+ */
+export declare function matchProjectsByRepo(projects: VercelProjectWithLink[], gitOwner: string, gitRepo: string): VercelProjectWithLink[];
+/**
+ * Creates a new Vercel project linked to a git repository.
+ */
+export declare function createVercelProject(token: string, teamId: string, name: string, repo: string, repoType: "github" | "gitlab" | "bitbucket"): Promise<VercelProject>;
 /**
  * Fetches the branch alias URL (stable, auto-updates with each push).
  * Returns null if no deployment exists for this branch.
  */
-export declare function getBranchAliasUrl(token: string, teamId: string, projectId: string, branch: string | null): Promise<string | null>;
+export interface BranchAlias {
+    url: string;
+    state: string;
+}
+export declare function getBranchAlias(token: string, teamId: string, projectId: string, branch: string | null): Promise<BranchAlias | null>;
 /**
  * Fetches recent deployments for a project.
  */
@@ -41,3 +89,4 @@ export declare function getRecentDeployments(token: string, teamId: string, proj
     limit?: number;
     branch?: string;
 }): Promise<VercelDeployment[]>;
+export {};

package/dist/lib/vercel.js

@@ -1,5 +1,5 @@
 import { execSync, spawn, exec } from "child_process";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync } from "fs";
 import { join } from "path";
 import { homedir, platform } from "os";
 import { promisify } from "util";
@@ -105,6 +105,42 @@ export async function ensureVercelAuth() {
     const auth = readVercelAuth();
     return auth?.token ?? null;
 }
+/**
+ * Reads `.vercel/project.json` from the given root directory.
+ * Created by `vercel link` or `vercel deploy`.
+ */
+export function readLocalVercelProject(root) {
+    const projectPath = join(root, ".vercel", "project.json");
+    if (!existsSync(projectPath))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(projectPath, "utf-8"));
+        if (typeof data.orgId === "string" && typeof data.projectId === "string") {
+            return { orgId: data.orgId, projectId: data.projectId };
+        }
+    }
+    catch { }
+    return null;
+}
+/**
+ * Writes `.vercel/project.json` at the given root directory and ensures `.vercel` is gitignored.
+ */
+export function writeLocalVercelProject(root, orgId, projectId) {
+    const vercelDir = join(root, ".vercel");
+    mkdirSync(vercelDir, { recursive: true });
+    writeFileSync(join(vercelDir, "project.json"), JSON.stringify({ orgId, projectId }, null, 2) + "\n");
+    // Ensure .vercel is in .gitignore
+    const gitignorePath = join(root, ".gitignore");
+    if (existsSync(gitignorePath)) {
+        const content = readFileSync(gitignorePath, "utf-8");
+        if (!content.split("\n").some((line) => line.trim() === ".vercel")) {
+            appendFileSync(gitignorePath, "\n.vercel\n");
+        }
+    }
+    else {
+        writeFileSync(gitignorePath, ".vercel\n");
+    }
+}
 // --- API calls (all take token + IDs explicitly) ---
 export async function getVercelTeams(token) {
     const res = await fetch("https://api.vercel.com/v2/teams", {
@@ -126,17 +162,78 @@ export async function getVercelProjects(token, teamId) {
     return data.projects;
 }
 /**
- * Fetches the branch alias URL (stable, auto-updates with each push).
- * Returns null if no deployment exists for this branch.
+ * Fetches details for a single Vercel project by ID.
+ */
+export async function getVercelProjectDetail(token, projectId, teamId) {
+    const params = new URLSearchParams({ teamId });
+    const res = await fetch(`https://api.vercel.com/v10/projects/${encodeURIComponent(projectId)}?${params}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok)
+        return null;
+    const data = (await res.json());
+    return { id: data.id, name: data.name };
+}
+/**
+ * Fetches all projects across all teams with their link info.
+ * Used for client-side repo matching.
+ */
+export async function fetchAllProjectsWithLinks(token) {
+    const teams = await getVercelTeams(token);
+    const all = [];
+    const fetches = teams.map(async (team) => {
+        const params = new URLSearchParams({ teamId: team.id, limit: "100" });
+        const res = await fetch(`https://api.vercel.com/v10/projects?${params}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            return;
+        const data = (await res.json());
+        for (const p of data.projects) {
+            all.push({ ...p, teamId: team.id, teamName: team.name });
+        }
+    });
+    await Promise.all(fetches);
+    return all;
+}
+/**
+ * Matches Vercel projects against a git remote's owner/repo.
+ * Exact match on link.org and link.repo.
  */
-export async function getBranchAliasUrl(token, teamId, projectId, branch) {
+export function matchProjectsByRepo(projects, gitOwner, gitRepo) {
+    const linked = projects.filter((p) => p.link?.org && p.link?.repo);
+    return linked.filter((p) => p.link?.org === gitOwner && p.link?.repo === gitRepo);
+}
+/**
+ * Creates a new Vercel project linked to a git repository.
+ */
+export async function createVercelProject(token, teamId, name, repo, repoType) {
+    const params = new URLSearchParams({ teamId });
+    const res = await fetch(`https://api.vercel.com/v11/projects${params ? `?${params}` : ""}`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            name,
+            gitRepository: { type: repoType, repo },
+        }),
+    });
+    if (!res.ok) {
+        const body = (await res.json().catch(() => null));
+        throw new Error(body?.error?.message ?? `Failed to create project (${res.status})`);
+    }
+    const data = (await res.json());
+    return { id: data.id, name: data.name };
+}
+export async function getBranchAlias(token, teamId, projectId, branch) {
     if (!branch)
         return null;
     const params = new URLSearchParams({
         projectId,
         teamId,
         limit: "1",
-        state: "READY",
         branch,
     });
     const res = await fetch(`https://api.vercel.com/v6/deployments?${params}`, {
@@ -156,7 +253,10 @@ export async function getBranchAliasUrl(token, teamId, projectId, branch) {
     if (!aliasRes.ok)
         return null;
     const aliasData = (await aliasRes.json());
-    return aliasData.automaticAliases?.[0] ?? null;
+    const url = aliasData.automaticAliases?.[0];
+    if (!url)
+        return null;
+    return { url, state: deploy.state };
 }
 /**
  * Fetches recent deployments for a project.
@@ -166,7 +266,6 @@ export async function getRecentDeployments(token, teamId, projectId, opts) {
         projectId,
         teamId,
         limit: String(opts?.limit ?? 10),
-        state: "READY",
     });
     if (opts?.branch) {
         params.set("branch", opts.branch);
@@ -179,6 +278,7 @@ export async function getRecentDeployments(token, teamId, projectId, opts) {
     const data = (await res.json());
     return data.deployments.map((d) => ({
         url: d.url,
+        state: d.state,
         branch: d.meta?.githubCommitRef ?? d.meta?.gitlabCommitRef ?? d.meta?.bitbucketCommitRef ?? null,
         commitSha: (d.meta?.githubCommitSha ?? d.meta?.gitlabCommitSha ?? d.meta?.bitbucketCommitSha ?? null)?.slice(0, 7) ??
             null,

package/dist/providers/vercel.d.ts

@@ -1,8 +1,8 @@
 import type { GitInfo } from "../lib/git.js";
 import type { VercelConfig } from "../lib/config.js";
 /**
- * Interactive team/project picker. Saves selection to global config.
- * Reused by both `inflight vercel` and the share flow.
+ * Interactive project picker. Saves selection to global config.
+ * Used by `inflight vercel` command for explicit manual override.
  */
 export declare function pickVercelProject(token: string): Promise<VercelConfig | null>;
 export declare function resolveVercelUrl(cwd: string, gitInfo: GitInfo): Promise<string | null>;

package/dist/providers/vercel.js

@@ -1,83 +1,189 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import { readVercelConfig, writeVercelConfig } from "../lib/config.js";
-import { ensureVercelCli, ensureVercelAuth, getVercelTeams, getVercelProjects, getBranchAliasUrl, getRecentDeployments, } from "../lib/vercel.js";
+import { parseGitRepo, getGitRoot } from "../lib/git.js";
+import { writeVercelConfig } from "../lib/config.js";
+import { ensureVercelCli, ensureVercelAuth, readLocalVercelProject, writeLocalVercelProject, getVercelProjectDetail, fetchAllProjectsWithLinks, matchProjectsByRepo, createVercelProject, getBranchAlias, getRecentDeployments, } from "../lib/vercel.js";
+// --- Auto-detection ---
 /**
- * Interactive team/project picker. Saves selection to global config.
- * Reused by both `inflight vercel` and the share flow.
+ * Auto-detect the Vercel project for the current git repo.
+ * Returns null only if user cancels or no projects exist at all.
+ *
+ * 1. `.vercel/project.json` at git root (instant, no API)
+ * 2. Fetch all projects, exact match on git remote
+ * 3. Multiple matches → pick from matches
+ * 4. Zero matches → pick from all projects
  */
-export async function pickVercelProject(token) {
-    const teams = await getVercelTeams(token);
-    if (teams.length === 0) {
-        p.log.error("No Vercel teams found.");
+async function autoDetectProject(cwd, gitInfo, token) {
+    const gitRoot = getGitRoot(cwd);
+    // Cache result to .vercel/project.json so subsequent runs skip API calls
+    const cacheResult = (project) => {
+        if (gitRoot) {
+            writeLocalVercelProject(gitRoot, project.teamId, project.projectId);
+        }
+        return project;
+    };
+    // --- Fast path: .vercel/project.json ---
+    if (gitRoot) {
+        const localProject = readLocalVercelProject(gitRoot);
+        if (localProject) {
+            const detail = await getVercelProjectDetail(token, localProject.projectId, localProject.orgId);
+            if (detail) {
+                p.log.info(`Detected Vercel project: ${pc.bold(detail.name)}`);
+                return { teamId: localProject.orgId, projectId: detail.id, projectName: detail.name };
+            }
+        }
+    }
+    // --- Fetch all projects ---
+    const spinner = p.spinner();
+    spinner.start("Detecting Vercel project...");
+    let allProjects;
+    try {
+        allProjects = await fetchAllProjectsWithLinks(token);
+    }
+    catch {
+        spinner.stop("Could not fetch Vercel projects.");
         return null;
     }
+    if (allProjects.length === 0) {
+        spinner.stop("No Vercel projects found.");
+        return null;
+    }
+    // --- Try exact match on git remote ---
+    const gitRepo = gitInfo.remoteUrl ? parseGitRepo(gitInfo.remoteUrl) : null;
+    if (gitRepo) {
+        const matches = matchProjectsByRepo(allProjects, gitRepo.owner, gitRepo.name);
+        if (matches.length === 1) {
+            spinner.stop(`Detected Vercel project: ${pc.bold(matches[0].name)}`);
+            return cacheResult({
+                teamId: matches[0].teamId,
+                projectId: matches[0].id,
+                projectName: matches[0].name,
+            });
+        }
+        if (matches.length > 1) {
+            spinner.stop(`Found ${matches.length} Vercel projects for this repo.`);
+            const picked = await pickFromList(allProjects);
+            return picked ? cacheResult(picked) : null;
+        }
+    }
+    // --- No match ---
+    spinner.stop("Could not auto-detect Vercel project.");
+    const canCreate = gitRepo && gitRepo.provider !== "unknown";
+    const picked = await pickFromList(allProjects, canCreate ? { token, gitRepo } : undefined);
+    return picked ? cacheResult(picked) : null;
+}
+async function pickFromList(projects, createCtx) {
+    const maxName = Math.max(...projects.map((proj) => proj.name.length));
+    const selected = await p.select({
+        message: "Select a Vercel project",
+        options: [
+            ...projects.map((proj) => ({
+                value: proj,
+                label: proj.teamName ? `${proj.name.padEnd(maxName)}  ${pc.dim(`(${proj.teamName})`)}` : proj.name,
+            })),
+            ...(createCtx
+                ? [{ value: "create", label: pc.dim("Create new Vercel project") }]
+                : []),
+        ],
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    if (selected === "create" && createCtx) {
+        return createProjectFlow(projects, createCtx);
+    }
+    const match = selected;
+    return { teamId: match.teamId, projectId: match.id, projectName: match.name };
+}
+async function createProjectFlow(projects, ctx) {
+    const { token, gitRepo } = ctx;
+    // Pick team from unique teams
+    const teams = [...new Map(projects.map((proj) => [proj.teamId, proj.teamName])).entries()];
     let teamId;
-    let teamName;
     if (teams.length === 1) {
-        teamId = teams[0].id;
-        teamName = teams[0].name;
+        teamId = teams[0][0];
     }
     else {
-        const selected = await p.select({
-            message: "Select a Vercel team",
-            options: teams.map((t) => ({ value: t.id, label: t.name })),
+        const selectedTeam = await p.select({
+            message: "Which Vercel team?",
+            options: teams.map(([id, name]) => ({ value: id, label: name })),
         });
-        if (p.isCancel(selected)) {
+        if (p.isCancel(selectedTeam)) {
             p.cancel("Cancelled.");
-            return null;
+            process.exit(0);
         }
-        teamId = selected;
-        teamName = teams.find((t) => t.id === teamId)?.name ?? teamId;
+        teamId = selectedTeam;
+    }
+    const spinner = p.spinner();
+    spinner.start("Creating Vercel project...");
+    try {
+        const created = await createVercelProject(token, teamId, gitRepo.name, `${gitRepo.owner}/${gitRepo.name}`, gitRepo.provider);
+        spinner.stop(`Created ${pc.bold(created.name)}`);
+        return { teamId, projectId: created.id, projectName: created.name };
+    }
+    catch (e) {
+        spinner.stop(e.message);
+        return null;
     }
-    const projects = await getVercelProjects(token, teamId);
-    if (projects.length === 0) {
-        p.log.error("No Vercel projects found for this team.");
+}
+// --- Manual picker (used by `inflight vercel` command) ---
+/**
+ * Interactive project picker. Saves selection to global config.
+ * Used by `inflight vercel` command for explicit manual override.
+ */
+export async function pickVercelProject(token) {
+    const allProjects = await fetchAllProjectsWithLinks(token);
+    if (allProjects.length === 0) {
+        p.log.error("No Vercel projects found.");
         return null;
     }
-    const selectedProject = await p.select({
+    const selected = await p.select({
         message: "Select a Vercel project",
-        options: projects.map((proj) => ({ value: proj.id, label: proj.name })),
+        options: allProjects.map((proj) => ({
+            value: proj,
+            label: proj.teamName ? `${proj.name} ${pc.dim(`(${proj.teamName})`)}` : proj.name,
+        })),
     });
-    if (p.isCancel(selectedProject)) {
+    if (p.isCancel(selected)) {
         p.cancel("Cancelled.");
         return null;
     }
-    const projectId = selectedProject;
-    const projectName = projects.find((proj) => proj.id === projectId)?.name ?? projectId;
-    const config = { teamId, teamName, projectId, projectName };
+    const match = selected;
+    const config = {
+        teamId: match.teamId,
+        teamName: match.teamName,
+        projectId: match.id,
+        projectName: match.name,
+    };
     writeVercelConfig(config);
     return config;
 }
+// --- Main resolve function ---
 export async function resolveVercelUrl(cwd, gitInfo) {
-    // Ensure Vercel CLI is installed (only logs if installing)
     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"));
         return null;
     }
-    // Ensure auth
     const token = await ensureVercelAuth();
     if (!token) {
         p.log.error("Vercel login failed.");
         return null;
     }
-    // Get or pick Vercel project
-    let config = readVercelConfig();
-    if (!config) {
-        config = await pickVercelProject(token);
-        if (!config)
-            return null;
-    }
+    const project = await autoDetectProject(cwd, gitInfo, token);
+    if (!project)
+        return null;
     // Fetch branch alias
-    const branchAlias = await getBranchAliasUrl(token, config.teamId, config.projectId, gitInfo.branch);
+    const branchAlias = await getBranchAlias(token, project.teamId, project.projectId, gitInfo.branch);
     if (branchAlias) {
-        p.log.info(`Branch preview (auto-updates with each push):\n  → ${pc.cyan(branchAlias)}`);
+        const stateLabel = branchAlias.state !== "READY" ? `  ${pc.yellow(`(${branchAlias.state.toLowerCase()})`)}` : "";
+        p.log.info(`Branch preview (auto-updates with each push):\n  → ${pc.cyan(branchAlias.url)}${stateLabel}`);
         const choice = await p.select({
-            message: "Use this URL, or pick a different deployment?",
+            message: "Use this URL, or pick a specific deployment?",
             options: [
                 { value: "branch", label: "Use branch preview (recommended)" },
-                { value: "recent", label: "Pick from recent deployments" },
+                { value: "recent", label: "Pick a specific deployment" },
                 { value: "manual", label: "Paste a URL manually" },
             ],
         });
@@ -86,26 +192,27 @@ export async function resolveVercelUrl(cwd, gitInfo) {
             process.exit(0);
         }
         if (choice === "branch")
-            return branchAlias;
+            return branchAlias.url;
         if (choice === "manual")
             return null;
     }
     // Show recent deployments
-    const recent = await getRecentDeployments(token, config.teamId, config.projectId);
+    const recent = await getRecentDeployments(token, project.teamId, project.projectId);
     if (recent.length === 0) {
         p.log.warn("No deployments found. Paste a URL instead.");
         return null;
     }
     const maxBranch = Math.max(...recent.map((d) => (d.branch ?? "unknown").length));
     const selected = await p.select({
-        message: "Select a deployment",
+        message: "Select a specific deployment",
         options: [
             ...recent.map((d) => {
                 const branch = (d.branch ?? "unknown").padEnd(maxBranch);
                 const ago = timeAgo(d.createdAt).padEnd(8);
+                const state = d.state !== "READY" ? `  ${pc.yellow(`(${d.state.toLowerCase()})`)}` : "";
                 const firstLine = (d.commitMessage ?? "No commit message").split("\n")[0];
                 const message = truncate(firstLine, 55);
-                return { value: d.url, label: `${branch}  ${ago}  ${pc.dim(message)}` };
+                return { value: d.url, label: `${branch}  ${ago}${state}  ${pc.dim(message)}` };
             }),
             { value: "manual", label: "Paste a URL manually" },
         ],

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "inflight-cli",
-	"version": "2.0.9",
+	"version": "2.1.0",
 	"description": "Get feedback directly on your staging URL",
 	"bin": {
 		"inflight": "dist/index.js",