inflight-cli 1.1.4 → 2.0.0

package/dist/index.js

@@ -3,15 +3,25 @@ import { Command } from "commander";
 import updateNotifier from "update-notifier";
 import { loginCommand } from "./commands/login.js";
 import { shareCommand } from "./commands/share.js";
-import { workspaceCommand } from "./commands/workspace.js";
 import { logoutCommand } from "./commands/logout.js";
+import { resetCommand } from "./commands/reset.js";
+import { workspacesCommand } from "./commands/workspaces.js";
+import { registerVercelCommand } from "./commands/vercel.js";
+import { setupCommand } from "./commands/setup.js";
 import pkg from "../package.json" with { type: "json" };
 const { version } = pkg;
 updateNotifier({ pkg }).notify();
 const program = new Command();
 program.name("inflight").description("Get feedback directly on your staging URL").version(version);
+program.command("setup").description("Set up Inflight in your project").action(setupCommand);
 program.command("login").description("Authenticate with your Inflight account").action(loginCommand);
-program.command("share").description("Get feedback on your staging URL").action(shareCommand);
+program
+    .command("share")
+    .description("Get feedback on your staging URL")
+    .option("--url <url>", "Staging URL (skips provider selection)")
+    .option("--workspace <id>", "Workspace ID (skips workspace selection)")
+    .option("--json", "Output result as JSON")
+    .action((opts) => shareCommand(opts));
 // program
 // 	.command("preview")
 // 	.description("Preview a live component from your code")
