@cimplify/cli 0.2.0

package/dist/deploy-WCZOGMED.mjs

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import { pollDeployment } from './chunk-TAMGCHIL.mjs';
+import { fetchCloneToken } from './chunk-5XH72JMJ.mjs';
+import { promptYesNo } from './chunk-L6474RPL.mjs';
+import { TOKEN_PURPOSE, ENV_SCOPE, DEPLOY_TRIGGER, DEPLOYMENT_STATUS } from './chunk-MQMNWLMU.mjs';
+import { parseArgs, flagBool, flagString } from './chunk-D7D75ONX.mjs';
+import { ApiClient } from './chunk-4ZVTPMUZ.mjs';
+import { readAuth, readProjectLink, writeProjectState } from './chunk-JJYWETGA.mjs';
+import { CliError, CLI_ERROR_CODE, step, info, dim, success, result, EXIT_CODE } from './chunk-NZ4RG62Z.mjs';
+import { spawn } from 'child_process';
+
+var GIT_BINARY = "git";
+var ENCODING_UTF8 = "utf8";
+var REMOTE_DEFAULT = "origin";
+var ARGS_STATUS_PORCELAIN = ["status", "--porcelain=v1"];
+var ARGS_REV_PARSE_HEAD = ["rev-parse", "HEAD"];
+var ARGS_REV_PARSE_ABBREV_REF = ["rev-parse", "--abbrev-ref", "HEAD"];
+var ARGS_REV_PARSE_SHOW_TOPLEVEL = ["rev-parse", "--show-toplevel"];
+var ARGS_REMOTE_GET_URL = ["remote", "get-url"];
+var ARGS_PUSH = ["push"];
+async function runGit(args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(GIT_BINARY, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+    child.on("error", (err) => {
+      reject(new CliError(CLI_ERROR_CODE.GIT_ERROR, `git not found: ${err.message}`));
+    });
+    child.on("close", (code) => {
+      resolve({
+        code: code ?? -1,
+        stdout: Buffer.concat(stdoutChunks).toString(ENCODING_UTF8),
+        stderr: Buffer.concat(stderrChunks).toString(ENCODING_UTF8)
+      });
+    });
+  });
+}
+async function runGitOk(args, cwd) {
+  const { code, stdout, stderr } = await runGit(args, cwd);
+  if (code !== 0) {
+    throw new CliError(
+      CLI_ERROR_CODE.GIT_ERROR,
+      `git ${args.join(" ")} failed: ${stderr.trim() || stdout.trim() || `exit ${code}`}`
+    );
+  }
+  return stdout.trimEnd();
+}
+async function gitStatusPorcelain(cwd) {
+  return runGitOk(ARGS_STATUS_PORCELAIN, cwd);
+}
+async function gitCurrentSha(cwd) {
+  return runGitOk(ARGS_REV_PARSE_HEAD, cwd);
+}
+async function gitCurrentBranch(cwd) {
+  return runGitOk(ARGS_REV_PARSE_ABBREV_REF, cwd);
+}
+async function gitDetectRoot(cwd) {
+  const { code, stdout } = await runGit(ARGS_REV_PARSE_SHOW_TOPLEVEL, cwd);
+  if (code !== 0) return null;
+  return stdout.trimEnd() || null;
+}
+async function gitGetRemoteUrl(cwd, name = REMOTE_DEFAULT) {
+  const { code, stdout } = await runGit([...ARGS_REMOTE_GET_URL, name], cwd);
+  if (code !== 0) return null;
+  return stdout.trimEnd() || null;
+}
+async function gitPush(cwd, branch) {
+  const args = branch ? [...ARGS_PUSH, REMOTE_DEFAULT, branch] : [...ARGS_PUSH];
+  await runGitOk(args, cwd);
+}
+async function gitPushToUrl(cwd, url, branch) {
+  await runGitOk([...ARGS_PUSH, url, branch], cwd);
+}
+var FREESTYLE_GIT_HOST = "git.freestyle.sh";
+function isFreestyleRemote(url) {
+  if (!url) return false;
+  try {
+    return new URL(url).hostname === FREESTYLE_GIT_HOST;
+  } catch {
+    return url.includes(FREESTYLE_GIT_HOST);
+  }
+}
+
+// src/commands/deploy.ts
+var FLAG_PROD = "prod";
+var FLAG_REF = "ref";
+var FLAG_NO_PUSH = "no-push";
+var FLAG_ALLOW_DIRTY = "allow-dirty";
+var FLAG_NO_POLL = "no-poll";
+function deployEndpoint(businessId, projectId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/deploy`;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const auth = await readAuth();
+  const link = await readProjectLink();
+  const client = ApiClient.fromAuth(auth);
+  const cwd = process.cwd();
+  const root = await gitDetectRoot(cwd);
+  if (!root) {
+    throw new CliError(
+      CLI_ERROR_CODE.GIT_ERROR,
+      "Not inside a git repository. `cimplify deploy` needs git history."
+    );
+  }
+  const allowDirty = flagBool(args, FLAG_ALLOW_DIRTY);
+  const dirty = (await gitStatusPorcelain(root)).length > 0;
+  if (dirty && !allowDirty) {
+    const proceed = await promptYesNo(
+      "You have uncommitted changes. Continue anyway?",
+      true
+    );
+    if (!proceed) {
+      throw new CliError(CLI_ERROR_CODE.ABORTED, "Aborted by user.");
+    }
+  }
+  const explicitRef = flagString(args, FLAG_REF);
+  const branch = await gitCurrentBranch(root);
+  const localSha = await gitCurrentSha(root);
+  const gitRef = explicitRef ?? localSha;
+  if (!flagBool(args, FLAG_NO_PUSH)) {
+    const originUrl = await gitGetRemoteUrl(root);
+    if (isFreestyleRemote(originUrl)) {
+      step(`Pushing ${branch} to Freestyle (with minted clone token)`);
+      const token = await fetchCloneToken(
+        client,
+        link.businessId,
+        link.projectId,
+        TOKEN_PURPOSE.EDITOR
+      );
+      await gitPushToUrl(root, token.clone_url, branch);
+    } else {
+      step(`Pushing ${branch} to origin`);
+      await gitPush(root, branch);
+    }
+  } else {
+    info(dim("Skipping git push (--no-push)"));
+  }
+  const envScope = flagBool(args, FLAG_PROD) ? ENV_SCOPE.PRODUCTION : ENV_SCOPE.PREVIEW;
+  const body = {
+    git_ref: gitRef,
+    env_scope: envScope,
+    trigger: DEPLOY_TRIGGER.CLI
+  };
+  step(`Triggering ${envScope} deploy for ${gitRef.slice(0, 12)}`);
+  const enqueued = await client.post(
+    deployEndpoint(link.businessId, link.projectId),
+    body
+  );
+  await writeProjectState({
+    lastDeploymentId: enqueued.deployment_id,
+    lastDeploymentSha: enqueued.git_sha,
+    lastDeploymentEnv: envScope,
+    lastDeploymentAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (enqueued.existing) {
+    info(
+      dim(
+        `Existing deployment ${enqueued.deployment_id} for sha ${enqueued.git_sha.slice(0, 12)} is already in progress; resuming poll`
+      )
+    );
+  } else {
+    success(`Enqueued deployment ${enqueued.deployment_id} (sha ${enqueued.git_sha.slice(0, 12)})`);
+  }
+  if (flagBool(args, FLAG_NO_POLL)) {
+    result({
+      deployment: {
+        id: enqueued.deployment_id,
+        git_sha: enqueued.git_sha,
+        existing: enqueued.existing,
+        environment: envScope,
+        status: enqueued.existing ? "in_progress" : "queued"
+      }
+    });
+    return;
+  }
+  const final = await pollDeployment(
+    client,
+    link.businessId,
+    link.projectId,
+    enqueued.deployment_id
+  );
+  result({
+    deployment: {
+      id: enqueued.deployment_id,
+      git_sha: enqueued.git_sha,
+      environment: envScope,
+      status: final.status,
+      url: final.url ?? null,
+      error_message: final.error_message ?? null
+    }
+  });
+  if (final.status === DEPLOYMENT_STATUS.ACTIVE) {
+    process.exitCode = EXIT_CODE.OK;
+    return;
+  }
+  if (final.status === DEPLOYMENT_STATUS.SUPERSEDED) {
+    process.exitCode = EXIT_CODE.SUPERSEDED;
+    return;
+  }
+  process.exitCode = EXIT_CODE.ERROR;
+}
+
+export { run as default };

package/dist/dev-4HKIXWXX.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import { parseEnvFile, formatEnvFile } from './chunk-4YSOZ6LY.mjs';
+import { ENV_SCOPE, PUBLIC_ENV_PREFIX } from './chunk-MQMNWLMU.mjs';
+import { parseArgs, flagBool } from './chunk-D7D75ONX.mjs';
+import { ApiClient } from './chunk-4ZVTPMUZ.mjs';
+import { readAuth, readProjectLink } from './chunk-JJYWETGA.mjs';
+import { info, CliError, CLI_ERROR_CODE, dim } from './chunk-NZ4RG62Z.mjs';
+import { spawn } from 'child_process';
+import { promises } from 'fs';
+import path from 'path';
+
+var FLAG_REMOTE = "remote";
+var PACKAGE_JSON = "package.json";
+var ENV_LOCAL_FILE = ".env.local";
+var PUBLIC_API_URL_KEY = "NEXT_PUBLIC_CIMPLIFY_API_URL";
+var SCRIPT_DEV = "dev";
+var PM_BUN = "bun";
+var PM_PNPM = "pnpm";
+var PM_YARN = "yarn";
+var PM_NPM = "npm";
+var LOCKFILE_BUN = "bun.lock";
+var LOCKFILE_BUN_BINARY = "bun.lockb";
+var LOCKFILE_PNPM = "pnpm-lock.yaml";
+var LOCKFILE_YARN = "yarn.lock";
+var BUNFIG = "bunfig.toml";
+function envEndpoint(businessId, projectId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/env-vars`;
+}
+async function detectPackageManager(cwd) {
+  if (await pathExists(path.join(cwd, LOCKFILE_BUN))) return PM_BUN;
+  if (await pathExists(path.join(cwd, LOCKFILE_BUN_BINARY))) return PM_BUN;
+  if (await pathExists(path.join(cwd, BUNFIG))) return PM_BUN;
+  if (await pathExists(path.join(cwd, LOCKFILE_PNPM))) return PM_PNPM;
+  if (await pathExists(path.join(cwd, LOCKFILE_YARN))) return PM_YARN;
+  return PM_NPM;
+}
+async function pathExists(target) {
+  try {
+    await promises.stat(target);
+    return true;
+  } catch (err) {
+    if (err.code === "ENOENT") return false;
+    throw err;
+  }
+}
+async function readPackageJson(cwd) {
+  const pkgPath = path.join(cwd, PACKAGE_JSON);
+  let raw;
+  try {
+    raw = await promises.readFile(pkgPath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new CliError(
+        CLI_ERROR_CODE.INVALID_INPUT,
+        `No package.json in ${cwd}. \`cimplify dev\` runs your project's dev script.`
+      );
+    }
+    throw err;
+  }
+  return JSON.parse(raw);
+}
+function mergeEnvEntries(existing, incoming) {
+  const seen = new Set(existing.map((e) => e.key));
+  const merged = [...existing];
+  for (const entry of incoming) {
+    if (seen.has(entry.key)) continue;
+    merged.push(entry);
+    seen.add(entry.key);
+  }
+  return merged;
+}
+async function applyRemoteEnv(client, businessId, projectId, apiBaseUrl, cwd) {
+  const records = await client.get(envEndpoint(businessId, projectId), {
+    query: { scope: ENV_SCOPE.PRODUCTION }
+  });
+  const incoming = records.filter((r) => r.value !== null && !r.is_secret).map((r) => ({ key: r.key, value: r.value }));
+  incoming.push({ key: PUBLIC_API_URL_KEY, value: apiBaseUrl });
+  const envPath = path.join(cwd, ENV_LOCAL_FILE);
+  let existing = [];
+  try {
+    const raw = await promises.readFile(envPath, "utf8");
+    existing = parseEnvFile(raw);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const merged = mergeEnvEntries(existing, incoming);
+  await promises.writeFile(envPath, formatEnvFile(merged), "utf8");
+  const publicCount = incoming.filter((e) => e.key.startsWith(PUBLIC_ENV_PREFIX)).length;
+  return publicCount;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const remote = flagBool(args, FLAG_REMOTE);
+  const cwd = process.cwd();
+  if (remote) {
+    const auth = await readAuth();
+    const link = await readProjectLink();
+    const client = ApiClient.fromAuth(auth);
+    const publicCount = await applyRemoteEnv(
+      client,
+      link.businessId,
+      link.projectId,
+      auth.apiBaseUrl,
+      cwd
+    );
+    const label = link.businessHandle ?? auth.businessHandle ?? auth.businessId;
+    info(`Dev mode: connected to ${label} production data (${publicCount} public var${publicCount === 1 ? "" : "s"} merged)`);
+  } else {
+    info("Dev mode: using local mock (`cimplify mock`)");
+  }
+  const pkg = await readPackageJson(cwd);
+  if (!pkg.scripts || !pkg.scripts[SCRIPT_DEV]) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `No "${SCRIPT_DEV}" script in package.json. Add one (e.g. "next dev") and re-run.`
+    );
+  }
+  const pm = await detectPackageManager(cwd);
+  info(dim(`(running: ${pm} run ${SCRIPT_DEV})`));
+  const child = spawn(pm, ["run", SCRIPT_DEV], { cwd, stdio: "inherit" });
+  await new Promise((resolve, reject) => {
+    child.on("error", (err) => reject(new CliError(CLI_ERROR_CODE.INVALID_INPUT, `Failed to spawn ${pm}: ${err.message}`)));
+    child.on("close", (code) => {
+      process.exitCode = code ?? 0;
+      resolve();
+    });
+  });
+}
+
+export { run as default, detectPackageManager, mergeEnvEntries };

