inflight-cli 0.1.1 → 1.0.0

package/README.md

@@ -18,17 +18,24 @@ Authenticate with your Inflight account:
 inflight login
 ```
 
-This opens a browser window to complete authentication. Your credentials are stored in `~/.inflight/config.json`.
+This opens a browser window to complete authentication. Your credentials are stored in `~/Library/Application Support/co.inflight.cli/auth.json` (macOS) or `~/.local/share/co.inflight.cli/auth.json` (Linux).
 
-### Create a version
+### Share a version
 
-Create a new draft version for the current project:
+Share a new design version for the current project:
 
 ```bash
-inflight create
+inflight share
 ```
 
-You'll be prompted for a title (defaults to your current git branch name) and a staging URL. Git context (branch, commit, diff) is automatically captured if you're in a git repo.
+This will:
+1. Detect your git branch and commit info automatically
+2. Ask where your staging URL is hosted (Vercel or paste a URL)
+3. Create a version on Inflight and open it in your browser
+
+On first run, you'll be prompted to link your Vercel project and select a workspace. These are saved locally so subsequent runs are fast.
+
+Git context (branch, commit, diff) is captured automatically and used to generate a version title and feedback questions.
 
 ## Requirements
 

package/dist/commands/create.d.ts

@@ -1,3 +1 @@
-export declare function createCommand(opts: {
-    title?: string;
-}): Promise<void>;
+export declare function createCommand(): Promise<void>;

package/dist/commands/create.js

@@ -1,23 +1,23 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import { readGlobalConfig, writeGlobalConfig } from "../lib/config.js";
+import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
 import { getGitInfo, isGitRepo } from "../lib/git.js";
-import { detectStagingUrl } from "../lib/vercel.js";
+import { providers } from "../providers/index.js";
 import { apiGetMe, apiCreateVersion } from "../lib/api.js";
-export async function createCommand(opts) {
+export async function createCommand() {
     const cwd = process.cwd();
-    const config = readGlobalConfig();
-    if (!config) {
+    const auth = readGlobalAuth();
+    if (!auth) {
         p.log.error("Not logged in. Run " + pc.cyan("inflight login") + " first.");
         process.exit(1);
     }
-    p.intro(pc.bgBlue(pc.white(" inflight create ")));
-    // Resolve workspace — lazy, cached after first use
-    let workspaceId = config.workspaceId;
+    p.intro(pc.bgBlue(pc.white(" inflight share ")));
+    // Resolve workspace — read from .inflight/workspace.json, prompt if not linked
+    let workspaceId = readWorkspaceConfig(cwd)?.workspaceId;
     if (!workspaceId) {
         const spinner = p.spinner();
         spinner.start("Loading workspaces...");
-        const me = await apiGetMe(config.apiKey, config.apiUrl).catch((e) => {
+        const me = await apiGetMe(auth.apiKey, auth.apiUrl).catch((e) => {
             spinner.stop("Failed.");
             p.log.error(e.message);
             process.exit(1);
@@ -42,31 +42,34 @@ export async function createCommand(opts) {
             }
             workspaceId = selected;
         }
-        writeGlobalConfig({ ...config, workspaceId });
+        writeWorkspaceConfig(cwd, { workspaceId });
     }
     // Git info
     const gitInfo = isGitRepo(cwd)
         ? getGitInfo(cwd)
         : { branch: null, commitShort: null, commitFull: null, commitMessage: null, remoteUrl: null, isDirty: false, diff: null };
-    // Title defaults to branch name
-    const defaultTitle = gitInfo.branch ?? "Untitled";
-    const titleInput = opts.title ??
-        (await p.text({
-            message: "Version title",
-            placeholder: defaultTitle,
-            defaultValue: defaultTitle,
-        }));
-    if (p.isCancel(titleInput)) {
+    // Title is auto-generated server-side from the diff/branch/commit
+    const title = gitInfo.branch ?? "Untitled";
+    // Staging URL — user picks provider
+    const providerChoice = await p.select({
+        message: "Where is your staging URL hosted?",
+        options: [
+            ...providers.map((prov) => ({ value: prov.id, label: prov.label })),
+            { value: "manual", label: "Paste a URL" },
+        ],
+    });
+    if (p.isCancel(providerChoice)) {
         p.cancel("Cancelled.");
         process.exit(0);
     }
-    const title = titleInput;
-    // Staging URL — auto-detected from env or prompted
-    let stagingUrl = detectStagingUrl();
-    if (stagingUrl) {
-        p.log.info(`Staging URL: ${pc.cyan(stagingUrl)}`);
+    const providerSpinner = p.spinner();
+    const provider = providers.find((prov) => prov.id === providerChoice);
+    let stagingUrl;
+    if (provider) {
+        stagingUrl = (await provider.resolve(cwd, gitInfo, providerSpinner)) ?? undefined;
     }
-    else {
+    // Manual input (or fallback if provider returned no URL)
+    if (!stagingUrl) {
         const input = await p.text({
             message: "Staging URL",
             placeholder: "https://my-branch.vercel.app",
@@ -90,8 +93,8 @@ export async function createCommand(opts) {
     const spinner = p.spinner();
     spinner.start("Creating version...");
     const result = await apiCreateVersion({
-        apiKey: config.apiKey,
-        apiUrl: config.apiUrl,
+        apiKey: auth.apiKey,
+        apiUrl: auth.apiUrl,
         workspaceId,
         title,
         stagingUrl,

package/dist/commands/login.js

@@ -1,7 +1,7 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { createServer } from "http";
-import { writeGlobalConfig } from "../lib/config.js";
+import { writeGlobalAuth } from "../lib/config.js";
 import { apiGetMe } from "../lib/api.js";
 const DEFAULT_API_URL = process.env.INFLIGHT_API_URL ?? "https://api.inflight.co";
 const WEB_URL = process.env.INFLIGHT_WEB_URL ?? "https://inflight.co";
@@ -18,7 +18,7 @@ export async function loginCommand() {
         process.exit(1);
     });
     spinner.stop(`Authenticated as ${pc.bold(me.name)}`);
-    writeGlobalConfig({ apiKey, apiUrl });
+    writeGlobalAuth({ apiKey, apiUrl });
     p.outro(pc.green("✓ Logged in successfully"));
     process.exit(0);
 }

package/dist/commands/share.d.ts

@@ -0,0 +1 @@
+export declare function shareCommand(): Promise<void>;

package/dist/commands/share.js

@@ -0,0 +1,110 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { readGlobalAuth, readWorkspaceConfig, writeWorkspaceConfig } from "../lib/config.js";
+import { getGitInfo, isGitRepo } from "../lib/git.js";
+import { providers } from "../providers/index.js";
+import { apiGetMe, apiCreateVersion } from "../lib/api.js";
+export async function shareCommand() {
+    const cwd = process.cwd();
+    const auth = readGlobalAuth();
+    if (!auth) {
+        p.log.error("Not logged in. Run " + pc.cyan("inflight login") + " first.");
+        process.exit(1);
+    }
+    p.intro(pc.bgBlue(pc.white(" inflight share ")));
+    // Resolve workspace — read from .inflight/workspace.json, prompt if not linked
+    let workspaceId = readWorkspaceConfig(cwd)?.workspaceId;
+    if (!workspaceId) {
+        const spinner = p.spinner();
+        spinner.start("Loading workspaces...");
+        const me = await apiGetMe(auth.apiKey, auth.apiUrl).catch((e) => {
+            spinner.stop("Failed.");
+            p.log.error(e.message);
+            process.exit(1);
+        });
+        spinner.stop("");
+        if (me.workspaces.length === 0) {
+            p.log.error("No workspaces found. Create one at inflight.co first.");
+            process.exit(1);
+        }
+        else if (me.workspaces.length === 1) {
+            workspaceId = me.workspaces[0].id;
+            p.log.info(`Workspace: ${pc.bold(me.workspaces[0].name)}`);
+        }
+        else {
+            const selected = await p.select({
+                message: "Select a workspace",
+                options: me.workspaces.map((w) => ({ value: w.id, label: w.name })),
+            });
+            if (p.isCancel(selected)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            workspaceId = selected;
+        }
+        writeWorkspaceConfig(cwd, { workspaceId });
+    }
+    // Git info
+    const gitInfo = isGitRepo(cwd)
+        ? getGitInfo(cwd)
+        : { branch: null, commitShort: null, commitFull: null, commitMessage: null, remoteUrl: null, isDirty: false, diff: null };
+    // Staging URL — user picks provider
+    const providerChoice = await p.select({
+        message: "Where is your staging URL hosted?",
+        options: [
+            ...providers.map((prov) => ({ value: prov.id, label: prov.label })),
+            { value: "manual", label: "Paste a URL" },
+        ],
+    });
+    if (p.isCancel(providerChoice)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    const providerSpinner = p.spinner();
+    const provider = providers.find((prov) => prov.id === providerChoice);
+    let stagingUrl;
+    if (provider) {
+        stagingUrl = (await provider.resolve(cwd, gitInfo, providerSpinner)) ?? undefined;
+    }
+    // Manual input (or fallback if provider returned no URL)
+    if (!stagingUrl) {
+        const input = await p.text({
+            message: "Staging URL",
+            placeholder: "https://my-branch.vercel.app",
+            validate: (v) => {
+                if (!v)
+                    return "Staging URL is required";
+                try {
+                    new URL(v);
+                }
+                catch {
+                    return "Must be a valid URL (include https://)";
+                }
+            },
+        });
+        if (p.isCancel(input)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        stagingUrl = input;
+    }
+    const spinner = p.spinner();
+    // spinner.start("Creating version...");
+    const result = await apiCreateVersion({
+        apiKey: auth.apiKey,
+        apiUrl: auth.apiUrl,
+        workspaceId,
+        stagingUrl,
+        gitInfo,
+    }).catch((e) => {
+        spinner.stop("Failed.");
+        p.log.error(e.message);
+        process.exit(1);
+    });
+    // spinner.stop("Version created");
+    p.note(result.inflightUrl, "Your Inflight version");
+    p.outro(pc.green("✓ Done") + " — opening Inflight...");
+    const { default: open } = await import("open");
+    await open(result.inflightUrl);
+    process.exit(0);
+}

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import { loginCommand } from "./commands/login.js";
-import { createCommand } from "./commands/create.js";
+import { shareCommand } from "./commands/share.js";
 const program = new Command();
 program
     .name("inflight")
@@ -12,8 +12,7 @@ program
     .description("Authenticate with your Inflight account")
     .action(loginCommand);
 program
-    .command("create")
-    .description("Create a new draft version for this project")
-    .option("-t, --title <title>", "Version title")
-    .action((opts) => createCommand({ title: opts.title }));
+    .command("share")
+    .description("Share a new version for this project")
+    .action(() => shareCommand());
 program.parse();

package/dist/lib/api.d.ts

@@ -16,7 +16,6 @@ export declare function apiCreateVersion(opts: {
     apiKey: string;
     apiUrl: string;
     workspaceId: string;
-    title: string;
     stagingUrl: string;
     gitInfo: GitInfo;
 }): Promise<CreateVersionResult>;

package/dist/lib/api.js

@@ -15,7 +15,6 @@ export async function apiCreateVersion(opts) {
         },
         body: JSON.stringify({
             workspaceId: opts.workspaceId,
-            title: opts.title,
             stagingUrl: opts.stagingUrl,
             gitInfo: opts.gitInfo,
         }),

package/dist/lib/config.d.ts

@@ -1,7 +1,11 @@
-export interface GlobalConfig {
+export interface GlobalAuth {
     apiKey: string;
     apiUrl: string;
-    workspaceId?: string;
 }
-export declare function readGlobalConfig(): GlobalConfig | null;
-export declare function writeGlobalConfig(config: GlobalConfig): void;
+export declare function readGlobalAuth(): GlobalAuth | null;
+export declare function writeGlobalAuth(auth: GlobalAuth): void;
+export interface WorkspaceConfig {
+    workspaceId: string;
+}
+export declare function readWorkspaceConfig(cwd: string): WorkspaceConfig | null;
+export declare function writeWorkspaceConfig(cwd: string, config: WorkspaceConfig): void;

package/dist/lib/config.js

@@ -1,22 +1,61 @@
-import { homedir } from "os";
+import { homedir, platform } from "os";
 import { join } from "path";
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-const CONFIG_DIR = join(homedir(), ".inflight");
-const CONFIG_FILE = join(CONFIG_DIR, "config.json");
-const DEFAULT_API_URL = process.env.INFLIGHT_API_URL ?? "https://api-staging.inflight.co";
-export function readGlobalConfig() {
-    if (!existsSync(CONFIG_FILE))
+function getGlobalConfigDir() {
+    if (platform() === "darwin") {
+        return join(homedir(), "Library", "Application Support", "co.inflight.cli");
+    }
+    if (platform() === "win32") {
+        return join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "co.inflight.cli");
+    }
+    return join(homedir(), ".local", "share", "co.inflight.cli");
+}
+const AUTH_FILE = join(getGlobalConfigDir(), "auth.json");
+const DEFAULT_API_URL = process.env.INFLIGHT_API_URL ?? "https://api.inflight.co";
+export function readGlobalAuth() {
+    if (!existsSync(AUTH_FILE))
+        return null;
+    try {
+        const auth = JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+        return { ...auth, apiUrl: DEFAULT_API_URL };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeGlobalAuth(auth) {
+    mkdirSync(getGlobalConfigDir(), { recursive: true });
+    writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2), { mode: 0o600 });
+}
+// --- Project-level config (per-directory, like .vercel/project.json) ---
+const WORKSPACE_FILE = ".inflight/workspace.json";
+export function readWorkspaceConfig(cwd) {
+    const file = join(cwd, WORKSPACE_FILE);
+    if (!existsSync(file))
         return null;
     try {
-        const config = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
-        // Allow env var to override stored API URL (useful for local dev)
-        return { ...config, apiUrl: DEFAULT_API_URL };
+        return JSON.parse(readFileSync(file, "utf-8"));
     }
     catch {
         return null;
     }
 }
-export function writeGlobalConfig(config) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+export function writeWorkspaceConfig(cwd, config) {
+    const dir = join(cwd, ".inflight");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(cwd, WORKSPACE_FILE), JSON.stringify(config, null, 2));
+    addToGitignore(cwd);
+}
+function addToGitignore(cwd) {
+    const gitignorePath = join(cwd, ".gitignore");
+    const entry = ".inflight";
+    try {
+        const contents = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : "";
+        if (!contents.split("\n").some((line) => line.trim() === entry)) {
+            writeFileSync(gitignorePath, contents + (contents.endsWith("\n") ? "" : "\n") + entry + "\n");
+        }
+    }
+    catch {
+        // non-fatal
+    }
 }

package/dist/lib/vercel.d.ts

@@ -1,5 +1,26 @@
+export declare function isVercelLoggedIn(): Promise<boolean>;
+export declare function isVercelLinked(cwd: string): boolean;
+/** Opens browser-based Vercel login — suppresses CLI output, browser opens automatically. */
+export declare function vercelLogin(): boolean;
+export interface VercelTeam {
+    id: string;
+    name: string;
+    slug: string;
+}
+export interface VercelProject {
+    id: string;
+    name: string;
+}
+export declare function getVercelTeams(): Promise<VercelTeam[]>;
+export declare function getVercelProjects(teamId: string): Promise<VercelProject[]>;
+/** Links the directory to a specific Vercel project silently. */
+export declare function vercelLink(cwd: string, projectId: string): Promise<boolean>;
+export interface VercelDeployment {
+    url: string;
+    label: string;
+}
 /**
- * Detect staging URL from hosting provider environment variables.
- * Only works when running inside a CI/CD build environment.
+ * Fetches Vercel deployments for the current commit SHA.
+ * Falls back to recent deployments if no SHA match is found.
  */
-export declare function detectStagingUrl(): string | null;
+export declare function getVercelDeployments(cwd: string, commitSha: string | null, branch: string | null): Promise<VercelDeployment[]>;

package/dist/lib/vercel.js

@@ -1,18 +1,177 @@
+import { execSync, spawnSync, spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 /**
- * Detect staging URL from hosting provider environment variables.
- * Only works when running inside a CI/CD build environment.
+ * Returns the vercel command to use — the installed CLI if available,
+ * otherwise falls back to npx so users don't need a global install.
  */
-export function detectStagingUrl() {
-    // Vercel preview deployments
-    if (process.env.VERCEL_URL) {
-        return `https://${process.env.VERCEL_URL}`;
+function getVercelCmd() {
+    try {
+        execSync("vercel --version", { stdio: "pipe" });
+        return { cmd: "vercel", args: [] };
     }
-    // Netlify deploy previews
-    if (process.env.DEPLOY_PRIME_URL) {
-        return process.env.DEPLOY_PRIME_URL;
+    catch {
+        return { cmd: "npx", args: ["--yes", "vercel"] };
     }
-    if (process.env.DEPLOY_URL) {
-        return process.env.DEPLOY_URL;
+}
+export function isVercelLoggedIn() {
+    const { cmd, args } = getVercelCmd();
+    return new Promise((resolve) => {
+        const child = spawn(cmd, [...args, "whoami"], { stdio: "pipe" });
+        child.on("close", (code) => resolve(code === 0));
+        child.on("error", () => resolve(false));
+    });
+}
+export function isVercelLinked(cwd) {
+    return existsSync(join(cwd, ".vercel", "project.json"));
+}
+/** Opens browser-based Vercel login — suppresses CLI output, browser opens automatically. */
+export function vercelLogin() {
+    const { cmd, args } = getVercelCmd();
+    const result = spawnSync(cmd, [...args, "login"], { stdio: "pipe" });
+    return result.status === 0;
+}
+export async function getVercelTeams() {
+    const token = getVercelAuthToken();
+    if (!token)
+        return [];
+    const res = await fetch("https://api.vercel.com/v2/teams", {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok)
+        return [];
+    const data = (await res.json());
+    return data.teams;
+}
+export async function getVercelProjects(teamId) {
+    const token = getVercelAuthToken();
+    if (!token)
+        return [];
+    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;
+}
+/** Links the directory to a specific Vercel project silently. */
+export function vercelLink(cwd, projectId) {
+    const { cmd, args } = getVercelCmd();
+    return new Promise((resolve) => {
+        const child = spawn(cmd, [...args, "link", "--yes", "--project", projectId], {
+            stdio: "pipe",
+            cwd,
+        });
+        child.on("close", (code) => resolve(code === 0));
+        child.on("error", () => resolve(false));
+    });
+}
+/** Reads the auth token saved by the Vercel CLI after login. */
+function getVercelAuthToken() {
+    const candidates = [
+        join(homedir(), "Library", "Application Support", "com.vercel.cli", "auth.json"), // macOS
+        join(homedir(), ".local", "share", "com.vercel.cli", "auth.json"), // Linux
+        join(homedir(), ".config", "vercel", "auth.json"), // older versions
+    ];
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            try {
+                const data = JSON.parse(readFileSync(p, "utf-8"));
+                return data.token ?? null;
+            }
+            catch {
+                continue;
+            }
+        }
     }
     return null;
 }
+/** Reads the project + team IDs from `.vercel/project.json`. */
+function getVercelProjectConfig(cwd) {
+    const configPath = join(cwd, ".vercel", "project.json");
+    if (!existsSync(configPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fetches Vercel deployments for the current commit SHA.
+ * Falls back to recent deployments if no SHA match is found.
+ */
+export async function getVercelDeployments(cwd, commitSha, branch) {
+    const token = getVercelAuthToken();
+    const project = getVercelProjectConfig(cwd);
+    if (!token || !project)
+        return [];
+    async function fetchDeployments(extraParams) {
+        const params = new URLSearchParams({
+            projectId: project.projectId,
+            teamId: project.orgId,
+            limit: "1",
+            state: "READY",
+            ...extraParams,
+        });
+        const res = await fetch(`https://api.vercel.com/v6/deployments?${params}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        return data.deployments;
+    }
+    async function fetchAutomaticAliases(uid) {
+        const params = new URLSearchParams({ teamId: project.orgId });
+        const res = await fetch(`https://api.vercel.com/v13/deployments/${uid}?${params}`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        return data.automaticAliases ?? [];
+    }
+    // Fetch commit deployment and latest branch deployment in parallel
+    const [commitDeployments, branchDeployments] = await Promise.all([
+        commitSha ? fetchDeployments({ sha: commitSha }) : Promise.resolve([]),
+        branch ? fetchDeployments({ branch }) : Promise.resolve([]),
+    ]);
+    const results = [];
+    const seenUrls = new Set();
+    // Branch alias URL from automaticAliases (auto-updates with each push)
+    const branchDeploy = branchDeployments[0];
+    if (branchDeploy) {
+        const aliases = await fetchAutomaticAliases(branchDeploy.uid);
+        for (const alias of aliases) {
+            const url = `https://${alias}`;
+            if (!seenUrls.has(url)) {
+                results.push({ url, label: `branch: ${branch}  (${alias})` });
+                seenUrls.add(url);
+            }
+        }
+    }
+    // Commit-specific URL
+    const commitDeploy = commitDeployments[0];
+    if (commitDeploy) {
+        const url = `https://${commitDeploy.url}`;
+        if (!seenUrls.has(url)) {
+            results.push({ url, label: `commit: ${commitSha?.slice(0, 7)}  (${commitDeploy.url})` });
+            seenUrls.add(url);
+        }
+    }
+    // Fallback: most recent deployment
+    if (results.length === 0) {
+        const recent = await fetchDeployments({});
+        const d = recent[0];
+        if (d) {
+            const b = d.meta?.githubCommitRef ?? d.meta?.gitlabCommitRef ?? d.meta?.bitbucketCommitRef;
+            results.push({ url: `https://${d.url}`, label: b ? `${b}  (${d.url})` : d.url });
+        }
+    }
+    return results;
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,9 @@
+import * as p from "@clack/prompts";
+import type { GitInfo } from "../lib/git.js";
+export type ProviderSpinner = ReturnType<typeof p.spinner>;
+export interface Provider {
+    id: string;
+    label: string;
+    resolve: (cwd: string, gitInfo: GitInfo, spinner: ProviderSpinner) => Promise<string | null>;
+}
+export declare const providers: Provider[];

package/dist/providers/index.js

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

package/dist/providers/vercel.d.ts

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

package/dist/providers/vercel.js

@@ -0,0 +1,78 @@
+import * as p from "@clack/prompts";
+import { isVercelLoggedIn, isVercelLinked, vercelLogin, vercelLink, getVercelTeams, getVercelProjects, getVercelDeployments, } from "../lib/vercel.js";
+export async function resolveVercelUrl(cwd, gitInfo, spinner) {
+    // Ensure logged in
+    spinner.start("Checking Vercel...");
+    const loggedIn = await isVercelLoggedIn();
+    if (!loggedIn) {
+        spinner.stop("Opening browser to log in to Vercel...");
+        const ok = vercelLogin();
+        if (!ok) {
+            p.log.error("Vercel login failed.");
+            process.exit(1);
+        }
+    }
+    else {
+        spinner.stop("Vercel ready");
+    }
+    // Ensure project is linked
+    if (!isVercelLinked(cwd)) {
+        const teams = await getVercelTeams();
+        if (teams.length === 0) {
+            p.log.error("No Vercel teams found.");
+            process.exit(1);
+        }
+        let teamId;
+        if (teams.length === 1) {
+            teamId = teams[0].id;
+        }
+        else {
+            const selectedTeam = await p.select({
+                message: "Select a Vercel team",
+                options: teams.map((t) => ({ value: t.id, label: t.name })),
+            });
+            if (p.isCancel(selectedTeam)) {
+                p.cancel("Cancelled.");
+                process.exit(0);
+            }
+            teamId = selectedTeam;
+        }
+        const projects = await getVercelProjects(teamId);
+        if (projects.length === 0) {
+            p.log.error("No Vercel projects found.");
+            process.exit(1);
+        }
+        const selectedProject = await p.select({
+            message: "Select a Vercel project",
+            options: projects.map((proj) => ({ value: proj.id, label: proj.name })),
+        });
+        if (p.isCancel(selectedProject)) {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        }
+        spinner.start("Linking to Vercel project...");
+        const ok = await vercelLink(cwd, selectedProject);
+        spinner.stop(ok ? "Linked to Vercel project" : "");
+        if (!ok) {
+            p.log.error("Vercel link failed.");
+            process.exit(1);
+        }
+    }
+    // Fetch deployments
+    spinner.start("Fetching Vercel deployments...");
+    const deployments = await getVercelDeployments(cwd, gitInfo.commitFull, gitInfo.branch);
+    spinner.stop("Fetched Vercel deployments");
+    if (deployments.length === 0) {
+        p.log.warn("No Vercel deployments found. Paste a URL instead.");
+        return null;
+    }
+    const selected = await p.select({
+        message: "Select a deployment",
+        options: deployments.map((d) => ({ value: d.url, label: d.label })),
+    });
+    if (p.isCancel(selected)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+    }
+    return selected;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "inflight-cli",
-	"version": "0.1.1",
-	"description": "Inflight CLI — create and share design versions from the terminal",
+	"version": "1.0.0",
+	"description": "Get feedback directly on your staging URL",
 	"bin": {
 		"inflight": "dist/index.js"
 	},
@@ -10,7 +10,7 @@
 	"files": [
 		"dist"
 	],
-	"license": "MIT",
+	"license": "UNLICENSED",
 	"homepage": "https://inflight.co",
 	"scripts": {
 		"build": "tsc && chmod +x dist/index.js",