inflight-cli 1.0.4 → 1.1.0

package/dist/lib/api.js

@@ -1,5 +1,6 @@
-export async function apiGetMe(apiKey, apiUrl) {
-    const res = await fetch(`${apiUrl}/api/cli/me`, {
+import { API_URL } from "./env.js";
+export async function apiGetMe(apiKey) {
+    const res = await fetch(`${API_URL}/api/cli/me`, {
         headers: { Authorization: `Bearer ${apiKey}` },
     });
     if (!res.ok)
@@ -7,7 +8,7 @@ export async function apiGetMe(apiKey, apiUrl) {
     return res.json();
 }
 export async function apiCreateVersion(opts) {
-    const res = await fetch(`${opts.apiUrl}/api/cli/version/create`, {
+    const res = await fetch(`${API_URL}/api/cli/version/create`, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",

package/dist/lib/config.d.ts

@@ -1,9 +1,9 @@
 export interface GlobalAuth {
     apiKey: string;
-    apiUrl: string;
 }
 export declare function readGlobalAuth(): GlobalAuth | null;
 export declare function writeGlobalAuth(auth: GlobalAuth): void;
+export declare function clearGlobalAuth(): void;
 export interface WorkspaceConfig {
     workspaceId: string;
 }

package/dist/lib/config.js

@@ -1,6 +1,6 @@
 import { homedir, platform } from "os";
 import { join } from "path";
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from "fs";
 function getGlobalConfigDir() {
     if (platform() === "darwin") {
         return join(homedir(), "Library", "Application Support", "co.inflight.cli");
@@ -11,13 +11,11 @@ function getGlobalConfigDir() {
     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 };
+        return JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
     }
     catch {
         return null;
@@ -27,6 +25,11 @@ export function writeGlobalAuth(auth) {
     mkdirSync(getGlobalConfigDir(), { recursive: true });
     writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2), { mode: 0o600 });
 }
+export function clearGlobalAuth() {
+    if (existsSync(AUTH_FILE)) {
+        unlinkSync(AUTH_FILE);
+    }
+}
 // --- Project-level config (per-directory, like .vercel/project.json) ---
 const WORKSPACE_FILE = ".inflight/workspace.json";
 export function readWorkspaceConfig(cwd) {

package/dist/lib/env.d.ts

@@ -0,0 +1,2 @@
+export declare const API_URL: string;
+export declare const WEB_URL: string;

package/dist/lib/env.js

@@ -0,0 +1,2 @@
+export const API_URL = process.env.INFLIGHT_API_URL ?? "https://api.inflight.co";
+export const WEB_URL = process.env.INFLIGHT_WEB_URL ?? "https://inflight.co";

package/dist/lib/files.d.ts

@@ -0,0 +1,29 @@
+/**
+ * File Utilities
+ *
+ * Handles file reading and chunking for uploading codebases to the share API.
+ * Properly handles binary files by encoding them as base64.
+ *
+ * Ported from inflight-claude-plugin/plugin/local-mcp/utils/file-utils.ts
+ */
+export interface FileContent {
+    content: string;
+    encoding: "utf-8" | "base64";
+}
+export interface FileMap {
+    [path: string]: string | FileContent;
+}
+export declare function readProjectFiles(rootDir: string): FileMap;
+export declare const MAX_CHUNK_SIZE: number;
+export declare const CHUNK_THRESHOLD: number;
+export declare function calculateTotalSize(files: FileMap): number;
+export declare function needsChunkedUpload(files: FileMap): boolean;
+export declare function chunkFiles(files: FileMap, maxChunkSize?: number): FileMap[];
+export declare function getChunkStats(chunks: FileMap[]): {
+    totalChunks: number;
+    chunkSizes: number[];
+    totalFiles: number;
+    totalSize: number;
+};
+export declare function getFileCount(files: FileMap): number;
+export declare function formatSize(bytes: number): string;

package/dist/lib/files.js

@@ -0,0 +1,187 @@
+/**
+ * File Utilities
+ *
+ * Handles file reading and chunking for uploading codebases to the share API.
+ * Properly handles binary files by encoding them as base64.
+ *
+ * Ported from inflight-claude-plugin/plugin/local-mcp/utils/file-utils.ts
+ */
+import * as fs from "fs";
+import * as path from "path";
+const BINARY_EXTENSIONS = [
+    // Images
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".svg", ".bmp", ".tiff", ".avif", ".heic", ".heif",
+    // Fonts
+    ".woff", ".woff2", ".ttf", ".eot", ".otf",
+    // Audio/Video
+    ".mp3", ".mp4", ".webm", ".ogg", ".wav", ".m4a", ".flac", ".avi", ".mov", ".mkv",
+    // Documents
+    ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx",
+    // Archives
+    ".zip", ".tar", ".gz", ".bz2", ".7z", ".rar",
+    // Other binary
+    ".exe", ".dll", ".so", ".dylib", ".bin", ".dat", ".db", ".sqlite", ".sqlite3", ".wasm", ".lockb",
+];
+function isBinaryFile(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return BINARY_EXTENSIONS.includes(ext);
+}
+function containsBinaryContent(buffer) {
+    const sampleSize = Math.min(buffer.length, 8192);
+    let nonPrintable = 0;
+    for (let i = 0; i < sampleSize; i++) {
+        const byte = buffer[i];
+        if (byte === 0)
+            return true;
+        if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) {
+            nonPrintable++;
+        }
+    }
+    return (nonPrintable / sampleSize) > 0.1;
+}
+const EXCLUDE_PATTERNS = [
+    // Version control
+    /^\.git$/,
+    /(^|\/)\.git\//,
+    // Dependencies
+    /(^|\/)node_modules\//,
+    // Build outputs
+    /(^|\/)\.next\//,
+    /(^|\/)dist\//,
+    /(^|\/)build\//,
+    /(^|\/)out\//,
+    /(^|\/)\.output\//,
+    /(^|\/)\.svelte-kit\//,
+    // Cache directories
+    /(^|\/)\.vercel\//,
+    /(^|\/)\.turbo\//,
+    /(^|\/)\.cache\//,
+    /(^|\/)\.parcel-cache\//,
+    /(^|\/)\.vite\//,
+    /(^|\/)\.nuxt\//,
+    /(^|\/)\.expo\//,
+    // Lock files
+    /package-lock\.json$/,
+    /yarn\.lock$/,
+    /pnpm-lock\.yaml$/,
+    /bun\.lockb$/,
+    // OS/editor files
+    /\.DS_Store$/,
+    /\.log$/,
+    /Thumbs\.db$/,
+    // Coverage
+    /(^|\/)coverage\//,
+    /(^|\/)\.nyc_output\//,
+];
+const ENV_PATTERNS = [/^\.env/, /\.env\./];
+function shouldExclude(filePath) {
+    if (EXCLUDE_PATTERNS.some(pattern => pattern.test(filePath)))
+        return true;
+    const fileName = filePath.split("/").pop() ?? "";
+    if (ENV_PATTERNS.some(pattern => pattern.test(fileName)))
+        return true;
+    return false;
+}
+export function readProjectFiles(rootDir) {
+    const files = {};
+    function walkDir(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry);
+            const relativePath = path.relative(rootDir, fullPath);
+            if (shouldExclude(relativePath))
+                continue;
+            let stat;
+            try {
+                stat = fs.statSync(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                walkDir(fullPath);
+            }
+            else if (stat.isFile()) {
+                try {
+                    const buffer = fs.readFileSync(fullPath);
+                    const isBinaryByExt = isBinaryFile(entry);
+                    const isBinaryByContent = !isBinaryByExt && containsBinaryContent(buffer);
+                    if (isBinaryByExt || isBinaryByContent) {
+                        files[relativePath] = { content: buffer.toString("base64"), encoding: "base64" };
+                    }
+                    else {
+                        files[relativePath] = buffer.toString("utf-8");
+                    }
+                }
+                catch {
+                    // Skip files that can't be read
+                }
+            }
+        }
+    }
+    walkDir(rootDir);
+    return files;
+}
+// Chunking configuration
+export const MAX_CHUNK_SIZE = 2 * 1024 * 1024; // 2MB per chunk
+export const CHUNK_THRESHOLD = 3 * 1024 * 1024; // 3MB triggers chunked mode
+function getFileSize(file) {
+    return typeof file === "string" ? file.length : file.content.length;
+}
+export function calculateTotalSize(files) {
+    return Object.values(files).reduce((sum, file) => sum + getFileSize(file), 0);
+}
+export function needsChunkedUpload(files) {
+    return calculateTotalSize(files) > CHUNK_THRESHOLD;
+}
+export function chunkFiles(files, maxChunkSize = MAX_CHUNK_SIZE) {
+    const chunks = [];
+    let currentChunk = {};
+    let currentSize = 0;
+    const entries = Object.entries(files).sort((a, b) => getFileSize(a[1]) - getFileSize(b[1]));
+    for (const [filePath, file] of entries) {
+        const fileSize = getFileSize(file);
+        if (fileSize > maxChunkSize) {
+            if (Object.keys(currentChunk).length > 0) {
+                chunks.push(currentChunk);
+                currentChunk = {};
+                currentSize = 0;
+            }
+            chunks.push({ [filePath]: file });
+            continue;
+        }
+        if (currentSize + fileSize > maxChunkSize && Object.keys(currentChunk).length > 0) {
+            chunks.push(currentChunk);
+            currentChunk = {};
+            currentSize = 0;
+        }
+        currentChunk[filePath] = file;
+        currentSize += fileSize;
+    }
+    if (Object.keys(currentChunk).length > 0) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
+export function getChunkStats(chunks) {
+    const chunkSizes = chunks.map((chunk) => calculateTotalSize(chunk));
+    const totalFiles = chunks.reduce((sum, chunk) => sum + Object.keys(chunk).length, 0);
+    const totalSize = chunkSizes.reduce((sum, size) => sum + size, 0);
+    return { totalChunks: chunks.length, chunkSizes, totalFiles, totalSize };
+}
+export function getFileCount(files) {
+    return Object.keys(files).length;
+}
+export function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/dist/lib/git.d.ts

@@ -7,5 +7,30 @@ export interface GitInfo {
     isDirty: boolean;
     diff: string | null;
 }
+export interface DiffScope {
+    mode: "branch" | "uncommitted" | "staged" | "commits" | "files";
+    commitCount?: number;
+    paths?: string[];
+}
+export interface GitDiffResult {
+    diff: string;
+    diffStat: string;
+    baseBranch: string;
+    currentBranch: string;
+}
+export declare function getDefaultBranch(cwd: string): string;
+export declare function getRemoteUrl(cwd: string): string | null;
+/**
+ * Get a structured diff result for the share API, supporting multiple scope modes.
+ */
+export declare function getGitDiffResult(cwd: string, scope?: DiffScope): GitDiffResult | null;
+/**
+ * Parse a --stat output into structured file change info.
+ */
+export declare function parseDiffStat(diffStat: string): Array<{
+    file: string;
+    insertions: number;
+    deletions: number;
+}>;
 export declare function getGitInfo(cwd: string): GitInfo;
 export declare function isGitRepo(cwd: string): boolean;

package/dist/lib/git.js

@@ -1,4 +1,4 @@
-import { execSync } from "child_process";
+import { execSync, execFileSync } from "child_process";
 function run(cmd, cwd) {
     try {
         return execSync(cmd, { cwd, stdio: ["pipe", "pipe", "pipe"] })
@@ -9,7 +9,15 @@ function run(cmd, cwd) {
         return null;
     }
 }
-// Files matching these patterns are stripped from the diff before sending to GPT.
+function runLarge(cmd, cwd) {
+    try {
+        return execSync(cmd, { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+// Files matching these patterns are stripped from the diff before sending.
 // They consume token budget without providing useful feedback signal.
 const EXCLUDED_FILE_PATTERNS = [
     /^(dist|build|\.next|out)\//,
@@ -30,33 +38,170 @@ function isExcludedFile(filePath) {
  * 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 true;
         return !isExcludedFile(match[1]);
     })
         .join("");
 }
+const MAX_DIFF_CHARS = 100_000;
+function capDiff(raw) {
+    const filtered = filterDiff(raw).slice(0, MAX_DIFF_CHARS);
+    return filtered.trim();
+}
 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);
+    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 capDiff(raw);
+}
+export function getDefaultBranch(cwd) {
+    // Check upstream default first
+    const remoteHead = run("git symbolic-ref refs/remotes/origin/HEAD", cwd);
+    if (remoteHead) {
+        const branch = remoteHead.replace("refs/remotes/origin/", "");
+        if (branch)
+            return branch;
+    }
+    try {
+        execSync("git show-ref --verify --quiet refs/heads/main", { cwd, stdio: "pipe" });
+        return "main";
+    }
+    catch {
+        try {
+            execSync("git show-ref --verify --quiet refs/heads/master", { cwd, stdio: "pipe" });
+            return "master";
+        }
+        catch {
+            return "main";
+        }
+    }
+}
+export function getRemoteUrl(cwd) {
+    return run("git remote get-url origin", cwd);
+}
+/**
+ * Get a structured diff result for the share API, supporting multiple scope modes.
+ */
+export function getGitDiffResult(cwd, scope) {
+    const currentBranch = run("git rev-parse --abbrev-ref HEAD", cwd);
+    if (!currentBranch)
+        return null;
+    const baseBranch = getDefaultBranch(cwd);
+    const mode = scope?.mode ?? "branch";
+    let diff = "";
+    let diffStat = "";
+    switch (mode) {
+        case "uncommitted": {
+            diff = runLarge("git diff HEAD", cwd) ?? "";
+            diffStat = run("git diff HEAD --stat", cwd) ?? "";
+            break;
+        }
+        case "staged": {
+            diff = runLarge("git diff --cached", cwd) ?? "";
+            diffStat = run("git diff --cached --stat", cwd) ?? "";
+            break;
+        }
+        case "commits": {
+            const count = scope?.commitCount ?? 1;
+            diff = runLarge(`git diff HEAD~${count}...HEAD`, cwd) ?? "";
+            diffStat = run(`git diff HEAD~${count}...HEAD --stat`, cwd) ?? "";
+            if (!diff) {
+                // Not enough history — diff from root commit
+                const rootCommit = run("git rev-list --max-parents=0 HEAD", cwd)?.split("\n")[0];
+                if (rootCommit) {
+                    diff = runLarge(`git diff ${rootCommit}...HEAD`, cwd) ?? "";
+                    diffStat = run(`git diff ${rootCommit}...HEAD --stat`, cwd) ?? "";
+                }
+            }
+            break;
+        }
+        case "files": {
+            const paths = scope?.paths ?? [];
+            if (paths.length > 0) {
+                const targets = [`${baseBranch}...HEAD`, `origin/${baseBranch}...HEAD`];
+                for (const target of targets) {
+                    try {
+                        diff = execFileSync("git", ["diff", target, "--", ...paths], {
+                            cwd,
+                            encoding: "utf-8",
+                            maxBuffer: 10 * 1024 * 1024,
+                        }).trim();
+                        diffStat = execFileSync("git", ["diff", target, "--stat", "--", ...paths], {
+                            cwd,
+                            encoding: "utf-8",
+                        }).trim();
+                    }
+                    catch {
+                        diff = "";
+                        diffStat = "";
+                    }
+                    if (diff)
+                        break;
+                }
+            }
+            break;
+        }
+        case "branch":
+        default: {
+            const targets = [`${baseBranch}...HEAD`, `origin/${baseBranch}...HEAD`, "HEAD"];
+            for (const target of targets) {
+                const cmd = target === "HEAD" ? "git diff HEAD" : `git diff ${target}`;
+                diff = runLarge(cmd, cwd) ?? "";
+                diffStat = run(`${cmd} --stat`, cwd) ?? "";
+                if (diff)
+                    break;
+            }
+            break;
+        }
+    }
+    if (!diff.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;
+    const filtered = capDiff(diff);
+    if (!filtered)
+        return null;
+    return { diff: filtered, diffStat, baseBranch, currentBranch };
+}
+/**
+ * Parse a --stat output into structured file change info.
+ */
+export function parseDiffStat(diffStat) {
+    const lines = diffStat.split("\n").filter((l) => l.includes("|"));
+    return lines
+        .map((line) => {
+        const match = line.match(/^\s*(.+?)\s*\|\s*(\d+)\s*([+-]*)/);
+        if (!match)
+            return null;
+        const file = match[1].trim();
+        const total = parseInt(match[2], 10);
+        const changes = match[3] ?? "";
+        const insertions = (changes.match(/\+/g) ?? []).length;
+        const deletions = (changes.match(/-/g) ?? []).length;
+        if (insertions === 0 && deletions === 0) {
+            return { file, insertions: total, deletions: 0 };
+        }
+        const ratio = total / (insertions + deletions);
+        return { file, insertions: Math.round(insertions * ratio), deletions: Math.round(deletions * ratio) };
+    })
+        .filter((entry) => entry !== null);
 }
+const EMPTY_GIT_INFO = {
+    branch: null,
+    commitShort: null,
+    commitFull: null,
+    commitMessage: null,
+    remoteUrl: null,
+    isDirty: false,
+    diff: null,
+};
 export function getGitInfo(cwd) {
+    if (!isGitRepo(cwd))
+        return EMPTY_GIT_INFO;
     return {
         branch: run("git rev-parse --abbrev-ref HEAD", cwd),
         commitShort: run("git rev-parse --short HEAD", cwd),

package/dist/lib/progress.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Maps raw technical progress messages from the share API to user-friendly equivalents.
+ *
+ * Phases:
+ * 0-12%   - Local preparation (git, files, auth)
+ * 12-42%  - Upload (standard or chunked)
+ * 42-70%  - Claude analysis (server-side)
+ * 70-90%  - Prototype deploy (install, start server, tunnel)
+ * 90-100% - InFlight version creation & finalization
+ *
+ * Ported from inflight-claude-plugin/plugin/local-mcp/utils/progress-messages.ts
+ */
+/**
+ * Create a progress message handler with built-in deduplication.
+ * Returns a function that converts raw progress to friendly messages,
+ * returning null for consecutive duplicates.
+ */
+export declare function createProgressHandler(): (percentage: number, rawMessage: string) => string | null;

package/dist/lib/progress.js

@@ -0,0 +1,106 @@
+/**
+ * Maps raw technical progress messages from the share API to user-friendly equivalents.
+ *
+ * Phases:
+ * 0-12%   - Local preparation (git, files, auth)
+ * 12-42%  - Upload (standard or chunked)
+ * 42-70%  - Claude analysis (server-side)
+ * 70-90%  - Prototype deploy (install, start server, tunnel)
+ * 90-100% - InFlight version creation & finalization
+ *
+ * Ported from inflight-claude-plugin/plugin/local-mcp/utils/progress-messages.ts
+ */
+const CONTENT_MATCHERS = [
+    // Local prep phase
+    { pattern: /Starting share for/i, message: "Preparing your project..." },
+    { pattern: /Checking Share API/i, message: "Preparing your project..." },
+    { pattern: /Share API is healthy/i, message: "Preparing your project..." },
+    { pattern: /Getting git info/i, message: "Loading your code..." },
+    { pattern: /Reading project files|Reading all project/i, message: "Loading your code..." },
+    { pattern: /Analyzing dependencies/i, message: "Loading your code..." },
+    { pattern: /Reading.*analyzed files/i, message: "Loading your code..." },
+    { pattern: /Authenticating with InFlight/i, message: "Loading your code..." },
+    { pattern: /Starting share on server/i, message: "Uploading your project..." },
+    // Chunked upload phase
+    { pattern: /Large project.*chunked/i, message: "Uploading your project..." },
+    { pattern: /Splitting into.*chunks/i, message: "Uploading your project..." },
+    { pattern: /Initializing chunked/i, message: "Uploading your project..." },
+    { pattern: /Uploading chunk/i, message: "Uploading your project..." },
+    { pattern: /Finalizing upload/i, message: "Upload complete, starting analysis..." },
+    // Server sandbox & upload phase
+    { pattern: /Validating workspace/i, message: "Setting things up..." },
+    { pattern: /Creating sandbox/i, message: "Setting things up..." },
+    { pattern: /Uploading.*files/i, message: "Uploading your project..." },
+    { pattern: /Writing git diff/i, message: "Preparing your changes for review..." },
+    { pattern: /Preparing analysis/i, message: "Getting ready to analyze..." },
+    // Claude installation & analysis phase
+    { pattern: /Checking Claude|Installing Claude/i, message: "Getting ready to analyze..." },
+    { pattern: /Setting up.*user|non-root/i, message: "Getting ready to analyze..." },
+    { pattern: /Starting Claude/i, message: "Running a detailed analysis of your changes..." },
+    { pattern: /Claude is analyzing/i, message: "Analyzing your changes..." },
+    { pattern: /Claude is working/i, message: "Still analyzing..." },
+    { pattern: /^Claude:/i, message: "Analyzing your changes..." },
+    { pattern: /Analyzing\.\.\. \(\d+s\)/i, message: "Still analyzing..." },
+    { pattern: /Claude finished/i, message: "Analysis complete! Building your preview..." },
+    // Prototype found
+    { pattern: /Prototype ready|Prototype found/i, message: "Analysis complete! Building your preview..." },
+    // Deploy phase
+    { pattern: /Configuring preview/i, message: "Building your preview..." },
+    { pattern: /Installing dependencies/i, message: "Installing dependencies..." },
+    { pattern: /Starting dev server/i, message: "Starting your preview..." },
+    { pattern: /Waiting for server/i, message: "Starting your preview..." },
+    { pattern: /Setting up preview tunnel/i, message: "Setting up your preview link..." },
+    { pattern: /Preview tunnel ready/i, message: "Preview link is ready!" },
+    { pattern: /Waiting for Vite/i, message: "Almost there..." },
+    { pattern: /Preview ready/i, message: "Preview is live!" },
+    { pattern: /Preview may still be compiling/i, message: "Almost there..." },
+    // Finalization
+    { pattern: /Creating InFlight version/i, message: "Creating your InFlight version..." },
+    { pattern: /Tracking sandbox/i, message: "Saving your share..." },
+    { pattern: /Generating diff summary/i, message: "Summarizing your changes..." },
+    { pattern: /Generating review/i, message: "Preparing feedback questions..." },
+    { pattern: /^Complete!$/i, message: "All done!" },
+    { pattern: /Share complete/i, message: "All done!" },
+];
+const PHASE_MESSAGES = [
+    { maxPct: 5, message: "Preparing your project..." },
+    { maxPct: 12, message: "Loading your code..." },
+    { maxPct: 42, message: "Uploading your project..." },
+    { maxPct: 50, message: "Setting things up..." },
+    { maxPct: 55, message: "Getting ready to analyze..." },
+    { maxPct: 70, message: "Analyzing your changes..." },
+    { maxPct: 80, message: "Building your preview..." },
+    { maxPct: 90, message: "Setting up your preview link..." },
+    { maxPct: 96, message: "Creating your InFlight version..." },
+    { maxPct: 100, message: "Wrapping up..." },
+];
+/**
+ * Create a progress message handler with built-in deduplication.
+ * Returns a function that converts raw progress to friendly messages,
+ * returning null for consecutive duplicates.
+ */
+export function createProgressHandler() {
+    let lastFriendlyMessage = "";
+    return (percentage, rawMessage) => {
+        let friendly;
+        for (const matcher of CONTENT_MATCHERS) {
+            if (matcher.pattern.test(rawMessage)) {
+                friendly = matcher.message;
+                break;
+            }
+        }
+        if (!friendly) {
+            for (const phase of PHASE_MESSAGES) {
+                if (percentage <= phase.maxPct) {
+                    friendly = phase.message;
+                    break;
+                }
+            }
+        }
+        friendly = friendly ?? "Working on it...";
+        if (friendly === lastFriendlyMessage)
+            return null;
+        lastFriendlyMessage = friendly;
+        return friendly;
+    };
+}