ship-em 0.1.0

package/dist/index.js

@@ -0,0 +1,2427 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/deploy.ts
+import inquirer from "inquirer";
+import chalk4 from "chalk";
+import axios2 from "axios";
+import FormData2 from "form-data";
+import { createReadStream } from "fs";
+import { rmSync, existsSync as existsSync5, appendFileSync, writeFileSync as writeFileSync2, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
+import { join as join6 } from "path";
+import { tmpdir } from "os";
+import { create as tarCreate } from "tar";
+
+// src/ui/terminal.ts
+import chalk from "chalk";
+import ora from "ora";
+var brand = {
+  blue: chalk.hex("#3B82F6"),
+  brightBlue: chalk.hex("#60A5FA"),
+  green: chalk.hex("#22C55E"),
+  yellow: chalk.hex("#EAB308"),
+  red: chalk.hex("#EF4444"),
+  gray: chalk.hex("#6B7280"),
+  white: chalk.white,
+  bold: chalk.bold,
+  dim: chalk.dim
+};
+function visibleLen(str) {
+  return str.replace(/\x1B\[[0-9;]*[mGKHFJsu]/g, "").length;
+}
+function timeAgo(isoStr) {
+  const diff = Date.now() - new Date(isoStr).getTime();
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins === 1) return "1 minute ago";
+  if (mins < 60) return `${mins} minutes ago`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs === 1) return "1 hour ago";
+  if (hrs < 24) return `${hrs} hours ago`;
+  const days = Math.floor(hrs / 24);
+  return days === 1 ? "yesterday" : `${days} days ago`;
+}
+var ui = {
+  // Banner shown at startup
+  banner() {
+    console.log("");
+    console.log(
+      brand.blue.bold("  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557")
+    );
+    console.log(
+      brand.blue.bold("  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551")
+    );
+    console.log(
+      brand.brightBlue.bold("  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551")
+    );
+    console.log(
+      brand.brightBlue.bold("  \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551")
+    );
+    console.log(
+      brand.blue.bold("  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551")
+    );
+    console.log(
+      brand.blue.bold("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u255D")
+    );
+    console.log("");
+    console.log(
+      `  ${brand.gray("Your AI built it.")} ${brand.blue.bold("We'll ship it.")}`
+    );
+    console.log("");
+  },
+  // Section header
+  section(title) {
+    console.log(`${brand.blue("\u203A")} ${brand.bold(title)}`);
+  },
+  // Success item
+  success(message) {
+    console.log(`  ${brand.green("\u2713")} ${message}`);
+  },
+  // Info item
+  info(message) {
+    console.log(`  ${brand.blue("\xB7")} ${message}`);
+  },
+  // Warning
+  warn(message) {
+    console.log(`  ${brand.yellow("\u26A0")} ${brand.yellow(message)}`);
+  },
+  // Error
+  error(message) {
+    console.log(`  ${brand.red("\u2717")} ${brand.red(message)}`);
+  },
+  // Dim/secondary text
+  dim(message) {
+    console.log(`    ${brand.dim(message)}`);
+  },
+  // Blank line
+  br() {
+    console.log("");
+  },
+  // Key-value display
+  kv(key, value) {
+    console.log(`  ${brand.gray(key + ":")} ${value}`);
+  },
+  // Highlighted URL
+  url(label, url) {
+    console.log(`  ${brand.green("\u2192")} ${brand.bold(label)}: ${brand.brightBlue.underline(url)}`);
+  },
+  // Box for important info
+  box(lines) {
+    const maxLen = Math.max(...lines.map((l) => l.length));
+    const border = brand.blue("\u2500".repeat(maxLen + 4));
+    console.log(`  \u256D${border}\u256E`);
+    for (const line of lines) {
+      const padding = " ".repeat(maxLen - line.length);
+      console.log(`  \u2502  ${line}${padding}  \u2502`);
+    }
+    console.log(`  \u2570${border}\u256F`);
+  },
+  // Spinner
+  spinner(text) {
+    return ora({
+      text,
+      spinner: "dots",
+      color: "blue",
+      prefixText: "  "
+    }).start();
+  },
+  // Fatal error with exit
+  fatal(message, hint) {
+    console.log("");
+    console.log(`  ${brand.red.bold("Error:")} ${message}`);
+    if (hint) {
+      console.log(`  ${brand.gray("Hint:")} ${hint}`);
+    }
+    console.log("");
+    process.exit(1);
+  },
+  // Structured friendly error: what happened, why, and exactly what to do
+  friendlyError(title, why, fix, extra) {
+    console.log("");
+    console.log(`  ${brand.red("\u2717")} ${brand.red.bold(title)}`);
+    console.log("");
+    console.log(`    ${brand.dim("Why:")} ${brand.dim(why)}`);
+    console.log(`    ${chalk.bold("Fix:")} ${fix}`);
+    if (extra) {
+      console.log("");
+      console.log(`    ${brand.dim(extra)}`);
+    }
+    console.log("");
+  },
+  // Project analysis card — shown after detection
+  projectAnalysis(info) {
+    const buildLabel = info.buildCommand ? `${info.buildCommand} \u2192 ${info.outputDir}` : `No build step \u2192 ${info.outputDir}`;
+    const envLabel = info.envVarCount > 0 ? `${info.envVarCount} environment variable${info.envVarCount !== 1 ? "s" : ""} found` : "No environment variables";
+    const rows = [
+      [`\u{1F4E6} ${info.name}`, `\u{1F4E6} ${brand.bold(info.name)}`],
+      [`\u26A1 ${info.framework}`, `\u26A1 ${ui.framework(info.framework)}`],
+      [`\u{1F4C1} ${info.fileCount} source files`, `\u{1F4C1} ${chalk.cyan(String(info.fileCount))} source files`],
+      [
+        `\u{1F527} ${buildLabel}`,
+        info.buildCommand ? `\u{1F527} ${chalk.cyan(info.buildCommand)} \u2192 ${chalk.cyan(info.outputDir)}` : `\u{1F527} ${brand.dim("No build step")} \u2192 ${chalk.cyan(info.outputDir)}`
+      ],
+      [`\u{1F30D} Deploy target: ${info.deployTarget}`, `\u{1F30D} Deploy target: ${chalk.cyan(info.deployTarget)}`],
+      [
+        `\u{1F511} ${envLabel}`,
+        info.envVarCount > 0 ? `\u{1F511} ${chalk.cyan(envLabel)}` : `\u{1F511} ${brand.dim(envLabel)}`
+      ]
+    ];
+    const title = " Project Analysis ";
+    const maxPlain = Math.max(...rows.map(([p]) => visibleLen(p)));
+    const innerWidth = Math.max(maxPlain + 4, title.length + 2);
+    const topBorder = title + "\u2500".repeat(innerWidth - title.length);
+    const bottomBorder = "\u2500".repeat(innerWidth);
+    console.log("");
+    console.log(`  ${brand.blue("\u250C" + topBorder + "\u2510")}`);
+    console.log(`  ${brand.blue("\u2502")}${" ".repeat(innerWidth)}${brand.blue("\u2502")}`);
+    for (const [plain, colored] of rows) {
+      const rightPad = innerWidth - 2 - visibleLen(plain);
+      console.log(
+        `  ${brand.blue("\u2502")}  ${colored}${" ".repeat(Math.max(0, rightPad))}${brand.blue("\u2502")}`
+      );
+    }
+    console.log(`  ${brand.blue("\u2502")}${" ".repeat(innerWidth)}${brand.blue("\u2502")}`);
+    console.log(`  ${brand.blue("\u2514" + bottomBorder + "\u2518")}`);
+    console.log("");
+  },
+  // Compact header for re-deploys — skips the banner
+  redeployHeader(projectName, lastUrl, lastDeployedAt) {
+    const ago = timeAgo(lastDeployedAt);
+    console.log("");
+    console.log(`  \u{1F504} ${brand.bold("Re-deploying")} ${brand.blue.bold(projectName)}`);
+    console.log("");
+    console.log(
+      `  ${brand.dim("Last deploy:")} ${brand.dim(ago)} ${brand.dim("\u2192")} ${brand.brightBlue.underline(lastUrl)}`
+    );
+    console.log("");
+  },
+  // Deploy celebration box — shown on success
+  deployBox(appName, url, elapsedSec, fileCount, totalBytes) {
+    const statsLine = `Deployed in ${elapsedSec.toFixed(1)}s \xB7 ${fileCount} files \xB7 ${ui.formatBytes(totalBytes)}`;
+    const content = [
+      ["\u{1F680} Shipped!", brand.green.bold("\u{1F680} Shipped!")],
+      null,
+      [`${appName} is live`, `${brand.white.bold(appName)} is live`],
+      null,
+      [`\u2192 ${url}`, `${brand.blue("\u2192")} ${brand.brightBlue.underline(url)}`],
+      null,
+      [statsLine, brand.dim(statsLine)]
+    ];
+    const maxPlain = Math.max(
+      ...content.filter((item) => item !== null).map(([p]) => visibleLen(p))
+    );
+    const innerWidth = maxPlain + 6;
+    console.log("");
+    console.log(`  ${brand.blue("\u256D" + "\u2500".repeat(innerWidth) + "\u256E")}`);
+    console.log(`  ${brand.blue("\u2502")}${" ".repeat(innerWidth)}${brand.blue("\u2502")}`);
+    for (const item of content) {
+      if (!item) {
+        console.log(`  ${brand.blue("\u2502")}${" ".repeat(innerWidth)}${brand.blue("\u2502")}`);
+      } else {
+        const [plain, colored] = item;
+        const rightPad = innerWidth - 3 - visibleLen(plain);
+        console.log(
+          `  ${brand.blue("\u2502")}   ${colored}${" ".repeat(Math.max(0, rightPad))}${brand.blue("\u2502")}`
+        );
+      }
+    }
+    console.log(`  ${brand.blue("\u2502")}${" ".repeat(innerWidth)}${brand.blue("\u2502")}`);
+    console.log(`  ${brand.blue("\u2570" + "\u2500".repeat(innerWidth) + "\u256F")}`);
+    console.log("");
+    console.log(`  ${brand.bold("Next steps:")}`);
+    console.log(`    ${brand.gray("Update")}   \u2192 ${chalk.cyan("npx shipem")}`);
+    console.log(`    ${brand.gray("Status")}   \u2192 ${chalk.cyan("npx shipem status")}`);
+    console.log(`    ${brand.gray("Remove")}   \u2192 ${chalk.cyan("npx shipem down")}`);
+    console.log("");
+    console.log(`  ${brand.dim("Tip: Share your app! Just send the URL.")}`);
+    console.log("");
+  },
+  // Format bytes
+  formatBytes(bytes) {
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  },
+  // Colorize framework name
+  framework(name) {
+    const colors = {
+      nextjs: "#ffffff",
+      "vite-react": "#61DAFB",
+      "vite-vue": "#42B883",
+      "vite-svelte": "#FF3E00",
+      astro: "#FF5D01",
+      sveltekit: "#FF3E00",
+      remix: "#818cf8",
+      nuxt: "#00DC82",
+      gatsby: "#663399",
+      flask: "#22c55e",
+      fastapi: "#009688",
+      django: "#22c55e",
+      express: "#fbbf24",
+      hono: "#E36002"
+    };
+    const color = colors[name] ?? "#3B82F6";
+    return chalk.hex(color).bold(name);
+  }
+};
+
+// src/detect/scanner.ts
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+function readJson(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readFile(filePath) {
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function listTopLevelFiles(cwd) {
+  try {
+    return readdirSync(cwd).filter((f) => {
+      try {
+        return statSync(join(cwd, f)).isFile();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function listTopLevelDirs(cwd) {
+  try {
+    return readdirSync(cwd).filter((f) => {
+      try {
+        return statSync(join(cwd, f)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function detectEnvVarsFromFiles(cwd) {
+  const envVars = [];
+  const seen = /* @__PURE__ */ new Set();
+  const envExampleFiles = [".env.example", ".env.local.example", ".env.sample", ".env.template"];
+  for (const file of envExampleFiles) {
+    const content = readFile(join(cwd, file));
+    if (content) {
+      for (const line of content.split("\n")) {
+        const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+        if (match && !seen.has(match[1])) {
+          seen.add(match[1]);
+          envVars.push({
+            name: match[1],
+            description: line.includes("#") ? line.split("#")[1].trim() : "",
+            required: true
+          });
+        }
+      }
+    }
+  }
+  const envContent = readFile(join(cwd, ".env"));
+  if (envContent) {
+    for (const line of envContent.split("\n")) {
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)=/);
+      if (match && !seen.has(match[1])) {
+        seen.add(match[1]);
+        envVars.push({
+          name: match[1],
+          description: "",
+          required: true
+        });
+      }
+    }
+  }
+  return envVars;
+}
+function getNodeVersion(pkg, cwd) {
+  const nvmrc = readFile(join(cwd, ".nvmrc"));
+  if (nvmrc) return nvmrc.trim().replace("v", "");
+  const nodeVersion = readFile(join(cwd, ".node-version"));
+  if (nodeVersion) return nodeVersion.trim().replace("v", "");
+  if (pkg.engines?.node) {
+    const match = pkg.engines.node.match(/(\d+)/);
+    if (match) return match[1];
+  }
+  return "20";
+}
+function scanProject(cwd = process.cwd()) {
+  const files = listTopLevelFiles(cwd);
+  const dirs = listTopLevelDirs(cwd);
+  const allEntries = [...files, ...dirs];
+  const hasFile = (name) => files.includes(name);
+  const hasDir = (name) => dirs.includes(name);
+  if (hasFile("package.json")) {
+    const pkg = readJson(join(cwd, "package.json"));
+    if (!pkg) {
+      return buildUnknown(cwd, files);
+    }
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const projectName = pkg.name ?? cwd.split("/").pop() ?? "my-app";
+    const nodeVersion = getNodeVersion(pkg, cwd);
+    const envVars = detectEnvVarsFromFiles(cwd);
+    if (deps["next"]) {
+      const isAppRouter = hasDir("app") || existsSync(join(cwd, "src/app"));
+      const hasServerComponents = isAppRouter;
+      const hasApiRoutes = hasDir("pages") || existsSync(join(cwd, "pages/api")) || existsSync(join(cwd, "src/pages/api")) || existsSync(join(cwd, "app/api")) || existsSync(join(cwd, "src/app/api"));
+      const serverType = hasServerComponents || hasApiRoutes ? "serverless" : "static";
+      const commonNextEnvVars = [];
+      if (deps["@supabase/supabase-js"] || deps["@supabase/auth-helpers-nextjs"]) {
+        commonNextEnvVars.push(
+          { name: "NEXT_PUBLIC_SUPABASE_URL", description: "Supabase project URL", required: true, autoProvision: true },
+          { name: "NEXT_PUBLIC_SUPABASE_ANON_KEY", description: "Supabase anon key", required: true, autoProvision: true }
+        );
+      }
+      if (deps["openai"]) {
+        commonNextEnvVars.push({ name: "OPENAI_API_KEY", description: "OpenAI API key", required: true });
+      }
+      if (deps["@anthropic-ai/sdk"] || deps["@anthropic-ai/claude"]) {
+        commonNextEnvVars.push({ name: "ANTHROPIC_API_KEY", description: "Anthropic API key", required: true });
+      }
+      if (deps["stripe"]) {
+        commonNextEnvVars.push(
+          { name: "STRIPE_SECRET_KEY", description: "Stripe secret key", required: true },
+          { name: "NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY", description: "Stripe publishable key", required: true }
+        );
+      }
+      const mergedEnvVars = mergeEnvVars(envVars, commonNextEnvVars);
+      return {
+        framework: "nextjs",
+        buildCommand: pkg.scripts?.build ?? "npm run build",
+        outputDirectory: ".next",
+        installCommand: detectPackageManager(cwd),
+        serverType,
+        deployTarget: "cloudflare-pages",
+        nodeVersion,
+        envVars: mergedEnvVars,
+        projectName,
+        confidence: 0.98,
+        files: allEntries
+      };
+    }
+    if (deps["astro"]) {
+      return {
+        framework: "astro",
+        buildCommand: pkg.scripts?.build ?? "npm run build",
+        outputDirectory: "dist",
+        installCommand: detectPackageManager(cwd),
+        serverType: "static",
+        deployTarget: "cloudflare-pages",
+        nodeVersion,
+        envVars,
+        projectName,
+        confidence: 0.97,
+        files: allEntries
+      };
+    }
+    if (deps["@sveltejs/kit"]) {
+      return {
+        framework: "sveltekit",
+        buildCommand: pkg.scripts?.build ?? "npm run build",
+        outputDirectory: ".svelte-kit",
+        installCommand: detectPackageManager(cwd),
+        serverType: "serverless",
+        deployTarget: "cloudflare-pages",
+        nodeVersion,
+        envVars,
+        projectName,
+        confidence: 0.97,
+        files: allEntries
+      };
+    }
+    if (deps["nuxt"] || deps["nuxt3"]) {
+      return {
+        framework: "nuxt",
+        buildCommand: pkg.scripts?.build ?? "npm run build",
+        outputDirectory: ".output",
+        installCommand: detectPackageManager(cwd),
+        serverType: "serverless",
+        deployTarget: "cloudflare-pages",
+        nodeVersion,
+        envVars,
+        projectName,
+        confidence: 0.97,
+        files: allEntries
+      };
+    }
+    if (deps["@remix-run/node"] || deps["@remix-run/react"]) {
+      return {
+        framework: "remix",
+        buildCommand: pkg.scripts?.build ?? "npm run build",
+        outputDirectory: "build",
+        installCommand: detectPackageManager(cwd),
+        serverType: "serverless",
+        deployTarget: "cloudflare-pages",
+        nodeVersion,
+        envVars,
+        projectName,
+        confidence: 0.97,
+        files: allEntries
+      };
+    }
+    if (deps["gatsby"]) {
+      return {
+        framework: "gatsby",
+        buildCommand: pkg.scripts?.build ?? "npm run build",
+        outputDirectory: "public",
+        installCommand: detectPackageManager(cwd),
+        serverType: "static",
+        deployTarget: "cloudflare-pages",
+        nodeVersion,
+        envVars,
+        projectName,
+        confidence: 0.97,
+        files: allEntries
+      };
+    }
+    if (deps["vite"]) {
+      let framework = "vite-react";
+      if (deps["vue"] || deps["@vue/core"]) framework = "vite-vue";
+      else if (deps["svelte"]) framework = "vite-svelte";
+      return {
+        framework,
+        buildCommand: pkg.scripts?.build ?? "npm run build",
+        outputDirectory: "dist",
+        installCommand: detectPackageManager(cwd),
+        serverType: "static",
+        deployTarget: "cloudflare-pages",
+        nodeVersion,
+        envVars,
+        projectName,
+        confidence: 0.95,
+        files: allEntries
+      };
+    }
+    if (deps["react-scripts"]) {
+      return {
+        framework: "create-react-app",
+        buildCommand: pkg.scripts?.build ?? "npm run build",
+        outputDirectory: "build",
+        installCommand: detectPackageManager(cwd),
+        serverType: "static",
+        deployTarget: "cloudflare-pages",
+        nodeVersion,
+        envVars,
+        projectName,
+        confidence: 0.95,
+        files: allEntries
+      };
+    }
+    if (deps["hono"]) {
+      return {
+        framework: "hono",
+        buildCommand: pkg.scripts?.build ?? "npm run build",
+        outputDirectory: "dist",
+        installCommand: detectPackageManager(cwd),
+        serverType: "serverless",
+        deployTarget: "cloudflare-workers",
+        nodeVersion,
+        envVars,
+        projectName,
+        confidence: 0.9,
+        files: allEntries
+      };
+    }
+    if (deps["express"]) {
+      return {
+        framework: "express",
+        buildCommand: pkg.scripts?.build ?? "npm run build",
+        outputDirectory: "dist",
+        installCommand: detectPackageManager(cwd),
+        serverType: "server",
+        deployTarget: "flyio",
+        nodeVersion,
+        envVars,
+        projectName,
+        confidence: 0.88,
+        files: allEntries
+      };
+    }
+    if (pkg.scripts?.build) {
+      return {
+        framework: "unknown",
+        buildCommand: pkg.scripts.build,
+        outputDirectory: "dist",
+        installCommand: detectPackageManager(cwd),
+        serverType: "server",
+        deployTarget: "cloudflare-pages",
+        nodeVersion,
+        envVars,
+        projectName,
+        confidence: 0.6,
+        files: allEntries
+      };
+    }
+  }
+  if (hasFile("requirements.txt") || hasFile("pyproject.toml") || hasFile("Pipfile")) {
+    const projectName = cwd.split("/").pop() ?? "my-app";
+    const envVars = detectEnvVarsFromFiles(cwd);
+    let framework = "unknown";
+    let buildCommand = "pip install -r requirements.txt";
+    const requirements = readFile(join(cwd, "requirements.txt")) ?? "";
+    const pyproject = readFile(join(cwd, "pyproject.toml")) ?? "";
+    const combined = requirements + pyproject;
+    if (combined.includes("fastapi")) {
+      framework = "fastapi";
+      buildCommand = "pip install -r requirements.txt";
+    } else if (combined.includes("flask")) {
+      framework = "flask";
+      buildCommand = "pip install -r requirements.txt";
+    } else if (combined.includes("django")) {
+      framework = "django";
+      buildCommand = "pip install -r requirements.txt && python manage.py collectstatic --noinput";
+    }
+    return {
+      framework,
+      buildCommand,
+      outputDirectory: ".",
+      installCommand: "pip install -r requirements.txt",
+      serverType: "server",
+      deployTarget: "flyio",
+      pythonVersion: detectPythonVersion(cwd),
+      envVars,
+      projectName,
+      confidence: 0.85,
+      files: allEntries
+    };
+  }
+  if (hasFile("index.html")) {
+    const projectName = cwd.split("/").pop() ?? "my-app";
+    return {
+      framework: "static-html",
+      buildCommand: "",
+      outputDirectory: ".",
+      installCommand: "",
+      serverType: "static",
+      deployTarget: "cloudflare-pages",
+      envVars: [],
+      projectName,
+      confidence: 0.9,
+      files: allEntries
+    };
+  }
+  return buildUnknown(cwd, files);
+}
+function buildUnknown(cwd, files) {
+  return {
+    framework: "unknown",
+    buildCommand: "",
+    outputDirectory: ".",
+    installCommand: "",
+    serverType: "static",
+    deployTarget: "cloudflare-pages",
+    envVars: [],
+    projectName: cwd.split("/").pop() ?? "my-app",
+    confidence: 0,
+    files
+  };
+}
+function detectPackageManager(cwd) {
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn install";
+  if (existsSync(join(cwd, "bun.lockb"))) return "bun install";
+  return "npm install";
+}
+function detectPythonVersion(cwd) {
+  const pythonVersion = readFile(join(cwd, ".python-version"));
+  if (pythonVersion) return pythonVersion.trim();
+  const pyproject = readFile(join(cwd, "pyproject.toml"));
+  if (pyproject) {
+    const match = pyproject.match(/python\s*=\s*["']([^"']+)["']/);
+    if (match) return match[1].replace(/[^0-9.]/g, "");
+  }
+  return "3.11";
+}
+function mergeEnvVars(base, extra) {
+  const seen = new Set(base.map((v) => v.name));
+  const merged = [...base];
+  for (const v of extra) {
+    if (!seen.has(v.name)) {
+      seen.add(v.name);
+      merged.push(v);
+    }
+  }
+  return merged;
+}
+function collectFileSamples(cwd, maxFiles = 20) {
+  const samples = {};
+  const importantFiles = [
+    "package.json",
+    "tsconfig.json",
+    "vite.config.ts",
+    "vite.config.js",
+    "next.config.js",
+    "next.config.ts",
+    "astro.config.mjs",
+    "svelte.config.js",
+    "nuxt.config.ts",
+    "remix.config.js",
+    "requirements.txt",
+    "pyproject.toml",
+    "Pipfile",
+    "Dockerfile",
+    "docker-compose.yml",
+    ".env.example",
+    ".env.local.example",
+    "wrangler.toml",
+    "fly.toml"
+  ];
+  for (const file of importantFiles) {
+    const content = readFile(join(cwd, file));
+    if (content) {
+      samples[file] = content.slice(0, 2e3);
+      if (Object.keys(samples).length >= maxFiles) break;
+    }
+  }
+  const topLevel = readdirSync(cwd).slice(0, 30);
+  samples["[directory listing]"] = topLevel.join("\n");
+  return samples;
+}
+
+// src/detect/ai-detect.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { z } from "zod";
+
+// src/config.ts
+import Conf from "conf";
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var SHIPEM_API_URL = process.env.SHIPEM_API_URL ?? "https://api.shipem.dev";
+var globalConf = new Conf({
+  projectName: "shipem",
+  schema: {
+    cloudflare: {
+      type: "object",
+      properties: {
+        apiToken: { type: "string" },
+        accountId: { type: "string" }
+      }
+    },
+    anthropicApiKey: { type: "string" },
+    sessionToken: { type: "string" }
+  }
+});
+function getCloudflareCredentials() {
+  const creds = globalConf.get("cloudflare");
+  const token = process.env.CLOUDFLARE_API_TOKEN ?? creds?.apiToken;
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID ?? creds?.accountId;
+  if (token && accountId) {
+    return { apiToken: token, accountId };
+  }
+  return null;
+}
+function getAnthropicApiKey() {
+  return process.env.ANTHROPIC_API_KEY ?? globalConf.get("anthropicApiKey") ?? null;
+}
+function getSessionToken() {
+  return globalConf.get("sessionToken") ?? null;
+}
+function setSessionToken(token) {
+  globalConf.set("sessionToken", token);
+}
+function clearSessionToken() {
+  globalConf.delete("sessionToken");
+}
+var SHIPIT_CONFIG_FILE = "shipem.json";
+function readProjectConfig(cwd = process.cwd()) {
+  const configPath = join2(cwd, SHIPIT_CONFIG_FILE);
+  if (!existsSync2(configPath)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    const config = JSON.parse(raw);
+    warnIfConfigContainsSecrets(config, configPath);
+    return config;
+  } catch {
+    return {};
+  }
+}
+function writeProjectConfig(config, cwd = process.cwd()) {
+  const configPath = join2(cwd, SHIPIT_CONFIG_FILE);
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+var SECRET_KEY_PATTERN = /token|secret|key|password|credential|api_?key/i;
+function warnIfConfigContainsSecrets(config, configPath) {
+  const envVars = config.project?.envVars ?? [];
+  const populated = envVars.filter((v) => v.value && SECRET_KEY_PATTERN.test(v.name));
+  if (populated.length > 0) {
+    const names = populated.map((v) => v.name).join(", ");
+    process.stderr.write(
+      `
+[Shipem] Warning: ${configPath} contains values for sensitive env vars (${names}).
+  Ensure shipem.json is listed in .gitignore to avoid committing credentials.
+
+`
+    );
+  }
+}
+
+// src/detect/ai-detect.ts
+var AIDetectionSchema = z.object({
+  framework: z.string().describe("The detected framework or stack"),
+  frameworkId: z.enum([
+    "nextjs",
+    "vite-react",
+    "vite-vue",
+    "vite-svelte",
+    "astro",
+    "sveltekit",
+    "remix",
+    "nuxt",
+    "gatsby",
+    "create-react-app",
+    "flask",
+    "fastapi",
+    "django",
+    "express",
+    "hono",
+    "static-html",
+    "unknown"
+  ]),
+  buildCommand: z.string().describe("Command to build the project"),
+  outputDirectory: z.string().describe("Directory containing built output"),
+  installCommand: z.string().describe("Command to install dependencies"),
+  serverType: z.enum(["static", "serverless", "server"]),
+  deployTarget: z.enum(["cloudflare-pages", "cloudflare-workers", "flyio"]),
+  nodeVersion: z.string().optional(),
+  pythonVersion: z.string().optional(),
+  envVars: z.array(z.object({
+    name: z.string(),
+    description: z.string(),
+    required: z.boolean(),
+    autoProvision: z.boolean().optional()
+  })),
+  notes: z.string().describe("Brief explanation of detection decisions"),
+  confidence: z.number().min(0).max(1)
+});
+async function aiDetectProject(fileSamples, heuristicResult) {
+  const apiKey = getAnthropicApiKey();
+  if (!apiKey) {
+    return null;
+  }
+  const client = new Anthropic({ apiKey });
+  const fileContent = Object.entries(fileSamples).map(([name, content]) => `### ${name}
+\`\`\`
+${content}
+\`\`\``).join("\n\n");
+  const heuristicContext = heuristicResult ? `
+Heuristic detection suggests: ${JSON.stringify(heuristicResult, null, 2)}
+` : "";
+  const prompt = `You are analyzing a software project to determine how to deploy it.
+
+${heuristicContext}
+
+Here are the key project files:
+
+${fileContent}
+
+Based on these files, determine:
+1. The exact framework/stack being used
+2. The correct build command
+3. The output directory after build
+4. Required environment variables (look carefully at the code for API keys, database URLs, etc.)
+5. Whether this is a static site, serverless, or needs a persistent server
+6. The best deploy target (cloudflare-pages for static/JAMstack, cloudflare-workers for edge/serverless, flyio for full-stack servers)
+
+Be thorough about environment variables - check imports, API clients, and configuration files for any external services being used.
+
+Call the analyze_project tool with your findings.`;
+  const toolInputSchema = {
+    type: "object",
+    properties: {
+      framework: { type: "string", description: "The detected framework or stack" },
+      frameworkId: {
+        type: "string",
+        enum: [
+          "nextjs",
+          "vite-react",
+          "vite-vue",
+          "vite-svelte",
+          "astro",
+          "sveltekit",
+          "remix",
+          "nuxt",
+          "gatsby",
+          "create-react-app",
+          "flask",
+          "fastapi",
+          "django",
+          "express",
+          "hono",
+          "static-html",
+          "unknown"
+        ]
+      },
+      buildCommand: { type: "string", description: "Command to build the project" },
+      outputDirectory: { type: "string", description: "Directory containing built output" },
+      installCommand: { type: "string", description: "Command to install dependencies" },
+      serverType: { type: "string", enum: ["static", "serverless", "server"] },
+      deployTarget: { type: "string", enum: ["cloudflare-pages", "cloudflare-workers", "flyio"] },
+      nodeVersion: { type: "string" },
+      pythonVersion: { type: "string" },
+      envVars: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            description: { type: "string" },
+            required: { type: "boolean" },
+            autoProvision: { type: "boolean" }
+          },
+          required: ["name", "description", "required"]
+        }
+      },
+      notes: { type: "string", description: "Brief explanation of detection decisions" },
+      confidence: { type: "number", minimum: 0, maximum: 1 }
+    },
+    required: [
+      "framework",
+      "frameworkId",
+      "buildCommand",
+      "outputDirectory",
+      "installCommand",
+      "serverType",
+      "deployTarget",
+      "envVars",
+      "notes",
+      "confidence"
+    ]
+  };
+  try {
+    const response = await client.messages.create({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 4096,
+      tools: [
+        {
+          name: "analyze_project",
+          description: "Analyze a software project to determine its framework, build config, and deployment configuration",
+          input_schema: toolInputSchema
+        }
+      ],
+      tool_choice: { type: "tool", name: "analyze_project" },
+      messages: [{ role: "user", content: prompt }]
+    });
+    let toolInput = null;
+    for (const block of response.content) {
+      if (block.type === "tool_use" && block.name === "analyze_project") {
+        toolInput = block.input;
+        break;
+      }
+    }
+    if (!toolInput) {
+      return null;
+    }
+    const validated = AIDetectionSchema.parse(toolInput);
+    return {
+      framework: validated.frameworkId,
+      buildCommand: validated.buildCommand,
+      outputDirectory: validated.outputDirectory,
+      installCommand: validated.installCommand,
+      serverType: validated.serverType,
+      deployTarget: validated.deployTarget,
+      nodeVersion: validated.nodeVersion,
+      pythonVersion: validated.pythonVersion,
+      envVars: validated.envVars,
+      notes: validated.notes,
+      confidence: validated.confidence
+    };
+  } catch (err) {
+    return null;
+  }
+}
+function mergeDetectionResults(heuristic, aiResult) {
+  if (!aiResult || aiResult.confidence < 0.7) {
+    return heuristic;
+  }
+  const seen = new Set(heuristic.envVars.map((v) => v.name));
+  const mergedEnvVars = [...heuristic.envVars];
+  for (const v of aiResult.envVars) {
+    if (!seen.has(v.name)) {
+      seen.add(v.name);
+      mergedEnvVars.push(v);
+    }
+  }
+  return {
+    framework: aiResult.framework !== "unknown" ? aiResult.framework : heuristic.framework,
+    buildCommand: aiResult.buildCommand || heuristic.buildCommand,
+    outputDirectory: aiResult.outputDirectory || heuristic.outputDirectory,
+    installCommand: aiResult.installCommand || heuristic.installCommand,
+    serverType: aiResult.serverType,
+    deployTarget: aiResult.deployTarget,
+    nodeVersion: aiResult.nodeVersion ?? heuristic.nodeVersion,
+    pythonVersion: aiResult.pythonVersion ?? heuristic.pythonVersion,
+    envVars: mergedEnvVars,
+    notes: aiResult.notes,
+    confidence: Math.max(heuristic.confidence, aiResult.confidence)
+  };
+}
+
+// src/build/builder.ts
+import { execa } from "execa";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import chalk2 from "chalk";
+async function buildProject(config, cwd = process.cwd()) {
+  const start = Date.now();
+  if (config.installCommand) {
+    const installSpinner = ui.spinner(`Installing dependencies (${config.installCommand})`);
+    const outputLines = [];
+    let lineCount = 0;
+    try {
+      const [installBin, ...installArgs] = config.installCommand.split(" ");
+      const installProc = execa(installBin, installArgs, {
+        cwd,
+        env: { ...process.env, CI: "true" },
+        timeout: 5 * 60 * 1e3,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      installProc.stdout?.on("data", (chunk) => {
+        for (const line of chunk.toString().split("\n")) {
+          if (line.trim()) {
+            outputLines.push(line);
+            lineCount++;
+            installSpinner.text = `Installing dependencies... (${lineCount} lines)`;
+          }
+        }
+      });
+      installProc.stderr?.on("data", (chunk) => {
+        for (const line of chunk.toString().split("\n")) {
+          if (line.trim()) {
+            outputLines.push(line);
+            lineCount++;
+            installSpinner.text = `Installing dependencies... (${lineCount} lines)`;
+          }
+        }
+      });
+      await installProc;
+      installSpinner.succeed(`Dependencies installed (${lineCount} lines)`);
+    } catch (err) {
+      installSpinner.fail("Dependency installation failed");
+      const tail = outputLines.slice(-20);
+      if (tail.length > 0) {
+        console.log("");
+        for (const line of tail) {
+          process.stdout.write(chalk2.dim("    " + line) + "\n");
+        }
+      }
+      return {
+        success: false,
+        outputDirectory: config.outputDirectory,
+        durationMs: Date.now() - start,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    console.log("");
+  }
+  if (config.buildCommand) {
+    const buildSpinner = ui.spinner("Building...");
+    const outputLines = [];
+    let lineCount = 0;
+    const buildEnv = {
+      ...process.env,
+      NODE_ENV: "production",
+      CI: "true"
+    };
+    for (const envVar of config.envVars) {
+      if (envVar.value) {
+        buildEnv[envVar.name] = envVar.value;
+      }
+    }
+    try {
+      const [finalBin, ...finalArgs] = config.buildCommand.split(" ");
+      const buildProc = execa(finalBin, finalArgs, {
+        cwd,
+        env: buildEnv,
+        timeout: 10 * 60 * 1e3,
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      buildProc.stdout?.on("data", (chunk) => {
+        for (const line of chunk.toString().split("\n")) {
+          if (line.trim()) {
+            outputLines.push(line);
+            lineCount++;
+            buildSpinner.text = `Building... (${lineCount} lines)`;
+          }
+        }
+      });
+      buildProc.stderr?.on("data", (chunk) => {
+        for (const line of chunk.toString().split("\n")) {
+          if (line.trim()) {
+            outputLines.push(line);
+            lineCount++;
+            buildSpinner.text = `Building... (${lineCount} lines)`;
+          }
+        }
+      });
+      await buildProc;
+      const durationSec = ((Date.now() - start) / 1e3).toFixed(1);
+      buildSpinner.succeed(`Build successful (${lineCount} lines, ${durationSec}s)`);
+    } catch (err) {
+      buildSpinner.fail("Build failed");
+      const tail = outputLines.slice(-30);
+      if (tail.length > 0) {
+        console.log("");
+        for (const line of tail) {
+          process.stdout.write(chalk2.dim("    " + line) + "\n");
+        }
+      }
+      const errMsg = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        outputDirectory: config.outputDirectory,
+        durationMs: Date.now() - start,
+        error: parseErrorMessage(errMsg, outputLines)
+      };
+    }
+    console.log("");
+  }
+  const outputPath = join3(cwd, config.outputDirectory);
+  if (config.buildCommand && !existsSync3(outputPath)) {
+    return {
+      success: false,
+      outputDirectory: config.outputDirectory,
+      durationMs: Date.now() - start,
+      error: `Build completed but output directory '${config.outputDirectory}' not found. Check your build configuration.`
+    };
+  }
+  return {
+    success: true,
+    outputDirectory: config.outputDirectory,
+    durationMs: Date.now() - start
+  };
+}
+function parseErrorMessage(raw, outputLines) {
+  const errorLines = outputLines.filter(
+    (l) => l.includes("Error:") || l.includes("error:") || l.includes("ERROR") || l.includes("Failed") || l.includes("Cannot find") || l.includes("Module not found")
+  );
+  if (errorLines.length > 0) {
+    return errorLines.slice(0, 3).join("\n");
+  }
+  if (outputLines.length > 0) {
+    return outputLines.slice(-5).join("\n");
+  }
+  const lines = raw.split("\n").filter((l) => l.trim());
+  return lines.slice(-5).join("\n");
+}
+
+// src/commands/login.ts
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+import open from "open";
+var CALLBACK_PORT_START = 9999;
+var MAX_PORT_ATTEMPTS = 10;
+async function loginCommand(opts = {}) {
+  if (!opts.skipBanner) ui.banner();
+  ui.section("Logging in to Shipem...");
+  ui.br();
+  const cliState = randomBytes(16).toString("hex");
+  let resolveToken;
+  let rejectToken;
+  const tokenPromise = new Promise((resolve, reject) => {
+    resolveToken = resolve;
+    rejectToken = reject;
+  });
+  let hasHandled = false;
+  const server = createServer((req, res) => {
+    if (!req.url) return;
+    if (hasHandled) {
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end('<html><body style="font-family:sans-serif;padding:40px">Login already completed. You can close this tab.</body></html>');
+      return;
+    }
+    const url = new URL(req.url, `http://127.0.0.1:${actualPort}`);
+    const token2 = url.searchParams.get("token");
+    const login = url.searchParams.get("login");
+    const returnedState = url.searchParams.get("state");
+    if (returnedState !== cliState) {
+      hasHandled = true;
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end('<html><body style="font-family:sans-serif;padding:40px;color:red">State mismatch \u2014 possible CSRF. Please try logging in again.</body></html>');
+      rejectToken(new Error("State mismatch in OAuth callback \u2014 possible CSRF attack"));
+      return;
+    }
+    if (token2) {
+      hasHandled = true;
+      const html = `<!DOCTYPE html>
+<html>
+<head><title>Shipem \u2014 Logged in!</title>
+<style>
+  body { font-family: -apple-system, sans-serif; text-align: center; padding: 60px; background: #0f172a; color: #e2e8f0; }
+  h2 { color: #22c55e; font-size: 2rem; margin-bottom: 12px; }
+  p { color: #94a3b8; font-size: 1.1rem; }
+</style>
+</head>
+<body>
+  <h2>\u2705 Logged in${login ? ` as @${login}` : ""}!</h2>
+  <p>You can close this tab and return to your terminal.</p>
+</body>
+</html>`;
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(html);
+      resolveToken(token2);
+    } else {
+      hasHandled = true;
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end('<html><body style="font-family:sans-serif;padding:40px">Authentication failed. Please try again.</body></html>');
+      rejectToken(new Error("Authentication failed \u2014 no token received"));
+    }
+  });
+  let actualPort = CALLBACK_PORT_START;
+  let bound = false;
+  for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
+    try {
+      await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(actualPort, "127.0.0.1", resolve);
+      });
+      bound = true;
+      break;
+    } catch (err) {
+      if (err.code === "EADDRINUSE") {
+        actualPort++;
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (!bound) {
+    throw new Error(`Could not bind to any port in range ${CALLBACK_PORT_START}\u2013${CALLBACK_PORT_START + MAX_PORT_ATTEMPTS - 1}. Please free up a port and try again.`);
+  }
+  const callbackUrl = `http://localhost:${actualPort}`;
+  const loginUrl = `${SHIPEM_API_URL}/auth/github?cli_callback=${encodeURIComponent(callbackUrl)}&cli_state=${cliState}`;
+  ui.info("Opening your browser for GitHub login...");
+  ui.dim(`If the browser doesn't open, visit:`);
+  ui.dim(loginUrl);
+  ui.br();
+  await open(loginUrl);
+  const timeoutMs = 5 * 60 * 1e3;
+  let token;
+  try {
+    token = await Promise.race([
+      tokenPromise,
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Login timed out after 5 minutes. Please try again.")), timeoutMs)
+      )
+    ]);
+  } finally {
+    server.close();
+  }
+  setSessionToken(token);
+  ui.success("Logged in successfully!");
+  ui.dim("Your session is saved \u2014 you won't need to log in again.");
+  ui.br();
+}
+
+// src/deploy/cloudflare.ts
+import axios from "axios";
+import { createHash } from "crypto";
+import { readdirSync as readdirSync2, statSync as statSync2, readFileSync as readFileSync4 } from "fs";
+import { join as join5, relative } from "path";
+
+// src/deploy/exclude.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
+import chalk3 from "chalk";
+var DEFAULT_PATTERNS = [
+  ".git",
+  "node_modules",
+  ".env",
+  ".env.local",
+  ".env.production",
+  ".DS_Store",
+  "shipem.json",
+  "__pycache__",
+  ".pytest_cache",
+  ".venv",
+  "venv",
+  ".idea",
+  ".vscode"
+];
+var DEFAULT_GLOB_PATTERNS = [
+  ".env*.local",
+  ".shipem*",
+  "*.pem",
+  "*.key",
+  "*.p12"
+];
+function matchesGlob(name, pattern) {
+  const starIdx = pattern.indexOf("*");
+  if (starIdx === -1) return name === pattern;
+  const prefix = pattern.slice(0, starIdx);
+  const suffix = pattern.slice(starIdx + 1);
+  return name.startsWith(prefix) && name.endsWith(suffix) && name.length >= prefix.length + suffix.length;
+}
+function matchesAnyDefaultPattern(segment) {
+  if (DEFAULT_PATTERNS.includes(segment)) return true;
+  for (const pat of DEFAULT_GLOB_PATTERNS) {
+    if (matchesGlob(segment, pat)) return true;
+  }
+  return false;
+}
+function matchesIgnoreLine(relPath, line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("!")) return false;
+  const pattern = trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+  const segments = relPath.replace(/\\/g, "/").split("/").filter(Boolean);
+  const last = segments[segments.length - 1];
+  if (last && matchesGlob(last, pattern)) return true;
+  if (matchesGlob(relPath.replace(/\\/g, "/"), pattern)) return true;
+  for (const seg of segments) {
+    if (matchesGlob(seg, pattern)) return true;
+  }
+  return false;
+}
+function loadIgnoreLines(filePath) {
+  if (!existsSync4(filePath)) return [];
+  try {
+    return readFileSync3(filePath, "utf-8").split("\n");
+  } catch {
+    return [];
+  }
+}
+function shouldExclude(filePath, projectRoot) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const segments = normalized.split("/").filter((s) => s && s !== ".");
+  for (const seg of segments) {
+    if (matchesAnyDefaultPattern(seg)) return true;
+  }
+  if (projectRoot) {
+    const relPath = normalized;
+    const shipemIgnoreLines = loadIgnoreLines(join4(projectRoot, ".shipemignore"));
+    for (const line of shipemIgnoreLines) {
+      if (matchesIgnoreLine(relPath, line)) return true;
+    }
+    const gitIgnoreLines = loadIgnoreLines(join4(projectRoot, ".gitignore"));
+    for (const line of gitIgnoreLines) {
+      if (matchesIgnoreLine(relPath, line)) return true;
+    }
+  }
+  return false;
+}
+function warnIfEnvFilesInOutputDir(outputDir) {
+  const envFiles = [".env", ".env.local", ".env.production"];
+  for (const name of envFiles) {
+    if (existsSync4(join4(outputDir, name))) {
+      process.stderr.write(
+        chalk3.yellow(`
+\u26A0  Warning: ${name} found in output directory \u2014 it will be excluded from deployment.
+`)
+      );
+    }
+  }
+}
+
+// src/deploy/cloudflare.ts
+var CF_API_BASE = "https://api.cloudflare.com/client/v4";
+var CloudflarePages = class {
+  client;
+  accountId;
+  constructor(apiToken, accountId) {
+    this.accountId = accountId;
+    this.client = axios.create({
+      baseURL: CF_API_BASE,
+      headers: {
+        Authorization: `Bearer ${apiToken}`,
+        "Content-Type": "application/json"
+      },
+      timeout: 6e4
+    });
+  }
+  async getOrCreateProject(projectName, config) {
+    try {
+      const res = await this.client.get(
+        `/accounts/${this.accountId}/pages/projects/${projectName}`
+      );
+      if (res.data.success) {
+        return res.data.result;
+      }
+    } catch (err) {
+      const status = err.response?.status;
+      if (status !== 404) {
+        throw new Error(`Failed to check project: ${extractCFError(err)}`);
+      }
+    }
+    try {
+      const res = await this.client.post(
+        `/accounts/${this.accountId}/pages/projects`,
+        {
+          name: projectName,
+          production_branch: "main",
+          build_config: {
+            build_command: config.buildCommand || null,
+            destination_dir: config.outputDirectory,
+            root_dir: ""
+          },
+          deployment_configs: {
+            production: {
+              compatibility_date: "2024-01-01",
+              environment_variables: {}
+            },
+            preview: {
+              compatibility_date: "2024-01-01",
+              environment_variables: {}
+            }
+          }
+        }
+      );
+      if (!res.data.success) {
+        throw new Error(res.data.errors[0]?.message ?? "Unknown error creating project");
+      }
+      return res.data.result;
+    } catch (err) {
+      throw new Error(`Failed to create Pages project: ${extractCFError(err)}`);
+    }
+  }
+  async setEnvironmentVariables(projectName, envVars) {
+    if (Object.keys(envVars).length === 0) return;
+    const formattedVars = {};
+    for (const [key, value] of Object.entries(envVars)) {
+      const isSecret = key.toLowerCase().includes("secret") || key.toLowerCase().includes("key") || key.toLowerCase().includes("token") || key.toLowerCase().includes("password");
+      formattedVars[key] = {
+        value,
+        type: isSecret ? "secret_text" : "plain_text"
+      };
+    }
+    try {
+      await this.client.patch(
+        `/accounts/${this.accountId}/pages/projects/${projectName}`,
+        {
+          deployment_configs: {
+            production: {
+              environment_variables: formattedVars
+            }
+          }
+        }
+      );
+    } catch (err) {
+      throw new Error(`Failed to set environment variables: ${extractCFError(err)}`);
+    }
+  }
+  async deployDirectory(projectName, outputDir, cwd = process.cwd()) {
+    const fullOutputPath = join5(cwd, outputDir);
+    const filePaths = collectFiles(fullOutputPath);
+    let totalBytes = 0;
+    const fileMap = /* @__PURE__ */ new Map();
+    for (const filePath of filePaths) {
+      const content = readFileSync4(filePath);
+      const hash = createHash("sha256").update(content).digest("hex");
+      const urlPath = "/" + relative(fullOutputPath, filePath).replace(/\\/g, "/");
+      fileMap.set(urlPath, { hash, content });
+      totalBytes += content.length;
+    }
+    const hashToContent = /* @__PURE__ */ new Map();
+    for (const { hash, content } of fileMap.values()) {
+      if (!hashToContent.has(hash)) hashToContent.set(hash, content);
+    }
+    const fileCount = filePaths.length;
+    const manifest = {};
+    for (const [urlPath, { hash }] of fileMap) {
+      manifest[urlPath] = hash;
+    }
+    const deploySpinner = ui.spinner("Creating deployment...");
+    let jwt;
+    let requiredFiles;
+    let deployment;
+    try {
+      const res = await this.client.post(
+        `/accounts/${this.accountId}/pages/projects/${projectName}/deployments`,
+        { files: manifest, branch: "main" },
+        { timeout: 6e4 }
+      );
+      if (!res.data.success) {
+        deploySpinner.fail("Deployment creation failed");
+        throw new Error(res.data.errors[0]?.message ?? "Deployment failed");
+      }
+      jwt = res.data.result.jwt;
+      requiredFiles = res.data.result.required_files ?? [];
+      deployment = res.data.result;
+      deploySpinner.succeed("Deployment created");
+    } catch (err) {
+      deploySpinner.fail("Deployment creation failed");
+      throw new Error(`Deployment failed: ${extractCFError(err)}`);
+    }
+    if (requiredFiles.length > 0) {
+      const uploadSpinner = ui.spinner(
+        `Uploading ${requiredFiles.length} files (${ui.formatBytes(totalBytes)})`
+      );
+      let uploaded = 0;
+      for (const hash of requiredFiles) {
+        const content = hashToContent.get(hash);
+        if (!content) continue;
+        try {
+          const formData = new FormData();
+          formData.append(hash, new Blob([content], { type: "application/octet-stream" }), hash);
+          await fetch("https://upload.storageapi.cloudflare.com/pages-uploads", {
+            method: "POST",
+            headers: { Authorization: `Bearer ${jwt}` },
+            body: formData
+          }).then(async (res) => {
+            if (!res.ok) {
+              const text = await res.text().catch(() => res.statusText);
+              throw new Error(`Upload failed (${res.status}): ${text}`);
+            }
+          });
+        } catch (err) {
+          uploadSpinner.fail("Upload failed");
+          throw new Error(`Failed to upload file (hash ${hash}): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        uploaded++;
+        uploadSpinner.text = `Uploading files... ${uploaded}/${requiredFiles.length}`;
+      }
+      uploadSpinner.succeed(`Upload complete \u2014 ${fileCount} files (${ui.formatBytes(totalBytes)})`);
+    }
+    ui.success("Live!");
+    return { deployment, fileCount, totalBytes };
+  }
+  async waitForDeployment(projectName, deploymentId, timeoutMs = 3 * 60 * 1e3) {
+    const deploySpinner = ui.spinner("Deploying to Cloudflare Pages");
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      await sleep(3e3);
+      try {
+        const res = await this.client.get(
+          `/accounts/${this.accountId}/pages/projects/${projectName}/deployments/${deploymentId}`
+        );
+        if (!res.data.success) continue;
+        const deployment = res.data.result;
+        const stage = deployment.latest_stage;
+        deploySpinner.text = `Deploying... (${stage?.name ?? "initializing"})`;
+        if (stage?.status === "success") {
+          deploySpinner.succeed("Deployed successfully");
+          return deployment;
+        }
+        if (stage?.status === "failure") {
+          deploySpinner.fail("Deployment failed");
+          throw new Error(
+            `Deployment failed at stage '${stage.name}'. Check the Cloudflare Pages dashboard for details.`
+          );
+        }
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("Deployment failed")) {
+          throw err;
+        }
+      }
+    }
+    deploySpinner.fail("Deployment timed out");
+    throw new Error("Deployment timed out. Check the Cloudflare Pages dashboard for status.");
+  }
+  async getDeploymentStatus(projectName, deploymentId) {
+    try {
+      const res = await this.client.get(
+        `/accounts/${this.accountId}/pages/projects/${projectName}/deployments/${deploymentId}`
+      );
+      return res.data.success ? res.data.result : null;
+    } catch {
+      return null;
+    }
+  }
+  async getDeploymentLogs(projectName, deploymentId) {
+    try {
+      const res = await this.client.get(
+        `/accounts/${this.accountId}/pages/projects/${projectName}/deployments/${deploymentId}/history/logs`
+      );
+      if (!res.data.success) return [];
+      return res.data.result.data.map((entry) => `[${entry.ts}] ${entry.message}`);
+    } catch {
+      return [];
+    }
+  }
+  async deleteProject(projectName) {
+    try {
+      await this.client.delete(
+        `/accounts/${this.accountId}/pages/projects/${projectName}`
+      );
+    } catch (err) {
+      throw new Error(`Failed to delete project: ${extractCFError(err)}`);
+    }
+  }
+  getProjectUrl(projectName) {
+    return `https://${projectName}.pages.dev`;
+  }
+  getDashboardUrl(projectName) {
+    return `https://dash.cloudflare.com/${this.accountId}/pages/view/${projectName}`;
+  }
+  // Validate credentials and get account info
+  async validateCredentials() {
+    try {
+      const res = await this.client.get(
+        `/accounts/${this.accountId}`
+      );
+      return { valid: res.data.success, accountName: res.data.result?.name };
+    } catch {
+      return { valid: false };
+    }
+  }
+};
+function collectFiles(dir) {
+  const results = [];
+  function walk(currentDir) {
+    const entries = readdirSync2(currentDir);
+    for (const entry of entries) {
+      const fullPath = join5(currentDir, entry);
+      if (shouldExclude(fullPath)) continue;
+      if (entry.startsWith(".") && entry !== ".well-known") continue;
+      const stat = statSync2(fullPath);
+      if (stat.isDirectory()) {
+        walk(fullPath);
+      } else {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+function extractCFError(err) {
+  if (err instanceof Error) {
+    const cfErr = err;
+    const msg = cfErr.response?.data?.errors?.[0]?.message;
+    if (msg) return msg;
+    return err.message;
+  }
+  return String(err);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function sanitizeProjectName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 28);
+}
+
+// src/commands/deploy.ts
+var ENV_VAR_HELP = {
+  OPENAI_API_KEY: { desc: "OpenAI API key for AI features", url: "https://platform.openai.com/api-keys" },
+  ANTHROPIC_API_KEY: { desc: "Anthropic API key for Claude AI", url: "https://console.anthropic.com/" },
+  SUPABASE_URL: { desc: "Your Supabase project URL", url: "https://app.supabase.com" },
+  SUPABASE_ANON_KEY: { desc: "Your Supabase anonymous key", url: "https://app.supabase.com" },
+  NEXT_PUBLIC_SUPABASE_URL: { desc: "Supabase project URL (public)", url: "https://app.supabase.com" },
+  NEXT_PUBLIC_SUPABASE_ANON_KEY: { desc: "Supabase anon key (public)", url: "https://app.supabase.com" },
+  VITE_SUPABASE_URL: { desc: "Supabase project URL for Vite apps", url: "https://app.supabase.com" },
+  VITE_SUPABASE_ANON_KEY: { desc: "Supabase anon key for Vite apps", url: "https://app.supabase.com" },
+  DATABASE_URL: { desc: "PostgreSQL database connection string" },
+  STRIPE_SECRET_KEY: { desc: "Stripe secret key for payments", url: "https://dashboard.stripe.com/apikeys" },
+  STRIPE_PUBLISHABLE_KEY: { desc: "Stripe publishable key", url: "https://dashboard.stripe.com/apikeys" },
+  NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: { desc: "Stripe publishable key (public)", url: "https://dashboard.stripe.com/apikeys" }
+};
+async function apiRequest(config) {
+  try {
+    return await axios2(config);
+  } catch (err) {
+    if (axios2.isAxiosError(err)) {
+      const code = err.code;
+      if (code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "ETIMEDOUT") {
+        throw new Error("Cannot reach Shipem servers. Check your internet connection and try again.");
+      }
+      const status = err.response?.status;
+      if (status === 401) throw err;
+      if (status === 500) throw new Error("Shipem servers are having issues. Try again in a moment.");
+      if (status === 429) throw new Error("Too many requests. Please wait before deploying again.");
+      if (status === 413) throw new Error("Project is too large to deploy (max 100 MB).");
+    }
+    throw err;
+  }
+}
+function countSourceFiles(dir) {
+  const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".next", "dist", "build", "out", ".turbo", "coverage"]);
+  let count = 0;
+  function walk(d) {
+    try {
+      const entries = readdirSync3(d, { withFileTypes: true });
+      for (const entry of entries) {
+        if (SKIP.has(entry.name) || entry.name.startsWith(".")) continue;
+        if (entry.isDirectory()) walk(join6(d, entry.name));
+        else count++;
+      }
+    } catch {
+    }
+  }
+  walk(dir);
+  return count;
+}
+function countOutputFiles(dir) {
+  let fileCount = 0;
+  let totalBytes = 0;
+  function walk(d) {
+    try {
+      const entries = readdirSync3(d, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join6(d, entry.name);
+        if (entry.isDirectory()) walk(fullPath);
+        else {
+          fileCount++;
+          try {
+            totalBytes += statSync3(fullPath).size;
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  walk(dir);
+  return { fileCount, totalBytes };
+}
+async function deployCommand(options) {
+  const startTime = Date.now();
+  const cwd = process.cwd();
+  const existingConfig = readProjectConfig(cwd);
+  const isRedeploy = !!existingConfig.project && !!existingConfig.deployment;
+  const isFirstRun = !getSessionToken() && !existingConfig.project;
+  if (isRedeploy) {
+    ui.redeployHeader(
+      existingConfig.deployment.projectName,
+      existingConfig.deployment.url,
+      existingConfig.deployment.deployedAt
+    );
+  } else {
+    ui.banner();
+  }
+  if (isFirstRun) {
+    console.log(`  ${chalk4.white.bold("Welcome to Shipem!")} \u2728`);
+    console.log("");
+    console.log(`  ${chalk4.dim("One-time setup (takes 30 seconds):")}`);
+    console.log(`  ${chalk4.dim("1. Sign in with GitHub")}`);
+    console.log(`  ${chalk4.dim("2. We handle everything else")}`);
+    console.log("");
+  }
+  let sessionToken = getSessionToken();
+  if (!sessionToken) {
+    await loginCommand({ skipBanner: true });
+    sessionToken = getSessionToken();
+    if (!sessionToken) {
+      ui.fatal("Login failed. Please try again with: shipem login");
+    }
+    console.log("");
+    console.log(`  ${chalk4.hex("#22C55E")("\u2713")} ${chalk4.bold("Signed in!")}`);
+    console.log("");
+    console.log(`  Now deploying your app...`);
+    console.log("");
+  }
+  ui.section("Scanning project...");
+  ui.br();
+  let projectConfig;
+  if (existingConfig.project && options.yes) {
+    projectConfig = existingConfig.project;
+    ui.success(`Using saved config: ${ui.framework(projectConfig.framework)}`);
+  } else {
+    const scanSpinner = ui.spinner("Scanning project files");
+    const heuristicResult = scanProject(cwd);
+    scanSpinner.succeed("Project files scanned");
+    const sourceFileCount = countSourceFiles(cwd);
+    let finalDetection;
+    const anthropicKey = getAnthropicApiKey();
+    const heuristicAsAnalysis = {
+      framework: heuristicResult.framework,
+      buildCommand: heuristicResult.buildCommand,
+      outputDirectory: heuristicResult.outputDirectory,
+      installCommand: heuristicResult.installCommand,
+      serverType: heuristicResult.serverType,
+      deployTarget: heuristicResult.deployTarget,
+      nodeVersion: heuristicResult.nodeVersion,
+      pythonVersion: heuristicResult.pythonVersion,
+      envVars: heuristicResult.envVars,
+      notes: "",
+      confidence: heuristicResult.confidence
+    };
+    if (anthropicKey) {
+      const aiSpinner = ui.spinner("Analyzing with Claude AI");
+      try {
+        const fileSamples = collectFileSamples(cwd);
+        const aiResult = await aiDetectProject(fileSamples, heuristicAsAnalysis);
+        finalDetection = mergeDetectionResults(heuristicAsAnalysis, aiResult);
+        aiSpinner.succeed("AI analysis complete");
+        if (aiResult?.notes) {
+          ui.dim(aiResult.notes);
+        }
+      } catch {
+        aiSpinner.warn("AI analysis failed, using heuristic detection");
+        finalDetection = heuristicAsAnalysis;
+      }
+    } else {
+      finalDetection = heuristicAsAnalysis;
+    }
+    const projectName = options.name ?? heuristicResult.projectName;
+    ui.projectAnalysis({
+      name: projectName,
+      framework: finalDetection.framework,
+      fileCount: sourceFileCount,
+      buildCommand: finalDetection.buildCommand,
+      outputDir: finalDetection.outputDirectory,
+      deployTarget: finalDetection.deployTarget,
+      envVarCount: finalDetection.envVars.length
+    });
+    if (finalDetection.confidence < 0.7 && !options.yes) {
+      ui.warn(`Low confidence detection (${Math.round(finalDetection.confidence * 100)}%). Please verify the settings.`);
+      ui.br();
+    }
+    if (finalDetection.confidence < 0.4 && !existsSync5(join6(cwd, "package.json")) && !existsSync5(join6(cwd, "requirements.txt")) && !existsSync5(join6(cwd, "index.html"))) {
+      ui.friendlyError(
+        "This does not look like a project",
+        "No package.json, requirements.txt, or index.html found",
+        "cd into your project directory first",
+        `You are in: ${cwd}`
+      );
+      if (!options.yes) {
+        const { proceed } = await inquirer.prompt([
+          {
+            type: "confirm",
+            name: "proceed",
+            message: "Continue anyway?",
+            default: false
+          }
+        ]);
+        if (!proceed) {
+          ui.info("Cancelled. Navigate to your project directory and run `shipem` again.");
+          ui.br();
+          process.exit(0);
+        }
+      }
+    }
+    projectConfig = {
+      name: projectName,
+      framework: finalDetection.framework,
+      buildCommand: finalDetection.buildCommand,
+      outputDirectory: finalDetection.outputDirectory,
+      installCommand: finalDetection.installCommand,
+      serverType: finalDetection.serverType,
+      nodeVersion: finalDetection.nodeVersion,
+      pythonVersion: finalDetection.pythonVersion,
+      envVars: finalDetection.envVars,
+      deployTarget: finalDetection.deployTarget,
+      detectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      aiAnalysis: finalDetection.notes
+    };
+  }
+  const envVarsToSet = {};
+  if (projectConfig.envVars.length > 0 && !options.yes) {
+    const unresolvedVars = projectConfig.envVars.filter(
+      (v) => !v.autoProvision && !v.value && !process.env[v.name]
+    );
+    if (unresolvedVars.length > 0) {
+      ui.section("Environment setup...");
+      ui.br();
+      ui.dim("(Stored locally only, never sent to Shipem servers)");
+      ui.br();
+      for (const envVar of unresolvedVars) {
+        const existing = process.env[envVar.name];
+        if (existing) {
+          ui.success(`${envVar.name}: (from environment)`);
+          envVarsToSet[envVar.name] = existing;
+          continue;
+        }
+        const helpInfo = ENV_VAR_HELP[envVar.name];
+        const desc = envVar.description || helpInfo?.desc || "";
+        const helpUrl = helpInfo?.url;
+        const messageParts = [envVar.name];
+        if (desc) messageParts.push(chalk4.gray(` \u2014 ${desc}`));
+        if (helpUrl) messageParts.push(chalk4.dim(` (${helpUrl})`));
+        const message = messageParts.join("");
+        const { value } = await inquirer.prompt([
+          {
+            type: "password",
+            name: "value",
+            message,
+            mask: "*",
+            validate: (v) => !envVar.required || v.trim().length > 0 || `${envVar.name} is required`
+          }
+        ]);
+        if (value.trim()) {
+          envVarsToSet[envVar.name] = value.trim();
+          projectConfig.envVars = projectConfig.envVars.map(
+            (v) => v.name === envVar.name ? { ...v, value: value.trim() } : v
+          );
+        }
+      }
+      ui.br();
+    }
+  } else {
+    for (const envVar of projectConfig.envVars) {
+      const existing = process.env[envVar.name];
+      if (existing) {
+        envVarsToSet[envVar.name] = existing;
+      }
+    }
+  }
+  if (!options.skipBuild) {
+    ui.section("Building...");
+    ui.br();
+    let buildResult = await buildProject(projectConfig, cwd);
+    if (!buildResult.success) {
+      ui.br();
+      const errMsg = buildResult.error ?? "Unknown build error";
+      const moduleMatch = errMsg.match(/Cannot find module ['"]([^'"]+)['"]/);
+      if (moduleMatch) {
+        ui.friendlyError(
+          "Your app failed to build",
+          `Module '${moduleMatch[1]}' not found`,
+          'Run "npm install" in your project, then try again'
+        );
+      } else {
+        ui.friendlyError(
+          "Your app failed to build",
+          errMsg.split("\n")[0] ?? errMsg,
+          "Fix the error above, then run `npx shipem` again"
+        );
+      }
+      if (options.yes) {
+        process.exit(1);
+      }
+      const { action } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "action",
+          message: "Build failed. What would you like to do?",
+          choices: [
+            { name: "Try again", value: "retry" },
+            { name: "Deploy without building (use existing output directory)", value: "skip" },
+            { name: "Quit", value: "quit" }
+          ]
+        }
+      ]);
+      if (action === "quit") {
+        ui.br();
+        process.exit(1);
+      }
+      if (action === "retry") {
+        ui.br();
+        ui.section("Building (retry)...");
+        ui.br();
+        buildResult = await buildProject(projectConfig, cwd);
+        if (!buildResult.success) {
+          ui.br();
+          ui.friendlyError(
+            "Your app failed to build again",
+            buildResult.error?.split("\n")[0] ?? "Unknown build error",
+            "Fix the error above, then run `npx shipem` again"
+          );
+          process.exit(1);
+        }
+      }
+      ui.br();
+    } else {
+      ui.br();
+    }
+  }
+  ui.section("Deploying...");
+  ui.br();
+  let liveUrl;
+  let projectId;
+  let deployFileCount = 0;
+  let deployTotalBytes = 0;
+  const cfCreds = getCloudflareCredentials();
+  const useDirectDeploy = options.direct === true || cfCreds !== null;
+  if (useDirectDeploy) {
+    if (!cfCreds) {
+      ui.friendlyError(
+        "Direct deploy requires Cloudflare credentials",
+        "CLOUDFLARE_API_TOKEN or CLOUDFLARE_ACCOUNT_ID is not set",
+        "Set CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID environment variables, then try again"
+      );
+      process.exit(1);
+    }
+    ui.dim("Direct Cloudflare deployment (using your credentials)...");
+    ui.br();
+    try {
+      const cf = new CloudflarePages(cfCreds.apiToken, cfCreds.accountId);
+      const cfProjectName = sanitizeProjectName(projectConfig.name);
+      await cf.getOrCreateProject(cfProjectName, projectConfig);
+      if (Object.keys(envVarsToSet).length > 0) {
+        await cf.setEnvironmentVariables(cfProjectName, envVarsToSet);
+      }
+      const result = await cf.deployDirectory(cfProjectName, projectConfig.outputDirectory, cwd);
+      deployFileCount = result.fileCount;
+      deployTotalBytes = result.totalBytes;
+      const finalDeployment = await cf.waitForDeployment(cfProjectName, result.deployment.id);
+      liveUrl = finalDeployment.url || cf.getProjectUrl(cfProjectName);
+      projectId = cfProjectName;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      ui.friendlyError(
+        "Deployment failed",
+        msg,
+        "Check your Cloudflare credentials and try again"
+      );
+      process.exit(1);
+    }
+  } else {
+    const tarPath = join6(tmpdir(), `shipem-${Date.now()}.tar.gz`);
+    try {
+      const outputPath = join6(cwd, projectConfig.outputDirectory);
+      warnIfEnvFilesInOutputDir(outputPath);
+      const stats = countOutputFiles(outputPath);
+      deployFileCount = stats.fileCount;
+      deployTotalBytes = stats.totalBytes;
+      const packagingSpinner = ui.spinner("Packaging files...");
+      await tarCreate(
+        {
+          gzip: true,
+          file: tarPath,
+          cwd: outputPath,
+          filter: (filePath) => !shouldExclude(filePath, cwd)
+        },
+        ["."]
+      );
+      packagingSpinner.succeed(
+        `Packaged ${deployFileCount} files (${ui.formatBytes(deployTotalBytes)})`
+      );
+      const uploadStart = Date.now();
+      const uploadSpinner = ui.spinner("Uploading to cloud...");
+      let activatingSpinner = null;
+      const form = new FormData2();
+      form.append("config", JSON.stringify({
+        name: projectConfig.name,
+        framework: projectConfig.framework,
+        deployTarget: projectConfig.deployTarget,
+        outputDirectory: projectConfig.outputDirectory
+      }));
+      form.append("artifacts", createReadStream(tarPath), {
+        filename: "artifacts.tar.gz",
+        contentType: "application/gzip"
+      });
+      const deployConfig = {
+        method: "post",
+        url: `${SHIPEM_API_URL}/projects/deploy`,
+        data: form,
+        headers: {
+          ...form.getHeaders(),
+          Authorization: `Bearer ${sessionToken}`
+        },
+        maxBodyLength: Infinity,
+        timeout: 5 * 60 * 1e3,
+        onUploadProgress: (evt) => {
+          if (!activatingSpinner && evt.total && evt.loaded >= evt.total) {
+            const uploadSec = ((Date.now() - uploadStart) / 1e3).toFixed(1);
+            uploadSpinner.succeed(`Upload complete (${uploadSec}s)`);
+            activatingSpinner = ui.spinner("Activating deployment...");
+          }
+        }
+      };
+      let response;
+      try {
+        response = await apiRequest(deployConfig);
+      } catch (err) {
+        if (axios2.isAxiosError(err) && err.response?.status === 401) {
+          if (activatingSpinner) {
+            activatingSpinner.text = "Session expired. Logging in again...";
+          } else {
+            uploadSpinner.text = "Session expired. Logging in again...";
+          }
+          await loginCommand({ skipBanner: true });
+          sessionToken = getSessionToken();
+          if (!sessionToken) {
+            throw new Error("Login failed after session expiry. Please run: shipem login");
+          }
+          const retryForm = new FormData2();
+          retryForm.append("config", JSON.stringify({
+            name: projectConfig.name,
+            framework: projectConfig.framework,
+            deployTarget: projectConfig.deployTarget,
+            outputDirectory: projectConfig.outputDirectory
+          }));
+          retryForm.append("artifacts", createReadStream(tarPath), {
+            filename: "artifacts.tar.gz",
+            contentType: "application/gzip"
+          });
+          deployConfig.data = retryForm;
+          deployConfig.headers = {
+            ...retryForm.getHeaders(),
+            Authorization: `Bearer ${sessionToken}`
+          };
+          try {
+            response = await apiRequest(deployConfig);
+          } catch (retryErr) {
+            if (axios2.isAxiosError(retryErr) && retryErr.response?.status === 401) {
+              throw new Error("Authentication failed after re-login. Please run: shipem login");
+            }
+            throw retryErr;
+          }
+        } else {
+          throw err;
+        }
+      }
+      if (activatingSpinner) {
+        activatingSpinner.succeed("Live!");
+      } else {
+        uploadSpinner.succeed("Deployed successfully");
+      }
+      liveUrl = response.data.url;
+      projectId = response.data.projectId;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("Cannot reach")) {
+        ui.friendlyError(
+          "Cannot reach Shipem servers",
+          "Network connection failed",
+          "Check your internet and try again"
+        );
+      } else {
+        ui.friendlyError(
+          "Deployment failed",
+          msg,
+          "Check your connection and try again with: npx shipem"
+        );
+      }
+      process.exit(1);
+    } finally {
+      try {
+        rmSync(tarPath);
+      } catch {
+      }
+    }
+  }
+  const configToSave = {
+    ...projectConfig,
+    envVars: projectConfig.envVars.map(({ value: _stripped, ...rest }) => rest)
+  };
+  const deploymentState = {
+    projectName: projectConfig.name,
+    deploymentId: projectId,
+    url: liveUrl,
+    deployTarget: projectConfig.deployTarget,
+    deployedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "success"
+  };
+  writeProjectConfig({ project: configToSave, deployment: deploymentState }, cwd);
+  const gitignorePath = join6(cwd, ".gitignore");
+  if (existsSync5(gitignorePath)) {
+    const gitignoreContent = readFileSync5(gitignorePath, "utf-8");
+    const lines = gitignoreContent.split("\n").map((l) => l.trim());
+    if (!lines.includes("shipem.json")) {
+      appendFileSync(gitignorePath, "\n# Shipem config\nshipem.json\n");
+    }
+  } else {
+    writeFileSync2(gitignorePath, "# Shipem config\nshipem.json\n");
+  }
+  const elapsedSec = (Date.now() - startTime) / 1e3;
+  ui.deployBox(projectConfig.name, liveUrl, elapsedSec, deployFileCount, deployTotalBytes);
+}
+
+// src/commands/status.ts
+import chalk5 from "chalk";
+async function statusCommand() {
+  const cwd = process.cwd();
+  const config = readProjectConfig(cwd);
+  if (!config.deployment) {
+    ui.warn("No deployment found in this directory.");
+    ui.dim("Run `shipem` to deploy your app.");
+    process.exit(0);
+  }
+  const { deployment, project } = config;
+  ui.section("Deployment Status");
+  ui.br();
+  ui.kv("App", deployment.projectName);
+  ui.kv("URL", chalk5.blue.underline(deployment.url));
+  ui.kv("Deployed", new Date(deployment.deployedAt).toLocaleString());
+  ui.kv("Target", deployment.deployTarget);
+  ui.br();
+  if ((deployment.deployTarget === "cloudflare-pages" || deployment.deployTarget === "cloudflare-workers") && deployment.cloudflareProjectName) {
+    const cfCreds = getCloudflareCredentials();
+    if (cfCreds) {
+      const spinner = ui.spinner("Fetching live status from Cloudflare");
+      const cf = new CloudflarePages(cfCreds.apiToken, cfCreds.accountId);
+      try {
+        const status = await cf.getDeploymentStatus(
+          deployment.cloudflareProjectName,
+          deployment.deploymentId
+        );
+        if (status) {
+          spinner.succeed("Status fetched");
+          ui.kv("Deployment ID", status.id);
+          ui.kv(
+            "Status",
+            status.latest_stage?.status === "success" ? chalk5.green("\u2713 Active") : chalk5.yellow(status.latest_stage?.status ?? "unknown")
+          );
+          ui.br();
+          if (status.stages && status.stages.length > 0) {
+            ui.section("Build stages:");
+            for (const stage of status.stages) {
+              const icon = stage.status === "success" ? chalk5.green("\u2713") : stage.status === "failure" ? chalk5.red("\u2717") : chalk5.gray("\xB7");
+              ui.info(`${icon} ${stage.name}`);
+            }
+            ui.br();
+          }
+        } else {
+          spinner.warn("Could not fetch live status");
+        }
+      } catch {
+        spinner.warn("Could not fetch live status from Cloudflare");
+      }
+    }
+  }
+  ui.url("Live URL", deployment.url);
+  if (deployment.cloudflareProjectName) {
+    ui.url(
+      "Dashboard",
+      `https://dash.cloudflare.com/${deployment.cloudflareAccountId}/pages/view/${deployment.cloudflareProjectName}`
+    );
+  }
+  ui.br();
+}
+
+// src/commands/logs.ts
+import chalk6 from "chalk";
+async function logsCommand(options) {
+  const cwd = process.cwd();
+  const config = readProjectConfig(cwd);
+  if (!config.deployment) {
+    ui.warn("No deployment found in this directory.");
+    ui.dim("Run `shipem` to deploy your app.");
+    process.exit(0);
+  }
+  const { deployment } = config;
+  if (deployment.deployTarget !== "cloudflare-pages" && deployment.deployTarget !== "cloudflare-workers") {
+    ui.warn("Log streaming is only available for Cloudflare Pages deployments.");
+    ui.dim(`For Fly.io apps, run: flyctl logs --app ${deployment.projectName}`);
+    process.exit(0);
+  }
+  if (!deployment.cloudflareProjectName) {
+    ui.fatal("Missing Cloudflare project name in deployment config.");
+  }
+  const cfCreds = getCloudflareCredentials();
+  if (!cfCreds) {
+    ui.fatal(
+      "Cloudflare credentials not found.",
+      "Set CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID environment variables."
+    );
+  }
+  ui.section("Deployment Logs");
+  ui.br();
+  ui.kv("App", deployment.projectName);
+  ui.kv("Deployment", deployment.deploymentId);
+  ui.br();
+  const spinner = ui.spinner("Fetching logs");
+  const cf = new CloudflarePages(cfCreds.apiToken, cfCreds.accountId);
+  try {
+    const logs = await cf.getDeploymentLogs(
+      deployment.cloudflareProjectName,
+      deployment.deploymentId
+    );
+    spinner.stop();
+    if (logs.length === 0) {
+      ui.info("No logs available for this deployment.");
+    } else {
+      const linesToShow = options.lines ?? logs.length;
+      const displayLogs = logs.slice(-linesToShow);
+      for (const line of displayLogs) {
+        if (line.includes("ERROR") || line.includes("error") || line.includes("FAIL")) {
+          console.log(chalk6.red(`  ${line}`));
+        } else if (line.includes("WARN") || line.includes("warn")) {
+          console.log(chalk6.yellow(`  ${line}`));
+        } else {
+          console.log(chalk6.gray(`  ${line}`));
+        }
+      }
+    }
+  } catch (err) {
+    spinner.fail("Failed to fetch logs");
+    ui.error(err instanceof Error ? err.message : "Unknown error");
+  }
+  ui.br();
+}
+
+// src/commands/down.ts
+import inquirer2 from "inquirer";
+import axios3 from "axios";
+async function downCommand(options) {
+  const cwd = process.cwd();
+  const config = readProjectConfig(cwd);
+  if (!config.deployment) {
+    ui.warn("No deployment found in this directory.");
+    ui.dim("Run `shipem` to deploy your app first.");
+    process.exit(0);
+  }
+  const { deployment } = config;
+  ui.section("Taking down deployment");
+  ui.br();
+  ui.kv("App", deployment.projectName);
+  ui.kv("URL", deployment.url);
+  ui.br();
+  if (!options.yes) {
+    const { confirmed } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "confirmed",
+        message: `Are you sure you want to take down ${deployment.projectName}? This cannot be undone.`,
+        default: false
+      }
+    ]);
+    if (!confirmed) {
+      ui.info("Cancelled.");
+      process.exit(0);
+    }
+  }
+  ui.br();
+  if ((deployment.deployTarget === "cloudflare-pages" || deployment.deployTarget === "cloudflare-workers") && deployment.cloudflareProjectName) {
+    const cfCreds = getCloudflareCredentials();
+    if (!cfCreds) {
+      ui.fatal(
+        "Cloudflare credentials not found.",
+        "Set CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID environment variables."
+      );
+    }
+    const spinner = ui.spinner(`Deleting ${deployment.projectName} from Cloudflare Pages`);
+    const cf = new CloudflarePages(cfCreds.apiToken, cfCreds.accountId);
+    try {
+      await cf.deleteProject(deployment.cloudflareProjectName);
+      spinner.succeed("Deployment deleted from Cloudflare Pages");
+    } catch (err) {
+      spinner.fail("Failed to delete deployment");
+      ui.error(err instanceof Error ? err.message : "Unknown error");
+      process.exit(1);
+    }
+  } else if ((deployment.deployTarget === "cloudflare-pages" || deployment.deployTarget === "cloudflare-workers") && !deployment.cloudflareProjectName) {
+    const token = getSessionToken();
+    if (!token) {
+      ui.fatal("Not logged in. Run `shipem login` first.");
+    }
+    const spinner = ui.spinner(`Deleting ${deployment.projectName} from Shipem`);
+    try {
+      await axios3.delete(`${SHIPEM_API_URL}/projects/${deployment.deploymentId}`, {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+      spinner.succeed("Deployment deleted");
+    } catch (err) {
+      spinner.fail("Failed to delete deployment");
+      ui.error(err instanceof Error ? err.message : "Unknown error");
+      process.exit(1);
+    }
+  } else if (deployment.deployTarget === "flyio") {
+    ui.warn("Fly.io apps cannot be deleted automatically. Manual cleanup required:");
+    ui.info(`flyctl apps destroy ${deployment.projectName} --yes`);
+    ui.br();
+    ui.warn("Local deployment config has NOT been cleared \u2014 re-run after manual deletion.");
+    ui.br();
+    return;
+  }
+  writeProjectConfig({ project: config.project }, cwd);
+  ui.br();
+  ui.success("Deployment removed successfully.");
+  ui.dim("Your local code is untouched. Run `shipem` to deploy again.");
+  ui.br();
+}
+
+// src/commands/logout.ts
+import axios4 from "axios";
+async function logoutCommand() {
+  const token = getSessionToken();
+  if (!token) {
+    ui.info("You are not currently logged in.");
+    ui.br();
+    return;
+  }
+  try {
+    await axios4.post(`${SHIPEM_API_URL}/auth/logout`, { token }, { timeout: 5e3 });
+  } catch {
+  }
+  clearSessionToken();
+  ui.success("Logged out successfully.");
+  ui.br();
+}
+
+// src/index.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join7 } from "path";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var version = "0.1.0";
+try {
+  const pkg = JSON.parse(
+    readFileSync6(join7(__dirname2, "../package.json"), "utf-8")
+  );
+  version = pkg.version;
+} catch {
+}
+var program = new Command();
+program.name("shipem").description(
+  "One-command deployment for apps built by AI coding tools.\n\nYour AI built it. We'll ship it."
+).version(version, "-v, --version", "Display version number").addHelpText("before", () => {
+  ui.banner();
+  return "";
+}).addHelpText("after", `
+Quick start:
+  npx shipem          Deploy your app
+  npx shipem login    Authenticate with GitHub
+  npx shipem status   Check deployment status
+  npx shipem down     Take your app offline
+`);
+program.command("deploy", { isDefault: true }).description("Detect and deploy your app (default command)").option("-y, --yes", "Skip all prompts and use defaults").option("-n, --name <name>", "Override app name").option("--skip-build", "Skip the build step (deploy existing output directory)").option("--direct", "Deploy directly using your Cloudflare credentials (bypass Shipem API)").action(async (options) => {
+  try {
+    await deployCommand(options);
+  } catch (err) {
+    ui.br();
+    ui.error(err instanceof Error ? err.message : "An unexpected error occurred.");
+    if (process.env.DEBUG) {
+      console.error(err);
+    }
+    process.exit(1);
+  }
+});
+program.command("login").description("Log in to Shipem via GitHub").action(async () => {
+  try {
+    await loginCommand();
+  } catch (err) {
+    ui.error(err instanceof Error ? err.message : "Login failed.");
+    process.exit(1);
+  }
+});
+program.command("logout").description("Log out of Shipem").action(async () => {
+  try {
+    await logoutCommand();
+  } catch (err) {
+    ui.error(err instanceof Error ? err.message : "Logout failed.");
+    process.exit(1);
+  }
+});
+program.command("status").description("Check deployment status").action(async () => {
+  try {
+    await statusCommand();
+  } catch (err) {
+    ui.error(err instanceof Error ? err.message : "An unexpected error occurred.");
+    process.exit(1);
+  }
+});
+program.command("logs").description("View recent deployment logs").option("-n, --lines <number>", "Number of log lines to show", "100").action(async (options) => {
+  try {
+    await logsCommand({ lines: options.lines ? parseInt(options.lines, 10) : void 0 });
+  } catch (err) {
+    ui.error(err instanceof Error ? err.message : "An unexpected error occurred.");
+    process.exit(1);
+  }
+});
+program.command("down").description("Take down a deployment").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
+  try {
+    await downCommand(options);
+  } catch (err) {
+    ui.error(err instanceof Error ? err.message : "An unexpected error occurred.");
+    process.exit(1);
+  }
+});
+var domainsCmd = program.command("domains").description("Manage custom domains (coming soon)");
+domainsCmd.command("add <domain>").description("Add a custom domain to your deployment").action(() => {
+  ui.warn("Custom domains are coming soon!");
+  ui.dim("Follow our changelog at https://shipem.dev/changelog for updates.");
+  ui.br();
+});
+program.on("command:*", (cmds) => {
+  ui.error(`Unknown command: ${cmds[0]}`);
+  ui.dim("Run `shipem --help` to see available commands.");
+  process.exit(1);
+});
+program.parse(process.argv);