@cimplify/cli 0.2.0

package/README.md

@@ -0,0 +1,69 @@
+# @cimplify/cli
+
+The Cimplify command-line tool. Deploy from your terminal, manage env vars, attach domains, scaffold storefronts.
+
+## Install
+
+```bash
+curl -fsSL https://cimplify.io/install | sh
+```
+
+Detects your OS + arch, downloads the matching binary from the latest GitHub release, verifies its sha256, and drops it in `~/.local/bin/cimplify`. ~20 ms cold start. The binary bundles every storefront template and the full component registry — `init`, `add`, and `list` work without a separate `@cimplify/sdk` install.
+
+Override the destination with `--prefix`, pin a version with `--version cli-v0.1.0`, or skip the install entirely with `bunx @cimplify/cli <command>`.
+
+## What you can do
+
+```bash
+cimplify init my-store --template restaurant   # scaffold a working storefront
+cimplify login                                  # browser PKCE flow (or --api-key for CI)
+cimplify projects create my-store               # create a Cimplify project + Freestyle repo
+cimplify link <project-id>                      # bind the current directory to a project
+cimplify deploy [--prod]                        # push HEAD + build + deploy
+cimplify logs --follow                          # stream build logs
+cimplify rollback <deploy-id>                   # re-deploy a previous SHA
+cimplify env push                               # upload .env.local to the linked project
+cimplify domains add shop.example.com           # add a custom domain (prints DNS records)
+cimplify status                                 # latest deployment summary
+```
+
+`cimplify --help` lists every subcommand and flag.
+
+## Conventions
+
+- **Project link:** `cimplify link <project-id>` writes `.cimplify/project.json` in the working directory. Subsequent commands read it to know which project to act on — no `--project` flag needed for the common case.
+- **Auth:** credentials persist at `~/.config/cimplify/auth.json`. CI uses `--api-key dk_live_…` to skip the browser.
+- **JSON mode:** pass `--json` (or set `CIMPLIFY_JSON=1`) for `{ ok, data | error }` machine-readable output on stdout.
+- **Yes/no prompts:** pass `--yes` (or `-y`) to auto-confirm.
+
+## How it talks to Cimplify
+
+Every cloud command is a thin HTTP client over `https://api.cimplify.io` (override with `CIMPLIFY_API_URL`). The deploy flow specifically:
+
+1. `git push` to the project's git remote (uses a short-TTL token minted by Cimplify when the remote is Freestyle-hosted; falls back to your existing git auth otherwise).
+2. `POST /v1/businesses/<bid>/projects/<pid>/deploy` with the local SHA.
+3. Poll `/deployments/<id>/progress` every 1 second, printing log chunks as they arrive.
+4. Exit 0 on `active`, 2 on `superseded`, 1 on `failed` / `cancelled`.
+
+## Storefront templates
+
+`cimplify init` ships with six designs out of the box:
+
+| Template | Use case |
+|---|---|
+| `bakery` (default) | Warm food-style storefront |
+| `restaurant` | Menu + ordering UI |
+| `retail` | Product-grid retail |
+| `services` | Booking-style storefront |
+| `grocery` | Catalogue-heavy grocery layout |
+| `fashion` | Editorial fashion layout |
+
+Each is a full Next.js project wired to `@cimplify/sdk` with the design system pre-applied.
+
+## Related
+
+- [`@cimplify/sdk`](../sdk/README.md) — the runtime SDK + storefront components scaffolded by `cimplify init`.
+
+## License
+
+MIT.