@@ -19,6 +29,13 @@ program.command("share").description("Get feedback on your staging URL").action(
 // 	.option("--scope <mode>", "Skip scope prompt: branch, uncommitted, staged")
 // 	.option("--no-open", "Don't open result in browser")
 // 	.action((opts) => previewCommand(opts));
-program.command("workspace").description("Switch the active inflight workspace").action(workspaceCommand);
+program
+    .command("workspaces")
+    .description("List, select, or set your workspaces")
+    .option("--json", "Output as JSON")
+    .option("--set <id>", "Set the active workspace")
+    .action((opts) => workspacesCommand(opts));
+registerVercelCommand(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/api.d.ts

@@ -2,6 +2,7 @@ import type { GitInfo } from "./git.js";
 export interface Workspace {
     id: string;
     name: string;
+    widgetId: string;
 }
 export interface CreateVersionResult {
     projectId: string;
@@ -19,3 +20,14 @@ export declare function apiCreateVersion(opts: {
     stagingUrl: string;
     gitInfo: GitInfo;
 }): Promise<CreateVersionResult>;
+export interface WidgetLocationResult {
+    file: string | null;
+    insertAfter: string | null;
+    framework: string | null;
+    confidence: "high" | "low";
+}
+export declare function apiDetectWidgetLocation(opts: {
+    apiKey: string;
+    fileTree: string[];
+    fileContents: Record<string, string>;
+}): Promise<WidgetLocationResult>;

package/dist/lib/api.js

@@ -26,3 +26,20 @@ export async function apiCreateVersion(opts) {
     }
     return res.json();
 }
+export async function apiDetectWidgetLocation(opts) {
+    const res = await fetch(`${API_URL}/api/cli/detect-widget-location`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${opts.apiKey}`,
+        },
+        body: JSON.stringify({
+            fileTree: opts.fileTree,
+            fileContents: opts.fileContents,
+        }),
+    });
+    if (!res.ok) {
+        return { file: null, insertAfter: null, framework: null, confidence: "low" };
+    }
+    return res.json();
+}

package/dist/lib/config.d.ts

@@ -7,5 +7,15 @@ export declare function clearGlobalAuth(): void;
 export interface WorkspaceConfig {
     workspaceId: string;
 }
-export declare function readWorkspaceConfig(cwd: string): WorkspaceConfig | null;
-export declare function writeWorkspaceConfig(cwd: string, config: WorkspaceConfig): void;
+export declare function readWorkspaceConfig(): WorkspaceConfig | null;
+export declare function clearWorkspaceConfig(): void;
+export declare function writeWorkspaceConfig(config: WorkspaceConfig): void;
+export interface VercelConfig {
+    teamId: string;
+    teamName: string;
+    projectId: string;
+    projectName: string;
+}
+export declare function readVercelConfig(): VercelConfig | null;
+export declare function writeVercelConfig(config: VercelConfig): void;
+export declare function clearVercelConfig(): void;

package/dist/lib/config.js

@@ -30,35 +30,45 @@ export function clearGlobalAuth() {
         unlinkSync(AUTH_FILE);
     }
 }
-// --- 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))
+// --- Workspace config (global, persists across directories) ---
+const WORKSPACE_FILE = join(getGlobalConfigDir(), "workspace.json");
+export function readWorkspaceConfig() {
+    if (!existsSync(WORKSPACE_FILE))
         return null;
     try {
-        return JSON.parse(readFileSync(file, "utf-8"));
+        return JSON.parse(readFileSync(WORKSPACE_FILE, "utf-8"));
     }
     catch {
         return null;
     }
 }
-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);
+export function clearWorkspaceConfig() {
+    if (existsSync(WORKSPACE_FILE)) {
+        unlinkSync(WORKSPACE_FILE);
+    }
+}
+export function writeWorkspaceConfig(config) {
+    mkdirSync(getGlobalConfigDir(), { recursive: true });
+    writeFileSync(WORKSPACE_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
 }
-function addToGitignore(cwd) {
-    const gitignorePath = join(cwd, ".gitignore");
-    const entry = ".inflight";
+// --- Vercel config (global, persists across directories) ---
+const VERCEL_FILE = join(getGlobalConfigDir(), "vercel.json");
+export function readVercelConfig() {
+    if (!existsSync(VERCEL_FILE))
+        return null;
     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");
-        }
+        return JSON.parse(readFileSync(VERCEL_FILE, "utf-8"));
     }
     catch {
-        // non-fatal
+        return null;
+    }
+}
+export function writeVercelConfig(config) {
+    mkdirSync(getGlobalConfigDir(), { recursive: true });
+    writeFileSync(VERCEL_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+export function clearVercelConfig() {
+    if (existsSync(VERCEL_FILE)) {
+        unlinkSync(VERCEL_FILE);
     }
 }

package/dist/lib/framework.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Gathers a lightweight file tree and candidate file contents for AI detection.
+ * Scans cwd and common monorepo subdirectories.
+ */
+export declare function gatherProjectContext(cwd: string): {
+    fileTree: string[];
+    fileContents: Record<string, string>;
+};
+/**
+ * Returns true if any candidate file in the project already has the Inflight widget script.
+ */
+export declare function hasInflightWidget(cwd: string): boolean;
+/**
+ * Inserts the script tag into a file at the specified location.
+ * Returns the file path that was modified, or null if insertion failed.
+ */
+export declare function insertWidgetScript(cwd: string, file: string, insertAfter: string, widgetId: string): string | null;

package/dist/lib/framework.js

@@ -0,0 +1,154 @@
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync } from "fs";
+import { join, relative } from "path";
+/** File patterns that are likely layout/root files where a script tag belongs */
+const CANDIDATE_PATTERNS = [
+    "package.json",
+    "index.html",
+    "app/layout.tsx",
+    "app/layout.jsx",
+    "src/app/layout.tsx",
+    "src/app/layout.jsx",
+    "pages/_document.tsx",
+    "pages/_document.jsx",
+    "src/pages/_document.tsx",
+    "src/pages/_document.jsx",
+    "app/root.tsx",
+    "app/root.jsx",
+    "src/app.html",
+    "nuxt.config.ts",
+    "nuxt.config.js",
+    "src/layouts/Layout.astro",
+    "src/layouts/BaseLayout.astro",
+];
+/**
+ * Gathers a lightweight file tree and candidate file contents for AI detection.
+ * Scans cwd and common monorepo subdirectories.
+ */
+export function gatherProjectContext(cwd) {
+    const fileTree = [];
+    const fileContents = {};
+    const dirsToScan = [cwd];
+    // If monorepo, add common subdirectories
+    for (const dir of ["apps", "packages", "projects", "services", "libs"]) {
+        const baseDir = join(cwd, dir);
+        if (!existsSync(baseDir))
+            continue;
+        try {
+            for (const entry of readdirSync(baseDir)) {
+                const fullPath = join(baseDir, entry);
+                if (statSync(fullPath).isDirectory()) {
+                    dirsToScan.push(fullPath);
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    for (const dir of dirsToScan) {
+        // Add shallow file listing (1 level deep + key subdirs)
+        try {
+            for (const entry of readdirSync(dir)) {
+                fileTree.push(relative(cwd, join(dir, entry)));
+            }
+            // Also list key subdirectories
+            for (const sub of ["app", "src", "src/app", "src/layouts", "pages", "src/pages"]) {
+                const subDir = join(dir, sub);
+                if (!existsSync(subDir))
+                    continue;
+                for (const entry of readdirSync(subDir)) {
+                    fileTree.push(relative(cwd, join(subDir, entry)));
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+        // Read candidate files
+        for (const pattern of CANDIDATE_PATTERNS) {
+            const filePath = join(dir, pattern);
+            const relPath = relative(cwd, filePath);
+            if (existsSync(filePath) && !fileContents[relPath]) {
+                try {
+                    const content = readFileSync(filePath, "utf-8");
+                    // Truncate large files to save tokens
+                    fileContents[relPath] = content.length > 3000 ? content.slice(0, 3000) + "\n... (truncated)" : content;
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        // Also check for astro layouts dynamically
+        const layoutsDir = join(dir, "src", "layouts");
+        if (existsSync(layoutsDir)) {
+            try {
+                for (const f of readdirSync(layoutsDir).filter((f) => f.endsWith(".astro"))) {
+                    const filePath = join(layoutsDir, f);
+                    const relPath = relative(cwd, filePath);
+                    if (!fileContents[relPath]) {
+                        const content = readFileSync(filePath, "utf-8");
+                        fileContents[relPath] = content.length > 3000 ? content.slice(0, 3000) + "\n... (truncated)" : content;
+                    }
+                }
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+    return { fileTree, fileContents };
+}
+/**
+ * Returns true if any candidate file in the project already has the Inflight widget script.
+ */
+export function hasInflightWidget(cwd) {
+    const { fileContents } = gatherProjectContext(cwd);
+    return Object.values(fileContents).some((content) => content.includes("inflight.co/widget.js"));
+}
+/**
+ * Inserts the script tag into a file at the specified location.
+ * Returns the file path that was modified, or null if insertion failed.
+ */
+export function insertWidgetScript(cwd, file, insertAfter, widgetId) {
+    try {
+        const filePath = join(cwd, file);
+        const content = readFileSync(filePath, "utf-8");
+        if (content.includes("inflight.co/widget.js")) {
+            return file; // Already present
+        }
+        const isJsx = file.endsWith(".tsx") || file.endsWith(".jsx");
+        const tag = isJsx
+            ? `<script src="https://www.inflight.co/widget.js" data-workspace="${widgetId}" async />`
+            : `<script src="https://www.inflight.co/widget.js" data-workspace="${widgetId}" async></script>`;
+        let newContent;
+        if (insertAfter === "</body>") {
+            const lines = content.split("\n");
+            const bodyIdx = lines.findIndex((line) => line.includes("</body>"));
+            const bodyIndent = bodyIdx >= 0 ? (lines[bodyIdx].match(/^(\s*)/)?.[1] ?? "") : "";
+            // Use indentation of the nearest non-empty sibling line before </body>
+            let tagIndent = bodyIndent + "\t"; // fallback: one tab deeper than </body>
+            for (let i = bodyIdx - 1; i >= 0; i--) {
+                if (lines[i].trim()) {
+                    tagIndent = lines[i].match(/^(\s*)/)?.[1] ?? tagIndent;
+                    break;
+                }
+            }
+            newContent = content.replace("</body>", `${tagIndent}${tag}\n${bodyIndent}</body>`);
+        }
+        else {
+            const markerLine = content.split("\n").find((line) => line.includes(insertAfter));
+            const indent = markerLine?.match(/^(\s*)/)?.[1] ?? "";
+            const markerIndex = content.indexOf(insertAfter);
+            if (markerIndex === -1)
+                return null;
+            const insertPos = markerIndex + insertAfter.length;
+            newContent = content.slice(0, insertPos) + "\n" + indent + tag + content.slice(insertPos);
+        }
+        writeFileSync(filePath, newContent);
+        return file;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/skill.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Installs the Inflight skill for all detected AI agents using the skills CLI.
+ * Skips if already installed. Non-fatal — setup continues even if this fails.
+ */
+export declare function installSkill(): Promise<boolean>;

package/dist/lib/skill.js

@@ -0,0 +1,22 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const execAsync = promisify(exec);
+/**
+ * Installs the Inflight skill for all detected AI agents using the skills CLI.
+ * Skips if already installed. Non-fatal — setup continues even if this fails.
+ */
+export async function installSkill() {
+    if (existsSync(join(homedir(), ".claude", "skills", "inflight", "SKILL.md"))) {
+        return true;
+    }
+    try {
+        await execAsync("npx skills add inflightsoftware/skills -y -g");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/vercel.d.ts

@@ -1,9 +1,16 @@
-export declare function isVercelLoggedIn(): boolean;
-export declare function isVercelLinked(cwd: string): boolean;
-/** Opens browser-based Vercel login — suppresses CLI output, browser opens automatically. */
-export declare function vercelLogin(): boolean;
-/** Links the directory to a specific Vercel project silently. */
-export declare function vercelLink(cwd: string, projectId: string): Promise<boolean>;
+/** Ensures the Vercel CLI is available — installs globally if missing. */
+export declare function ensureVercelCli(log?: (msg: string) => void): Promise<boolean>;
+/**
+ * Gets a valid Vercel token. Refreshes silently via `vercel whoami` if expired.
+ * Does NOT prompt for login — returns null if no valid token available.
+ */
+export declare function getVercelToken(): string | null;
+/**
+ * Ensures a valid Vercel auth token is available.
+ * Checks existing token → refreshes if expired → opens browser login if needed.
+ * For interactive commands only.
+ */
+export declare function ensureVercelAuth(): Promise<string | null>;
 export interface VercelTeam {
     id: string;
     name: string;
@@ -13,8 +20,6 @@ export interface VercelProject {
     id: string;
     name: string;
 }
-export declare function getVercelTeams(): Promise<VercelTeam[]>;
-export declare function getVercelProjects(teamId: string): Promise<VercelProject[]>;
 export interface VercelDeployment {
     url: string;
     branch: string | null;
@@ -22,12 +27,17 @@ 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 the branch alias URL (stable, auto-updates with each push).
  * Returns null if no deployment exists for this branch.
  */
-export declare function getBranchAliasUrl(cwd: string, branch: string | null): Promise<string | null>;
+export declare function getBranchAliasUrl(token: string, teamId: string, projectId: string, branch: string | null): Promise<string | null>;
 /**
- * Fetches recent deployments for the project.
+ * Fetches recent deployments for a project.
  */
-export declare function getRecentDeployments(cwd: string, limit?: number): Promise<VercelDeployment[]>;
+export declare function getRecentDeployments(token: string, teamId: string, projectId: string, opts?: {
+    limit?: number;
+    branch?: string;
+}): Promise<VercelDeployment[]>;