@comergehq/cli 0.1.1

package/dist/cli.js

@@ -0,0 +1,1744 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import pc10 from "picocolors";
+
+// src/commands/shellInit.ts
+import path5 from "path";
+import os from "os";
+import pc from "picocolors";
+import prompts from "prompts";
+import fse4 from "fs-extra";
+
+// src/lib/errors.ts
+var CliError = class extends Error {
+  exitCode;
+  hint;
+  constructor(message, opts) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = opts?.exitCode ?? 1;
+    this.hint = opts?.hint ?? null;
+  }
+};
+
+// src/lib/packageJson.ts
+import fs from "fs/promises";
+async function readPackageJson(projectRoot) {
+  const raw = await fs.readFile(`${projectRoot}/package.json`, "utf8").catch(() => null);
+  if (!raw) {
+    throw new CliError("package.json not found", { exitCode: 2 });
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new CliError("Failed to parse package.json", { exitCode: 2 });
+  }
+}
+var STUDIO_PEERS = [
+  "@callstack/liquid-glass",
+  "@supabase/supabase-js",
+  "@gorhom/bottom-sheet",
+  "expo-file-system",
+  "expo-haptics",
+  "expo-linear-gradient",
+  "lucide-react-native",
+  "react-native-gesture-handler",
+  "react-native-reanimated",
+  "react-native-safe-area-context",
+  "react-native-svg",
+  "react-native-view-shot"
+];
+function buildShellPackageJson(params) {
+  const orig = params.original;
+  const warnings = [];
+  const dependencies = { ...orig.dependencies ?? {} };
+  const devDependencies = { ...orig.devDependencies ?? {} };
+  const main2 = "expo-router/entry";
+  dependencies["@comergehq/studio"] = params.studioVersion || "latest";
+  dependencies["@comergehq/runtime"] = params.studioVersion || "latest";
+  if (!dependencies["expo-router"] && !devDependencies["expo-router"]) {
+    dependencies["expo-router"] = "latest";
+    warnings.push("Added missing dependency expo-router@latest");
+  }
+  for (const dep of STUDIO_PEERS) {
+    if (dependencies[dep] || devDependencies[dep]) continue;
+    dependencies[dep] = "latest";
+    warnings.push(`Added missing peer dependency ${dep}@latest`);
+  }
+  const pkg = {
+    ...orig,
+    name: orig.name ? `${orig.name}-comerge-shell` : "comerge-shell",
+    private: true,
+    main: main2,
+    scripts: {
+      dev: "expo start -c",
+      ios: "expo start -c --ios",
+      android: "expo start -c --android",
+      web: "expo start -c --web",
+      ...orig.scripts ?? {}
+    },
+    dependencies,
+    devDependencies
+  };
+  return { pkg, warnings };
+}
+
+// src/lib/fs.ts
+import fs2 from "fs/promises";
+import path from "path";
+import fse from "fs-extra";
+async function ensureEmptyDir(dir) {
+  const exists2 = await fse.pathExists(dir);
+  if (exists2) {
+    throw new CliError("Output directory already exists", {
+      hint: `Choose a new --out directory or delete: ${dir}`,
+      exitCode: 2
+    });
+  }
+  await fse.mkdirp(dir);
+}
+async function writeJsonAtomic(filePath, value) {
+  const dir = path.dirname(filePath);
+  await fse.mkdirp(dir);
+  const tmp = `${filePath}.tmp-${Date.now()}`;
+  await fs2.writeFile(tmp, JSON.stringify(value, null, 2) + "\n", "utf8");
+  await fs2.rename(tmp, filePath);
+}
+async function writeTextAtomic(filePath, contents) {
+  const dir = path.dirname(filePath);
+  await fse.mkdirp(dir);
+  const tmp = `${filePath}.tmp-${Date.now()}`;
+  await fs2.writeFile(tmp, contents, "utf8");
+  await fs2.rename(tmp, filePath);
+}
+
+// src/lib/projectDetect.ts
+import fs3 from "fs/promises";
+import path2 from "path";
+async function fileExists(p) {
+  try {
+    const st = await fs3.stat(p);
+    return st.isFile();
+  } catch {
+    return false;
+  }
+}
+async function findExpoProjectRoot(startDir) {
+  let cur = path2.resolve(startDir);
+  while (true) {
+    const pkg = path2.join(cur, "package.json");
+    if (await fileExists(pkg)) {
+      const hasAppJson = await fileExists(path2.join(cur, "app.json"));
+      const hasAppConfig = await fileExists(path2.join(cur, "app.config.js")) || await fileExists(path2.join(cur, "app.config.ts"));
+      if (!hasAppJson && !hasAppConfig) {
+      } else {
+        return cur;
+      }
+    }
+    const parent = path2.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  throw new CliError("Not inside an Expo project", {
+    hint: "Run this command from the root of your Expo project repository.",
+    exitCode: 2
+  });
+}
+
+// src/lib/templates.ts
+function shellLayoutTsx() {
+  return `import { Stack } from 'expo-router';
+import { GestureHandlerRootView } from 'react-native-gesture-handler';
+
+export default function Layout() {
+  return (
+    <GestureHandlerRootView style={{ flex: 1 }}>
+      <Stack screenOptions={{ headerShown: false }} />
+    </GestureHandlerRootView>
+  );
+}
+`;
+}
+function shellIndexTsx() {
+  return `import * as React from 'react';
+import { View } from 'react-native';
+import { Stack } from 'expo-router';
+import { ComergeStudio } from '@comergehq/studio';
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import config from '../comerge.config.json';
+
+export default function Index() {
+  const appId = String((config as any)?.appId || '');
+  const appKey = String((config as any)?.appKey || 'MicroMain');
+  const apiKey = String((config as any)?.apiKey || '');
+  return (
+    <>
+      <Stack.Screen options={{ headerShown: false }} />
+      <View style={{ flex: 1 }}>
+        {appId ? <ComergeStudio appId={appId} apiKey={apiKey} appKey={appKey} /> : null}
+      </View>
+    </>
+  );
+}
+`;
+}
+function shellBabelConfigJs() {
+  return `module.exports = function (api) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo'],
+    plugins: ['react-native-reanimated/plugin'],
+  };
+};
+`;
+}
+function shellMetroConfigJs() {
+  return `const { getDefaultConfig } = require('expo/metro-config');
+
+const config = getDefaultConfig(__dirname);
+
+module.exports = config;
+`;
+}
+
+// src/lib/packageManager.ts
+import fs4 from "fs/promises";
+async function exists(p) {
+  try {
+    await fs4.stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectPackageManager(projectRoot) {
+  if (await exists(`${projectRoot}/pnpm-lock.yaml`)) return "pnpm";
+  if (await exists(`${projectRoot}/yarn.lock`)) return "yarn";
+  if (await exists(`${projectRoot}/package-lock.json`)) return "npm";
+  if (await exists(`${projectRoot}/bun.lockb`)) return "bun";
+  return "npm";
+}
+function installCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return { cmd: "pnpm", args: ["install"] };
+    case "yarn":
+      return { cmd: "yarn", args: ["install"] };
+    case "bun":
+      return { cmd: "bun", args: ["install"] };
+    case "npm":
+    default:
+      return { cmd: "npm", args: ["install"] };
+  }
+}
+
+// src/commands/shellInit.ts
+import { execa } from "execa";
+
+// src/lib/copyProject.ts
+import path3 from "path";
+import fse2 from "fs-extra";
+var ALWAYS_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".expo",
+  "dist",
+  "build"
+]);
+function normalizeRel(relPath) {
+  return relPath.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function shouldExclude(relPath) {
+  const rel = normalizeRel(relPath);
+  const parts = rel.split("/").filter(Boolean);
+  const top = parts[0] ?? "";
+  if (!top) return false;
+  if (ALWAYS_EXCLUDE_DIRS.has(top)) return true;
+  if (rel.startsWith("ios/build/") || rel === "ios/build") return true;
+  if (rel.startsWith("android/build/") || rel === "android/build") return true;
+  return false;
+}
+async function copyProject(params) {
+  const src = path3.resolve(params.projectRoot);
+  const dest = path3.resolve(params.outRoot);
+  const srcExists = await fse2.pathExists(src);
+  if (!srcExists) {
+    throw new CliError("Project root does not exist", { exitCode: 2 });
+  }
+  await fse2.copy(src, dest, {
+    dereference: true,
+    preserveTimestamps: true,
+    filter: (srcPath) => {
+      const rel = path3.relative(src, srcPath);
+      if (!rel) return true;
+      return !shouldExclude(rel);
+    }
+  });
+}
+
+// src/lib/stripProject.ts
+import path4 from "path";
+import fse3 from "fs-extra";
+var DEFAULT_STRIP_DIRS = ["app", "src", "components", "lib", "hooks", "providers"];
+async function stripProject(params) {
+  const dirs = params.dirs ?? DEFAULT_STRIP_DIRS;
+  await Promise.all(
+    dirs.map(async (d) => {
+      const p = path4.join(params.outRoot, d);
+      const exists2 = await fse3.pathExists(p);
+      if (!exists2) return;
+      await fse3.remove(p);
+    })
+  );
+}
+
+// src/commands/shellInit.ts
+import fs7 from "fs/promises";
+
+// src/lib/appJsonPatch.ts
+import fs5 from "fs/promises";
+function pluginName(entry) {
+  if (Array.isArray(entry)) return typeof entry[0] === "string" ? entry[0] : null;
+  return typeof entry === "string" ? entry : null;
+}
+async function ensureComergeShellPlugins(appJsonPath) {
+  let raw;
+  try {
+    raw = await fs5.readFile(appJsonPath, "utf8");
+  } catch {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new CliError("Failed to parse app.json in generated shell", { exitCode: 2 });
+  }
+  const expo = parsed.expo;
+  if (!expo || typeof expo !== "object") return false;
+  const plugins = Array.isArray(expo.plugins) ? [...expo.plugins] : [];
+  const routerEntry = plugins.find((p) => pluginName(p) === "expo-router");
+  const runtimeEntry = plugins.find((p) => pluginName(p) === "@comergehq/runtime");
+  const needsRouter = !routerEntry;
+  const needsRuntime = !runtimeEntry;
+  if (!needsRouter && !needsRuntime) return false;
+  const rest = plugins.filter((p) => {
+    const name = pluginName(p);
+    return name !== "expo-router" && name !== "@comergehq/runtime";
+  });
+  expo.plugins = [routerEntry ?? "expo-router", runtimeEntry ?? "@comergehq/runtime", ...rest];
+  await fs5.writeFile(appJsonPath, JSON.stringify({ expo }, null, 2) + "\n", "utf8");
+  return true;
+}
+
+// src/lib/reanimated.ts
+import fs6 from "fs/promises";
+async function ensureReanimatedBabelPlugin(babelConfigPath) {
+  const raw = await fs6.readFile(babelConfigPath, "utf8").catch(() => null);
+  if (!raw) return false;
+  if (raw.includes("react-native-reanimated/plugin")) return false;
+  const patched = patchBabelConfigAddReanimatedPlugin(raw);
+  if (patched === raw) return false;
+  await fs6.writeFile(babelConfigPath, patched, "utf8");
+  return true;
+}
+function patchBabelConfigAddReanimatedPlugin(raw) {
+  const pluginsMatch = /(^|\n)([ \t]*)plugins\s*:\s*\[/m.exec(raw);
+  if (pluginsMatch) {
+    const matchIdx = pluginsMatch.index + pluginsMatch[1].length;
+    const indent = pluginsMatch[2] ?? "";
+    const bracketIdx = raw.indexOf("[", matchIdx);
+    if (bracketIdx >= 0) {
+      const closeIdx = findMatchingBracket(raw, bracketIdx, "[", "]");
+      if (closeIdx >= 0) {
+        const inner = raw.slice(bracketIdx + 1, closeIdx);
+        const innerTrim = inner.trim();
+        const innerTrimEnd = inner.replace(/[ \t\r\n]+$/g, "");
+        const elementIndent = indent + "  ";
+        let insert = "";
+        if (!innerTrim) {
+          insert = `
+${elementIndent}'react-native-reanimated/plugin'
+${indent}`;
+        } else if (innerTrimEnd.endsWith(",")) {
+          insert = `
+${elementIndent}'react-native-reanimated/plugin'`;
+        } else {
+          insert = `,
+${elementIndent}'react-native-reanimated/plugin'`;
+        }
+        return raw.slice(0, closeIdx) + insert + raw.slice(closeIdx);
+      }
+    }
+  }
+  const presetsMatch = /(^|\n)([ \t]*)presets\s*:\s*\[[^\]]*\]\s*,?/m.exec(raw);
+  if (presetsMatch) {
+    const indent = presetsMatch[2] ?? "";
+    const insertAt = presetsMatch.index + presetsMatch[0].length;
+    const insertion = `
+${indent}// Required by react-native-reanimated. Must be listed last.
+${indent}plugins: ['react-native-reanimated/plugin'],`;
+    return raw.slice(0, insertAt) + insertion + raw.slice(insertAt);
+  }
+  return raw;
+}
+function findMatchingBracket(text, openIdx, open, close) {
+  let depth = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inTemplate = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = openIdx; i < text.length; i++) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (!inSingle && !inDouble && !inTemplate) {
+      if (ch === "/" && next === "/") {
+        inLineComment = true;
+        i++;
+        continue;
+      }
+      if (ch === "/" && next === "*") {
+        inBlockComment = true;
+        i++;
+        continue;
+      }
+    }
+    if (!inDouble && !inTemplate && ch === "'" && text[i - 1] !== "\\") {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (!inSingle && !inTemplate && ch === `"` && text[i - 1] !== "\\") {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "`" && text[i - 1] !== "\\") {
+      inTemplate = !inTemplate;
+      continue;
+    }
+    if (inSingle || inDouble || inTemplate) continue;
+    if (ch === open) depth++;
+    if (ch === close) {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+// src/commands/shellInit.ts
+async function shellInit(params) {
+  const projectRoot = await findExpoProjectRoot(process.cwd());
+  const outDirDefault = params.outDir || "comerge-shell";
+  let outDir = outDirDefault;
+  let appId = params.appId ?? "";
+  let apiKey = params.apiKey ?? "";
+  let appKey = params.appKey ?? "MicroMain";
+  if (!params.yes) {
+    const res = await prompts(
+      [
+        {
+          type: "text",
+          name: "outDir",
+          message: "Output directory",
+          initial: outDir
+        },
+        {
+          type: "text",
+          name: "appKey",
+          message: "App key",
+          initial: appKey
+        },
+        {
+          type: "text",
+          name: "appId",
+          message: "Comerge appId",
+          initial: appId,
+          validate: (value) => String(value || "").trim().length > 0 ? true : "appId is required"
+        },
+        {
+          type: "password",
+          name: "apiKey",
+          message: "Comerge apiKey",
+          initial: apiKey,
+          validate: (value) => String(value || "").trim().length > 0 ? true : "apiKey is required"
+        }
+      ],
+      {
+        onCancel: () => {
+          throw new CliError("Cancelled", { exitCode: 130 });
+        }
+      }
+    );
+    outDir = String(res.outDir || outDir);
+    appKey = String(res.appKey || appKey);
+    appId = String(res.appId || appId);
+    apiKey = String(res.apiKey || apiKey);
+  }
+  appId = String(appId || "").trim();
+  apiKey = String(apiKey || "").trim();
+  if (!appId) {
+    throw new CliError("Missing required appId", {
+      hint: "Pass --app-id <uuid> (or omit --yes to be prompted).",
+      exitCode: 2
+    });
+  }
+  if (!apiKey) {
+    throw new CliError("Missing required apiKey", {
+      hint: "Pass --api-key <key> (or omit --yes to be prompted).",
+      exitCode: 2
+    });
+  }
+  const outputPath = path5.resolve(projectRoot, outDir);
+  console.log(pc.dim(`Project: ${projectRoot}`));
+  console.log(pc.dim(`Output:  ${outputPath}`));
+  if (await fse4.pathExists(outputPath)) {
+    throw new CliError("Output directory already exists", {
+      hint: `Delete ${outputPath} or choose a different --out path.`,
+      exitCode: 2
+    });
+  }
+  const outputIsInsideProject = outputPath === projectRoot || outputPath.startsWith(projectRoot + path5.sep);
+  const stagingPath = outputIsInsideProject ? await fs7.mkdtemp(path5.join(os.tmpdir(), "comerge-shell-")) : outputPath;
+  let movedToFinal = false;
+  try {
+    if (!outputIsInsideProject) {
+      await ensureEmptyDir(stagingPath);
+    }
+    await copyProject({ projectRoot, outRoot: stagingPath });
+    await stripProject({ outRoot: stagingPath });
+    try {
+      const didPatch = await ensureComergeShellPlugins(path5.join(stagingPath, "app.json"));
+      if (didPatch) {
+        console.log(pc.dim("Patched app.json to include required Comerge shell plugins."));
+      }
+    } catch {
+    }
+    await writeJsonAtomic(path5.join(stagingPath, "comerge.config.json"), {
+      appId,
+      appKey: appKey || "MicroMain",
+      apiKey
+    });
+    await writeTextAtomic(path5.join(stagingPath, "app/_layout.tsx"), shellLayoutTsx());
+    await writeTextAtomic(path5.join(stagingPath, "app/index.tsx"), shellIndexTsx());
+    await ensureTextFile(path5.join(stagingPath, "babel.config.js"), shellBabelConfigJs());
+    await ensureTextFile(path5.join(stagingPath, "metro.config.js"), shellMetroConfigJs());
+    try {
+      const didPatch = await ensureReanimatedBabelPlugin(path5.join(stagingPath, "babel.config.js"));
+      if (didPatch) console.log(pc.dim("Patched babel.config.js to include react-native-reanimated/plugin."));
+    } catch {
+    }
+    await ensureTextFile(
+      path5.join(stagingPath, "tsconfig.json"),
+      JSON.stringify(
+        {
+          extends: "expo/tsconfig.base",
+          compilerOptions: { strict: true, resolveJsonModule: true }
+        },
+        null,
+        2
+      ) + "\n"
+    );
+    const originalPkg = await readPackageJson(stagingPath);
+    const { pkg: shellPkg, warnings } = buildShellPackageJson({
+      original: originalPkg,
+      studioVersion: params.studioVersion
+    });
+    await writeJsonAtomic(path5.join(stagingPath, "package.json"), shellPkg);
+    for (const w of warnings) console.log(pc.yellow(`Warning: ${w}`));
+    if (outputIsInsideProject) {
+      await fse4.move(stagingPath, outputPath, { overwrite: false });
+      movedToFinal = true;
+    }
+    const finalPath = outputIsInsideProject ? outputPath : stagingPath;
+    if (params.install) {
+      const pm = params.packageManager ?? await detectPackageManager(projectRoot);
+      const { cmd, args } = installCommand(pm);
+      console.log(pc.dim(`Installing deps with ${cmd}...`));
+      const res = await execa(cmd, args, { cwd: finalPath, stdio: "inherit" });
+      if (res.exitCode !== 0) {
+        throw new CliError("Dependency install failed", { exitCode: res.exitCode ?? 1 });
+      }
+    }
+    console.log(pc.green("Shell app generated."));
+    console.log(pc.dim(`Next: cd ${path5.relative(process.cwd(), finalPath)} && (install deps) && expo prebuild`));
+  } finally {
+    if (outputIsInsideProject && !movedToFinal) {
+      try {
+        await fse4.remove(stagingPath);
+      } catch {
+      }
+    }
+  }
+}
+async function ensureTextFile(filePath, contents) {
+  try {
+    await fs7.access(filePath);
+    return;
+  } catch {
+  }
+  await writeTextAtomic(filePath, contents);
+}
+
+// src/commands/shell.ts
+function registerShellCommands(program) {
+  const shell = program.command("shell").description("Shell app utilities");
+  shell.command("init").description("Generate an Expo Router shell app that renders Comerge Studio").option("--out <dir>", "Output directory", "comerge-shell").requiredOption("--app-id <uuid>", "Comerge appId (required)").requiredOption("--api-key <key>", "Comerge apiKey (required)").option("--app-key <key>", "Bundle app key (default MicroMain)", "MicroMain").option("--yes", "Non-interactive; use defaults", false).option("--install", "Install dependencies in the generated shell folder", false).option(
+    "--package-manager <pm>",
+    "Override package manager detection (pnpm|npm|yarn|bun)"
+  ).option("--studio-version <ver>", "Version to use for @comergehq/studio", "latest").action(async (opts) => {
+    await shellInit({
+      outDir: String(opts.out),
+      appId: String(opts.appId ?? ""),
+      apiKey: String(opts.apiKey ?? ""),
+      appKey: String(opts.appKey ?? "MicroMain"),
+      yes: Boolean(opts.yes),
+      install: Boolean(opts.install),
+      packageManager: opts.packageManager ? String(opts.packageManager) : null,
+      studioVersion: String(opts.studioVersion ?? "latest")
+    });
+  });
+}
+
+// src/commands/login.ts
+import pc2 from "picocolors";
+
+// src/lib/config.ts
+import { z } from "zod";
+var urlSchema = z.string().min(1).transform((s) => s.trim()).refine((s) => {
+  try {
+    new URL(s);
+    return true;
+  } catch {
+    return false;
+  }
+}, "Invalid URL").transform((s) => s.replace(/\/+$/, ""));
+var configSchema = z.object({
+  apiUrl: urlSchema,
+  supabaseUrl: urlSchema,
+  supabaseAnonKey: z.string().min(1)
+});
+function pickEnv(names) {
+  for (const n of names) {
+    const v = process.env[n];
+    if (typeof v === "string" && v.trim().length > 0) return v;
+  }
+  return void 0;
+}
+function resolveConfig(opts) {
+  void opts;
+  const apiUrl = pickEnv(["COMERGE_API_URL"]);
+  const supabaseUrl = pickEnv(["COMERGE_SUPABASE_URL"]);
+  const supabaseAnonKey = pickEnv(["COMERGE_SUPABASE_ANON_KEY"]);
+  const parsed = configSchema.safeParse({
+    apiUrl,
+    supabaseUrl,
+    supabaseAnonKey
+  });
+  if (!parsed.success) {
+    const missing = [];
+    if (!apiUrl) missing.push("COMERGE_API_URL");
+    if (!supabaseUrl) missing.push("COMERGE_SUPABASE_URL");
+    if (!supabaseAnonKey) missing.push("COMERGE_SUPABASE_ANON_KEY");
+    const hintLines = [];
+    hintLines.push("Set required environment variables:");
+    hintLines.push(`  - COMERGE_API_URL`);
+    hintLines.push(`  - COMERGE_SUPABASE_URL`);
+    hintLines.push(`  - COMERGE_SUPABASE_ANON_KEY`);
+    throw new CliError("Missing or invalid CLI configuration", {
+      exitCode: 2,
+      hint: missing.length ? `${hintLines.join("\n")}
+
+Missing: ${missing.join(", ")}` : `${hintLines.join("\n")}
+
+Details: ${parsed.error.issues.map((i) => `${i.path.join(".") || "config"}: ${i.message}`).join("; ")}`
+    });
+  }
+  return parsed.data;
+}
+
+// src/lib/oauthCallbackServer.ts
+import http from "http";
+async function startOAuthCallbackServer(params) {
+  const timeoutMs = params?.timeoutMs ?? 3 * 6e4;
+  const requestedPort = params?.port ?? null;
+  let resolveCode = null;
+  let rejectCode = null;
+  const codePromise = new Promise((resolve, reject) => {
+    resolveCode = resolve;
+    rejectCode = reject;
+  });
+  const server = http.createServer((req, res) => {
+    try {
+      const base = `http://127.0.0.1`;
+      const u = new URL(req.url ?? "/", base);
+      const errorDescription = u.searchParams.get("error_description");
+      const error = u.searchParams.get("error");
+      const code = u.searchParams.get("code");
+      if (errorDescription || error) {
+        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(`<html><body><h3>Login failed</h3><p>${escapeHtml(errorDescription ?? error ?? "Unknown error")}</p></body></html>`);
+        rejectCode?.(new CliError("Login failed", { exitCode: 1, hint: errorDescription ?? error ?? void 0 }));
+        return;
+      }
+      if (!code) {
+        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(`<html><body><h3>Missing code</h3><p>No authorization code was provided.</p></body></html>`);
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(
+        `<html><body><h3>Login complete</h3><p>You can close this tab and return to the terminal.</p></body></html>`
+      );
+      resolveCode?.(code);
+    } catch (err) {
+      rejectCode?.(err);
+      res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("Internal error");
+    } finally {
+      try {
+        server.close();
+      } catch {
+      }
+    }
+  });
+  const listenPort = typeof requestedPort === "number" ? requestedPort : 0;
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(listenPort, "127.0.0.1", () => resolve());
+  });
+  const addr = server.address();
+  if (!addr || typeof addr === "string") {
+    server.close();
+    throw new CliError("Failed to start callback server", { exitCode: 1 });
+  }
+  const redirectTo = `http://127.0.0.1:${addr.port}/callback`;
+  const timeout = setTimeout(() => {
+    rejectCode?.(
+      new CliError("Login timed out", {
+        exitCode: 1,
+        hint: "Try running `comerge login` again."
+      })
+    );
+    try {
+      server.close();
+    } catch {
+    }
+  }, timeoutMs).unref();
+  const waitForCode = async () => {
+    try {
+      return await codePromise;
+    } finally {
+      clearTimeout(timeout);
+    }
+  };
+  const close = async () => {
+    clearTimeout(timeout);
+    await new Promise((resolve) => server.close(() => resolve())).catch(() => {
+    });
+  };
+  return { redirectTo, waitForCode, close };
+}
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\"/g, "&quot;").replace(/'/g, "&#039;");
+}
+
+// src/lib/browser.ts
+import { execa as execa2 } from "execa";
+async function openBrowser(url) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      await execa2("open", [url], { stdio: "ignore" });
+      return;
+    }
+    if (platform === "win32") {
+      await execa2("cmd", ["/c", "start", "", url], { stdio: "ignore", windowsHide: true });
+      return;
+    }
+    await execa2("xdg-open", [url], { stdio: "ignore" });
+  } catch (err) {
+    throw new CliError("Failed to open browser automatically", {
+      exitCode: 1,
+      hint: `Open this URL manually:
+${url}
+
+${err?.message ?? String(err)}`
+    });
+  }
+}
+
+// src/lib/supabase.ts
+import { createClient } from "@supabase/supabase-js";
+function createInMemoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    getItem: (k) => map.get(k) ?? null,
+    setItem: (k, v) => {
+      map.set(k, v);
+    },
+    removeItem: (k) => {
+      map.delete(k);
+    }
+  };
+}
+function createSupabaseClient(config, storage) {
+  return createClient(config.supabaseUrl, config.supabaseAnonKey, {
+    auth: {
+      flowType: "pkce",
+      persistSession: false,
+      autoRefreshToken: false,
+      detectSessionInUrl: false,
+      storage
+    },
+    global: {
+      headers: {
+        "X-Requested-By": "comerge-cli"
+      }
+    }
+  });
+}
+function toStoredSession(session) {
+  if (!session.access_token || !session.refresh_token || !session.expires_at) {
+    throw new CliError("Supabase session missing required fields", { exitCode: 1 });
+  }
+  return {
+    access_token: session.access_token,
+    refresh_token: session.refresh_token,
+    expires_at: session.expires_at,
+    token_type: session.token_type ?? void 0,
+    user: session.user ? { id: session.user.id, email: session.user.email ?? null } : void 0
+  };
+}
+function createSupabaseAuthHelpers(config) {
+  const storage = createInMemoryStorage();
+  const supabase = createSupabaseClient(config, storage);
+  return {
+    async startGoogleLogin(params) {
+      const { data, error } = await supabase.auth.signInWithOAuth({
+        provider: "google",
+        options: {
+          redirectTo: params.redirectTo,
+          skipBrowserRedirect: true,
+          queryParams: {
+            access_type: "offline",
+            prompt: "consent"
+          }
+        }
+      });
+      if (error) throw error;
+      if (!data?.url) throw new CliError("Supabase did not return an OAuth URL", { exitCode: 1 });
+      return { url: data.url };
+    },
+    async exchangeCode(params) {
+      const { data, error } = await supabase.auth.exchangeCodeForSession(params.code);
+      if (error) throw error;
+      if (!data?.session) throw new CliError("No session returned from Supabase", { exitCode: 1 });
+      return toStoredSession(data.session);
+    },
+    async refreshWithStoredSession(params) {
+      const { data, error } = await supabase.auth.setSession({
+        access_token: params.session.access_token,
+        refresh_token: params.session.refresh_token
+      });
+      if (error) throw error;
+      if (!data?.session) throw new CliError("No session returned after refresh", { exitCode: 1 });
+      return toStoredSession(data.session);
+    }
+  };
+}
+
+// src/lib/sessionStore.ts
+import fs8 from "fs/promises";
+import os2 from "os";
+import path6 from "path";
+import { z as z2 } from "zod";
+var storedSessionSchema = z2.object({
+  access_token: z2.string().min(1),
+  refresh_token: z2.string().min(1),
+  expires_at: z2.number().int().positive(),
+  token_type: z2.string().min(1).optional(),
+  user: z2.object({
+    id: z2.string().min(1),
+    email: z2.string().email().optional().nullable()
+  }).optional()
+});
+var KEYTAR_SERVICE = "comerge-cli";
+var KEYTAR_ACCOUNT = "default";
+function xdgConfigHome() {
+  const v = process.env.XDG_CONFIG_HOME;
+  if (typeof v === "string" && v.trim().length > 0) return v;
+  return path6.join(os2.homedir(), ".config");
+}
+function sessionFilePath() {
+  return path6.join(xdgConfigHome(), "comerge", "session.json");
+}
+async function maybeLoadKeytar() {
+  try {
+    const mod = await import("keytar");
+    const candidates = [mod?.default, mod].filter(Boolean);
+    for (const c of candidates) {
+      if (c && typeof c.getPassword === "function" && typeof c.setPassword === "function" && typeof c.deletePassword === "function") {
+        return c;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function ensurePathPermissions(filePath) {
+  const dir = path6.dirname(filePath);
+  await fs8.mkdir(dir, { recursive: true });
+  try {
+    await fs8.chmod(dir, 448);
+  } catch {
+  }
+  try {
+    await fs8.chmod(filePath, 384);
+  } catch {
+  }
+}
+async function getSession() {
+  const keytar = await maybeLoadKeytar();
+  if (keytar) {
+    const raw2 = await keytar.getPassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT);
+    if (!raw2) return null;
+    try {
+      const parsed = storedSessionSchema.safeParse(JSON.parse(raw2));
+      if (!parsed.success) return null;
+      return parsed.data;
+    } catch {
+      return null;
+    }
+  }
+  const fp = sessionFilePath();
+  const raw = await fs8.readFile(fp, "utf8").catch(() => null);
+  if (!raw) return null;
+  try {
+    const parsed = storedSessionSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) return null;
+    await ensurePathPermissions(fp);
+    return parsed.data;
+  } catch {
+    return null;
+  }
+}
+async function setSession(session) {
+  const parsed = storedSessionSchema.safeParse(session);
+  if (!parsed.success) {
+    throw new CliError("Refusing to store invalid session", { exitCode: 1 });
+  }
+  const keytar = await maybeLoadKeytar();
+  if (keytar) {
+    await keytar.setPassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT, JSON.stringify(parsed.data));
+    return;
+  }
+  const fp = sessionFilePath();
+  await writeJsonAtomic(fp, parsed.data);
+  await ensurePathPermissions(fp);
+}
+async function clearSession() {
+  const keytar = await maybeLoadKeytar();
+  if (keytar) {
+    await keytar.deletePassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT);
+    return;
+  }
+  const fp = sessionFilePath();
+  await fs8.rm(fp, { force: true }).catch(() => {
+  });
+}
+
+// src/lib/api.ts
+function shouldRefreshSoon(session, skewSeconds = 60) {
+  const nowSec = Math.floor(Date.now() / 1e3);
+  return session.expires_at <= nowSec + skewSeconds;
+}
+async function readJsonSafe(res) {
+  const ct = res.headers.get("content-type") ?? "";
+  if (!ct.toLowerCase().includes("application/json")) return null;
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function getAuthToken(config) {
+  const envToken = process.env.COMERGE_ACCESS_TOKEN;
+  if (typeof envToken === "string" && envToken.trim().length > 0) {
+    return { token: envToken.trim(), session: null, fromEnv: true };
+  }
+  let session = await getSession();
+  if (!session) {
+    throw new CliError("Not logged in", {
+      exitCode: 2,
+      hint: "Run `comerge login` first, or set COMERGE_ACCESS_TOKEN for CI."
+    });
+  }
+  if (shouldRefreshSoon(session)) {
+    try {
+      const supabase = createSupabaseAuthHelpers(config);
+      session = await supabase.refreshWithStoredSession({ session });
+      await setSession(session);
+    } catch (err) {
+      void err;
+    }
+  }
+  return { token: session.access_token, session, fromEnv: false };
+}
+function createApiClient(config) {
+  const cfg = config ?? resolveConfig();
+  async function request(path10, init) {
+    const { token, session, fromEnv } = await getAuthToken(cfg);
+    const url = new URL(path10, cfg.apiUrl).toString();
+    const doFetch = async (bearer) => {
+      const res2 = await fetch(url, {
+        ...init,
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          ...init?.headers ?? {},
+          Authorization: `Bearer ${bearer}`
+        }
+      });
+      return res2;
+    };
+    let res = await doFetch(token);
+    if (res.status === 401 && !fromEnv && session?.refresh_token) {
+      const supabase = createSupabaseAuthHelpers(cfg);
+      const refreshed = await supabase.refreshWithStoredSession({ session });
+      await setSession(refreshed);
+      res = await doFetch(refreshed.access_token);
+    }
+    if (!res.ok) {
+      const body = await readJsonSafe(res);
+      const msg = (body && typeof body === "object" && body && "message" in body && typeof body.message === "string" ? body.message : null) ?? `Request failed (${res.status})`;
+      throw new CliError(msg, { exitCode: 1, hint: body ? JSON.stringify(body, null, 2) : null });
+    }
+    const json = await readJsonSafe(res);
+    return json ?? null;
+  }
+  return {
+    getMe: () => request("/v1/me", { method: "GET" }),
+    getApp: (appId) => request(`/v1/apps/${encodeURIComponent(appId)}`, { method: "GET" }),
+    presignImportUpload: (payload) => request("/v1/apps/import/upload/presign", { method: "POST", body: JSON.stringify(payload) }),
+    importFromUpload: (payload) => request("/v1/apps/import/upload", { method: "POST", body: JSON.stringify(payload) })
+  };
+}
+
+// src/commands/login.ts
+function registerLoginCommand(program) {
+  program.command("login").description("Authenticate with Comerge").option("--no-browser", "Do not open browser automatically; print the URL").option("--port <port>", "Local callback port (default: random available port)").option("--json", "Output machine-readable JSON", false).action(async (opts) => {
+    const config = resolveConfig();
+    const portRaw = typeof opts.port === "string" ? opts.port.trim() : "";
+    let port = null;
+    if (portRaw) {
+      const parsed = Number(portRaw);
+      if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+        throw new CliError("Invalid --port", { exitCode: 2, hint: "Example: --port 8085" });
+      }
+      port = parsed;
+    }
+    const server = await startOAuthCallbackServer({ port });
+    try {
+      const supabase = createSupabaseAuthHelpers(config);
+      const { url } = await supabase.startGoogleLogin({ redirectTo: server.redirectTo });
+      const shouldOpenBrowser = Boolean(opts.browser ?? true);
+      if (shouldOpenBrowser) {
+        try {
+          await openBrowser(url);
+          console.log(pc2.dim("Opened browser for login..."));
+        } catch (err) {
+          console.error(pc2.yellow("Could not open the browser automatically."));
+          console.error(pc2.dim(err?.message ?? String(err)));
+          console.log(`Open this URL manually:
+${url}`);
+        }
+      } else {
+        console.log(`Open this URL to login:
+${url}`);
+      }
+      const code = await server.waitForCode();
+      const session = await supabase.exchangeCode({ code });
+      await setSession(session);
+      let me = null;
+      try {
+        const api = createApiClient(config);
+        me = await api.getMe();
+      } catch (err) {
+        await clearSession().catch(() => {
+        });
+        throw err;
+      }
+      if (opts.json) {
+        console.log(JSON.stringify({ success: true, me }, null, 2));
+      } else {
+        const profile = me?.responseObject;
+        const label = profile?.email ? `${profile.email}` : profile?.id ? `user ${profile.id}` : "user";
+        console.log(pc2.green(`Logged in as ${label}.`));
+      }
+    } finally {
+      await server.close();
+    }
+  });
+}
+
+// src/commands/logout.ts
+import pc3 from "picocolors";
+function registerLogoutCommand(program) {
+  program.command("logout").description("Clear local Comerge authentication session").option("--json", "Output machine-readable JSON", false).action(async (opts) => {
+    await clearSession();
+    const envToken = process.env.COMERGE_ACCESS_TOKEN;
+    if (opts.json) {
+      console.log(JSON.stringify({ success: true, cleared: true, envTokenPresent: Boolean(envToken) }, null, 2));
+      return;
+    }
+    console.log(pc3.green("Logged out (local session cleared)."));
+    if (envToken) {
+      console.log(pc3.dim("Note: COMERGE_ACCESS_TOKEN is set in your environment; it will still authenticate requests."));
+    }
+  });
+}
+
+// src/commands/whoami.ts
+import pc4 from "picocolors";
+function registerWhoamiCommand(program) {
+  program.command("whoami").description("Show the currently authenticated Comerge user").option("--json", "Output machine-readable JSON", false).action(async (opts) => {
+    const config = resolveConfig();
+    const api = createApiClient(config);
+    const me = await api.getMe();
+    if (opts.json) {
+      console.log(JSON.stringify(me, null, 2));
+      return;
+    }
+    const profile = me?.responseObject;
+    const label = profile?.email ? `${profile.email}` : profile?.id ? `user ${profile.id}` : "unknown user";
+    console.log(pc4.green(label));
+  });
+}
+
+// src/commands/import.ts
+import pc6 from "picocolors";
+
+// src/lib/importLocal.ts
+import path9 from "path";
+import pc5 from "picocolors";
+
+// src/lib/gitFiles.ts
+import { execa as execa3 } from "execa";
+async function canUseGit(cwd) {
+  try {
+    const res = await execa3("git", ["rev-parse", "--is-inside-work-tree"], { cwd, stdio: "ignore" });
+    return res.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+function parseGitLsFilesZ(buf) {
+  return buf.toString("utf8").split("\0").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+async function listFilesGit(params) {
+  const args = ["ls-files", "-z", "--cached", "--others", "--exclude-standard"];
+  if (params.pathspec) {
+    args.push("--", params.pathspec);
+  }
+  const res = await execa3("git", args, { cwd: params.cwd, stdout: "pipe", stderr: "ignore" });
+  return parseGitLsFilesZ(Buffer.from(res.stdout ?? "", "utf8"));
+}
+
+// src/lib/fileSelection.ts
+import fs9 from "fs/promises";
+import path7 from "path";
+import fg from "fast-glob";
+import ignore from "ignore";
+var BUILTIN_IGNORES = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/.expo/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/coverage/**",
+  "**/.turbo/**",
+  "**/.next/**",
+  "**/ios/build/**",
+  "**/android/build/**",
+  "**/.pnpm-store/**"
+];
+function normalizeRel2(p) {
+  return p.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+async function readGitignore(root) {
+  const fp = path7.join(root, ".gitignore");
+  return await fs9.readFile(fp, "utf8").catch(() => "");
+}
+async function listFilesFs(params) {
+  const ig = ignore();
+  const raw = await readGitignore(params.root);
+  if (raw) ig.add(raw);
+  const entries = await fg(["**/*"], {
+    cwd: params.root,
+    onlyFiles: true,
+    dot: true,
+    followSymbolicLinks: false,
+    unique: true,
+    ignore: [...BUILTIN_IGNORES]
+  });
+  const filtered = entries.filter((p) => {
+    const rel = normalizeRel2(p);
+    if (!params.includeDotenv && path7.posix.basename(rel).startsWith(".env")) return false;
+    return !ig.ignores(rel);
+  });
+  return filtered.map(normalizeRel2);
+}
+
+// src/lib/zip.ts
+import crypto from "crypto";
+import fs10 from "fs";
+import fsp from "fs/promises";
+import os3 from "os";
+import path8 from "path";
+import archiver from "archiver";
+var MAX_IMPORT_ZIP_BYTES = 50 * 1024 * 1024;
+var MAX_IMPORT_FILE_COUNT = 25e3;
+function normalizeRel3(p) {
+  return p.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\/+/, "");
+}
+function validateRelPath(rel) {
+  const p = normalizeRel3(rel);
+  if (!p) throw new CliError("Invalid file path", { exitCode: 1 });
+  if (p.startsWith("../") || p.includes("/../") || p === "..") {
+    throw new CliError("Refusing to zip path traversal entry", { exitCode: 1, hint: p });
+  }
+  if (p.startsWith("/")) {
+    throw new CliError("Refusing to zip absolute path", { exitCode: 1, hint: p });
+  }
+  return p;
+}
+async function computeStats(params) {
+  const largestN = params.largestN ?? 10;
+  if (params.files.length > MAX_IMPORT_FILE_COUNT) {
+    throw new CliError("Too many files to import", {
+      exitCode: 2,
+      hint: `File count ${params.files.length} exceeds limit ${MAX_IMPORT_FILE_COUNT}. Use --path or add ignores.`
+    });
+  }
+  let totalBytes = 0;
+  const largest = [];
+  for (const rel0 of params.files) {
+    const rel = validateRelPath(rel0);
+    const abs = path8.join(params.root, rel);
+    const st = await fsp.stat(abs);
+    if (!st.isFile()) continue;
+    const bytes = st.size;
+    totalBytes += bytes;
+    if (largestN > 0) {
+      largest.push({ path: rel, bytes });
+    }
+  }
+  largest.sort((a, b) => b.bytes - a.bytes);
+  return {
+    fileCount: params.files.length,
+    totalBytes,
+    largestFiles: largest.slice(0, largestN)
+  };
+}
+async function createZip(params) {
+  const zipName = (params.zipName ?? "import.zip").replace(/[^a-zA-Z0-9._-]+/g, "_");
+  const tmpDir = await fsp.mkdtemp(path8.join(os3.tmpdir(), "comerge-import-"));
+  const zipPath = path8.join(tmpDir, zipName);
+  await new Promise((resolve, reject) => {
+    const output = fs10.createWriteStream(zipPath);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    output.on("close", () => resolve());
+    output.on("error", (err) => reject(err));
+    archive.on("warning", (err) => {
+      reject(err);
+    });
+    archive.on("error", (err) => reject(err));
+    archive.pipe(output);
+    for (const rel0 of params.files) {
+      const rel = validateRelPath(rel0);
+      const abs = path8.join(params.root, rel);
+      archive.file(abs, { name: rel });
+    }
+    void archive.finalize();
+  });
+  const st = await fsp.stat(zipPath);
+  if (st.size > MAX_IMPORT_ZIP_BYTES) {
+    throw new CliError("Archive exceeds max upload size", {
+      exitCode: 2,
+      hint: `Zip size ${st.size} bytes exceeds limit ${MAX_IMPORT_ZIP_BYTES} bytes. Use --path or add ignores.`
+    });
+  }
+  return { zipPath };
+}
+async function sha256FileHex(filePath) {
+  const hash = crypto.createHash("sha256");
+  await new Promise((resolve, reject) => {
+    const s = fs10.createReadStream(filePath);
+    s.on("data", (chunk) => hash.update(chunk));
+    s.on("error", reject);
+    s.on("end", () => resolve());
+  });
+  return hash.digest("hex");
+}
+
+// src/lib/upload.ts
+import fs11 from "fs";
+import { PassThrough } from "stream";
+async function uploadPresigned(params) {
+  const st = await fs11.promises.stat(params.filePath).catch(() => null);
+  if (!st || !st.isFile()) throw new CliError("Upload file not found", { exitCode: 2 });
+  const totalBytes = st.size;
+  const fileStream = fs11.createReadStream(params.filePath);
+  const pass = new PassThrough();
+  let sent = 0;
+  fileStream.on("data", (chunk) => {
+    sent += chunk.length;
+    params.onProgress?.({ sentBytes: sent, totalBytes });
+  });
+  fileStream.on("error", (err) => pass.destroy(err));
+  fileStream.pipe(pass);
+  const res = await fetch(params.uploadUrl, {
+    method: "PUT",
+    headers: params.headers,
+    body: pass,
+    duplex: "half"
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new CliError("Upload failed", {
+      exitCode: 1,
+      hint: `Status: ${res.status}
+${text}`.trim() || null
+    });
+  }
+}
+
+// src/lib/importLocal.ts
+var SAFE_PATH_RE = /^[A-Za-z0-9._/-]+$/;
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let v = bytes;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i++;
+  }
+  return `${v.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+function deriveAppName(projectRoot) {
+  const base = path9.basename(projectRoot);
+  return base || "Imported App";
+}
+function validateOptionalSubdir(subdir) {
+  if (!subdir) return null;
+  const s = subdir.trim().replace(/^\/+/, "").replace(/\\/g, "/");
+  if (!s) return null;
+  if (!SAFE_PATH_RE.test(s) || s.includes("..")) {
+    throw new CliError("Invalid --path", {
+      exitCode: 2,
+      hint: "Use a safe subdirectory like packages/mobile-app (letters/numbers/._-/ only)."
+    });
+  }
+  return s;
+}
+function getAppStatus(appResp) {
+  const obj = appResp?.responseObject;
+  const status = typeof obj?.status === "string" ? obj.status : null;
+  const statusError = typeof obj?.statusError === "string" ? obj.statusError : null;
+  return { status, statusError };
+}
+async function importLocal(params) {
+  const cfg = resolveConfig();
+  const api = createApiClient(cfg);
+  const projectRoot = await findExpoProjectRoot(process.cwd());
+  const subdir = validateOptionalSubdir(params.subdir);
+  const importRoot = subdir ? path9.join(projectRoot, subdir) : projectRoot;
+  const appName = (params.appName ?? "").trim() || deriveAppName(projectRoot);
+  const log = (msg) => {
+    if (params.json) return;
+    console.log(msg);
+  };
+  log(pc5.dim(`Project: ${projectRoot}`));
+  if (subdir) log(pc5.dim(`Import path: ${subdir}`));
+  let files = [];
+  const useGit = await canUseGit(projectRoot);
+  if (useGit) {
+    const gitPaths = await listFilesGit({ cwd: projectRoot, pathspec: subdir ?? null });
+    files = gitPaths;
+    if (!params.includeDotenv) {
+      files = files.filter((p) => !path9.posix.basename(p).startsWith(".env"));
+    }
+  } else {
+    files = await listFilesFs({ root: importRoot, includeDotenv: params.includeDotenv });
+    if (subdir) {
+      files = files.map((p) => path9.posix.join(subdir, p));
+    }
+  }
+  if (files.length === 0) {
+    throw new CliError("No files found to upload", { exitCode: 2, hint: "Check .gitignore rules or try without --path." });
+  }
+  const stats = await computeStats({ root: projectRoot, files, largestN: 10 });
+  log(pc5.dim(`Files: ${stats.fileCount}  Total: ${formatBytes(stats.totalBytes)}`));
+  if (params.dryRun) {
+    const top = stats.largestFiles.slice(0, 10);
+    if (top.length > 0) {
+      log(pc5.dim("Largest files:"));
+      for (const f of top) {
+        log(pc5.dim(`  ${formatBytes(f.bytes)}  ${f.path}`));
+      }
+    }
+    return { uploadId: "dry-run", appId: "dry-run", status: "dry-run" };
+  }
+  log(pc5.dim("Creating zip..."));
+  const { zipPath } = await createZip({ root: projectRoot, files, zipName: "import.zip" });
+  const zipSha = await sha256FileHex(zipPath);
+  const zipSize = (await (await import("fs/promises")).stat(zipPath)).size;
+  log(pc5.dim("Requesting upload URL..."));
+  const presignResp = await api.presignImportUpload({
+    file: {
+      name: "import.zip",
+      mimeType: "application/zip",
+      size: zipSize,
+      checksumSha256: zipSha
+    }
+  });
+  const presign = presignResp?.responseObject;
+  const uploadId = String(presign?.uploadId ?? "");
+  const uploadUrl = String(presign?.uploadUrl ?? "");
+  const headers = presign?.headers ?? {};
+  if (!uploadId || !uploadUrl) {
+    throw new CliError("Presign response missing upload fields", { exitCode: 1, hint: JSON.stringify(presignResp, null, 2) });
+  }
+  log(pc5.dim("Uploading zip..."));
+  let lastPct = -1;
+  await uploadPresigned({
+    uploadUrl,
+    headers,
+    filePath: zipPath,
+    onProgress: ({ sentBytes, totalBytes }) => {
+      if (params.json) return;
+      const pct = totalBytes > 0 ? Math.floor(sentBytes / totalBytes * 100) : 0;
+      if (pct !== lastPct && (pct % 5 === 0 || pct === 100)) {
+        lastPct = pct;
+        process.stdout.write(pc5.dim(`Upload ${pct}%\r`));
+      }
+    }
+  });
+  if (!params.json) process.stdout.write("\n");
+  log(pc5.dim("Triggering import..."));
+  const importResp = await api.importFromUpload({
+    uploadId,
+    appName,
+    path: subdir ?? void 0
+  });
+  const importObj = importResp?.responseObject;
+  const appId = String(importObj?.appId ?? "");
+  const projectId = importObj?.projectId ? String(importObj.projectId) : void 0;
+  const threadId = importObj?.threadId ? String(importObj.threadId) : void 0;
+  if (!appId) {
+    throw new CliError("Import response missing appId", { exitCode: 1, hint: JSON.stringify(importResp, null, 2) });
+  }
+  if (params.noWait) {
+    return { uploadId, appId, projectId, threadId, status: "accepted" };
+  }
+  log(pc5.dim("Waiting for build..."));
+  const startedAt = Date.now();
+  let delay = 2e3;
+  let lastStatus = null;
+  while (Date.now() - startedAt < params.maxWaitMs) {
+    const appResp = await api.getApp(appId);
+    const { status, statusError } = getAppStatus(appResp);
+    if (status && status !== lastStatus) {
+      lastStatus = status;
+      log(pc5.dim(`Status: ${status}`));
+    }
+    if (status === "ready") {
+      return { uploadId, appId, projectId, threadId, status };
+    }
+    if (status === "error") {
+      throw new CliError("Import failed", { exitCode: 1, hint: statusError ?? "App status is error" });
+    }
+    await sleep(delay);
+    delay = Math.min(1e4, Math.floor(delay * 1.4));
+  }
+  throw new CliError("Timed out waiting for import", {
+    exitCode: 1,
+    hint: `Try again with --max-wait or check app status with: comerge import local --no-wait`
+  });
+}
+
+// src/commands/import.ts
+function registerImportCommands(program) {
+  const imp = program.command("import").description("Import source code into Comerge");
+  imp.command("local").description("Import the current local Expo project").option("--name <appName>", "Override app name (default: derived from Expo config / folder name)").option("--path <subdir>", "Optional subdirectory to import").option("--max-wait <sec>", "Max time to wait for import to finish (default: 1200)", "1200").option("--json", "Output machine-readable JSON", false).option("--no-wait", "Do not poll for completion; return immediately after enqueue", false).option("--no-include-dotenv", "Exclude .env* files from the uploaded archive", false).option("--dry-run", "Show what would be uploaded (no upload)", false).action(async (opts) => {
+    const maxWaitSec = Number(String(opts.maxWait ?? "1200").trim());
+    if (!Number.isFinite(maxWaitSec) || maxWaitSec <= 0) {
+      throw new CliError("Invalid --max-wait", { exitCode: 2, hint: "Example: --max-wait 1200" });
+    }
+    const res = await importLocal({
+      appName: opts.name ? String(opts.name) : null,
+      subdir: opts.path ? String(opts.path) : null,
+      maxWaitMs: Math.floor(maxWaitSec * 1e3),
+      noWait: Boolean(opts.noWait),
+      json: Boolean(opts.json),
+      includeDotenv: Boolean(opts.includeDotenv),
+      dryRun: Boolean(opts.dryRun)
+    });
+    if (Boolean(opts.json)) {
+      console.log(JSON.stringify(res, null, 2));
+      return;
+    }
+    console.log(pc6.green(`Import accepted. appId=${res.appId}`));
+    if (res.status && !opts.noWait) {
+      console.log(pc6.dim(`Final status: ${res.status}`));
+    }
+  });
+}
+
+// src/commands/init.ts
+import pc9 from "picocolors";
+
+// src/lib/initLocal.ts
+import pc8 from "picocolors";
+
+// src/lib/ensureAuth.ts
+import pc7 from "picocolors";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function validateBackendSession() {
+  const cfg = resolveConfig();
+  const api = createApiClient(cfg);
+  await api.getMe();
+}
+async function ensureAuth(params) {
+  const envToken = process.env.COMERGE_ACCESS_TOKEN;
+  if (typeof envToken === "string" && envToken.trim().length > 0) return;
+  const existing = await getSession();
+  if (existing) {
+    try {
+      await validateBackendSession();
+      return;
+    } catch {
+    }
+  }
+  const interactive = isInteractive();
+  const yes = Boolean(params?.yes);
+  if (!interactive || yes) {
+    throw new CliError("Not logged in", {
+      exitCode: 2,
+      hint: "Run `comerge login` first, or set COMERGE_ACCESS_TOKEN for CI."
+    });
+  }
+  const cfg = resolveConfig();
+  const server = await startOAuthCallbackServer({ port: null });
+  try {
+    const supabase = createSupabaseAuthHelpers(cfg);
+    const { url } = await supabase.startGoogleLogin({ redirectTo: server.redirectTo });
+    try {
+      await openBrowser(url);
+      if (!params?.json) console.log(pc7.dim("Opened browser for login..."));
+    } catch {
+      if (!params?.json) {
+        console.log(pc7.yellow("Could not open the browser automatically."));
+        console.log(`Open this URL manually:
+${url}`);
+      }
+    }
+    const code = await server.waitForCode();
+    const session = await supabase.exchangeCode({ code });
+    await setSession(session);
+    try {
+      await validateBackendSession();
+    } catch (err) {
+      await clearSession().catch(() => {
+      });
+      throw err;
+    }
+  } finally {
+    await server.close();
+  }
+}
+
+// src/lib/apiKey.ts
+import prompts2 from "prompts";
+function isInteractive2() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function resolveStudioApiKey(params) {
+  const fromFlag = (params.flagApiKey ?? "").trim();
+  if (fromFlag) return fromFlag;
+  const fromEnv = (process.env.COMERGE_STUDIO_API_KEY ?? "").trim();
+  if (fromEnv) return fromEnv;
+  if (params.yes || !isInteractive2()) {
+    throw new CliError("Missing required Studio API key", {
+      exitCode: 2,
+      hint: "Pass --api-key <pk_...> or set COMERGE_STUDIO_API_KEY."
+    });
+  }
+  const res = await prompts2(
+    [
+      {
+        type: "password",
+        name: "apiKey",
+        message: "Studio API key",
+        validate: (v) => String(v || "").trim().length > 0 ? true : "apiKey is required"
+      }
+    ],
+    {
+      onCancel: () => {
+        throw new CliError("Cancelled", { exitCode: 130 });
+      }
+    }
+  );
+  const apiKey = String(res.apiKey ?? "").trim();
+  if (!apiKey) {
+    throw new CliError("Missing required Studio API key", { exitCode: 2 });
+  }
+  return apiKey;
+}
+
+// src/lib/initLocal.ts
+async function initLocal(params) {
+  if (params.dryRun) {
+    const res = await importLocal({
+      appName: params.appName,
+      subdir: params.subdir,
+      maxWaitMs: params.maxWaitMs,
+      noWait: true,
+      json: params.json,
+      includeDotenv: params.includeDotenv,
+      dryRun: true
+    });
+    return {
+      appId: res.appId,
+      uploadId: res.uploadId,
+      projectId: res.projectId,
+      threadId: res.threadId,
+      status: res.status,
+      shellOutDir: params.outDir,
+      noWait: params.noWait
+    };
+  }
+  await ensureAuth({ yes: params.yes, json: params.json });
+  const apiKey = await resolveStudioApiKey({ flagApiKey: params.apiKey, yes: params.yes });
+  const appKey = String(params.appKey || "MicroMain").trim() || "MicroMain";
+  if (!params.json) console.log(pc8.dim("Importing project..."));
+  const imported = await importLocal({
+    appName: params.appName,
+    subdir: params.subdir,
+    maxWaitMs: params.maxWaitMs,
+    noWait: params.noWait,
+    json: params.json,
+    includeDotenv: params.includeDotenv,
+    dryRun: false
+  });
+  if (!params.json) console.log(pc8.dim("Generating shell..."));
+  await shellInit({
+    outDir: params.outDir,
+    appId: imported.appId,
+    apiKey,
+    appKey,
+    yes: true,
+    install: params.install,
+    packageManager: params.packageManager,
+    studioVersion: params.studioVersion
+  });
+  return {
+    appId: imported.appId,
+    uploadId: imported.uploadId,
+    projectId: imported.projectId,
+    threadId: imported.threadId,
+    status: imported.status,
+    shellOutDir: params.outDir,
+    noWait: params.noWait
+  };
+}
+
+// src/commands/init.ts
+function registerInitCommands(program) {
+  const init = program.command("init").description("Full loop: import + generate shell wrapper");
+  init.command("local").description("Login if needed, import the local Expo project, then generate the shell wrapper").option("--api-key <pk>", "Studio API key (or set COMERGE_STUDIO_API_KEY)").option("--app-key <key>", "Bundle app key", "MicroMain").option("--out <dir>", "Output directory for shell wrapper", "comerge-shell").option("--install", "Install dependencies in generated shell", false).option("--package-manager <pm>", "Override package manager detection (pnpm|npm|yarn|bun)").option("--studio-version <ver>", "Version to use for @comergehq/studio", "latest").option("--name <appName>", "Override imported app name").option("--path <subdir>", "Optional subdirectory to import").option("--max-wait <sec>", "Max time to wait for import to finish (default: 1200)", "1200").option("--no-wait", "Do not poll for completion; generate shell immediately", false).option("--no-include-dotenv", "Exclude .env* files from the uploaded archive").option("--dry-run", "Show what would be uploaded (no login/import/shell)", false).option("--yes", "Non-interactive; do not prompt", false).option("--json", "Output machine-readable JSON", false).action(async (opts) => {
+    const maxWaitSec = Number(String(opts.maxWait ?? "1200").trim());
+    if (!Number.isFinite(maxWaitSec) || maxWaitSec <= 0) {
+      throw new CliError("Invalid --max-wait", { exitCode: 2, hint: "Example: --max-wait 1200" });
+    }
+    const res = await initLocal({
+      apiKey: opts.apiKey ? String(opts.apiKey) : null,
+      appKey: opts.appKey ? String(opts.appKey) : "MicroMain",
+      outDir: opts.out ? String(opts.out) : "comerge-shell",
+      install: Boolean(opts.install),
+      packageManager: opts.packageManager ? String(opts.packageManager) : null,
+      studioVersion: opts.studioVersion ? String(opts.studioVersion) : "latest",
+      appName: opts.name ? String(opts.name) : null,
+      subdir: opts.path ? String(opts.path) : null,
+      maxWaitMs: Math.floor(maxWaitSec * 1e3),
+      noWait: Boolean(opts.noWait),
+      includeDotenv: Boolean(opts.includeDotenv),
+      dryRun: Boolean(opts.dryRun),
+      yes: Boolean(opts.yes),
+      json: Boolean(opts.json)
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(res, null, 2));
+      return;
+    }
+    console.log(pc9.green(`Done. appId=${res.appId}`));
+    console.log(pc9.dim(`Shell: ${res.shellOutDir}`));
+    if (res.status) console.log(pc9.dim(`Status: ${res.status}`));
+    if (res.noWait) console.log(pc9.yellow("Note: --no-wait was used; bundles may still be building."));
+  });
+}
+
+// src/cli.ts
+async function main(argv) {
+  const program = new Command();
+  program.name("comerge").description("Comerge CLI").version("0.1.0");
+  registerShellCommands(program);
+  registerLoginCommand(program);
+  registerWhoamiCommand(program);
+  registerLogoutCommand(program);
+  registerImportCommands(program);
+  registerInitCommands(program);
+  program.configureOutput({
+    outputError: (str, write) => write(pc10.red(str))
+  });
+  try {
+    await program.parseAsync(argv);
+  } catch (err) {
+    const e = err;
+    if (e instanceof CliError) {
+      console.error(pc10.red(`Error: ${e.message}`));
+      if (e.hint) console.error(pc10.dim(e.hint));
+      process.exitCode = e.exitCode;
+      return;
+    }
+    console.error(pc10.red(`Unexpected error: ${e?.message ?? String(e)}`));
+    process.exitCode = 1;
+  }
+}
+void main(process.argv);
+export {
+  main
+};
+//# sourceMappingURL=cli.js.map