inflight-cli 2.2.0 → 2.3.0

package/dist/commands/netlify.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerNetlifyCommand(program: Command): void;

package/dist/commands/netlify.js

@@ -0,0 +1,79 @@
+import { readNetlifyConfig } from "../lib/config.js";
+import { getGitInfo, parseGitRepo, getGitRoot } from "../lib/git.js";
+import { getNetlifyToken, getNetlifyDeploys, getNetlifySites, readLocalNetlifySite, matchSitesByRepo, } from "../lib/netlify.js";
+// --- Action handlers ---
+async function listSites() {
+    const token = requireNetlifyToken();
+    const sites = await getNetlifySites(token);
+    console.log(JSON.stringify(sites.map((s) => ({
+        id: s.id,
+        name: s.name,
+        accountSlug: s.account_slug,
+        accountName: s.account_name,
+    }))));
+}
+/**
+ * Resolves siteId for subcommands.
+ * Priority: explicit flag → .netlify/state.json → git remote match → saved global config → error
+ */
+async function resolveSite(opts) {
+    if (opts.site)
+        return opts.site;
+    const cwd = process.cwd();
+    const gitRoot = getGitRoot(cwd);
+    if (gitRoot) {
+        const local = readLocalNetlifySite(gitRoot);
+        if (local)
+            return local.siteId;
+    }
+    const token = requireNetlifyToken();
+    const gitInfo = getGitInfo(cwd);
+    if (gitInfo.remoteUrl) {
+        const gitRepo = parseGitRepo(gitInfo.remoteUrl);
+        if (gitRepo) {
+            try {
+                const allSites = await getNetlifySites(token);
+                const matches = matchSitesByRepo(allSites, gitRepo.owner, gitRepo.name);
+                if (matches.length === 1)
+                    return matches[0].id;
+            }
+            catch { }
+        }
+    }
+    const config = readNetlifyConfig();
+    if (config)
+        return config.siteId;
+    console.log(JSON.stringify({
+        error: "netlify_not_configured",
+        message: "Could not auto-detect Netlify site. Run 'inflight netlify sites' to list available sites, then pass --site to 'inflight netlify deploys'.",
+    }));
+    process.exit(1);
+}
+async function listDeploys(opts) {
+    const token = requireNetlifyToken();
+    const siteId = await resolveSite(opts);
+    const deploys = await getNetlifyDeploys(token, siteId);
+    console.log(JSON.stringify({ deploys }));
+}
+/** Gets token silently, exits with JSON error if unavailable. */
+function requireNetlifyToken() {
+    const token = getNetlifyToken();
+    if (!token) {
+        console.log(JSON.stringify({
+            error: "netlify_not_authenticated",
+            message: "Netlify auth missing. Run 'netlify login' first, or set NETLIFY_AUTH_TOKEN.",
+        }));
+        process.exit(1);
+    }
+    return token;
+}
+// --- Command registration ---
+export function registerNetlifyCommand(program) {
+    const netlify = program.command("netlify").description("Netlify integration commands");
+    netlify.command("sites").description("List all Netlify sites (JSON)").action(listSites);
+    netlify
+        .command("deploys")
+        .description("List recent deploys for a site (JSON)")
+        .option("--site <id>", "Netlify site ID (auto-detected if omitted)")
+        .action(listDeploys);
+}

package/dist/commands/reset.js