package/dist/add-ZJQJZJEF.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { REGISTRY_INDEX, REGISTRY } from './chunk-XSWWWO6H.mjs';
+import { promptYesNo } from './chunk-L6474RPL.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-D7D75ONX.mjs';
+import { CliError, CLI_ERROR_CODE, info, bold, dim, success, result, yellow } from './chunk-NZ4RG62Z.mjs';
+import { mkdirSync, existsSync, writeFileSync } from 'fs';
+import { resolve, join, dirname } from 'path';
+
+var DEFAULT_TARGET_DIR = "src/components/cimplify";
+function loadIndex() {
+  const index = REGISTRY_INDEX;
+  if (!index || !Array.isArray(index.components)) {
+    throw new CliError(
+      CLI_ERROR_CODE.NOT_FOUND,
+      "Embedded SDK component registry is empty.",
+      {
+        remediation: "Rebuild the CLI with the SDK present: `cd packages/sdk && bun run build && cd ../cli && bun run build`."
+      }
+    );
+  }
+  return index;
+}
+function loadComponent(name) {
+  const entry = REGISTRY[name];
+  if (!entry) {
+    const known = new Set(loadIndex().components.map((c) => c.name));
+    const remediation = known.has(name) ? "The CLI bundle is missing this component's payload \u2014 rebuild via `bun run build`." : "Run `cimplify list` to see available components.";
+    throw new CliError(
+      CLI_ERROR_CODE.NOT_FOUND,
+      `Component "${name}" is not in the registry.`,
+      { remediation }
+    );
+  }
+  return entry;
+}
+async function writeComponent(component, options) {
+  const outcome = {
+    component: component.name,
+    written: [],
+    skipped: []
+  };
+  mkdirSync(options.targetDir, { recursive: true });
+  for (const file of component.files) {
+    const targetPath = join(options.targetDir, file.path);
+    mkdirSync(dirname(targetPath), { recursive: true });
+    if (existsSync(targetPath) && !options.force) {
+      info(`  ${yellow("skip")}   ${file.path} ${dim("(exists; pass --force to overwrite)")}`);
+      outcome.skipped.push(file.path);
+      continue;
+    }
+    writeFileSync(targetPath, file.content);
+    info(`  ${dim("wrote")}  ${file.path}`);
+    outcome.written.push(file.path);
+  }
+  return outcome;
+}
+function resolveDependencyOrder(roots) {
+  const visited = /* @__PURE__ */ new Set();
+  const order = [];
+  function visit(name) {
+    if (visited.has(name)) return;
+    visited.add(name);
+    const component = loadComponent(name);
+    for (const dep of component.registryDependencies) {
+      visit(dep);
+    }
+    order.push(name);
+  }
+  for (const root of roots) visit(root);
+  return order;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const dirFlag = flagString(args, "dir");
+  const force = flagBool(args, "force");
+  const all = flagBool(args, "all");
+  const noDeps = flagBool(args, "no-deps");
+  const targetDir = resolve(process.cwd(), dirFlag ?? DEFAULT_TARGET_DIR);
+  const names = args.positional;
+  let toInstall;
+  if (all) {
+    toInstall = loadIndex().components.map((c) => c.name);
+  } else {
+    if (names.length === 0) {
+      throw new CliError(
+        CLI_ERROR_CODE.INVALID_INPUT,
+        "No component name provided.",
+        { remediation: "Run `cimplify list` to see options, then `cimplify add <name>`." }
+      );
+    }
+    toInstall = noDeps ? names : resolveDependencyOrder(names);
+  }
+  if (!all && !noDeps && toInstall.length > names.length) {
+    const transitive = toInstall.filter((n) => !names.includes(n));
+    info(`${bold("Will install with dependencies:")}`);
+    info(`  Requested: ${names.join(", ")}`);
+    info(`  Transitive: ${transitive.join(", ")}`);
+    info(dim(`  Pass --no-deps to skip transitive components.`));
+    const proceed = await promptYesNo("Continue?", true);
+    if (!proceed) {
+      throw new CliError(CLI_ERROR_CODE.ABORTED, "Aborted by user.");
+    }
+  }
+  info("");
+  info(`Target: ${dim(targetDir)}`);
+  info("");
+  const outcomes = [];
+  for (const name of toInstall) {
+    const component = loadComponent(name);
+    info(bold(name));
+    const outcome = await writeComponent(component, { targetDir, force });
+    outcomes.push(outcome);
+    info("");
+  }
+  const totalWritten = outcomes.reduce((n, o) => n + o.written.length, 0);
+  const totalSkipped = outcomes.reduce((n, o) => n + o.skipped.length, 0);
+  success(`Wrote ${totalWritten} file(s), skipped ${totalSkipped}`);
+  result({
+    target_dir: targetDir,
+    components: outcomes,
+    totals: { written: totalWritten, skipped: totalSkipped }
+  });
+}
+
+export { run as default };

