inflight-cli 0.1.0

package/dist/commands/create.d.ts

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

package/dist/commands/create.js

@@ -0,0 +1,108 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { readGlobalConfig, writeGlobalConfig } from "../lib/config.js";
+import { getGitInfo, isGitRepo } from "../lib/git.js";
+import { detectStagingUrl } from "../lib/vercel.js";
+import { apiGetMe, apiCreateVersion } from "../lib/api.js";
+export async function createCommand(opts) {
+    const cwd = process.cwd();
+    const config = readGlobalConfig();
+    if (!config) {
+        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;
+    if (!workspaceId) {
+        const spinner = p.spinner();
+        spinner.start("Loading workspaces...");
+        const me = await apiGetMe(config.apiKey, config.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;
+        }
+        writeGlobalConfig({ ...config, 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)) {
+        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)}`);
+    }
+    else {
+        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: config.apiKey,
+        apiUrl: config.apiUrl,
+        workspaceId,
+        title,
+        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") + " — open Inflight to add feedback and publish when ready");
+    process.exit(0);
+}

package/dist/commands/login.d.ts

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

package/dist/commands/login.js

@@ -0,0 +1,60 @@
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { createServer } from "http";
+import { writeGlobalConfig } 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";
+export async function loginCommand() {
+    p.intro(pc.bgBlue(pc.white(" inflight login ")));
+    p.log.info("Opening browser to authenticate with Inflight...");
+    const apiKey = await browserAuth();
+    const apiUrl = DEFAULT_API_URL;
+    const spinner = p.spinner();
+    spinner.start("Validating...");
+    const me = await apiGetMe(apiKey, apiUrl).catch((e) => {
+        spinner.stop("Validation failed.");
+        p.log.error(e.message);
+        process.exit(1);
+    });
+    spinner.stop(`Authenticated as ${pc.bold(me.name)}`);
+    writeGlobalConfig({ apiKey, apiUrl });
+    p.outro(pc.green("✓ Logged in successfully"));
+    process.exit(0);
+}
+function browserAuth() {
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", "http://localhost");
+            const key = url.searchParams.get("api_key");
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(`
+				<html><body style="font-family:sans-serif;text-align:center;padding:60px">
+					<h2>Authenticated!</h2>
+					<p>You can close this tab and return to the terminal.</p>
+					<script>window.close()</script>
+				</body></html>
+			`);
+            server.close();
+            if (key) {
+                resolve(key);
+            }
+            else {
+                reject(new Error("No API key received from browser"));
+            }
+        });
+        server.listen(0, "127.0.0.1").unref();
+        server.once("listening", async () => {
+            const port = server.address().port;
+            const callbackUrl = `http://127.0.0.1:${port}`;
+            const authUrl = `${WEB_URL}/cli/connect?callback=${encodeURIComponent(callbackUrl)}`;
+            p.log.info(`Opening ${pc.cyan(authUrl)}`);
+            const { default: open } = await import("open");
+            await open(authUrl);
+        });
+        setTimeout(() => {
+            server.close();
+            reject(new Error("Authentication timed out after 5 minutes"));
+        }, 5 * 60 * 1000);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { loginCommand } from "./commands/login.js";
+import { createCommand } from "./commands/create.js";
+const program = new Command();
+program
+    .name("inflight")
+    .description("Create and share design versions from the terminal")
+    .version("0.1.0");
+program
+    .command("login")
+    .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 }));
+program.parse();

package/dist/lib/api.d.ts

@@ -0,0 +1,22 @@
+import type { GitInfo } from "./git.js";
+export interface Workspace {
+    id: string;
+    name: string;
+}
+export interface CreateVersionResult {
+    projectId: string;
+    versionId: string;
+    inflightUrl: string;
+}
+export declare function apiGetMe(apiKey: string, apiUrl: string): Promise<{
+    name: string;
+    workspaces: Workspace[];
+}>;
+export declare function apiCreateVersion(opts: {
+    apiKey: string;
+    apiUrl: string;
+    workspaceId: string;
+    title: string;
+    stagingUrl: string;
+    gitInfo: GitInfo;
+}): Promise<CreateVersionResult>;

package/dist/lib/api.js

