inflight-cli 2.1.4 → 2.1.6

package/dist/commands/share.js

@@ -1,24 +1,178 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
-import { getGitInfo } 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";
+/**
+ * Checks local git state and prompts the user to commit/push if needed.
+ * Returns { justPushed: true } if changes were pushed, { justPushed: false } otherwise.
+ * Provider-agnostic — works for Vercel, Netlify, or any future provider.
+ */
+async function checkAndSyncGit(cwd) {
+    const state = getGitSyncState(cwd);
+    if (state.status === "clean" || state.status === "detached") {
+        return { justPushed: false };
+    }
+    // After ruling out clean/detached, branch is guaranteed non-null
+    if (!state.branch)
+        return { justPushed: false };
+    const { branch } = state;
+    if (state.status === "uncommitted") {
+        // Show changed files
+        const maxFiles = 8;
+        const display = state.changedFiles.slice(0, maxFiles);
+        const lines = display.map((line) => {
+            const trimmed = line.trim();
+            // Parse git porcelain status: "M file.ts", "?? file.ts", "A file.ts", etc.
+            const match = trimmed.match(/^(\S+)\s+(.+)$/);
+            if (!match)
+                return `  ${pc.dim(trimmed)}`;
+            const status = match[1];
+            const file = match[2];
+            const label = status === "??"
+                ? "new"
+                : status === "M"
+                    ? "modified"
+                    : status === "A"
+                        ? "added"
+                        : status === "D"
+                            ? "deleted"
+                            : status === "R"
+                                ? "renamed"
+                                : "changed";
+            return `  ${pc.dim(file)} ${pc.dim(`(${label})`)}`;
+        });
+        if (state.changedFiles.length > maxFiles) {
+            lines.push(`  ${pc.dim(`... and ${state.changedFiles.length - maxFiles} more`)}`);
+        }
+        lines.push("", pc.yellow("Your deployment won't include these changes."));
+        p.log.warn("You have uncommitted changes:\n" + lines.join("\n"));
+        const action = await p.select({
+            message: "What would you like to do?",
+            options: [
+                { value: "commit_push", label: "Commit & push (recommended)" },
+                { value: "continue", label: "Continue anyway — use existing deployment" },
+            ],
+        });
+        if (p.isCancel(action)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        if (action === "continue") {
+            return { justPushed: false };
+        }
+        // Commit & push flow
+        const defaultMessage = generateCommitMessage(state.branch);
+        const message = await p.text({
+            message: "Commit message",
+            initialValue: defaultMessage,
+            validate: (v) => {
+                if (!v.trim())
+                    return "Commit message is required";
+            },
+        });
+        if (p.isCancel(message)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        const spinner = p.spinner();
+        spinner.start("Committing and pushing...");
+        try {
+            commitAndPush(cwd, message.trim(), branch);
+            spinner.stop("Changes pushed!");
+            return { justPushed: true };
+        }
+        catch (e) {
+            spinner.stop(`Push failed: ${e.message}`);
+            p.log.warn("Continuing with existing deployment.");
+            return { justPushed: false };
+        }
+    }
+    if (state.status === "unpushed") {
+        // Show unpushed commits
+        const commitLines = state.unpushedCommits.slice(0, 5).map((line) => `  ${pc.dim(line)}`);
+        if (state.unpushedCommits.length > 5) {
+            commitLines.push(`  ${pc.dim(`... and ${state.unpushedCommits.length - 5} more`)}`);
+        }
+        commitLines.push("", pc.yellow("Your deployment won't include these commits."));
+        p.log.warn("You have unpushed commits:\n" + commitLines.join("\n"));
+        const action = await p.select({
+            message: "What would you like to do?",
+            options: [
+                { value: "push", label: "Push (recommended)" },
+                { value: "continue", label: "Continue anyway — use existing deployment" },
+            ],
+        });
+        if (p.isCancel(action)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        if (action === "continue") {
+            return { justPushed: false };
+        }
+        const spinner = p.spinner();
+        spinner.start("Pushing...");
+        try {
+            pushBranch(cwd, branch);
+            spinner.stop("Changes pushed!");
+            return { justPushed: true };
+        }
+        catch (e) {
+            spinner.stop(`Push failed: ${e.message}`);
+            p.log.warn("Continuing with existing deployment.");
+            return { justPushed: false };
+        }
+    }
+    if (state.status === "no_remote") {
+        // 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?",
+        });
+        if (p.isCancel(confirm)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        if (!confirm) {
+            return { justPushed: false };
+        }
+        const spinner = p.spinner();
+        spinner.start("Pushing...");
+        try {
+            pushBranch(cwd, branch);
+            spinner.stop("Branch pushed!");
+            return { justPushed: true };
+        }
+        catch (e) {
+            spinner.stop(`Push failed: ${e.message}`);
+            return { justPushed: false };
+        }
+    }
+    return { justPushed: false };
+}
 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);
     }
