inflight-cli 2.12.0 → 2.14.0

package/dist/providers/netlify.js

@@ -1,40 +1,48 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import { parseGitRepo, getGitRoot } from "../lib/git.js";
+import { parseGitRepo } from "../lib/git.js";
 import { isAgent } from "../lib/agent.js";
-import { writeNetlifyConfig } from "../lib/config.js";
-import { ensureNetlifyCli, ensureNetlifyAuth, readLocalNetlifySite, writeLocalNetlifySite, getNetlifySiteById, getNetlifySites, getNetlifyDeploys, matchSitesByRepo, } from "../lib/netlify.js";
+import { ensureNetlifyCli, ensureNetlifyAuth, readLocalNetlifySite, writeLocalNetlifySite, getNetlifySiteById, getNetlifySites, getNetlifyDeploys, getNetlifyDeployById, matchSitesByRepo, } from "../lib/netlify.js";
+import { resolveDeploymentUrl } from "./shared.js";
+// --- Netlify state mapping ---
+function normalizeNetlifyState(state) {
+    switch (state) {
+        case "ready":
+            return "ready";
+        case "error":
+            return "error";
+        case "enqueued":
+            return "queued";
+        default:
+            // building, uploading, preparing, processing, etc.
+            return "building";
+    }
+}
 // --- Auto-detection ---
 /**
  * Auto-detect the Netlify site for the current git repo.
  *
  * 1. `.netlify/state.json` at git root (instant, no API)
  * 2. Fetch all sites, exact match on git remote
- * 3. Multiple matches → pick from matches
- * 4. Zero matches → pick from all sites
+ * 3. Multiple matches -> pick from matches
+ * 4. Zero matches -> pick from all sites
  */