package/dist/chunk-4YSOZ6LY.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { CliError, CLI_ERROR_CODE } from './chunk-NZ4RG62Z.mjs';
+
+// src/envfile.ts
+var COMMENT_CHAR = "#";
+var QUOTE_DOUBLE = '"';
+var QUOTE_SINGLE = "'";
+var KEY_SEPARATOR = "=";
+var KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function parseEnvFile(text) {
+  const entries = [];
+  const lines = text.split("\n");
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (line.length === 0) continue;
+    if (line.startsWith(COMMENT_CHAR)) continue;
+    const eq = line.indexOf(KEY_SEPARATOR);
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    if (!KEY_PATTERN.test(key)) continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2) {
+      const first = value[0];
+      const last = value[value.length - 1];
+      if (first === QUOTE_DOUBLE && last === QUOTE_DOUBLE || first === QUOTE_SINGLE && last === QUOTE_SINGLE) {
+        value = value.slice(1, -1);
+      }
+    }
+    entries.push({ key, value });
+  }
+  return entries;
+}
+function parseKeyValueArg(input) {
+  const eq = input.indexOf(KEY_SEPARATOR);
+  if (eq === -1) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Expected KEY=VALUE, got "${input}".`
+    );
+  }
+  const key = input.slice(0, eq).trim();
+  if (!KEY_PATTERN.test(key)) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Invalid env var key "${key}". Must match ${KEY_PATTERN.source}.`
+    );
+  }
+  return { key, value: input.slice(eq + 1) };
+}
+function formatEnvFile(entries) {
+  const lines = [];
+  for (const { key, value } of entries) {
+    const needsQuote = /[\s"'#]/.test(value) || value.length === 0;
+    const rendered = needsQuote ? `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : value;
+    lines.push(`${key}=${rendered}`);
+  }
+  return lines.length === 0 ? "" : `${lines.join("\n")}
+`;
+}
+
+export { formatEnvFile, parseEnvFile, parseKeyValueArg };

package/dist/chunk-4ZVTPMUZ.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import { CliError, CLI_ERROR_CODE } from './chunk-NZ4RG62Z.mjs';
+
+// src/api-client.ts
+var DEFAULT_API_BASE_URL = "https://api.cimplify.io";
+var ENV_API_BASE_URL = "CIMPLIFY_API_URL";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var HEADER_AUTHORIZATION = "Authorization";
+var HEADER_CONTENT_TYPE = "Content-Type";
+var HEADER_ACCEPT = "Accept";
+var HEADER_USER_AGENT = "User-Agent";
+var BEARER_PREFIX = "Bearer ";
+var CONTENT_TYPE_JSON = "application/json";
+var USER_AGENT = "cimplify-cli";
+var METHOD_GET = "GET";
+var METHOD_POST = "POST";
+var METHOD_PUT = "PUT";
+var METHOD_DELETE = "DELETE";
+var STATUS_UNAUTHORIZED = 401;
+var STATUS_FORBIDDEN = 403;
+var STATUS_NOT_FOUND = 404;
+var STATUS_CONFLICT = 409;
+var STATUS_BAD_REQUEST_MIN = 400;
+var STATUS_SERVER_ERROR_MIN = 500;
+var ApiClient = class _ApiClient {
+  baseUrl;
+  apiKey;
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.apiKey = apiKey;
+  }
+  static fromAuth(auth) {
+    return new _ApiClient(auth.apiBaseUrl, auth.apiKey);
+  }
+  static unauthenticated(baseUrl = resolveBaseUrl()) {
+    return new _ApiClient(baseUrl, "");
+  }
+  static withKey(apiKey, baseUrl = resolveBaseUrl()) {
+    return new _ApiClient(baseUrl, apiKey);
+  }
+  get(pathname, options) {
+    return this.request(METHOD_GET, pathname, void 0, options);
+  }
+  post(pathname, body, options) {
+    return this.request(METHOD_POST, pathname, body, options);
+  }
+  put(pathname, body, options) {
+    return this.request(METHOD_PUT, pathname, body, options);
+  }
+  delete(pathname, options) {
+    return this.request(METHOD_DELETE, pathname, void 0, options);
+  }
+  async request(method, pathname, body, options) {
+    const url = this.buildUrl(pathname, options?.query);
+    const headers = {
+      [HEADER_ACCEPT]: CONTENT_TYPE_JSON,
+      [HEADER_USER_AGENT]: USER_AGENT
+    };
+    if (this.apiKey) {
+      headers[HEADER_AUTHORIZATION] = `${BEARER_PREFIX}${this.apiKey}`;
+    }
+    let payload;
+    if (body !== void 0) {
+      headers[HEADER_CONTENT_TYPE] = CONTENT_TYPE_JSON;
+      payload = JSON.stringify(body);
+    }
+    const controller = new AbortController();
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetch(url, {
+        method,
+        headers,
+        body: payload,
+        signal: controller.signal
+      });
+    } catch (err) {
+      clearTimeout(timer);
+      throw toNetworkError(err);
+    }
+    clearTimeout(timer);
+    return parseResponse(response);
+  }
+  buildUrl(pathname, query) {
+    const base = pathname.startsWith("/") ? pathname : `/${pathname}`;
+    const url = new URL(`${this.baseUrl}${base}`);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v === void 0 || v === null) continue;
+        url.searchParams.set(k, String(v));
+      }
+    }
+    return url.toString();
+  }
+};
+function resolveBaseUrl(override) {
+  if (override && override.length > 0) return override;
+  const fromEnv = process.env[ENV_API_BASE_URL];
+  return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_API_BASE_URL;
+}
+async function parseResponse(response) {
+  const text = await response.text();
+  let body = void 0;
+  if (text.length > 0) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      throw new CliError(
+        CLI_ERROR_CODE.SERVER_ERROR,
+        `Server returned non-JSON response (status ${response.status}): ${truncate(text)}`
+      );
+    }
+  }
+  if (response.ok) {
+    if (body && typeof body === "object" && "data" in body) {
+      return body.data;
+    }
+    return body;
+  }
+  const code = mapStatusToCode(response.status);
+  const message = extractErrorMessage(body, response.status);
+  throw new CliError(code, message);
+}
+function mapStatusToCode(status) {
+  if (status === STATUS_UNAUTHORIZED) return CLI_ERROR_CODE.AUTH_FAILED;
+  if (status === STATUS_FORBIDDEN) return CLI_ERROR_CODE.AUTH_FAILED;
+  if (status === STATUS_NOT_FOUND) return CLI_ERROR_CODE.PROJECT_NOT_FOUND;
+  if (status === STATUS_CONFLICT) return CLI_ERROR_CODE.ALREADY_LINKED;
+  if (status >= STATUS_SERVER_ERROR_MIN) return CLI_ERROR_CODE.SERVER_ERROR;
+  if (status >= STATUS_BAD_REQUEST_MIN) return CLI_ERROR_CODE.INVALID_INPUT;
+  return CLI_ERROR_CODE.SERVER_ERROR;
+}
+function extractErrorMessage(body, status) {
+  if (body && typeof body === "object") {
+    const envelope = body;
+    if (envelope.error && typeof envelope.error.error_message === "string") {
+      return envelope.error.error_code ? `${envelope.error.error_code}: ${envelope.error.error_message}` : envelope.error.error_message;
+    }
+    if (typeof envelope.message === "string") return envelope.message;
+  }
+  return `HTTP ${status}`;
+}
+function toNetworkError(err) {
+  if (err instanceof DOMException && err.name === "AbortError") {
+    return new CliError(CLI_ERROR_CODE.NETWORK_ERROR, "Request timed out.");
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return new CliError(CLI_ERROR_CODE.NETWORK_ERROR, `Network error: ${message}`);
+}
+function truncate(value, max = 200) {
+  return value.length > max ? `${value.slice(0, max)}\u2026` : value;
+}
+
+export { ApiClient, resolveBaseUrl };

package/dist/chunk-5XH72JMJ.mjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+import { promptYesNo } from './chunk-L6474RPL.mjs';
+import { TOKEN_PURPOSE, REPO_PROVIDER, REPO_PROVIDER_VALUES } from './chunk-MQMNWLMU.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-D7D75ONX.mjs';
+import { ApiClient } from './chunk-4ZVTPMUZ.mjs';
+import { readAuth, readProjectLink } from './chunk-JJYWETGA.mjs';
+import { CliError, CLI_ERROR_CODE, isJsonMode, result, dim, success, info, bold } from './chunk-NZ4RG62Z.mjs';
+
+// src/commands/repo.ts
+var SUB_PROVISION = "provision";
+var SUB_CONNECT = "connect";
+var SUB_INFO = "info";
+var SUB_UNLINK = "unlink";
+var SUB_ROTATE_TOKEN = "rotate-token";
+var SUB_CLONE_URL = "clone-url";
+var FLAG_PURGE = "purge";
+var FLAG_YES = "yes";
+var FLAG_PROVIDER = "provider";
+var FLAG_NAME = "name";
+var FLAG_BRANCH = "branch";
+function repoEndpoint(businessId, projectId) {
+  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/repo`;
+}
+function provisionEndpoint(businessId, projectId) {
+  return `${repoEndpoint(businessId, projectId)}/provision`;
+}
+function connectEndpoint(businessId, projectId) {
+  return `${repoEndpoint(businessId, projectId)}/connect`;
+}
+function cloneTokenEndpoint(businessId, projectId) {
+  return `${repoEndpoint(businessId, projectId)}/clone-token`;
+}
+async function fetchCloneToken(client, businessId, projectId, purpose = TOKEN_PURPOSE.EDITOR) {
+  return client.post(cloneTokenEndpoint(businessId, projectId), {
+    purpose
+  });
+}
+function resolveProvider(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!REPO_PROVIDER_VALUES.has(value)) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Invalid provider "${value}". Choose: ${[...REPO_PROVIDER_VALUES].join(", ")}.`
+    );
+  }
+  return value;
+}
+function detectProviderFromUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname === "git.freestyle.sh") return REPO_PROVIDER.FREESTYLE;
+    if (parsed.hostname === "github.com" || parsed.hostname.endsWith(".github.com")) {
+      return REPO_PROVIDER.GITHUB;
+    }
+    if (parsed.hostname.includes("gitea")) return REPO_PROVIDER.GITEA;
+  } catch {
+  }
+  return REPO_PROVIDER.EXTERNAL;
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const sub = args.positional[0];
+  if (!sub) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Usage: cimplify repo <${SUB_PROVISION}|${SUB_CONNECT}|${SUB_INFO}|${SUB_UNLINK}|${SUB_ROTATE_TOKEN}|${SUB_CLONE_URL}>`
+    );
+  }
+  const auth = await readAuth();
+  const link = await readProjectLink();
+  const client = ApiClient.fromAuth(auth);
+  switch (sub) {
+    case SUB_PROVISION:
+      await provisionRepo(client, link.businessId, link.projectId, args);
+      return;
+    case SUB_CONNECT:
+      await connectRepo(client, link.businessId, link.projectId, args);
+      return;
+    case SUB_INFO:
+      await repoInfo(client, link.businessId, link.projectId);
+      return;
+    case SUB_UNLINK:
+      await unlinkRepo(client, link.businessId, link.projectId, args);
+      return;
+    case SUB_ROTATE_TOKEN:
+      await provisionRepo(client, link.businessId, link.projectId, args);
+      return;
+    case SUB_CLONE_URL:
+      await printCloneUrl(client, link.businessId, link.projectId);
+      return;
+    default:
+      throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `Unknown repo subcommand "${sub}"`);
+  }
+}
+async function printCloneUrl(client, businessId, projectId) {
+  const token = await fetchCloneToken(client, businessId, projectId);
+  if (isJsonMode()) {
+    result({
+      clone_url: token.clone_url,
+      token: token.token ?? null,
+      repo_id: token.repo_id,
+      provider: token.provider,
+      expires_in_seconds: token.expires_in_seconds
+    });
+    return;
+  }
+  process.stdout.write(`${token.clone_url}
+`);
+  const hints = [
+    "",
+    dim(`Token TTL: ${token.expires_in_seconds}s. Re-run to mint a fresh one.`),
+    dim("Example:"),
+    dim(`  git remote set-url origin "${token.clone_url}"`),
+    dim("  # or one-shot:"),
+    dim(`  git push "${token.clone_url}" main`)
+  ];
+  for (const line of hints) process.stderr.write(`${line}
+`);
+}
+async function provisionRepo(client, businessId, projectId, args) {
+  const provider = resolveProvider(flagString(args, FLAG_PROVIDER), REPO_PROVIDER.FREESTYLE);
+  if (provider !== REPO_PROVIDER.FREESTYLE) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Provisioning is only supported for ${REPO_PROVIDER.FREESTYLE} today. Use \`cimplify repo connect\` for ${provider}.`
+    );
+  }
+  const body = {
+    provider,
+    name_hint: flagString(args, FLAG_NAME) ?? void 0,
+    default_branch: flagString(args, FLAG_BRANCH) ?? void 0
+  };
+  const repo = await client.post(provisionEndpoint(businessId, projectId), body);
+  success(`Provisioned ${repo.provider} repo`);
+  printRepo(repo);
+  result({ repo: repoPayload(repo) });
+}
+async function connectRepo(client, businessId, projectId, args) {
+  const remoteUrl = args.positional[1];
+  if (!remoteUrl) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      `Usage: cimplify repo ${SUB_CONNECT} <https-clone-url> [--provider <p>] [--branch <name>]`
+    );
+  }
+  const provider = resolveProvider(flagString(args, FLAG_PROVIDER), detectProviderFromUrl(remoteUrl));
+  if (provider === REPO_PROVIDER.FREESTYLE) {
+    throw new CliError(
+      CLI_ERROR_CODE.INVALID_INPUT,
+      "Cannot connect a Freestyle URL \u2014 use `cimplify repo provision` instead."
+    );
+  }
+  const body = {
+    provider,
+    remote_url: remoteUrl,
+    default_branch: flagString(args, FLAG_BRANCH) ?? void 0
+  };
+  const repo = await client.post(connectEndpoint(businessId, projectId), body);
+  success(`Connected ${repo.provider} remote ${repo.remote_url}`);
+  printRepo(repo);
+  result({ repo: repoPayload(repo) });
+}
+async function repoInfo(client, businessId, projectId) {
+  const repo = await client.get(repoEndpoint(businessId, projectId));
+  if (!repo) {
+    info(dim("No repo attached. Run `cimplify repo provision` to mint a Freestyle repo,"));
+    info(dim("or `cimplify repo connect <url>` to link an existing remote."));
+    result({ repo: null });
+    return;
+  }
+  printRepo(repo);
+  result({ repo: repoPayload(repo) });
+}
+async function unlinkRepo(client, businessId, projectId, args) {
+  const purge = flagBool(args, FLAG_PURGE);
+  const skipPrompt = flagBool(args, FLAG_YES);
+  if (!skipPrompt) {
+    const message = purge ? "Unlink and DELETE the upstream Freestyle repo? This cannot be undone." : "Unlink the repo from this project? (Upstream repo will be preserved.)";
+    const proceed = await promptYesNo(message, false);
+    if (!proceed) {
+      throw new CliError(CLI_ERROR_CODE.ABORTED, "Aborted by user.");
+    }
+  }
+  await client.delete(repoEndpoint(businessId, projectId), {
+    query: purge ? { purge: "true" } : void 0
+  });
+  success(purge ? "Repo unlinked and purged" : "Repo unlinked (upstream preserved)");
+  result({ unlinked: true, purged: purge });
+}
+function printRepo(repo) {
+  info(bold("Repo:"));
+  info(`  provider:       ${repo.provider}`);
+  info(`  id:             ${repo.id}`);
+  info(`  remote_url:     ${repo.remote_url}`);
+  info(`  default_branch: ${repo.default_branch}`);
+  if (repo.last_pushed_commit) {
+    info(`  last_pushed:    ${repo.last_pushed_commit.slice(0, 12)} (${repo.last_pushed_at ?? "\u2014"})`);
+  }
+}
+function repoPayload(repo) {
+  return {
+    provider: repo.provider,
+    id: repo.id,
+    remote_url: repo.remote_url,
+    default_branch: repo.default_branch,
+    last_pushed_commit: repo.last_pushed_commit ?? null,
+    last_pushed_at: repo.last_pushed_at ?? null
+  };
+}
+
+export { fetchCloneToken, run };

package/dist/chunk-D7D75ONX.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// src/args.ts
+function parseArgs(argv) {
+  const positional = [];
+  const flags = /* @__PURE__ */ new Map();
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const eq = arg.indexOf("=");
+    if (eq !== -1) {
+      flags.set(arg.slice(2, eq), arg.slice(eq + 1));
+      continue;
+    }
+    const name = arg.slice(2);
+    const next = argv[i + 1];
+    if (next !== void 0 && !next.startsWith("--")) {
+      flags.set(name, next);
+      i++;
+    } else {
+      flags.set(name, true);
+    }
+  }
+  return { positional, flags };
+}
+function flagString(args, name) {
+  const v = args.flags.get(name);
+  return typeof v === "string" ? v : void 0;
+}
+function flagBool(args, name) {
+  return args.flags.has(name);
+}
+
+export { flagBool, flagString, parseArgs };