inflight-cli 2.1.5 → 2.1.7

package/dist/commands/share.js

@@ -1,10 +1,27 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
-import { getGitInfo, getGitSyncState, generateCommitMessage, commitAndPush, pushBranch } from "../lib/git.js";
+import { getGitInfo, getGitSyncState, generateCommitMessage, commitAndPush, pushBranch, hasCommitsAhead, } from "../lib/git.js";
 import open from "open";
 import { providers } from "../providers/index.js";
-import { apiGetMe, apiCreateVersion } from "../lib/api.js";
+import { apiGetMe, apiCreateVersion, apiGetRecentProjects } from "../lib/api.js";
+function formatRelativeTime(timestampMs) {
+    const seconds = Math.floor((Date.now() - timestampMs) / 1000);
+    if (seconds < 60)
+        return "just 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);
+    if (days === 1)
+        return "yesterday";
+    if (days < 7)
+        return `${days}d ago`;
+    return new Date(timestampMs).toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
 /**
  * Checks local git state and prompts the user to commit/push if needed.
  * Returns { justPushed: true } if changes were pushed, { justPushed: false } otherwise.
@@ -126,7 +143,13 @@ async function checkAndSyncGit(cwd) {
         }
     }
     if (state.status === "no_remote") {
-        // Working tree is clean (uncommitted was checked first in getGitSyncState), just need to push
+        // Working tree is clean (uncommitted was checked first in getGitSyncState).
+        // Check if this branch actually has commits ahead of the default branch —
+        // if not, pushing won't trigger a deployment.
+        if (!hasCommitsAhead(cwd)) {
+            p.log.info(`Branch ${pc.bold(branch)} has no new commits — using existing deployments.`);
+            return { justPushed: false };
+        }
         p.log.warn(`Branch ${pc.bold(branch)} hasn't been pushed yet — no deployment exists.`);
         const confirm = await p.confirm({
             message: "Push to create a deployment?",
@@ -154,14 +177,15 @@ async function checkAndSyncGit(cwd) {
 }
 export async function shareCommand(opts = {}) {
     const cwd = process.cwd();
+    // TODO: Add a step to login if not authenticated
     // ── Step 1: Auth ──
     const auth = readGlobalAuth();
     if (!auth) {
         if (opts.json) {
-            console.log(JSON.stringify({ error: "not_authenticated", message: "Not logged in. Run inflight login first." }));
+            console.log(JSON.stringify({ error: "not_authenticated", message: "Not logged in. Run inflight setup first." }));
         }
         else {
-            p.log.error("Not logged in. Run " + pc.cyan("inflight login") + " first.");
+            p.log.error("Not logged in. Run " + pc.cyan("inflight setup") + " first.");
         }
         process.exit(1);
     }
@@ -296,16 +320,75 @@ export async function shareCommand(opts = {}) {
     if (!stagingUrl.startsWith("http")) {
         stagingUrl = `https://${stagingUrl}`;
     }
+    // ── Step 4: Project selection ──
+    let selectedProjectId;
+    let overrideVersionId;
+    const { projects: recentProjects } = await apiGetRecentProjects(auth.apiKey, workspaceId).catch(() => ({
+        projects: [],
+    }));
+    if (recentProjects.length > 0) {
+        const projectChoice = await p.select({
+            message: "Add to an existing version or start fresh?",
+            options: [
+                ...recentProjects.map((proj) => ({
+                    value: proj.projectId,
+                    label: `"${proj.latestVersion.title}"`,
+                    hint: `created ${formatRelativeTime(proj.latestVersion.createdAt)}`,
+                })),
+                { value: "new", label: "Start fresh" },
+            ],
+        });
+        if (p.isCancel(projectChoice)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        if (projectChoice !== "new") {
+            selectedProjectId = projectChoice;
+            // Check for override opportunity — only when latest version has no feedback
+            const selectedProject = recentProjects.find((proj) => proj.projectId === selectedProjectId);
+            if (selectedProject && selectedProject.latestVersion.commentCount === 0) {
+                const overrideChoice = await p.select({
+                    message: `"${selectedProject.latestVersion.title}" has no feedback yet.`,
+                    options: [
+                        {
+                            value: "override",
+                            label: "Update its staging URL",
+                            hint: `replace with ${new URL(stagingUrl).hostname}`,
+                        },
+                        {
+                            value: "new_version",
+                            label: "Add a new version",
+                            hint: "keep both in version history",
+                        },
+                    ],
+                });
+                if (p.isCancel(overrideChoice)) {
+                    p.cancel("Cancelled.");
+                    process.exit(0);
+                }
+                if (overrideChoice === "override") {
+                    overrideVersionId = selectedProject.latestVersion.id;
+                }
+            }
+        }
+    }
     await apiCreateVersion({
         apiKey: auth.apiKey,
         workspaceId,
         stagingUrl,
         gitInfo,
+        ...(selectedProjectId && { projectId: selectedProjectId }),
+        ...(overrideVersionId && { overrideVersionId }),
     }).catch((e) => {
         p.log.error(e.message);
         process.exit(1);
     });
     p.log.info(`Staging URL: ${pc.cyan(stagingUrl)}`);
-    p.outro(pc.green("✓ Inflight added to your staging URL") + " — opening in browser...");
+    if (overrideVersionId) {
+        p.outro(pc.green("✓ Staging URL updated") + " — opening in browser...");
+    }
+    else {
+        p.outro(pc.green("✓ Inflight added to your staging URL") + " — opening in browser...");
+    }
     await open(stagingUrl);
 }

package/dist/lib/api.d.ts

@@ -9,16 +9,31 @@ export interface CreateVersionResult {
     versionId: string;
     inflightUrl: string;
 }
+export interface RecentProject {
+    projectId: string;
+    latestVersion: {
+        id: string;
+        title: string;
+        stagingUrl: string | null;
+        commentCount: number;
+        createdAt: number;
+    };
+}
 export declare function apiGetMe(apiKey: string): Promise<{
     name: string | null;
     email: string | null;
     workspaces: Workspace[];
 }>;
+export declare function apiGetRecentProjects(apiKey: string, workspaceId: string): Promise<{
+    projects: RecentProject[];
+}>;
 export declare function apiCreateVersion(opts: {
     apiKey: string;
     workspaceId: string;
     stagingUrl: string;
     gitInfo: GitInfo;
+    projectId?: string;
+    overrideVersionId?: string;
 }): Promise<CreateVersionResult>;
 export interface WidgetLocationResult {
     file: string | null;

package/dist/lib/api.js

@@ -7,6 +7,16 @@ 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)}`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: res.statusText }));
+        throw new Error(body.error ?? `API error ${res.status}`);
+    }
+    return res.json();
+}
 export async function apiCreateVersion(opts) {
     const res = await fetch(`${API_URL}/api/cli/version/create`, {
         method: "POST",
@@ -18,6 +28,8 @@ export async function apiCreateVersion(opts) {
             workspaceId: opts.workspaceId,
             stagingUrl: opts.stagingUrl,
             gitInfo: opts.gitInfo,
+            ...(opts.projectId && { projectId: opts.projectId }),
+            ...(opts.overrideVersionId && { overrideVersionId: opts.overrideVersionId }),
         }),
     });
     if (!res.ok) {

package/dist/lib/git.d.ts

@@ -74,4 +74,9 @@ export declare function commitAndPush(cwd: string, message: string, branch: stri
 /**
  * Pushes existing commits. Uses `-u` if no upstream exists.
  */
+/**
+ * Returns true if the current branch has commits ahead of the default branch (main/master).
+ * Used to avoid pushing branches with no new commits (which won't trigger a deployment).
+ */
+export declare function hasCommitsAhead(cwd: string): boolean;
 export declare function pushBranch(cwd: string, branch: string): void;

package/dist/lib/git.js

@@ -315,6 +315,15 @@ export function commitAndPush(cwd, message, branch) {
 /**
  * Pushes existing commits. Uses `-u` if no upstream exists.
  */
+/**
+ * Returns true if the current branch has commits ahead of the default branch (main/master).
+ * Used to avoid pushing branches with no new commits (which won't trigger a deployment).
+ */
+export function hasCommitsAhead(cwd) {
+    const defaultBranch = getDefaultBranch(cwd);
+    const count = run(`git rev-list ${defaultBranch}..HEAD --count`, cwd);
+    return count !== null && count !== "0";
+}
 export function pushBranch(cwd, branch) {
     const upstream = run(`git rev-parse --abbrev-ref ${branch}@{upstream}`, cwd);
     if (upstream) {

package/dist/providers/vercel.js

@@ -3,7 +3,7 @@ import pc from "picocolors";
 import { execSync } from "child_process";
 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";
+import { ensureVercelCli, ensureVercelAuth, readLocalVercelProject, writeLocalVercelProject, getVercelProjectDetail, fetchAllProjectsWithLinks, matchProjectsByRepo, createVercelProject, getRecentDeployments, } from "../lib/vercel.js";
 // --- Auto-detection ---
 /**
  * Auto-detect the Vercel project for the current git repo.
@@ -29,7 +29,7 @@ async function autoDetectProject(cwd, gitInfo, token) {
         if (localProject) {
             const detail = await getVercelProjectDetail(token, localProject.projectId, localProject.orgId);
             if (detail) {
-                p.log.info(`Detected Vercel project: ${pc.bold(detail.name)}`);
+                // p.log.info(`Detected Vercel project: ${pc.bold(detail.name)}`);
                 return { teamId: localProject.orgId, projectId: detail.id, projectName: detail.name };
             }
         }
@@ -196,61 +196,57 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
     const project = await autoDetectProject(cwd, gitInfo, token);
     if (!project)
         return null;
-    // Fetch branch alias — if just pushed, poll until it appears
-    let branchAlias = await getBranchAlias(token, project.teamId, project.projectId, gitInfo.branch);
-    if (!branchAlias && opts?.justPushed) {
+    const commitSha = gitInfo.commitShort?.slice(0, 7) ?? null;
+    // Try to find a deployment matching the current commit
+    let deployments = await getRecentDeployments(token, project.teamId, project.projectId, {
+        branch: gitInfo.branch ?? undefined,
+    });
+    let commitDeploy = deployments.find((d) => d.commitSha === commitSha);
+    // If just pushed, poll until the commit deployment appears
+    if (!commitDeploy && opts?.justPushed) {
         const pollSpinner = p.spinner();
         pollSpinner.start("Waiting for Vercel deployment...");
         for (let i = 0; i < 30; i++) {
             await new Promise((r) => setTimeout(r, 2000));
-            branchAlias = await getBranchAlias(token, project.teamId, project.projectId, gitInfo.branch);
-            if (branchAlias)
+            deployments = await getRecentDeployments(token, project.teamId, project.projectId, {
+                branch: gitInfo.branch ?? undefined,
+            });
+            commitDeploy = deployments.find((d) => d.commitSha === commitSha);
+            if (commitDeploy)
                 break;
         }
-        if (branchAlias) {
+        if (commitDeploy) {
             pollSpinner.stop("Deployment found!");
         }
         else {
             pollSpinner.stop("Deployment is still building...");
         }
     }
-    if (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 specific deployment?",
-            options: [
-                { value: "branch", label: "Use branch preview (recommended)" },
-                { value: "recent", label: "Pick a specific deployment" },
-                { value: "manual", label: "Paste a URL manually" },
-            ],
-        });
-        if (p.isCancel(choice)) {
-            p.cancel("Cancelled.");
-            process.exit(0);
-        }
-        if (choice === "branch")
-            return branchAlias.url;
-        if (choice === "manual")
-            return null;
+    // If we found a commit-specific deployment, use it automatically
+    if (commitDeploy) {
+        const stateLabel = commitDeploy.state !== "READY" ? ` ${pc.yellow(`(${commitDeploy.state.toLowerCase()})`)}` : "";
+        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;
     }
-    // Show recent deployments
-    const recent = await getRecentDeployments(token, project.teamId, project.projectId);
-    if (recent.length === 0) {
+    // 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(...recent.map((d) => (d.branch ?? "unknown").length));
+    const maxBranch = Math.max(...deployments.map((d) => (d.branch ?? "unknown").length));
     const selected = await p.select({
-        message: "Select a specific deployment",
+        message: "No deployment found for current commit. Select one:",
         options: [
-            ...recent.map((d) => {
+            ...deployments.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}${state}  ${pc.dim(message)}` };
+                const msg = truncate(firstLine, 55);
+                return { value: d.url, label: `${branch}  ${ago}${state}  ${pc.dim(msg)}` };
             }),
             { value: "manual", label: "Paste a URL manually" },
         ],

package/package.json

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