-async function autoDetectSite(cwd, gitInfo, token) {
-    const gitRoot = getGitRoot(cwd);
+async function autoDetectSite(gitRoot, gitInfo, token) {
     // Cache result to .netlify/state.json so subsequent runs skip API calls
-    const cacheResult = (site) => {
-        if (gitRoot) {
-            writeLocalNetlifySite(gitRoot, site.siteId);
-        }
-        return site;
+    const cacheResult = (project) => {
+        writeLocalNetlifySite(gitRoot, project.id);
+        return project;
     };
     // --- Fast path: .netlify/state.json ---
-    if (gitRoot) {
-        const localSite = readLocalNetlifySite(gitRoot);
-        if (localSite) {
-            const detail = await getNetlifySiteById(token, localSite.siteId);
-            if (detail) {
-                return {
-                    siteId: detail.id,
-                    siteName: detail.name,
-                    teamSlug: detail.account_slug,
-                    repoPath: detail.build_settings?.repo_path ?? null,
-                };
-            }
+    const localSite = readLocalNetlifySite(gitRoot);
+    if (localSite) {
+        const detail = await getNetlifySiteById(token, localSite.siteId);
+        if (detail) {
+            return {
+                id: detail.id,
+                name: detail.name,
+                teamId: detail.account_slug,
+            };
         }
     }
     // --- Fetch all sites ---
@@ -61,10 +69,9 @@ async function autoDetectSite(cwd, gitInfo, token) {
         if (matches.length === 1) {
             spinner?.stop(`Detected Netlify site: ${pc.bold(matches[0].name)}`);
             return cacheResult({
-                siteId: matches[0].id,
-                siteName: matches[0].name,
-                teamSlug: matches[0].account_slug,
-                repoPath: matches[0].build_settings?.repo_path ?? null,
+                id: matches[0].id,
+                name: matches[0].name,
+                teamId: matches[0].account_slug,
             });
         }
         if (matches.length > 1) {
@@ -95,251 +102,47 @@ async function pickFromList(sites) {
     }
     const match = selected;
     return {
-        siteId: match.id,
-        siteName: match.name,
-        teamSlug: match.account_slug,
-        repoPath: match.build_settings?.repo_path ?? null,
-    };
-}
-// --- Manual picker (used by `inflight netlify` command) ---
-export async function pickNetlifySite(token) {
-    const allSites = await getNetlifySites(token);
-    if (allSites.length === 0) {
-        if (!isAgent)
-            p.log.error("No Netlify sites found.");
-        return null;
-    }
-    if (isAgent)
-        return null;
-    const selected = await p.select({
-        message: "Select a Netlify site",
-        options: allSites.map((s) => ({
-            value: s,
-            label: s.account_name ? `${s.name} ${pc.dim(`(${s.account_name})`)}` : s.name,
-        })),
-    });
-    if (p.isCancel(selected)) {
-        p.cancel("Cancelled.");
-        return null;
-    }
-    const match = selected;
-    const config = {
-        siteId: match.id,
-        siteName: match.name,
-        teamSlug: match.account_slug,
+        id: match.id,
+        name: match.name,
+        teamId: match.account_slug,
     };
-    writeNetlifyConfig(config);
-    return config;
 }
-// --- Main resolve function ---
-export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
-    const cli = await ensureNetlifyCli((msg) => { if (!isAgent)
-        p.log.step(msg); });
-    if (!cli.ok) {
-        if (!isAgent) {
-            p.log.error("Could not install the Netlify CLI automatically.");
-            if (cli.error) {
-                p.log.message(pc.dim(cli.error.trim()));
-            }
-            p.log.info(`Paste the error above into your AI agent — it can fix this for you.\n\nThen re-run ${pc.cyan("inflight share")}.`);
-        }
-        process.exit(0);
-    }
-    const token = await ensureNetlifyAuth();
-    if (!token) {
-        if (!isAgent)
-            p.log.error("Netlify login failed.");
-        return null;
-    }
-    const site = await autoDetectSite(cwd, gitInfo, token);
-    if (!site)
-        return null;
-    const commitSha = gitInfo.commitShort?.slice(0, 7) ?? null;
-    // Check if the current git repo matches the Netlify site's linked repo
-    const gitRepo = gitInfo.remoteUrl ? parseGitRepo(gitInfo.remoteUrl) : null;
-    const localRepoPath = gitRepo ? `${gitRepo.owner}/${gitRepo.name}`.toLowerCase() : null;
-    const repoMatches = site.repoPath && localRepoPath ? site.repoPath.toLowerCase() === localRepoPath : false;
-    // Only filter by branch if we're in the matching repo — otherwise show all deploys
-    let deploys = await getNetlifyDeploys(token, site.siteId, site.siteName, {
-        branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
-    });
-    let commitDeploy = repoMatches ? deploys.find((d) => d.commitRef === commitSha) : undefined;
-    // If just pushed, poll until the commit deployment appears
-    if (!commitDeploy && repoMatches && opts?.justPushed) {
-        const pollSpinner = !isAgent ? p.spinner({ indicator: "timer" }) : null;
-        pollSpinner?.start("Waiting for deploy");
-        for (let i = 0; i < 30; i++) {
-            await new Promise((r) => setTimeout(r, 2000));
-            deploys = await getNetlifyDeploys(token, site.siteId, site.siteName, {
-                branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
-            });
-            commitDeploy = deploys.find((d) => d.commitRef === commitSha);
-            if (commitDeploy)
-                break;
-        }
-        if (commitDeploy) {
-            pollSpinner?.clear();
-        }
-        else {
-            pollSpinner?.stop("No deployment detected yet — Netlify may still be processing.");
-        }
-    }
-    // If we found a commit-specific deployment, handle based on state
-    if (commitDeploy) {
-        const commitLabel = pc.bold(commitSha);
-        const message = commitDeploy.commitMessage
-            ? pc.dim(` — ${truncate(commitDeploy.commitMessage.split("\n")[0], 50)}`)
-            : "";
-        if (commitDeploy.state === "error") {
-            if (!isAgent)
-                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.)
-            if (!isAgent)
-                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 = !isAgent ? p.spinner({ indicator: "timer" }) : null;
-            spinner?.start("Waiting for build");
-            try {
-                while (Date.now() - startTime < maxWaitMs) {
-                    await new Promise((r) => setTimeout(r, pollIntervalMs));
-                    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") {
-                        spinner?.stop("Netlify deployment ready!");
-                        if (!isAgent)
-                            p.log.info(`Netlify deployment for ${commitLabel}${message}:\n  → ${pc.cyan(fresh.deploySslUrl)}`);
-                        return fresh.deploySslUrl;
-                    }
-                    if (fresh.state === "error") {
-                        spinner?.stop(pc.red("Netlify deployment failed."));
-                        if (!isAgent)
-                            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) {
-                    spinner?.stop("Still building...");
-                    if (isAgent)
-                        return buildingUrl;
-                    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 (e) {
-                spinner?.stop("Error checking deployment status.");
-                if (!isAgent && e instanceof Error)
-                    p.log.message(pc.dim(e.message));
-            }
-        }
-        else {
-            // ready — use it
-            if (!isAgent)
-                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) {
-        if (!isAgent)
-            p.log.warn("No deployments found. Paste a URL instead.");
-        return null;
-    }
-    const hasWorkingDeploy = deploys.some((d) => d.state !== "error");
-    if (!hasWorkingDeploy) {
-        if (!isAgent)
-            p.log.warn("All recent deployments failed. Fix the build and push again, or paste a URL.");
-        return null;
-    }
-    if (isAgent) {
-        const ready = deploys.find((d) => d.state === "ready");
-        return ready?.deploySslUrl ?? deploys[0]?.deploySslUrl ?? 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 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" },
-        ],
-    });
-    if (p.isCancel(selected)) {
-        p.cancel("Cancelled.");
-        process.exit(0);
-    }
-    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") {
-        if (isAgent)
+// --- Adapter ---
+const netlifyAdapter = {
+    name: "Netlify",
+    ensureCli: (log) => ensureNetlifyCli(log),
+    ensureAuth: () => ensureNetlifyAuth(),
+    detectProject: (gitRoot, gitInfo, token) => autoDetectSite(gitRoot, gitInfo, token),
+    getDeployments: async (token, project, opts) => {
+        const raw = await getNetlifyDeploys(token, project.id, project.name, {
+            branch: opts?.branch,
+        });
+        return raw.map((d) => ({
+            id: d.id,
+            url: d.deploySslUrl,
+            state: normalizeNetlifyState(d.state),
+            branch: d.branch,
+            commitSha: d.commitRef,
+            commitMessage: d.commitMessage,
+            createdAt: d.createdAt,
+        }));
+    },
+    getDeploymentById: async (token, project, deployId) => {
+        const raw = await getNetlifyDeployById(token, deployId, project.name);
+        if (!raw)
             return null;
-        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;
-}
-function timeAgo(timestamp) {
-    const seconds = Math.floor((Date.now() - timestamp) / 1000);
-    if (seconds < 60)
-        return "now";
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes}m ago`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours}h ago`;
-    const days = Math.floor(hours / 24);
-    return `${days}d ago`;
+        return {
+            id: raw.id,
+            url: raw.deploySslUrl,
+            state: normalizeNetlifyState(raw.state),
+            branch: raw.branch,
+            commitSha: raw.commitRef,
+            commitMessage: raw.commitMessage,
+            createdAt: raw.createdAt,
+        };
+    },
+};
+// --- Main resolve function ---
+export async function resolveNetlifyUrl(gitRoot, gitInfo, opts) {
+    return resolveDeploymentUrl(netlifyAdapter, gitRoot, gitInfo, opts);
 }

package/dist/providers/shared.d.ts

@@ -0,0 +1,39 @@
+import type { GitInfo } from "../lib/git.js";
+import type { ProviderResolveOptions } from "./index.js";
+export interface Deployment {
+    id: string;
+    url: string;
+    /** Normalized: "ready" | "building" | "error" | "queued" */
+    state: "ready" | "building" | "error" | "queued";
+    branch: string | null;
+    commitSha: string | null;
+    commitMessage: string | null;
+    createdAt: number;
+}
+export interface DetectedProject {
+    id: string;
+    name: string;
+    /** teamId for Vercel, account_slug for Netlify — passed through to API calls */
+    teamId: string;
+}
+export interface ProviderAdapter {
+    /** Display name: "Vercel" | "Netlify" */
+    name: string;
+    /** Ensure CLI is installed, install if missing */
+    ensureCli(log?: (msg: string) => void): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    /** Ensure authenticated, return token or null */
+    ensureAuth(): Promise<string | null>;
+    /** Auto-detect or prompt for project. All provider-specific detection/picker logic lives here. */
+    detectProject(gitRoot: string, gitInfo: GitInfo, token: string): Promise<DetectedProject | null>;
+    /** Fetch deployments. Adapter normalizes states to Deployment format. */
+    getDeployments(token: string, project: DetectedProject, opts?: {
+        branch?: string;
+        sha?: string;
+    }): Promise<Deployment[]>;
+    /** Fetch a single deployment by ID. Used for polling build state. */
+    getDeploymentById(token: string, project: DetectedProject, deploymentId: string): Promise<Deployment | null>;
+}
+export declare function resolveDeploymentUrl(adapter: ProviderAdapter, gitRoot: string, gitInfo: GitInfo, opts?: ProviderResolveOptions): Promise<string | null>;

package/dist/providers/shared.js

@@ -0,0 +1,249 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { isAgent, agentError, agentActionRequired } from "../lib/agent.js";
+// --- Shared resolution logic ---
+export async function resolveDeploymentUrl(adapter, gitRoot, gitInfo, opts) {
+    // 1. Ensure CLI
+    const cli = await adapter.ensureCli((msg) => {
+        if (!isAgent)
+            p.log.step(msg);
+    });
+    if (!cli.ok) {
+        if (isAgent) {
+            agentError({
+                type: "cli_install_failed",
+                message: `Could not install the ${adapter.name} CLI.`,
+                ...(cli.error && { detail: cli.error.trim() }),
+                suggestion: `Install the ${adapter.name} CLI globally, fix any errors, then re-run \`inflight share\`.`,
+            });
+        }
+        p.log.error(`Could not install the ${adapter.name} CLI automatically.`);
+        if (cli.error)
+            p.log.message(pc.dim(cli.error.trim()));
+        p.log.info(`Paste the error above into your AI agent — it can fix this for you.\n\nThen re-run ${pc.cyan("inflight share")}.`);
+        process.exit(0);
+    }
+    // 2. Ensure auth
+    const token = await adapter.ensureAuth();
+    if (!token) {
+        if (isAgent) {
+            agentError({
+                type: "auth_failed",
+                message: `${adapter.name} login failed.`,
+                suggestion: `Run \`${adapter.name.toLowerCase()} login\` to authenticate, then re-run \`inflight share\`.`,
+            });
+        }
+        p.log.error(`${adapter.name} login failed.`);
+        return null;
+    }
+    // 3. Detect project
+    const project = await adapter.detectProject(gitRoot, gitInfo, token);
+    if (!project) {
+        if (isAgent) {
+            agentError({
+                type: "no_project",
+                message: `Could not detect a ${adapter.name} project for this repo.`,
+                suggestion: `Make sure you're in the right directory. Link your repo to a ${adapter.name} project, or re-run with: \`inflight share --url <staging-url>\` to skip provider detection.`,
+            });
+        }
+        return null;
+    }
+    const branch = gitInfo.branch ?? undefined;
+    // 4. Fetch deployments for current branch, filtered by SHA if supported
+    let deployments = await adapter.getDeployments(token, project, { branch, sha: gitInfo.commitFull });
+    // 5. Try SHA match
+    let currentDeployment = deployments.find((d) => d.commitSha === gitInfo.commitFull);
+    // 6. If just pushed, poll for the new deployment to appear
+    if (!currentDeployment && opts?.justPushed) {
+        const pollSpinner = !isAgent ? p.spinner({ indicator: "timer" }) : null;
+        pollSpinner?.start("Waiting for deploy");
+        for (let i = 0; i < 30; i++) {
+            await new Promise((r) => setTimeout(r, 2000));
+            const results = await adapter.getDeployments(token, project, { branch, sha: gitInfo.commitFull });
+            currentDeployment = results.find((d) => d.commitSha === gitInfo.commitFull);
+            if (currentDeployment)
+                break;
+        }
+        if (currentDeployment) {
+            pollSpinner?.clear();
+        }
+        else {
+            pollSpinner?.stop(`No deployment detected yet — ${adapter.name} may still be processing.`);
+        }
+    }
+    // 7. Handle commit-specific deployment states
+    if (currentDeployment) {
+        // Agent mode: return URL immediately — don't wait for build/error
+        if (isAgent)
+            return currentDeployment.url;
+        const commitLabel = pc.bold(gitInfo.commitShort);
+        const message = currentDeployment.commitMessage
+            ? pc.dim(` — ${truncate(currentDeployment.commitMessage.split("\n")[0], 50)}`)
+            : "";
+        switch (currentDeployment.state) {
+            case "ready":
+                p.log.info(`${adapter.name} deployment for ${commitLabel}${message}`);
+                return currentDeployment.url;
+            case "error":
+                p.log.error(`${adapter.name} deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
+                currentDeployment = undefined;
+                // Fall through to picker
+                break;
+            case "building":
+            case "queued": {
+                p.log.info(`${adapter.name} deployment for ${commitLabel}${message} — ${pc.yellow(currentDeployment.state)}`);
+                // Poll for build to finish (~2 min)
+                const buildingUrl = currentDeployment.url;
+                const startTime = Date.now();
+                const maxWaitMs = 120_000;
+                const pollIntervalMs = 3_000;
+                let resolved = false;
+                const spinner = p.spinner({ indicator: "timer" });
+                spinner.start("Waiting for build");
+                try {
+                    while (Date.now() - startTime < maxWaitMs) {
+                        await new Promise((r) => setTimeout(r, pollIntervalMs));
+                        const fresh = await adapter.getDeploymentById(token, project, currentDeployment.id);
+                        if (!fresh)
+                            break;
+                        if (fresh.state === "ready") {
+                            spinner.stop(`${adapter.name} deployment ready!`);
+                            return fresh.url;
+                        }
+                        if (fresh.state === "error") {
+                            spinner.stop(pc.red(`${adapter.name} deployment failed.`));
+                            p.log.error(`${adapter.name} deployment for ${commitLabel}${message} ${pc.red("failed")}.\n  Fix the build and push again, or select a different deployment below.`);
+                            currentDeployment = undefined;
+                            resolved = true;
+                            break;
+                        }
+                    }
+                    if (!resolved) {
+                        spinner.stop("Still building...");
+                        const action = await p.select({
+                            message: `${adapter.name} 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(`${adapter.name} deployment for ${commitLabel}${message}:\n  → ${pc.cyan(buildingUrl)} ${pc.yellow("(building)")}`);
+                            return buildingUrl;
+                        }
+                        currentDeployment = undefined;
+                        // Fall through to picker
+                    }
+                }
+                catch (e) {
+                    spinner.stop("Error checking deployment status.");
+                    if (e instanceof Error)
+                        p.log.message(pc.dim(e.message));
+                }
+                break;
+            }
+        }
+    }
+    // 8. Picker fallback — fetch all branch deployments (no SHA filter)
+    deployments = await adapter.getDeployments(token, project, { branch });
+    if (deployments.length === 0) {
+        if (isAgent) {
+            agentError({
+                type: "no_deployments",
+                message: `No deployments found for this branch. Ask the user for their staging URL.`,
+                suggestion: "Re-run with: `inflight share --url <staging-url>`",
+            });
+        }
+        p.log.warn("No deployments found for this branch. Paste a URL instead.");
+        return null;
+    }
+    const hasWorkingDeployment = deployments.some((d) => d.state !== "error");
+    if (!hasWorkingDeployment) {
+        if (isAgent) {
+            agentError({
+                type: "all_deployments_failed",
+                message: "All recent deployments failed. Ask the user to fix the build and push again, or provide a URL.",
+                suggestion: "Re-run with: `inflight share --url <staging-url>`",
+            });
+        }
+        p.log.warn("All recent deployments failed. Fix the build and push again, or paste a URL.");
+        return null;
+    }
+    if (isAgent) {
+        agentActionRequired({
+            type: "choose_deployment",
+            message: "No deployment found for the current commit. Ask the user which deployment to use.",
+            choices: [
+                ...deployments.map((d) => ({
+                    id: d.url,
+                    label: d.commitMessage ? truncate(d.commitMessage.split("\n")[0], 55) : "No commit message",
+                    hint: [
+                        timeAgo(d.createdAt),
+                        d.branch ?? "unknown",
+                        d.state === "error" ? "(failed)" : d.state !== "ready" ? `(${d.state})` : undefined,
+                    ].filter(Boolean).join(" · "),
+                })),
+                { id: "manual", label: "Paste a URL" },
+            ],
+            nextCommand: `inflight share --skip-git-check --url <URL>`,
+        });
+    }
+    const maxBranch = 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 isFailed = d.state === "error";
+                const branchLabel = (d.branch ?? "unknown").padEnd(maxBranch);
+                const ago = timeAgo(d.createdAt).padEnd(8);
+                const firstLine = (d.commitMessage ?? "No commit message").split("\n")[0];
+                const msg = truncate(firstLine, 55);
+                if (isFailed) {
+                    return {
+                        value: d.url,
+                        label: pc.dim(`${branchLabel}  ${ago}  ${pc.red("(failed)")}  ${msg}`),
+                    };
+                }
+                const state = d.state !== "ready" ? `  ${pc.yellow(`(${d.state})`)}` : "";
+                return { value: d.url, label: `${branchLabel}  ${ago}${state}  ${pc.dim(msg)}` };
+            }),
+            { value: "manual", label: "Paste a URL manually" },
+        ],
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    if (selected === "manual")
+        return null;
+    // Warn if the user picked a failed deployment
+    const pickedDeploy = deployments.find((d) => d.url === selected);
+    if (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;
+}
+// --- Helpers ---
+function truncate(str, max) {
+    return str.length > max ? str.slice(0, max - 1) + "…" : str;
+}
+function timeAgo(timestamp) {
+    const seconds = Math.floor((Date.now() - timestamp) / 1000);
+    if (seconds < 60)
+        return "now";
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}

package/dist/providers/vercel.d.ts

@@ -1,3 +1,3 @@
 import type { GitInfo } from "../lib/git.js";
 import type { ProviderResolveOptions } from "./index.js";
-export declare function resolveVercelUrl(cwd: string, gitInfo: GitInfo, opts?: ProviderResolveOptions): Promise<string | null>;
+export declare function resolveVercelUrl(gitRoot: string, gitInfo: GitInfo, opts?: ProviderResolveOptions): Promise<string | null>;