@@ -1,6 +1,6 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import { clearGlobalAuth, clearWorkspaceConfig, clearVercelConfig } from "../lib/config.js";
+import { clearGlobalAuth, clearWorkspaceConfig, clearVercelConfig, clearNetlifyConfig } from "../lib/config.js";
 export async function resetCommand() {
     const confirm = await p.confirm({
         message: "This will clear all Inflight auth and workspace config. Continue?",
@@ -13,5 +13,6 @@ export async function resetCommand() {
     clearGlobalAuth();
     clearWorkspaceConfig();
     clearVercelConfig();
+    clearNetlifyConfig();
     p.log.success(pc.green("All Inflight config cleared."));
 }

package/dist/commands/share.js

@@ -328,14 +328,14 @@ export async function shareCommand(opts = {}) {
     }));
     if (recentProjects.length > 0) {
         const projectChoice = await p.select({
-            message: "Add to an existing version or start fresh?",
+            message: "Add to an existing project or start a new one?",
             options: [
+                { value: "new", label: "Start a new project" },
                 ...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)) {

package/dist/commands/vercel.js

@@ -1,10 +1,10 @@
 import { readVercelConfig } from "../lib/config.js";
 import { getGitInfo, parseGitRepo, getGitRoot } from "../lib/git.js";
-import { getVercelToken, getRecentDeployments, getBranchAlias, readLocalVercelProject, fetchAllProjectsWithLinks, matchProjectsByRepo, } from "../lib/vercel.js";
+import { getVercelToken, getVercelDeployments, getBranchAlias, readLocalVercelProject, getVercelProjects, matchVercelProjectsByRepo, } from "../lib/vercel.js";
 // --- Action handlers ---
 async function listProjects() {
     const token = requireVercelToken();
-    const projects = await fetchAllProjectsWithLinks(token);
+    const projects = await getVercelProjects(token);
     console.log(JSON.stringify(projects.map((p) => ({ id: p.id, name: p.name, teamId: p.teamId, teamName: p.teamName }))));
 }
 /**
@@ -28,8 +28,8 @@ async function resolveProject(opts) {
         const gitRepo = parseGitRepo(gitInfo.remoteUrl);
         if (gitRepo) {
             try {
-                const allProjects = await fetchAllProjectsWithLinks(token);
-                const matches = matchProjectsByRepo(allProjects, gitRepo.owner, gitRepo.name);
+                const allProjects = await getVercelProjects(token);
+                const matches = matchVercelProjectsByRepo(allProjects, gitRepo.owner, gitRepo.name);
                 if (matches.length === 1) {
                     return { teamId: matches[0].teamId, projectId: matches[0].id };
                 }
@@ -53,7 +53,7 @@ async function listDeployments(opts) {
     const gitInfo = getGitInfo(cwd);
     const currentBranch = gitInfo.branch;
     const [deployments, branchAlias] = await Promise.all([
-        getRecentDeployments(token, teamId, projectId),
+        getVercelDeployments(token, teamId, projectId),
         currentBranch ? getBranchAlias(token, teamId, projectId, currentBranch) : Promise.resolve(null),
     ]);
     console.log(JSON.stringify({

package/dist/index.js

@@ -7,6 +7,7 @@ import { logoutCommand } from "./commands/logout.js";
 import { resetCommand } from "./commands/reset.js";
 import { workspaceCommand } from "./commands/workspace.js";
 import { registerVercelCommand } from "./commands/vercel.js";
+import { registerNetlifyCommand } from "./commands/netlify.js";
 import { setupCommand } from "./commands/setup.js";
 import pkg from "../package.json" with { type: "json" };
 const { version } = pkg;
@@ -32,6 +33,7 @@ program
     .option("--set <id>", "Set the active workspace")
     .action((opts) => workspaceCommand(opts));
 registerVercelCommand(program);
+registerNetlifyCommand(program);
 program.command("logout").description("Disconnect your Inflight account").action(logoutCommand);
 program.command("reset").description("Clear all Inflight auth and config").action(resetCommand);
 program.parse();

package/dist/lib/config.d.ts

@@ -19,3 +19,11 @@ export interface VercelConfig {
 export declare function readVercelConfig(): VercelConfig | null;
 export declare function writeVercelConfig(config: VercelConfig): void;
 export declare function clearVercelConfig(): void;
+export interface NetlifyConfig {
+    siteId: string;
+    siteName: string;
+    teamSlug: string;
+}
+export declare function readNetlifyConfig(): NetlifyConfig | null;
+export declare function writeNetlifyConfig(config: NetlifyConfig): void;
+export declare function clearNetlifyConfig(): void;

package/dist/lib/config.js

@@ -72,3 +72,24 @@ export function clearVercelConfig() {
         unlinkSync(VERCEL_FILE);
     }
 }
+// --- Netlify config (global, persists across directories) ---
+const NETLIFY_FILE = join(getGlobalConfigDir(), "netlify.json");
+export function readNetlifyConfig() {
+    if (!existsSync(NETLIFY_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(NETLIFY_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeNetlifyConfig(config) {
+    mkdirSync(getGlobalConfigDir(), { recursive: true });
+    writeFileSync(NETLIFY_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+export function clearNetlifyConfig() {
+    if (existsSync(NETLIFY_FILE)) {
+        unlinkSync(NETLIFY_FILE);
+    }
+}

package/dist/lib/netlify.d.ts

@@ -0,0 +1,67 @@
+export declare function ensureNetlifyCli(log?: (msg: string) => void): Promise<boolean>;
+/**
+ * Gets the Netlify auth token non-interactively.
+ * Priority: NETLIFY_AUTH_TOKEN env var → CLI config file.
+ * Returns null if no valid token available.
+ */
+export declare function getNetlifyToken(): string | null;
+/**
+ * Ensures a valid Netlify auth token is available.
+ * Checks env/config first → opens browser login if needed.
+ * For interactive commands only.
+ */
+export declare function ensureNetlifyAuth(): Promise<string | null>;
+interface LocalNetlifySite {
+    siteId: string;
+}
+/**
+ * Reads `.netlify/state.json` from the given root directory.
+ * Created by `netlify link`.
+ */
+export declare function readLocalNetlifySite(root: string): LocalNetlifySite | null;
+/**
+ * Writes `.netlify/state.json` at the given root directory and ensures `.netlify` is gitignored.
+ */
+export declare function writeLocalNetlifySite(root: string, siteId: string): void;
+export interface NetlifySite {
+    id: string;
+    name: string;
+    url: string;
+    ssl_url: string;
+    admin_url: string;
+    account_name: string;
+    account_slug: string;
+    build_settings?: {
+        provider?: string;
+        repo_path?: string;
+        repo_url?: string;
+        repo_branch?: string;
+    };
+}
+export interface NetlifyDeploy {
+    id: string;
+    state: string;
+    branch: string | null;
+    commitRef: string | null;
+    commitMessage: string | null;
+    deploySslUrl: string;
+    context: string;
+    createdAt: number;
+}
+export declare function getNetlifyUser(token: string): Promise<{
+    id: string;
+    name: string;
+    email: string;
+} | null>;
+export declare function getNetlifySites(token: string): Promise<NetlifySite[]>;
+export declare function getNetlifySiteById(token: string, siteId: string): Promise<NetlifySite | null>;
+export declare function getNetlifyDeploys(token: string, siteId: string, opts?: {
+    branch?: string;
+    limit?: number;
+}): Promise<NetlifyDeploy[]>;
+/**
+ * Matches Netlify sites against a git remote's owner/repo.
+ * Compares build_settings.repo_path against "owner/repo".
+ */
+export declare function matchSitesByRepo(sites: NetlifySite[], gitOwner: string, gitRepo: string): NetlifySite[];
+export {};

package/dist/lib/netlify.js

@@ -0,0 +1,191 @@
+import { execSync, spawn, exec } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync } from "fs";
+import { join } from "path";
+import { homedir, platform } from "os";
+import { promisify } from "util";
+const execAsync = promisify(exec);
+// --- Netlify CLI management ---
+function hasNetlifyCli() {
+    try {
+        execSync("netlify --version", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureNetlifyCli(log) {
+    if (hasNetlifyCli())
+        return true;
+    log?.("Installing Netlify CLI...");
+    try {
+        await execAsync("npm install -g netlify-cli");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Returns the Netlify CLI config directory for the current platform.
+ * Matches the paths used by netlify-cli via env-paths('netlify', { suffix: '' }).
+ */
+function getNetlifyConfigDir() {
+    if (platform() === "darwin") {
+        return join(homedir(), "Library", "Preferences", "netlify");
+    }
+    if (platform() === "win32") {
+        return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "netlify", "Config");
+    }
+    return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "netlify");
+}
+function readNetlifyCliConfig() {
+    const configPath = join(getNetlifyConfigDir(), "config.json");
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(configPath, "utf-8"));
+        return data.userId ? data : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Gets the Netlify auth token non-interactively.
+ * Priority: NETLIFY_AUTH_TOKEN env var → CLI config file.
+ * Returns null if no valid token available.
+ */
+export function getNetlifyToken() {
+    const envToken = process.env.NETLIFY_AUTH_TOKEN;
+    if (envToken && envToken !== "null")
+        return envToken;
+    const config = readNetlifyCliConfig();
+    if (!config)
+        return null;
+    const user = config.users[config.userId];
+    return user?.auth?.token ?? null;
+}
+/**
+ * Ensures a valid Netlify auth token is available.
+ * Checks env/config first → opens browser login if needed.
+ * For interactive commands only.
+ */
+export async function ensureNetlifyAuth() {
+    const existing = getNetlifyToken();
+    if (existing)
+        return existing;
+    // Need browser login
+    const ok = await new Promise((resolve) => {
+        const child = spawn("netlify", ["login"], { stdio: "inherit" });
+        child.on("close", (code) => resolve(code === 0));
+        child.on("error", () => resolve(false));
+    });
+    if (!ok)
+        return null;
+    return getNetlifyToken();
+}
+/**
+ * Reads `.netlify/state.json` from the given root directory.
+ * Created by `netlify link`.
+ */
+export function readLocalNetlifySite(root) {
+    const statePath = join(root, ".netlify", "state.json");
+    if (!existsSync(statePath))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(statePath, "utf-8"));
+        if (typeof data.siteId === "string") {
+            return { siteId: data.siteId };
+        }
+    }
+    catch { }
+    return null;
+}
+/**
+ * Writes `.netlify/state.json` at the given root directory and ensures `.netlify` is gitignored.
+ */
+export function writeLocalNetlifySite(root, siteId) {
+    const netlifyDir = join(root, ".netlify");
+    mkdirSync(netlifyDir, { recursive: true });
+    writeFileSync(join(netlifyDir, "state.json"), JSON.stringify({ siteId }, null, 2) + "\n");
+    // Ensure .netlify is in .gitignore
+    const gitignorePath = join(root, ".gitignore");
+    if (existsSync(gitignorePath)) {
+        const content = readFileSync(gitignorePath, "utf-8");
+        if (!content.split("\n").some((line) => line.trim() === ".netlify")) {
+            appendFileSync(gitignorePath, "\n.netlify\n");
+        }
+    }
+    else {
+        writeFileSync(gitignorePath, ".netlify\n");
+    }
+}
+// --- API calls (all take token explicitly) ---
+const NETLIFY_API = "https://api.netlify.com/api/v1";
+export async function getNetlifyUser(token) {
+    const res = await fetch(`${NETLIFY_API}/user`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok)
+        return null;
+    const data = (await res.json());
+    return { id: data.id, name: data.full_name, email: data.email };
+}
+export async function getNetlifySites(token) {
+    const all = [];
+    let page = 1;
+    while (true) {
+        const params = new URLSearchParams({ filter: "all", per_page: "100", page: String(page) });
+        const res = await fetch(`${NETLIFY_API}/sites?${params}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            break;
+        const sites = (await res.json());
+        if (sites.length === 0)
+            break;
+        all.push(...sites);
+        if (sites.length < 100)
+            break;
+        page++;
+    }
+    return all;
+}
+export async function getNetlifySiteById(token, siteId) {
+    const res = await fetch(`${NETLIFY_API}/sites/${encodeURIComponent(siteId)}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok)
+        return null;
+    return (await res.json());
+}
+export async function getNetlifyDeploys(token, siteId, opts) {
+    const params = new URLSearchParams({ per_page: String(opts?.limit ?? 20) });
+    if (opts?.branch)
+        params.set("branch", opts.branch);
+    const res = await fetch(`${NETLIFY_API}/sites/${encodeURIComponent(siteId)}/deploys?${params}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok)
+        return [];
+    const deploys = (await res.json());
+    return deploys.map((d) => ({
+        id: d.id,
+        state: d.state,
+        branch: d.branch,
+        commitRef: d.commit_ref?.slice(0, 7) ?? null,
+        commitMessage: d.title,
+        deploySslUrl: d.deploy_ssl_url,
+        context: d.context,
+        createdAt: new Date(d.created_at).getTime(),
+    }));
+}
+/**
+ * Matches Netlify sites against a git remote's owner/repo.
+ * Compares build_settings.repo_path against "owner/repo".
+ */
+export function matchSitesByRepo(sites, gitOwner, gitRepo) {
+    const target = `${gitOwner}/${gitRepo}`.toLowerCase();
+    return sites.filter((s) => s.build_settings?.repo_path?.toLowerCase() === target);
+}

package/dist/lib/vercel.d.ts

@@ -32,6 +32,14 @@ export interface VercelTeam {
 export interface VercelProject {
     id: string;
     name: string;
+    teamId: string;
+    teamName?: string;
+    link?: {
+        org?: string;
+        repo?: string;
+        repoId?: number;
+        type?: string;
+    };
 }
 export interface VercelDeployment {
     url: string;
@@ -41,34 +49,20 @@ export interface VercelDeployment {
     commitMessage: string | null;
     createdAt: number;
 }
-export declare function getVercelTeams(token: string): Promise<VercelTeam[]>;
-export declare function getVercelProjects(token: string, teamId: string): Promise<VercelProject[]>;
 /**
  * Fetches details for a single Vercel project by ID.
  */
-export declare function getVercelProjectDetail(token: string, projectId: string, teamId: string): Promise<VercelProject | null>;
-export interface VercelProjectWithLink {
-    id: string;
-    name: string;
-    teamId: string;
-    teamName: string;
-    link?: {
-        org?: string;
-        repo?: string;
-        repoId?: number;
-        type?: string;
-    };
-}
+export declare function getVercelProjectById(token: string, projectId: string, teamId: string): Promise<VercelProject | null>;
 /**
  * Fetches all projects across all teams with their link info.
  * Used for client-side repo matching.
  */
-export declare function fetchAllProjectsWithLinks(token: string): Promise<VercelProjectWithLink[]>;
+export declare function getVercelProjects(token: string): Promise<VercelProject[]>;
 /**
  * Matches Vercel projects against a git remote's owner/repo.
  * Exact match on link.org and link.repo.
  */
-export declare function matchProjectsByRepo(projects: VercelProjectWithLink[], gitOwner: string, gitRepo: string): VercelProjectWithLink[];
+export declare function matchVercelProjectsByRepo(projects: VercelProject[], gitOwner: string, gitRepo: string): VercelProject[];
 /**
  * Creates a new Vercel project linked to a git repository.
  */
@@ -85,7 +79,7 @@ export declare function getBranchAlias(token: string, teamId: string, projectId:
 /**
  * Fetches recent deployments for a project.
  */
-export declare function getRecentDeployments(token: string, teamId: string, projectId: string, opts?: {
+export declare function getVercelDeployments(token: string, teamId: string, projectId: string, opts?: {
     limit?: number;
     branch?: string;
 }): Promise<VercelDeployment[]>;

package/dist/lib/vercel.js

@@ -142,7 +142,7 @@ export function writeLocalVercelProject(root, orgId, projectId) {
     }
 }
 // --- API calls (all take token + IDs explicitly) ---
-export async function getVercelTeams(token) {
+async function getVercelTeams(token) {
     const res = await fetch("https://api.vercel.com/v2/teams", {
         headers: { Authorization: `Bearer ${token}` },
     });
@@ -151,20 +151,10 @@ export async function getVercelTeams(token) {
     const data = (await res.json());
     return data.teams;
 }
-export async function getVercelProjects(token, teamId) {
-    const params = new URLSearchParams({ teamId, limit: "100" });
-    const res = await fetch(`https://api.vercel.com/v10/projects?${params}`, {
-        headers: { Authorization: `Bearer ${token}` },
-    });
-    if (!res.ok)
-        return [];
-    const data = (await res.json());
-    return data.projects;
-}
 /**
  * Fetches details for a single Vercel project by ID.
  */
-export async function getVercelProjectDetail(token, projectId, teamId) {
+export async function getVercelProjectById(token, projectId, teamId) {
     const params = new URLSearchParams({ teamId });
     const res = await fetch(`https://api.vercel.com/v10/projects/${encodeURIComponent(projectId)}?${params}`, {
         headers: { Authorization: `Bearer ${token}` },
@@ -172,13 +162,13 @@ export async function getVercelProjectDetail(token, projectId, teamId) {
     if (!res.ok)
         return null;
     const data = (await res.json());
-    return { id: data.id, name: data.name };
+    return { id: data.id, name: data.name, teamId, link: data.link };
 }
 /**
  * Fetches all projects across all teams with their link info.
  * Used for client-side repo matching.
  */
-export async function fetchAllProjectsWithLinks(token) {
+export async function getVercelProjects(token) {
     const teams = await getVercelTeams(token);
     const all = [];
     const fetches = teams.map(async (team) => {
@@ -200,7 +190,7 @@ export async function fetchAllProjectsWithLinks(token) {
  * Matches Vercel projects against a git remote's owner/repo.
  * Exact match on link.org and link.repo.
  */
-export function matchProjectsByRepo(projects, gitOwner, gitRepo) {
+export function matchVercelProjectsByRepo(projects, gitOwner, gitRepo) {
     const linked = projects.filter((p) => p.link?.org && p.link?.repo);
     return linked.filter((p) => p.link?.org === gitOwner && p.link?.repo === gitRepo);
 }
@@ -225,7 +215,7 @@ export async function createVercelProject(token, teamId, name, repo, repoType) {
         throw new Error(body?.error?.message ?? `Failed to create project (${res.status})`);
     }
     const data = (await res.json());
-    return { id: data.id, name: data.name };
+    return { id: data.id, name: data.name, teamId };
 }
 export async function getBranchAlias(token, teamId, projectId, branch) {
     if (!branch)
@@ -261,7 +251,7 @@ export async function getBranchAlias(token, teamId, projectId, branch) {
 /**
  * Fetches recent deployments for a project.
  */
-export async function getRecentDeployments(token, teamId, projectId, opts) {
+export async function getVercelDeployments(token, teamId, projectId, opts) {
     const params = new URLSearchParams({
         projectId,
         teamId,

package/dist/providers/index.js

@@ -1,4 +1,6 @@
+import { resolveNetlifyUrl } from "./netlify.js";
 import { resolveVercelUrl } from "./vercel.js";
 export const providers = [
     { id: "vercel", label: "Vercel", resolve: resolveVercelUrl },
+    { id: "netlify", label: "Netlify", resolve: resolveNetlifyUrl },
 ];

package/dist/providers/netlify.d.ts

@@ -0,0 +1,5 @@
+import type { GitInfo } from "../lib/git.js";
+import type { ProviderResolveOptions } from "./index.js";
+import type { NetlifyConfig } from "../lib/config.js";
+export declare function pickNetlifySite(token: string): Promise<NetlifyConfig | null>;
+export declare function resolveNetlifyUrl(cwd: string, gitInfo: GitInfo, opts?: ProviderResolveOptions): Promise<string | null>;

package/dist/providers/netlify.js

@@ -0,0 +1,218 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { parseGitRepo, getGitRoot } from "../lib/git.js";
+import { writeNetlifyConfig } from "../lib/config.js";
+import { ensureNetlifyCli, ensureNetlifyAuth, readLocalNetlifySite, writeLocalNetlifySite, getNetlifySiteById, getNetlifySites, getNetlifyDeploys, matchSitesByRepo, } from "../lib/netlify.js";
+// --- 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
+ */
+async function autoDetectSite(cwd, gitInfo, token) {
+    const gitRoot = getGitRoot(cwd);
+    // Cache result to .netlify/state.json so subsequent runs skip API calls
+    const cacheResult = (site) => {
+        if (gitRoot) {
+            writeLocalNetlifySite(gitRoot, site.siteId);
+        }
+        return site;
+    };
+    // --- 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,
+                };
+            }
+        }
+    }
+    // --- Fetch all sites ---
+    const spinner = p.spinner();
+    spinner.start("Detecting Netlify site...");
+    let allSites;
+    try {
+        allSites = await getNetlifySites(token);
+    }
+    catch {
+        spinner.stop("Could not fetch Netlify sites.");
+        return null;
+    }
+    if (allSites.length === 0) {
+        spinner.stop("No Netlify sites found.");
+        return null;
+    }
+    // --- Try exact match on git remote ---
+    const gitRepo = gitInfo.remoteUrl ? parseGitRepo(gitInfo.remoteUrl) : null;
+    if (gitRepo) {
+        const matches = matchSitesByRepo(allSites, gitRepo.owner, gitRepo.name);
+        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,
+            });
+        }
+        if (matches.length > 1) {
+            spinner.stop(`Found ${matches.length} Netlify sites for this repo.`);
+            const picked = await pickFromList(matches);
+            return picked ? cacheResult(picked) : null;
+        }
+    }
+    // --- No match ---
+    spinner.stop("Could not auto-detect Netlify site.");
+    const picked = await pickFromList(allSites);
+    return picked ? cacheResult(picked) : null;
+}
+async function pickFromList(sites) {
+    const maxName = Math.max(...sites.map((s) => s.name.length));
+    const selected = await p.select({
+        message: "Select a Netlify site",
+        options: sites.map((s) => ({
+            value: s,
+            label: s.account_name
+                ? `${s.name.padEnd(maxName)}  ${pc.dim(`(${s.account_name})`)}`
+                : s.name,
+        })),
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    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) {
+        p.log.error("No Netlify sites found.");
+        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,
+    };
+    writeNetlifyConfig(config);
+    return config;
+}
+// --- Main resolve function ---
+export async function resolveNetlifyUrl(cwd, gitInfo, opts) {
+    const cliOk = await ensureNetlifyCli((msg) => p.log.step(msg));
+    if (!cliOk) {
+        p.log.error("Failed to install Netlify CLI. Install manually: " + pc.cyan("npm install -g netlify-cli"));
+        return null;
+    }
+    const token = await ensureNetlifyAuth();
+    if (!token) {
+        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, {
+        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 = p.spinner();
+        pollSpinner.start("Waiting for Netlify deployment...");
+        for (let i = 0; i < 30; i++) {
+            await new Promise((r) => setTimeout(r, 2000));
+            deploys = await getNetlifyDeploys(token, site.siteId, {
+                branch: repoMatches ? (gitInfo.branch ?? undefined) : undefined,
+            });
+            commitDeploy = deploys.find((d) => d.commitRef === commitSha);
+            if (commitDeploy)
+                break;
+        }
+        if (commitDeploy) {
+            pollSpinner.stop("Deployment found!");
+        }
+        else {
+            pollSpinner.stop("Deployment is still building...");
+        }
+    }
+    // If we found a commit-specific deployment, use it automatically
+    if (commitDeploy) {
+        const stateLabel = commitDeploy.state !== "ready" ? ` ${pc.yellow(`(${commitDeploy.state})`)}` : "";
+        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;
+    }
+    // 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 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 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);
+                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);
+    }
+    return selected === "manual" ? null : 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`;
+}

package/dist/providers/vercel.d.ts

@@ -1,9 +1,3 @@
 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, opts?: ProviderResolveOptions): Promise<string | null>;

package/dist/providers/vercel.js

@@ -2,8 +2,7 @@ import * as p from "@clack/prompts";
 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, getRecentDeployments, } from "../lib/vercel.js";
+import { ensureVercelCli, ensureVercelAuth, readLocalVercelProject, writeLocalVercelProject, getVercelProjectById, getVercelProjects, matchVercelProjectsByRepo, createVercelProject, getVercelDeployments, } from "../lib/vercel.js";
 // --- Auto-detection ---
 /**
  * Auto-detect the Vercel project for the current git repo.
@@ -27,10 +26,16 @@ async function autoDetectProject(cwd, gitInfo, token) {
     if (gitRoot) {
         const localProject = readLocalVercelProject(gitRoot);
         if (localProject) {
-            const detail = await getVercelProjectDetail(token, localProject.projectId, localProject.orgId);
+            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 };
+                return {
+                    teamId: localProject.orgId,
+                    projectId: detail.id,
+                    projectName: detail.name,
+                    repoOwner: detail.link?.org ?? null,
+                    repoName: detail.link?.repo ?? null,
+                };
             }
         }
     }
@@ -39,7 +44,7 @@ async function autoDetectProject(cwd, gitInfo, token) {
     spinner.start("Detecting Vercel project...");
     let allProjects;
     try {
-        allProjects = await fetchAllProjectsWithLinks(token);
+        allProjects = await getVercelProjects(token);
     }
     catch {
         spinner.stop("Could not fetch Vercel projects.");
@@ -52,13 +57,15 @@ async function autoDetectProject(cwd, gitInfo, token) {
     // --- Try exact match on git remote ---
     const gitRepo = gitInfo.remoteUrl ? parseGitRepo(gitInfo.remoteUrl) : null;
     if (gitRepo) {
-        const matches = matchProjectsByRepo(allProjects, gitRepo.owner, gitRepo.name);
+        const matches = matchVercelProjectsByRepo(allProjects, gitRepo.owner, gitRepo.name);
         if (matches.length === 1) {
             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,
             });
         }
         if (matches.length > 1) {
@@ -95,7 +102,13 @@ async function pickFromList(projects, createCtx) {
         return createProjectFlow(projects, createCtx);
     }
     const match = selected;
-    return { teamId: match.teamId, projectId: match.id, projectName: match.name };
+    return {
+        teamId: match.teamId,
+        projectId: match.id,
+        projectName: match.name,
+        repoOwner: match.link?.org ?? null,
+        repoName: match.link?.repo ?? null,
+    };
 }
 async function createProjectFlow(projects, ctx) {
     const { token, gitRepo } = ctx;
@@ -128,59 +141,45 @@ async function createProjectFlow(projects, ctx) {
         }
         catch {
             p.log.info("Push to git to trigger your first deployment.");
-            return { teamId, projectId: created.id, projectName: created.name };
+            return {
+                teamId,
+                projectId: created.id,
+                projectName: created.name,
+                repoOwner: gitRepo.owner,
+                repoName: gitRepo.name,
+            };
         }
         // Poll until a deployment appears
         const pollSpinner = p.spinner();
         pollSpinner.start("Waiting for Vercel to start deploying...");
         for (let i = 0; i < 30; i++) {
             await new Promise((r) => setTimeout(r, 2000));
-            const deps = await getRecentDeployments(token, teamId, created.id);
+            const deps = await getVercelDeployments(token, teamId, created.id);
             if (deps.length > 0) {
                 pollSpinner.stop("Deployment started.");
-                return { teamId, projectId: created.id, projectName: created.name };
+                return {
+                    teamId,
+                    projectId: created.id,
+                    projectName: created.name,
+                    repoOwner: gitRepo.owner,
+                    repoName: gitRepo.name,
+                };
             }
         }
         pollSpinner.stop("Deployment may take a moment to appear.");
-        return { teamId, projectId: created.id, projectName: created.name };
+        return {
+            teamId,
+            projectId: created.id,
+            projectName: created.name,
+            repoOwner: gitRepo.owner,
+            repoName: gitRepo.name,
+        };
     }
     catch (e) {
         spinner.stop(e.message);
         return null;
     }
 }
-// --- Manual picker (used by `inflight vercel` command) ---
-/**
- * Interactive project picker. Saves selection to global config.
- * Used by `inflight vercel` command for explicit manual override.
- */
-export async function pickVercelProject(token) {
-    const allProjects = await fetchAllProjectsWithLinks(token);
-    if (allProjects.length === 0) {
-        p.log.error("No Vercel projects found.");
-        return null;
-    }
-    const selected = await p.select({
-        message: "Select a Vercel project",
-        options: allProjects.map((proj) => ({
-            value: proj,
-            label: proj.teamName ? `${proj.name} ${pc.dim(`(${proj.teamName})`)}` : proj.name,
-        })),
-    });
-    if (p.isCancel(selected)) {
-        p.cancel("Cancelled.");
-        return null;
-    }
-    const match = selected;
-    const config = {
-        teamId: match.teamId,
-        teamName: match.teamName,
-        projectId: match.id,
-        projectName: match.name,
-    };
-    writeVercelConfig(config);
-    return config;
-}
 // --- Main resolve function ---
 export async function resolveVercelUrl(cwd, gitInfo, opts) {
     const cliOk = await ensureVercelCli((msg) => p.log.step(msg));
@@ -197,19 +196,25 @@ export async function resolveVercelUrl(cwd, gitInfo, opts) {
     if (!project)
         return null;
     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,
+    // 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 = deployments.find((d) => d.commitSha === commitSha);
+    let commitDeploy = repoMatches ? deployments.find((d) => d.commitSha === commitSha) : undefined;
     // If just pushed, poll until the commit deployment appears
-    if (!commitDeploy && opts?.justPushed) {
+    if (!commitDeploy && repoMatches && 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));
-            deployments = await getRecentDeployments(token, project.teamId, project.projectId, {
-                branch: gitInfo.branch ?? undefined,
+            deployments = await getVercelDeployments(token, project.teamId, project.projectId, {
+                branch: repoMatches ? gitInfo.branch ?? undefined : undefined,
             });
             commitDeploy = deployments.find((d) => d.commitSha === commitSha);
             if (commitDeploy)

package/package.json

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