inflight-cli 2.4.0 → 2.6.0

package/dist/commands/preview.js

@@ -115,6 +115,8 @@ export async function previewCommand(opts) {
                 message: "How many commits?",
                 placeholder: "1",
                 validate: (v) => {
+                    if (!v)
+                        return "Enter a positive number";
                     const n = parseInt(v, 10);
                     if (isNaN(n) || n < 1)
                         return "Enter a positive number";

package/dist/commands/share.js

@@ -5,6 +5,7 @@ import { getGitInfo, getGitSyncState, generateCommitMessage, commitAndPush, push
 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";
 function formatRelativeTime(timestampMs) {
     const seconds = Math.floor((Date.now() - timestampMs) / 1000);
     if (seconds < 60)
@@ -22,10 +23,10 @@ function formatRelativeTime(timestampMs) {
         return `${days}d ago`;
     return new Date(timestampMs).toLocaleDateString("en-US", { month: "short", day: "numeric" });
 }
-function isLocalhostUrl(url) {
+function isValidHostedUrl(url) {
     try {
         const hostname = new URL(url.startsWith("http") ? url : `https://${url}`).hostname;
-        return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0" || hostname === "[::1]";
+        return hostname.includes(".");
     }
     catch {
         return false;
@@ -95,7 +96,7 @@ async function checkAndSyncGit(cwd) {
             message: "Commit message",
             initialValue: defaultMessage,
             validate: (v) => {
-                if (!v.trim())
+                if (!v || !v.trim())
                     return "Commit message is required";
             },
         });
@@ -259,10 +260,12 @@ export async function shareCommand(opts = {}) {
         if (!stagingUrl.startsWith("http")) {
             stagingUrl = `https://${stagingUrl}`;
         }
-        if (isLocalhostUrl(stagingUrl)) {
-            const message = "Inflight needs a hosted URL — localhost isn't accessible to your team. Deploy to Vercel, Netlify, or another hosting provider first.";
+        if (!isValidHostedUrl(stagingUrl)) {
+            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 (opts.json) {
-                console.log(JSON.stringify({ error: "localhost_url", message }));
+                console.log(JSON.stringify({ error: "invalid_url", message }));
             }
             else {
                 p.log.error(message);
@@ -326,10 +329,12 @@ export async function shareCommand(opts = {}) {
                     new URL(v.startsWith("http") ? v : `https://${v}`);
                 }
                 catch {
-                    return "Must be a valid URL";
+                    return "Must be a valid URL (e.g., my-branch.vercel.app)";
                 }
-                if (isLocalhostUrl(v)) {
-                    return "Inflight needs a hosted URL — localhost isn't accessible to your team. Deploy to Vercel, Netlify, or another hosting provider first.";
+                if (!isValidHostedUrl(v)) {
+                    return v.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)";
                 }
             },
         });
@@ -345,18 +350,33 @@ export async function shareCommand(opts = {}) {
     // ── Step 4: Project selection ──
     let selectedProjectId;
     let overrideVersionId;
-    const { projects: recentProjects } = await apiGetRecentProjects(auth.apiKey, workspaceId).catch(() => ({
+    const { projects } = await apiGetRecentProjects(auth.apiKey, workspaceId, 20).catch(() => ({
         projects: [],
     }));
-    if (recentProjects.length > 0) {
-        const projectChoice = await p.select({
-            message: "Add to an existing project or start a new one?",
+    if (projects.length > 0) {
+        // Pre-select project whose latest version matches the current branch
+        const currentBranch = gitInfo.branch;
+        const branchMatch = currentBranch
+            ? projects.find((proj) => proj.latestVersion.branch === currentBranch)
+            : undefined;
+        // Move branch-matched project to the top of the list
+        const sortedProjects = branchMatch
+            ? [branchMatch, ...projects.filter((proj) => proj.projectId !== branchMatch.projectId)]
+            : projects;
+        const projectChoice = await scrollableSelect({
+            message: "Create a new project in Inflight, or update an existing one?",
+            maxItems: 5,
             options: [
                 { value: "new", label: "Start a new project" },
-                ...recentProjects.map((proj) => ({
+                ...sortedProjects.map((proj) => ({
                     value: proj.projectId,
                     label: `"${proj.latestVersion.title}"`,
-                    hint: `created ${formatRelativeTime(proj.latestVersion.createdAt)}`,
+                    hint: [
+                        formatRelativeTime(proj.latestVersion.createdAt),
+                        proj.latestVersion.branch === currentBranch ? `← current branch (${currentBranch})` : "",
+                    ]
+                        .filter(Boolean)
+                        .join(" · "),
                 })),
             ],
         });
@@ -367,7 +387,7 @@ export async function shareCommand(opts = {}) {
         if (projectChoice !== "new") {
             selectedProjectId = projectChoice;
             // Check for override opportunity — only when latest version has no feedback
-            const selectedProject = recentProjects.find((proj) => proj.projectId === selectedProjectId);
+            const selectedProject = projects.find((proj) => proj.projectId === selectedProjectId);
             if (selectedProject && selectedProject.latestVersion.commentCount === 0) {
                 const overrideChoice = await p.select({
                     message: `"${selectedProject.latestVersion.title}" has no feedback yet.`,

package/dist/lib/api.d.ts

@@ -17,6 +17,7 @@ export interface RecentProject {
         stagingUrl: string | null;
         commentCount: number;
         createdAt: number;
+        branch: string | null;
     };
 }
 export declare function apiGetMe(apiKey: string): Promise<{
@@ -24,7 +25,7 @@ export declare function apiGetMe(apiKey: string): Promise<{
     email: string | null;
     workspaces: Workspace[];
 }>;
-export declare function apiGetRecentProjects(apiKey: string, workspaceId: string): Promise<{
+export declare function apiGetRecentProjects(apiKey: string, workspaceId: string, limit?: number): Promise<{
     projects: RecentProject[];
 }>;
 export declare function apiCreateVersion(opts: {

package/dist/lib/api.js

@@ -7,8 +7,11 @@ export async function apiGetMe(apiKey) {
         throw new Error("Invalid API key");
     return res.json();
 }
-export async function apiGetRecentProjects(apiKey, workspaceId) {
-    const res = await fetch(`${API_URL}/api/cli/projects/recent?workspaceId=${encodeURIComponent(workspaceId)}`, {
+export async function apiGetRecentProjects(apiKey, workspaceId, limit) {
+    const params = new URLSearchParams({ workspaceId });
+    if (limit)
+        params.set("limit", String(limit));
+    const res = await fetch(`${API_URL}/api/cli/projects/recent?${params.toString()}`, {
         headers: { Authorization: `Bearer ${apiKey}` },
     });
     if (!res.ok) {

package/dist/lib/scrollable-select.d.ts

@@ -0,0 +1,13 @@
+interface Option<T> {
+    value: T;
+    label?: string;
+    hint?: string;
+}
+interface ScrollableSelectOptions<T> {
+    message: string;
+    options: Option<T>[];
+    maxItems?: number;
+    initialValue?: T;
+}
+export declare function scrollableSelect<T extends string>(opts: ScrollableSelectOptions<T>): Promise<T | symbol>;
+export {};

package/dist/lib/scrollable-select.js

@@ -0,0 +1,98 @@
+import { Prompt } from "@clack/core";
+import pc from "picocolors";
+const S_STEP_ACTIVE = "◆";
+const S_STEP_CANCEL = "■";
+const S_STEP_SUBMIT = "◇";
+const S_BAR = "│";
+const S_BAR_END = "└";
+const S_RADIO_ACTIVE = "●";
+const S_RADIO_INACTIVE = "○";
+function symbol(state) {
+    switch (state) {
+        case "initial":
+        case "active":
+            return pc.cyan(S_STEP_ACTIVE);
+        case "cancel":
+            return pc.red(S_STEP_CANCEL);
+        case "submit":
+            return pc.green(S_STEP_SUBMIT);
+        default:
+            return pc.cyan(S_STEP_ACTIVE);
+    }
+}
+export function scrollableSelect(opts) {
+    const options = opts.options;
+    const max = Math.min(opts.maxItems ?? 5, Math.max(process.stdout.rows - 4, 5));
+    let cursor = 0;
+    if (opts.initialValue !== undefined) {
+        const idx = options.findIndex((o) => o.value === opts.initialValue);
+        if (idx !== -1)
+            cursor = idx;
+    }
+    function styleOption(option, active) {
+        const label = option.label ?? String(option.value);
+        if (active) {
+            return `${pc.green(S_RADIO_ACTIVE)} ${label} ${option.hint ? pc.dim(`(${option.hint})`) : ""}`;
+        }
+        return `${pc.dim(S_RADIO_INACTIVE)} ${pc.dim(label)}`;
+    }
+    function getWindow() {
+        if (options.length <= max) {
+            return { start: 0, end: options.length };
+        }
+        let start = 0;
+        if (cursor >= start + max - 3) {
+            start = Math.max(Math.min(cursor - max + 3, options.length - max), 0);
+        }
+        else if (cursor < start + 2) {
+            start = Math.max(cursor - 2, 0);
+        }
+        return { start, end: start + max };
+    }
+    function renderOptions() {
+        const { start, end } = getWindow();
+        const above = start;
+        const below = options.length - end;
+        const lines = options.slice(start, end).map((opt, i) => styleOption(opt, start + i === cursor));
+        if (above > 0 || below > 0) {
+            const parts = [];
+            if (above > 0)
+                parts.push(`↑ ${above} more`);
+            if (below > 0)
+                parts.push(`↓ ${below} more`);
+            lines.push(pc.dim(parts.join("  ")));
+        }
+        return lines;
+    }
+    const prompt = new Prompt({
+        render() {
+            const title = `${pc.gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
+            switch (this.state) {
+                case "submit":
+                    return `${title}${pc.gray(S_BAR)}  ${pc.dim(options[cursor].label ?? String(options[cursor].value))}`;
+                case "cancel":
+                    return `${title}${pc.gray(S_BAR)}  ${pc.strikethrough(pc.dim(options[cursor].label ?? String(options[cursor].value)))}\n${pc.gray(S_BAR)}`;
+                default:
+                    return `${title}${pc.cyan(S_BAR)}  ${renderOptions().join(`\n${pc.cyan(S_BAR)}  `)}\n${pc.cyan(S_BAR_END)}\n`;
+            }
+        },
+    });
+    prompt.on("cursor", (action) => {
+        if (action === "up" || action === "left") {
+            if (cursor > 0)
+                cursor--;
+        }
+        else if (action === "down" || action === "right") {
+            if (cursor < options.length - 1)
+                cursor++;
+        }
+        prompt.value = options[cursor].value;
+    });
+    prompt.on("finalize", () => {
+        if (prompt.state === "submit") {
+            prompt.value = options[cursor].value;
+        }
+    });
+    prompt.value = options[cursor].value;
+    return prompt.prompt();
+}

package/dist/providers/netlify.js

@@ -159,36 +159,129 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
                 break;
         }
         if (commitDeploy) {
-            pollSpinner.stop("Deployment found!");
+            pollSpinner.stop("Netlify deployment found!");
         }
         else {
-            pollSpinner.stop("Deployment is still building...");
+            pollSpinner.stop("Netlify deployment is still building...");
         }
     }
-    // If we found a commit-specific deployment, use it automatically
+    // If we found a commit-specific deployment, handle based on state
     if (commitDeploy) {
-        const stateLabel = commitDeploy.state !== "ready" ? ` ${pc.yellow(`(${commitDeploy.state})`)}` : "";
+        const commitLabel = pc.bold(commitSha);
         const message = commitDeploy.commitMessage
             ? pc.dim(` — ${truncate(commitDeploy.commitMessage.split("\n")[0], 50)}`)
             : "";
-        p.log.info(`Deployment for ${pc.bold(commitSha)}${message}:\n  → ${pc.cyan(commitDeploy.deploySslUrl)}${stateLabel}`);
-        return commitDeploy.deploySslUrl;
+        if (commitDeploy.state === "error") {
+            p.log.error(`Netlify deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
+            commitDeploy = undefined;
+            // Fall through to the picker
+        }
+        else if (commitDeploy.state !== "ready") {
+            // Any non-ready, non-error state (building, enqueued, uploading, preparing, processing, etc.)
+            p.log.info(`Netlify deployment for ${commitLabel}${message} — ${pc.yellow(commitDeploy.state)}`);
+            const buildingUrl = commitDeploy.deploySslUrl;
+            const startTime = Date.now();
+            const maxWaitMs = 120_000;
+            const pollIntervalMs = 5_000;
+            let resolved = false;
+            const spinner = p.spinner();
+            const updateMessage = () => {
+                const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                spinner.message(`Waiting for Netlify to finish building... (${elapsed}s)`);
+            };
+            spinner.start("Waiting for Netlify to finish building... (0s)");
+            const ticker = setInterval(updateMessage, 1000);
+            try {
+                while (Date.now() - startTime < maxWaitMs) {
+                    await new Promise((r) => setTimeout(r, pollIntervalMs));
+                    updateMessage();
+                    const freshDeps = await getNetlifyDeploys(token, site.siteId, site.siteName, {
+                        branch: repoMatches ? (gitInfo.branch ?? undefined) : undefined,
+                    });
+                    const fresh = freshDeps.find((d) => d.commitRef === commitSha);
+                    if (!fresh)
+                        break;
+                    if (fresh.state === "ready") {
+                        clearInterval(ticker);
+                        const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                        spinner.stop(`Netlify deployment ready! (${elapsed}s)`);
+                        p.log.info(`Netlify deployment for ${commitLabel}${message}:\n  → ${pc.cyan(fresh.deploySslUrl)}`);
+                        return fresh.deploySslUrl;
+                    }
+                    if (fresh.state === "error") {
+                        clearInterval(ticker);
+                        spinner.stop(pc.red("Netlify deployment failed."));
+                        p.log.error(`Netlify deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
+                        commitDeploy = undefined;
+                        resolved = true;
+                        break;
+                    }
+                }
+                if (!resolved) {
+                    clearInterval(ticker);
+                    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                    spinner.stop(`Still building after ${elapsed}s.`);
+                    const action = await p.select({
+                        message: "Netlify deployment is still building.",
+                        options: [
+                            { value: "continue", label: "Use it anyway", hint: "URL may not be ready yet" },
+                            { value: "pick", label: "Select a different deployment" },
+                        ],
+                    });
+                    if (p.isCancel(action)) {
+                        p.cancel("Cancelled.");
+                        process.exit(0);
+                    }
+                    if (action === "continue") {
+                        p.log.info(`Netlify deployment for ${commitLabel}${message}:\n  → ${pc.cyan(buildingUrl)} ${pc.yellow("(building)")}`);
+                        return buildingUrl;
+                    }
+                    commitDeploy = undefined;
+                    // Fall through to picker
+                }
+            }
+            catch {
+                clearInterval(ticker);
+                spinner.stop("Error checking deployment status.");
+            }
+        }
+        else {
+            // ready — use it
+            p.log.info(`Netlify deployment for ${commitLabel}${message}:\n  → ${pc.cyan(commitDeploy.deploySslUrl)}`);
+            return commitDeploy.deploySslUrl;
+        }
     }
+    // Refresh deployments so the picker shows current states
+    deploys = await getNetlifyDeploys(token, site.siteId, site.siteName, {
+        branch: repoMatches ? (gitInfo.branch ?? undefined) : undefined,
+    });
     // Fallback: no commit deployment — let user pick from recent or paste manually
     if (deploys.length === 0) {
         p.log.warn("No deployments found. Paste a URL instead.");
         return null;
     }
+    const hasWorkingDeploy = deploys.some((d) => d.state !== "error");
+    if (!hasWorkingDeploy) {
+        p.log.warn("All recent deployments failed. Fix the build and push again, or paste a URL.");
+        return null;
+    }
     const maxBranch = Math.max(...deploys.map((d) => (d.branch ?? "unknown").length));
     const selected = await p.select({
         message: "No deployment found for current commit. Select one:",
         options: [
             ...deploys.map((d) => {
+                const isFailed = d.state === "error";
                 const branch = (d.branch ?? "unknown").padEnd(maxBranch);
                 const ago = timeAgo(d.createdAt).padEnd(8);
-                const state = d.state !== "ready" ? `  ${pc.yellow(`(${d.state})`)}` : "";
                 const firstLine = (d.commitMessage ?? "No commit message").split("\n")[0];
                 const msg = truncate(firstLine, 55);
+                if (isFailed) {
+                    return {
+                        value: d.deploySslUrl,
+                        label: pc.dim(`${branch}  ${ago}  ${pc.red("(failed)")}  ${msg}`),
+                    };
+                }
+                const state = d.state !== "ready" ? `  ${pc.yellow(`(${d.state})`)}` : "";
                 return { value: d.deploySslUrl, label: `${branch}  ${ago}${state}  ${pc.dim(msg)}` };
             }),
             { value: "manual", label: "Paste a URL manually" },
@@ -198,7 +291,17 @@ export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
         p.cancel("Cancelled.");
         process.exit(0);
     }
-    return selected === "manual" ? null : selected;
+    if (selected === "manual")
+        return null;
+    // Warn if the user picked a failed deployment
+    const pickedDeploy = deploys.find((d) => d.deploySslUrl === selected);
+    if (pickedDeploy && pickedDeploy.state === "error") {
+        p.log.warn("This deployment failed — the URL may not load.");
+        const confirm = await p.confirm({ message: "Use it anyway?" });
+        if (p.isCancel(confirm) || !confirm)
+            return null;
+    }
+    return selected;
 }
 function truncate(str, max) {
     return str.length > max ? str.slice(0, max - 1) + "…" : str;

package/dist/providers/vercel.js

@@ -156,7 +156,7 @@ async function createProjectFlow(projects, ctx) {
             await new Promise((r) => setTimeout(r, 2000));
             const deps = await getVercelDeployments(token, teamId, created.id);
             if (deps.length > 0) {
-                pollSpinner.stop("Deployment started.");
+                pollSpinner.stop("Vercel deployment started.");
                 return {
                     teamId,
                     projectId: created.id,
@@ -166,7 +166,7 @@ async function createProjectFlow(projects, ctx) {
                 };
             }
         }
-        pollSpinner.stop("Deployment may take a moment to appear.");
+        pollSpinner.stop("Vercel deployment may take a moment to appear.");
         return {
             teamId,
             projectId: created.id,
@@ -221,36 +221,132 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
                 break;
         }
         if (commitDeploy) {
-            pollSpinner.stop("Deployment found!");
+            pollSpinner.stop("Vercel deployment found!");
         }
         else {
-            pollSpinner.stop("Deployment is still building...");
+            pollSpinner.stop("Vercel deployment is still building...");
         }
     }
-    // If we found a commit-specific deployment, use it automatically
+    // If we found a commit-specific deployment, handle based on state
     if (commitDeploy) {
-        const stateLabel = commitDeploy.state !== "READY" ? ` ${pc.yellow(`(${commitDeploy.state.toLowerCase()})`)}` : "";
+        const commitLabel = pc.bold(commitSha);
         const message = commitDeploy.commitMessage
             ? pc.dim(` — ${truncate(commitDeploy.commitMessage.split("\n")[0], 50)}`)
             : "";
-        p.log.info(`Deployment for ${pc.bold(commitSha)}${message}:\n  → ${pc.cyan(commitDeploy.url)}${stateLabel}`);
-        return commitDeploy.url;
+        if (commitDeploy.state === "ERROR" || commitDeploy.state === "CANCELED") {
+            p.log.error(`Vercel deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
+            commitDeploy = undefined;
+            // Fall through to the picker
+        }
+        else if (commitDeploy.state === "BUILDING" ||
+            commitDeploy.state === "QUEUED" ||
+            commitDeploy.state === "INITIALIZING") {
+            // Show what we're waiting on
+            p.log.info(`Vercel deployment for ${commitLabel}${message} — ${pc.yellow(commitDeploy.state.toLowerCase())}`);
+            // Poll with a ticking timer for up to ~2 minutes
+            const buildingUrl = commitDeploy.url;
+            const startTime = Date.now();
+            const maxWaitMs = 120_000;
+            const pollIntervalMs = 5_000;
+            let resolved = false;
+            const spinner = p.spinner();
+            const updateMessage = () => {
+                const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                spinner.message(`Waiting for Vercel to finish building... (${elapsed}s)`);
+            };
+            spinner.start("Waiting for Vercel to finish building... (0s) ");
+            const ticker = setInterval(updateMessage, 1000);
+            try {
+                while (Date.now() - startTime < maxWaitMs) {
+                    await new Promise((r) => setTimeout(r, pollIntervalMs));
+                    updateMessage();
+                    const freshDeps = await getVercelDeployments(token, project.teamId, project.projectId, {
+                        branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
+                    });
+                    const fresh = freshDeps.find((d) => d.commitSha === commitSha);
+                    if (!fresh)
+                        break;
+                    if (fresh.state === "READY") {
+                        clearInterval(ticker);
+                        const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                        spinner.stop(`Vercel deployment ready! (${elapsed}s)`);
+                        p.log.info(`Vercel deployment for ${commitLabel}${message}:\n  → ${pc.cyan(fresh.url)}`);
+                        return fresh.url;
+                    }
+                    if (fresh.state === "ERROR" || fresh.state === "CANCELED") {
+                        clearInterval(ticker);
+                        spinner.stop(pc.red("Vercel deployment failed."));
+                        p.log.error(`Vercel deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
+                        commitDeploy = undefined;
+                        resolved = true;
+                        break;
+                    }
+                }
+                if (!resolved) {
+                    clearInterval(ticker);
+                    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                    spinner.stop(`Still building after ${elapsed}s.`);
+                    const action = await p.select({
+                        message: "Vercel deployment is still building.",
+                        options: [
+                            { value: "continue", label: "Use it anyway", hint: "URL may not be ready yet" },
+                            { value: "pick", label: "Select a different deployment" },
+                        ],
+                    });
+                    if (p.isCancel(action)) {
+                        p.cancel("Cancelled.");
+                        process.exit(0);
+                    }
+                    if (action === "continue") {
+                        p.log.info(`Vercel deployment for ${commitLabel}${message}:\n  → ${pc.cyan(buildingUrl)} ${pc.yellow("(building)")}`);
+                        return buildingUrl;
+                    }
+                    commitDeploy = undefined;
+                    // Fall through to picker
+                }
+            }
+            catch {
+                clearInterval(ticker);
+                spinner.stop("Error checking deployment status.");
+            }
+        }
+        else {
+            // READY or any other terminal state — use it
+            p.log.info(`Vercel deployment for ${commitLabel}${message}:\n  → ${pc.cyan(commitDeploy.url)}`);
+            return commitDeploy.url;
+        }
     }
+    // Refresh deployments so the picker shows current states
+    deployments = await getVercelDeployments(token, project.teamId, project.projectId, {
+        branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
+    });
     // Fallback: no commit deployment found — let user pick from recent or paste manually
     if (deployments.length === 0) {
         p.log.warn("No deployments found. Paste a URL instead.");
         return null;
     }
-    const maxBranch = Math.max(...deployments.map((d) => (d.branch ?? "unknown").length));
+    const hasWorkingDeployment = deployments.some((d) => d.state !== "ERROR" && d.state !== "CANCELED");
+    if (!hasWorkingDeployment) {
+        p.log.warn("All recent deployments failed. Fix the build and push again, or paste a URL.");
+        return null;
+    }
+    const maxBranchPick = Math.max(...deployments.map((d) => (d.branch ?? "unknown").length));
     const selected = await p.select({
         message: "No deployment found for current commit. Select one:",
         options: [
             ...deployments.map((d) => {
-                const branch = (d.branch ?? "unknown").padEnd(maxBranch);
+                const isFailed = d.state === "ERROR" || d.state === "CANCELED";
+                const branch = (d.branch ?? "unknown").padEnd(maxBranchPick);
                 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 msg = truncate(firstLine, 55);
+                if (isFailed) {
+                    return {
+                        value: d.url,
+                        label: pc.dim(`${branch}  ${ago}  ${pc.red("(failed)")}  ${msg}`),
+                    };
+                }
+                const state = d.state !== "READY" ? `  ${pc.yellow(`(${d.state.toLowerCase()})`)}` : "";
                 return { value: d.url, label: `${branch}  ${ago}${state}  ${pc.dim(msg)}` };
             }),
             { value: "manual", label: "Paste a URL manually" },
@@ -260,7 +356,17 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
         p.cancel("Cancelled.");
         process.exit(0);
     }
-    return selected === "manual" ? null : selected;
+    if (selected === "manual")
+        return null;
+    // Warn if the user picked a failed deployment
+    const pickedDeploy = deployments.find((d) => d.url === selected);
+    if (pickedDeploy && (pickedDeploy.state === "ERROR" || pickedDeploy.state === "CANCELED")) {
+        p.log.warn("This deployment failed — the URL may not load.");
+        const confirm = await p.confirm({ message: "Use it anyway?" });
+        if (p.isCancel(confirm) || !confirm)
+            return null;
+    }
+    return selected;
 }
 function truncate(str, max) {
     return str.length > max ? str.slice(0, max - 1) + "…" : str;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "inflight-cli",
-	"version": "2.4.0",
+	"version": "2.6.0",
 	"description": "Get feedback directly on your staging URL",
 	"bin": {
 		"inflight": "dist/index.js",
@@ -19,7 +19,8 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@clack/prompts": "0.8.2",
+		"@clack/core": "1.2.0",
+		"@clack/prompts": "1.2.0",
 		"commander": "12.1.0",
 		"open": "11.0.0",
 		"picocolors": "1.1.1",