-    const gitInfo = getGitInfo(cwd);
+    let gitInfo = getGitInfo(cwd);
     // ── Step 2: Resolve workspace ──
     const me = await apiGetMe(auth.apiKey).catch((e) => {
         if (opts.json) {
@@ -118,7 +272,12 @@ export async function shareCommand(opts = {}) {
     let stagingUrl;
     const provider = providers.find((prov) => prov.id === providerChoice);
     if (provider) {
-        stagingUrl = (await provider.resolve(cwd, gitInfo)) ?? undefined;
+        const { justPushed } = await checkAndSyncGit(cwd);
+        // Re-fetch git info after potential commit/push so provider AND apiCreateVersion see latest state
+        if (justPushed) {
+            gitInfo = getGitInfo(cwd);
+        }
+        stagingUrl = (await provider.resolve(cwd, gitInfo, { justPushed })) ?? undefined;
     }
     if (!stagingUrl) {
         const input = await p.text({

package/dist/lib/git.d.ts

@@ -42,3 +42,41 @@ export declare function getGitInfo(cwd: string): GitInfo;
 export declare function isGitRepo(cwd: string): boolean;
 /** Returns the root directory of the git repo, or null if not in one. */
 export declare function getGitRoot(cwd: string): string | null;
+export interface GitSyncState {
+    /** "clean" = nothing to do, "uncommitted" = dirty working tree, "unpushed" = clean but commits not pushed, "no_remote" = branch has never been pushed */
+    status: "clean" | "uncommitted" | "unpushed" | "no_remote" | "detached";
+    /** Short file status lines from `git status --porcelain` (only when uncommitted) */
+    changedFiles: string[];
+    /** Unpushed commit summary lines: "abc1234 commit message" (only when unpushed) */
+    unpushedCommits: string[];
+    /** Current branch name (null if detached) */
+    branch: string | null;
+}
+/**
+ * Determines whether the local repo has changes that haven't been deployed.
+ * Priority: detached > uncommitted > unpushed > no_remote > clean
+ */
+export declare function getGitSyncState(cwd: string): GitSyncState;
+/**
+ * Auto-generates a short commit message from the branch name.
+ * "feature/new-login-page" → "Update new login page"
+ * "fix-header-alignment"   → "Update header alignment"
+ * "main"                   → "Update main"
+ */
+export declare function generateCommitMessage(branch: string | null): string;
+/**
+ * Stages all changes, commits with the given message, and pushes.
+ * Uses `git add -A` (tracked + untracked — .gitignore handles exclusions).
+ * Pushes with `-u` if the branch has no upstream.
+ * Throws on failure.
+ */
+export declare function commitAndPush(cwd: string, message: string, branch: string): void;
+/**
+ * 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

@@ -251,3 +251,85 @@ export function isGitRepo(cwd) {
 export function getGitRoot(cwd) {
     return run("git rev-parse --show-toplevel", cwd);
 }
+/**
+ * Determines whether the local repo has changes that haven't been deployed.
+ * Priority: detached > uncommitted > unpushed > no_remote > clean
+ */
+export function getGitSyncState(cwd) {
+    const branch = run("git rev-parse --abbrev-ref HEAD", cwd);
+    // Detached HEAD — can't push meaningfully
+    if (!branch || branch === "HEAD") {
+        return { status: "detached", changedFiles: [], unpushedCommits: [], branch: null };
+    }
+    // No origin remote — can't push anywhere
+    if (!run("git remote get-url origin", cwd)) {
+        return { status: "clean", changedFiles: [], unpushedCommits: [], branch };
+    }
+    // Check for uncommitted changes (staged + unstaged + untracked)
+    const porcelain = run("git status --porcelain", cwd) ?? "";
+    const changedFiles = porcelain.split("\n").filter((l) => l.trim().length > 0);
+    if (changedFiles.length > 0) {
+        return { status: "uncommitted", changedFiles, unpushedCommits: [], branch };
+    }
+    // Check if branch has a remote tracking branch
+    const upstream = run(`git rev-parse --abbrev-ref ${branch}@{upstream}`, cwd);
+    if (!upstream) {
+        return { status: "no_remote", changedFiles: [], unpushedCommits: [], branch };
+    }
+    // Check for unpushed commits
+    const log = run(`git log ${upstream}..HEAD --oneline`, cwd) ?? "";
+    if (log.length > 0) {
+        const unpushedCommits = log.split("\n").filter((l) => l.trim().length > 0);
+        return { status: "unpushed", changedFiles: [], unpushedCommits, branch };
+    }
+    return { status: "clean", changedFiles: [], unpushedCommits: [], branch };
+}
+/**
+ * Auto-generates a short commit message from the branch name.
+ * "feature/new-login-page" → "Update new login page"
+ * "fix-header-alignment"   → "Update header alignment"
+ * "main"                   → "Update main"
+ */
+export function generateCommitMessage(branch) {
+    if (!branch)
+        return "Update changes";
+    // Strip common prefixes: feature/, fix/, feat/, chore/, etc.
+    const stripped = branch.replace(/^(feature|fix|feat|chore|bugfix|hotfix|release)\/?/i, "");
+    const humanized = (stripped || branch).replace(/[-_/]/g, " ").replace(/\s+/g, " ").trim();
+    return humanized ? `Update ${humanized}` : "Update changes";
+}
+/**
+ * Stages all changes, commits with the given message, and pushes.
+ * Uses `git add -A` (tracked + untracked — .gitignore handles exclusions).
+ * Pushes with `-u` if the branch has no upstream.
+ * Throws on failure.
+ */
+export function commitAndPush(cwd, message, branch) {
+    // Stage all changes (tracked + untracked — .gitignore handles exclusions)
+    execFileSync("git", ["add", "-A"], { cwd, stdio: "pipe" });
+    // Commit — use execFileSync to avoid shell injection via commit message
+    execFileSync("git", ["commit", "-m", message], { cwd, stdio: "pipe" });
+    // Push
+    pushBranch(cwd, 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) {
+        execFileSync("git", ["push"], { cwd, stdio: "pipe" });
+    }
+    else {
+        execFileSync("git", ["push", "-u", "origin", branch], { cwd, stdio: "pipe" });
+    }
+}

package/dist/providers/index.d.ts

@@ -1,7 +1,11 @@
 import type { GitInfo } from "../lib/git.js";
+export interface ProviderResolveOptions {
+    /** True if the user just committed/pushed during this session — provider should poll for new deployment */
+    justPushed?: boolean;
+}
 export interface Provider {
     id: string;
     label: string;
-    resolve: (cwd: string, gitInfo: GitInfo) => Promise<string | null>;
+    resolve: (cwd: string, gitInfo: GitInfo, opts?: ProviderResolveOptions) => Promise<string | null>;
 }
 export declare const providers: Provider[];

package/dist/providers/vercel.d.ts

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

package/dist/providers/vercel.js

@@ -182,7 +182,7 @@ export async function pickVercelProject(token) {
     return config;
 }
 // --- Main resolve function ---
-export async function resolveVercelUrl(cwd, gitInfo) {
+export async function resolveVercelUrl(cwd, gitInfo, opts) {
     const cliOk = await ensureVercelCli((msg) => p.log.step(msg));
     if (!cliOk) {
         p.log.error("Failed to install Vercel CLI. Install manually: " + pc.cyan("npm install -g vercel"));
@@ -196,8 +196,24 @@ export async function resolveVercelUrl(cwd, gitInfo) {
     const project = await autoDetectProject(cwd, gitInfo, token);
     if (!project)
         return null;
-    // Fetch branch alias
-    const branchAlias = await getBranchAlias(token, project.teamId, project.projectId, gitInfo.branch);
+    // 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 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)
+                break;
+        }
+        if (branchAlias) {
+            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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "inflight-cli",
-	"version": "2.1.4",
+	"version": "2.1.6",
 	"description": "Get feedback directly on your staging URL",
 	"bin": {
 		"inflight": "dist/index.js",
@@ -19,16 +19,16 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@clack/prompts": "^0.8.2",
-		"commander": "^12.1.0",
-		"open": "^11.0.0",
-		"picocolors": "^1.1.1",
-		"update-notifier": "^7.3.1"
+		"@clack/prompts": "0.8.2",
+		"commander": "12.1.0",
+		"open": "11.0.0",
+		"picocolors": "1.1.1",
+		"update-notifier": "7.3.1"
 	},
 	"devDependencies": {
-		"@types/node": "^22.0.0",
-		"@types/update-notifier": "^6.0.8",
-		"tsx": "^4.19.0",
-		"typescript": "^5.6.0"
+		"@types/node": "22.0.0",
+		"@types/update-notifier": "6.0.8",
+		"tsx": "4.19.0",
+		"typescript": "5.9.3"
 	}
 }