@@ -0,0 +1,28 @@
+export async function apiGetMe(apiKey, apiUrl) {
+    const res = await fetch(`${apiUrl}/api/cli/me`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok)
+        throw new Error("Invalid API key");
+    return res.json();
+}
+export async function apiCreateVersion(opts) {
+    const res = await fetch(`${opts.apiUrl}/api/cli/version/create`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${opts.apiKey}`,
+        },
+        body: JSON.stringify({
+            workspaceId: opts.workspaceId,
+            title: opts.title,
+            stagingUrl: opts.stagingUrl,
+            gitInfo: opts.gitInfo,
+        }),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: res.statusText }));
+        throw new Error(body.error ?? `API error ${res.status}`);
+    }
+    return res.json();
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,7 @@
+export interface GlobalConfig {
+    apiKey: string;
+    apiUrl: string;
+    workspaceId?: string;
+}
+export declare function readGlobalConfig(): GlobalConfig | null;
+export declare function writeGlobalConfig(config: GlobalConfig): void;

package/dist/lib/config.js

@@ -0,0 +1,22 @@
+import { homedir } 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.inflight.co";
+export function readGlobalConfig() {
+    if (!existsSync(CONFIG_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 };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeGlobalConfig(config) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}

package/dist/lib/git.d.ts

@@ -0,0 +1,11 @@
+export interface GitInfo {
+    branch: string | null;
+    commitShort: string | null;
+    commitFull: string | null;
+    commitMessage: string | null;
+    remoteUrl: string | null;
+    isDirty: boolean;
+    diff: string | null;
+}
+export declare function getGitInfo(cwd: string): GitInfo;
+export declare function isGitRepo(cwd: string): boolean;

package/dist/lib/git.js

@@ -0,0 +1,72 @@
+import { execSync } from "child_process";
+function run(cmd, cwd) {
+    try {
+        return execSync(cmd, { cwd, stdio: ["pipe", "pipe", "pipe"] })
+            .toString()
+            .trim();
+    }
+    catch {
+        return null;
+    }
+}
+// Files matching these patterns are stripped from the diff before sending to GPT.
+// They consume token budget without providing useful feedback signal.
+const EXCLUDED_FILE_PATTERNS = [
+    /^(dist|build|\.next|out)\//,
+    /\/dist\//,
+    /\/build\//,
+    /\.min\.(js|css)$/,
+    /public\/.*\.js$/, // minified embed bundles, compiled assets
+    /^(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|bun\.lockb|bun\.lock)$/,
+    /\.snap$/,
+    // Generated type files — large, no feedback signal
+    /supabase\.ts$/,
+];
+function isExcludedFile(filePath) {
+    return EXCLUDED_FILE_PATTERNS.some((re) => re.test(filePath));
+}
+/**
+ * Strip hunks for excluded files from a unified diff string.
+ * Each file section starts with "diff --git a/<path> b/<path>".
+ */
+function filterDiff(raw) {
+    // Split on file boundaries, keeping the delimiter
+    const sections = raw.split(/(?=^diff --git )/m);
+    return sections
+        .filter((section) => {
+        const match = section.match(/^diff --git a\/.+ b\/(.+)/);
+        if (!match)
+            return true; // keep preamble / unknown sections
+        return !isExcludedFile(match[1]);
+    })
+        .join("");
+}
+function getDiff(cwd) {
+    // Try to find merge base with origin/main or origin/master
+    const mergeBase = run("git merge-base origin/main HEAD", cwd) ?? run("git merge-base origin/master HEAD", cwd);
+    const raw = mergeBase
+        ? run(`git diff ${mergeBase}..HEAD`, cwd)
+        : run("git diff HEAD~1..HEAD", cwd);
+    if (!raw)
+        return null;
+    const filtered = filterDiff(raw);
+    if (!filtered.trim())
+        return null;
+    // Cap at 100k chars for truly enormous diffs
+    const MAX_DIFF_CHARS = 100_000;
+    return filtered.length > MAX_DIFF_CHARS ? filtered.slice(0, MAX_DIFF_CHARS) : filtered;
+}
+export function getGitInfo(cwd) {
+    return {
+        branch: run("git rev-parse --abbrev-ref HEAD", cwd),
+        commitShort: run("git rev-parse --short HEAD", cwd),
+        commitFull: run("git rev-parse HEAD", cwd),
+        commitMessage: run("git log -1 --pretty=%s", cwd),
+        remoteUrl: run("git remote get-url origin", cwd),
+        isDirty: run("git status --porcelain", cwd) !== "",
+        diff: getDiff(cwd),
+    };
+}
+export function isGitRepo(cwd) {
+    return run("git rev-parse --git-dir", cwd) !== null;
+}

package/dist/lib/vercel.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Detect staging URL from hosting provider environment variables.
+ * Only works when running inside a CI/CD build environment.
+ */
+export declare function detectStagingUrl(): string | null;

package/dist/lib/vercel.js

@@ -0,0 +1,18 @@
+/**
+ * Detect staging URL from hosting provider environment variables.
+ * Only works when running inside a CI/CD build environment.
+ */
+export function detectStagingUrl() {
+    // Vercel preview deployments
+    if (process.env.VERCEL_URL) {
+        return `https://${process.env.VERCEL_URL}`;
+    }
+    // Netlify deploy previews
+    if (process.env.DEPLOY_PRIME_URL) {
+        return process.env.DEPLOY_PRIME_URL;
+    }
+    if (process.env.DEPLOY_URL) {
+        return process.env.DEPLOY_URL;
+    }
+    return null;
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "inflight-cli",
+	"version": "0.1.0",
+	"description": "Inflight CLI — create and share design versions from the terminal",
+	"bin": {
+		"inflight": "./dist/index.js"
+	},
+	"main": "./dist/index.js",
+	"type": "module",
+	"files": [
+		"dist"
+	],
+	"license": "MIT",
+	"homepage": "https://inflight.co",
+	"scripts": {
+		"build": "tsc && chmod +x dist/index.js",
+		"dev": "tsx src/index.ts"
+	},
+	"dependencies": {
+		"@clack/prompts": "^0.8.2",
+		"commander": "^12.1.0",
+		"open": "^11.0.0",
+		"picocolors": "^1.1.1"
+	},
+	"devDependencies": {
+		"@types/node": "^22.0.0",
+		"tsx": "^4.19.0",
+		"typescript": "^5.6.0"
+	}
+}