inflight-cli 2.12.0 → 2.14.0

package/dist/providers/vercel.js

@@ -1,9 +1,27 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { execSync } from "child_process";
-import { parseGitRepo, getGitRoot } from "../lib/git.js";
+import { parseGitRepo } from "../lib/git.js";
 import { isAgent } from "../lib/agent.js";
-import { ensureVercelCli, ensureVercelAuth, readLocalVercelProject, writeLocalVercelProject, getVercelProjectById, getVercelProjects, matchVercelProjectsByRepo, createVercelProject, getVercelDeployments, } from "../lib/vercel.js";
+import { ensureVercelCli, ensureVercelAuth, readLocalVercelProject, writeLocalVercelProject, getVercelProjectById, getVercelProjects, matchVercelProjectsByRepo, createVercelProject, getVercelDeployments, getVercelDeploymentById, } from "../lib/vercel.js";
+import { resolveDeploymentUrl } from "./shared.js";
+// --- Vercel state normalization ---
+function normalizeVercelState(state) {
+    switch (state) {
+        case "READY":
+            return "ready";
+        case "ERROR":
+        case "CANCELED":
+            return "error";
+        case "BUILDING":
+        case "INITIALIZING":
+            return "building";
+        case "QUEUED":
+            return "queued";
+        default:
+            return "building";
+    }
+}
 // --- Auto-detection ---
 /**
  * Auto-detect the Vercel project for the current git repo.
@@ -11,33 +29,25 @@ import { ensureVercelCli, ensureVercelAuth, readLocalVercelProject, writeLocalVe
  *
  * 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
+ * 3. Multiple matches -> pick from matches
+ * 4. Zero matches -> pick from all projects
  */