package/dist/dispatcher.mjs

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+import { TEMPLATES } from './chunk-XSWWWO6H.mjs';
+
+// package.json
+var package_default = {
+  version: "0.2.0"};
+
+// src/dispatcher.ts
+var VERSION = package_default.version;
+var HELP = `cimplify \u2014 Cimplify CLI
+
+Usage:
+  cimplify <subcommand> [flags]
+
+Project:
+  cimplify init [dir] [flags]                Scaffold a working storefront from a template
+  cimplify login [flags]                     Open a browser to authorize this CLI (PKCE loopback)
+  cimplify logout                            Forget saved credentials
+  cimplify whoami                            Show the current account/business
+  cimplify projects ls                       List projects in the current business
+  cimplify projects create <name>            Create a Next.js project
+  cimplify link <project-id>                 Link CWD to a Cimplify project (writes .cimplify/project.json)
+  cimplify unlink                            Remove the local project link
+
+Deploy:
+  cimplify deploy [flags]                    Push current SHA + trigger a build
+  cimplify rollback <deploy-id>              Re-deploy a previous deployment's SHA
+  cimplify status                            Show the latest deployment for the linked project
+  cimplify logs [flags]                      Stream build logs for the latest (or given) deployment
+  cimplify dev [--remote]                    Run your project's dev script (optionally with prod env)
+
+Env vars:
+  cimplify env ls [--scope=<s>]              List env vars (default scope: preview)
+  cimplify env pull [--scope=<s>]            Write public env vars to .env.local
+  cimplify env push [--scope=<s>]            Push .env.local to the given scope
+  cimplify env add KEY=VAL [...]             Add a single env var
+  cimplify env rm KEY [--yes]                Remove an env var
+
+Components (eject from @cimplify/sdk's registry):
+  cimplify list [--components|--utilities]   List ejectable components from the SDK
+  cimplify add <name> [--dir <path>] [--force] [--no-deps]
+                                             Copy a component (and its registry deps) into your project
+  cimplify add --all [--dir <path>]          Eject the entire registry at once
+
+Repo:
+  cimplify repo provision                                Mint a Freestyle Git repo for the linked project
+  cimplify repo connect <url> [--provider=\u2026]             Connect an existing remote (GitHub, Gitea, external)
+  cimplify repo info                                     Show the linked project's repo metadata
+  cimplify repo unlink [--purge] [--yes]                 Unlink the repo (use --purge to also delete upstream)
+  cimplify repo rotate-token                             Rotate the access token (alias of provision)
+  cimplify repo clone-url                                Mint a short-lived auth-embedded clone URL (stdout)
+
+  Note: \`cimplify projects create <name>\` auto-provisions a Freestyle repo unless --no-repo is passed.
+        Use --connect <url> on create to attach an existing remote instead.
+
+Domains:
+  cimplify domains ls                                    List business domains
+  cimplify domains ls --attached                         List domains attached to the linked project
+  cimplify domains add <domain>                          Add a domain (prints DNS records to set)
+  cimplify domains verify <dom>                          Trigger verification after DNS is configured
+  cimplify domains rm <dom>                              Remove a domain
+  cimplify domains attach <dom> [flags]                  Attach a verified domain to the linked project
+                                                         flags: --env=preview|production --primary
+  cimplify domains detach <dom> [flags]                  Detach a domain from the linked project
+                                                         flags: --env=preview|production --yes
+  cimplify domains primary <dom> [--env=...]             Promote an attached domain to primary for its env
+
+Global flags (work with any cloud subcommand):
+  --json                   Emit a single JSON document on stdout instead
+                           of human progress; suppresses colorized text.
+                           Equivalent of CIMPLIFY_JSON=1 in the env.
+                           Success: { "ok": true, "data": ... }
+                           Failure: { "ok": false, "error": { "code": ..., "message": ..., "remediation": ... } }
+  --yes, -y                Auto-confirm yes/no prompts (e.g. --allow-dirty).
+                           Non-TTY runs throw INTERACTIVE_REQUIRED unless --yes is set.
+
+Misc:
+  cimplify --help, -h                        Show this help
+  cimplify --version, -v                     Show CLI version
+
+Init flags:
+  --template <name>, -t    bakery (default) | restaurant | retail | services | grocery | fashion
+                           Picks the storefront design.
+
+Login flags:
+  (no flags)               Open a browser to authorize this CLI (default)
+  --no-browser             Print the URL instead of opening it (useful over SSH)
+  --api-key <dk_...>       Skip the browser and authenticate with a key (CI / headless)
+  --base-url <url>         API base URL (env: CIMPLIFY_API_URL; default https://api.cimplify.io)
+
+Deploy flags:
+  --prod                   Deploy to production (default: preview)
+  --ref <sha>              Override the git ref (default: HEAD of current branch)
+  --no-push                Skip \`git push\` (assumes remote already has the SHA)
+  --allow-dirty            Skip the dirty-tree confirmation prompt
+  --no-poll                Return after enqueue; don't stream progress
+
+Env flags:
+  --scope <scope>          development | preview | staging | production
+  --show                   Reveal non-secret values in \`env ls\`
+  --out <path>             Output path for \`env pull\` (default .env.local)
+  --file <path>            Input path for \`env push\` (default .env.local)
+  --overwrite              Replace the entire scope on \`env push\`
+  --secret / --public      Force is_secret on \`env add\`
+  --yes                    Skip confirmation on \`env rm\`
+
+Logs flags:
+  --deployment <id>        Override which deployment to read (default: latest)
+  --follow                 Poll until the deployment terminates
+
+Need the mock storefront server? It ships with @cimplify/sdk:
+  bunx @cimplify/sdk mock [flags]            Boot the local Cimplify API mock
+`;
+var COMMANDS = {
+  login: () => import('./login-MRYWLQRY.mjs'),
+  logout: () => import('./logout-ZFZLSJ32.mjs'),
+  whoami: () => import('./whoami-INHDUHWA.mjs'),
+  projects: () => import('./projects-QJUGOCQZ.mjs'),
+  link: () => import('./link-SEJNW7JS.mjs'),
+  unlink: () => import('./unlink-5ABCT7B6.mjs'),
+  deploy: () => import('./deploy-WCZOGMED.mjs'),
+  rollback: () => import('./rollback-XO7RIG2A.mjs'),
+  env: () => import('./env-LBYBCBWV.mjs'),
+  domains: () => import('./domains-3RJ4T5IX.mjs'),
+  logs: () => import('./logs-LK7CMBCE.mjs'),
+  status: () => import('./status-7CMVLD54.mjs'),
+  dev: () => import('./dev-4HKIXWXX.mjs'),
+  repo: () => import('./repo-MV22OHON.mjs'),
+  list: () => import('./list-D4JC2VWY.mjs'),
+  add: () => import('./add-ZJQJZJEF.mjs')
+};
+var GLOBAL_FLAGS = /* @__PURE__ */ new Set(["--json", "--yes", "-y"]);
+function extractGlobalFlags(argv) {
+  const cleaned = [];
+  let json = process.env.CIMPLIFY_JSON === "1" || process.env.CIMPLIFY_JSON === "true";
+  let yes = false;
+  for (const a of argv) {
+    if (!GLOBAL_FLAGS.has(a)) {
+      cleaned.push(a);
+      continue;
+    }
+    if (a === "--json") json = true;
+    else if (a === "--yes" || a === "-y") yes = true;
+  }
+  return { args: cleaned, json, yes };
+}
+async function main() {
+  const cleaned = extractGlobalFlags(process.argv.slice(2));
+  if (cleaned.json) process.env.CIMPLIFY_JSON = "1";
+  if (cleaned.yes) process.env.CIMPLIFY_YES = "1";
+  process.argv = [process.argv[0], process.argv[1], ...cleaned.args];
+  const [maybeSub, ...rest] = cleaned.args;
+  const TOP_LEVEL_FLAGS = /* @__PURE__ */ new Set(["--help", "-h", "help", "--version", "-v", "version"]);
+  if (!maybeSub) {
+    console.log(HELP);
+    return;
+  }
+  if (TOP_LEVEL_FLAGS.has(maybeSub)) {
+    return await runDispatcherFlag(maybeSub);
+  }
+  const sub = maybeSub;
+  const args = rest;
+  if (sub === "init") {
+    await runInit(args);
+    return;
+  }
+  const loader = COMMANDS[sub];
+  if (!loader) {
+    console.error(`cimplify: unknown command "${sub}"`);
+    console.error(`Run \`cimplify --help\` for usage.`);
+    process.exit(1);
+  }
+  await runCommand(sub, loader, args);
+}
+async function runInit(args) {
+  const { existsSync, mkdirSync, readdirSync, writeFileSync } = await import('fs');
+  const { dirname, join, resolve } = await import('path');
+  const { spawnSync } = await import('child_process');
+  const dir = args.find((a) => !a.startsWith("-")) ?? "my-storefront";
+  const target = resolve(process.cwd(), dir);
+  if (existsSync(target) && readdirSync(target).length > 0) {
+    console.error(`cimplify init: directory ${target} is not empty`);
+    process.exit(1);
+  }
+  mkdirSync(target, { recursive: true });
+  const VALID_TEMPLATES = /* @__PURE__ */ new Set([
+    "bakery",
+    "restaurant",
+    "retail",
+    "services",
+    "grocery",
+    "fashion"
+  ]);
+  let template = "bakery";
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--template" || args[i] === "-t") {
+      const next = args[i + 1];
+      if (next && VALID_TEMPLATES.has(next)) template = next;
+      else {
+        console.error(
+          `cimplify init: unknown template "${next ?? ""}". Valid options: ${[...VALID_TEMPLATES].join(", ")}.`
+        );
+        process.exit(1);
+      }
+    } else if (args[i].startsWith("--template=")) {
+      const next = args[i].slice("--template=".length);
+      if (VALID_TEMPLATES.has(next)) template = next;
+      else {
+        console.error(
+          `cimplify init: unknown template "${next}". Valid options: ${[...VALID_TEMPLATES].join(", ")}.`
+        );
+        process.exit(1);
+      }
+    }
+  }
+  const templateKey = `storefront-${template}`;
+  const files = TEMPLATES[templateKey];
+  if (!files) {
+    console.error(
+      `cimplify init: template "${template}" not present in the embedded bundle. Available: ${Object.keys(TEMPLATES).join(", ")}`
+    );
+    process.exit(1);
+  }
+  const placeholderName = dir.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+  for (const file of files) {
+    const dst = join(target, file.path);
+    mkdirSync(dirname(dst), { recursive: true });
+    if (file.kind === "text") {
+      writeFileSync(dst, file.content.replaceAll("__STOREFRONT_NAME__", placeholderName));
+    } else {
+      writeFileSync(dst, Buffer.from(file.content, "base64"));
+    }
+  }
+  const envExample = join(target, ".env.example");
+  const envLocal = join(target, ".env.local");
+  if (existsSync(envExample) && !existsSync(envLocal)) {
+    const { copyFileSync } = await import('fs');
+    copyFileSync(envExample, envLocal);
+  }
+  console.log(`\u2713 Scaffolded ${placeholderName} in ${target}`);
+  console.log("");
+  console.log("Installing dependencies...");
+  const installer = spawnSync("bun", ["install"], { cwd: target, stdio: "inherit" });
+  if (installer.status !== 0) {
+    console.warn("(bun install failed; run it manually)");
+  }
+  console.log("");
+  console.log("Next steps:");
+  console.log(`  cd ${dir}`);
+  console.log("  bun dev          # boots both the mock API and the storefront");
+  console.log("");
+  console.log("Then open http://localhost:3000");
+}
+async function runCommand(sub, loader, args) {
+  let mod;
+  try {
+    mod = await loader();
+  } catch (err) {
+    await emitError(sub, err);
+    process.exit(1);
+  }
+  if (typeof mod.default !== "function") {
+    await emitError(sub, new Error("command module did not export a default function"));
+    process.exit(1);
+  }
+  try {
+    await mod.default(args);
+  } catch (err) {
+    await emitError(sub, err);
+    process.exit(exitCodeFromError(err));
+  }
+}
+function isCliErrorLike(err) {
+  return err !== null && typeof err === "object" && err.name === "CliError" && typeof err.code === "string" && typeof err.message === "string" && typeof err.exitCode === "number";
+}
+function exitCodeFromError(err) {
+  return isCliErrorLike(err) ? err.exitCode : 1;
+}
+async function emitError(sub, err) {
+  const json = process.env.CIMPLIFY_JSON === "1" || process.env.CIMPLIFY_JSON === "true";
+  if (json) {
+    if (isCliErrorLike(err)) {
+      const payload = {
+        ok: false,
+        error: {
+          code: err.code,
+          message: err.message,
+          ...err.remediation ? { remediation: err.remediation } : {}
+        }
+      };
+      process.stdout.write(`${JSON.stringify(payload)}
+`);
+    } else {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stdout.write(`${JSON.stringify({ ok: false, error: { code: "INTERNAL", message } })}
+`);
+    }
+    return;
+  }
+  if (isCliErrorLike(err)) {
+    console.error(`cimplify ${sub}: ${err.message}`);
+    if (err.remediation) console.error(`  \u2192 ${err.remediation}`);
+    return;
+  }
+  if (err instanceof Error) {
+    console.error(`cimplify ${sub}:`, err.stack ?? err.message);
+    return;
+  }
+  console.error(`cimplify ${sub}:`, String(err));
+}
+async function runDispatcherFlag(flag) {
+  if (flag === "-h" || flag === "--help" || flag === "help") {
+    console.log(HELP);
+    return;
+  }
+  console.log(VERSION);
+}
+main().catch((err) => {
+  console.error("cimplify:", err);
+  process.exit(1);
+});