-async function autoDetectProject(cwd, gitInfo, token) {
-    const gitRoot = getGitRoot(cwd);
+async function autoDetectProject(gitRoot, gitInfo, token) {
     // Cache result to .vercel/project.json so subsequent runs skip API calls
     const cacheResult = (project) => {
-        if (gitRoot) {
-            writeLocalVercelProject(gitRoot, project.teamId, project.projectId);
-        }
+        writeLocalVercelProject(gitRoot, project.teamId, project.id);
         return project;
     };
     // --- Fast path: .vercel/project.json ---
-    if (gitRoot) {
-        const localProject = readLocalVercelProject(gitRoot);
-        if (localProject) {
-            const detail = await getVercelProjectById(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,
-                    repoOwner: detail.link?.org ?? null,
-                    repoName: detail.link?.repo ?? null,
-                };
-            }
+    const localProject = readLocalVercelProject(gitRoot);
+    if (localProject) {
+        const detail = await getVercelProjectById(token, localProject.projectId, localProject.orgId);
+        if (detail) {
+            return {
+                teamId: localProject.orgId,
+                id: detail.id,
+                name: detail.name,
+            };
         }
     }
     // --- Fetch all projects ---
@@ -66,10 +76,8 @@ async function autoDetectProject(cwd, gitInfo, token) {
             spinner?.stop(`Detected Vercel project: ${pc.bold(matches[0].name)}`);
             return cacheResult({
                 teamId: matches[0].teamId,
-                projectId: matches[0].id,
-                projectName: matches[0].name,
-                repoOwner: matches[0].link?.org ?? null,
-                repoName: matches[0].link?.repo ?? null,
+                id: matches[0].id,
+                name: matches[0].name,
             });
         }
         if (matches.length > 1) {
@@ -110,12 +118,11 @@ async function pickFromList(projects, createCtx) {
     const match = selected;
     return {
         teamId: match.teamId,
-        projectId: match.id,
-        projectName: match.name,
-        repoOwner: match.link?.org ?? null,
-        repoName: match.link?.repo ?? null,
+        id: match.id,
+        name: match.name,
     };
 }
+// --- Create project flow ---
 async function createProjectFlow(projects, ctx) {
     if (isAgent)
         return null;
@@ -151,10 +158,8 @@ async function createProjectFlow(projects, ctx) {
             p.log.info("Push to git to trigger your first deployment.");
             return {
                 teamId,
-                projectId: created.id,
-                projectName: created.name,
-                repoOwner: gitRepo.owner,
-                repoName: gitRepo.name,
+                id: created.id,
+                name: created.name,
             };
         }
         // Poll until a deployment appears
@@ -167,20 +172,16 @@ async function createProjectFlow(projects, ctx) {
                 pollSpinner.stop("Vercel deployment started.");
                 return {
                     teamId,
-                    projectId: created.id,
-                    projectName: created.name,
-                    repoOwner: gitRepo.owner,
-                    repoName: gitRepo.name,
+                    id: created.id,
+                    name: created.name,
                 };
             }
         }
         pollSpinner.stop("Vercel deployment may take a moment to appear.");
         return {
             teamId,
-            projectId: created.id,
-            projectName: created.name,
-            repoOwner: gitRepo.owner,
-            repoName: gitRepo.name,
+            id: created.id,
+            name: created.name,
         };
     }
     catch (e) {
@@ -188,221 +189,49 @@ async function createProjectFlow(projects, ctx) {
         return null;
     }
 }
-// --- Main resolve function ---
-export async function resolveVercelUrl(cwd, gitInfo, opts) {
-    const cli = await ensureVercelCli((msg) => { if (!isAgent)
-        p.log.step(msg); });
-    if (!cli.ok) {
-        if (!isAgent)
-            p.log.error("Could not install the Vercel CLI automatically.");
-        if (cli.error) {
-            if (!isAgent)
-                p.log.message(pc.dim(cli.error.trim()));
-        }
-        if (!isAgent)
-            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 ensureVercelAuth();
-    if (!token) {
-        if (!isAgent)
-            p.log.error("Vercel login failed.");
-        return null;
-    }
-    const project = await autoDetectProject(cwd, gitInfo, token);
-    if (!project)
-        return null;
-    const commitSha = gitInfo.commitShort?.slice(0, 7) ?? null;
-    // Check if the current git repo matches the Vercel project's linked repo
-    const gitRepo = gitInfo.remoteUrl ? parseGitRepo(gitInfo.remoteUrl) : null;
-    const repoMatches = project.repoOwner && project.repoName && gitRepo
-        ? project.repoOwner.toLowerCase() === gitRepo.owner.toLowerCase() &&
-            project.repoName.toLowerCase() === gitRepo.name.toLowerCase()
-        : false;
-    // Only filter by branch if we're in the matching repo — otherwise show all deployments
-    let deployments = await getVercelDeployments(token, project.teamId, project.projectId, {
-        branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
-    });
-    let commitDeploy = repoMatches ? deployments.find((d) => d.commitSha === 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));
-            deployments = await getVercelDeployments(token, project.teamId, project.projectId, {
-                branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
-            });
-            commitDeploy = deployments.find((d) => d.commitSha === commitSha);
-            if (commitDeploy)
-                break;
-        }
-        if (commitDeploy) {
-            pollSpinner?.clear();
-        }
-        else {
-            pollSpinner?.stop("No deployment detected yet — Vercel 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" || commitDeploy.state === "CANCELED") {
-            if (!isAgent)
-                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
-            if (!isAgent)
-                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 = 3_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 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") {
-                        spinner?.stop("Vercel deployment ready!");
-                        return fresh.url;
-                    }
-                    if (fresh.state === "ERROR" || fresh.state === "CANCELED") {
-                        spinner?.stop(pc.red("Vercel deployment failed."));
-                        if (!isAgent)
-                            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) {
-                    if (isAgent)
-                        return buildingUrl;
-                    spinner?.stop("Still building...");
-                    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") {
-                        if (!isAgent)
-                            p.log.info(`Vercel 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 (e instanceof Error)
-                    if (!isAgent)
-                        p.log.message(pc.dim(e.message));
-            }
-        }
-        else {
-            // READY or any other terminal state — use it
-            if (!isAgent)
-                p.log.info(`Vercel deployment for ${commitLabel}${message}`);
-            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) {
-        if (!isAgent)
-            p.log.warn("No deployments found. Paste a URL instead.");
-        return null;
-    }
-    const hasWorkingDeployment = deployments.some((d) => d.state !== "ERROR" && d.state !== "CANCELED");
-    if (!hasWorkingDeployment) {
-        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 = deployments.find((d) => d.state === "READY");
-        return ready?.url ?? deployments[0]?.url ?? 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 isFailed = d.state === "ERROR" || d.state === "CANCELED";
-                const branch = (d.branch ?? "unknown").padEnd(maxBranchPick);
-                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(`${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" },
-        ],
-    });
-    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 && (pickedDeploy.state === "ERROR" || pickedDeploy.state === "CANCELED")) {
-        if (isAgent)
-            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)
+// --- Adapter ---
+const vercelAdapter = {
+    name: "Vercel",
+    async ensureCli(log) {
+        return ensureVercelCli(log);
+    },
+    async ensureAuth() {
+        return ensureVercelAuth();
+    },
+    async detectProject(gitRoot, gitInfo, token) {
+        return autoDetectProject(gitRoot, gitInfo, token);
+    },
+    async getDeployments(token, project, opts) {
+        const raw = await getVercelDeployments(token, project.teamId, project.id, {
+            branch: opts?.branch,
+            sha: opts?.sha,
+        });
+        return raw.map((d) => ({
+            id: d.id,
+            url: d.url,
+            state: normalizeVercelState(d.state),
+            branch: d.branch,
+            commitSha: d.commitSha,
+            commitMessage: d.commitMessage,
+            createdAt: d.createdAt,
+        }));
+    },
+    async getDeploymentById(token, project, deploymentId) {
+        const raw = await getVercelDeploymentById(token, deploymentId, project.teamId);
+        if (!raw)
             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.url,
+            state: normalizeVercelState(raw.state),
+            branch: raw.branch,
+            commitSha: raw.commitSha,
+            commitMessage: raw.commitMessage,
+            createdAt: raw.createdAt,
+        };
+    },
+};
+// --- Public API ---
+export async function resolveVercelUrl(gitRoot, gitInfo, opts) {
+    return resolveDeploymentUrl(vercelAdapter, gitRoot, gitInfo, opts);
 }

package/package.json

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