@cimplify/sdk 0.44.34 → 0.45.0

package/dist/cli/commands/domains.mjs

@@ -1,769 +0,0 @@
-import { promises } from 'fs';
-import os from 'os';
-import path from 'path';
-import readline from 'readline';
-
-// src/cli/errors.ts
-var CLI_ERROR_CODE = {
-  NOT_LOGGED_IN: "NOT_LOGGED_IN",
-  NOT_LINKED: "NOT_LINKED",
-  NETWORK_ERROR: "NETWORK_ERROR",
-  AUTH_FAILED: "AUTH_FAILED",
-  PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND",
-  INVALID_INPUT: "INVALID_INPUT",
-  ALREADY_LINKED: "ALREADY_LINKED",
-  SERVER_ERROR: "SERVER_ERROR",
-  ABORTED: "ABORTED",
-  /** Operation needs interactive confirmation and the shell is non-interactive. */
-  INTERACTIVE_REQUIRED: "INTERACTIVE_REQUIRED"
-};
-var EXIT_CODE = {
-  ABORTED: 3,
-  NOT_LINKED: 4,
-  ALREADY_LINKED: 5,
-  GIT_ERROR: 6,
-  INTERACTIVE_REQUIRED: 7,
-  PROJECT_NOT_FOUND: 8,
-  NETWORK_ERROR: 10,
-  SERVER_ERROR: 11,
-  TIMEOUT: 12,
-  NOT_LOGGED_IN: 20,
-  AUTH_FAILED: 21,
-  UNAUTHORIZED: 22,
-  INVALID_INPUT: 30
-};
-var EXIT_CODE_FOR = {
-  NOT_LOGGED_IN: EXIT_CODE.NOT_LOGGED_IN,
-  NOT_LINKED: EXIT_CODE.NOT_LINKED,
-  NETWORK_ERROR: EXIT_CODE.NETWORK_ERROR,
-  AUTH_FAILED: EXIT_CODE.AUTH_FAILED,
-  PROJECT_NOT_FOUND: EXIT_CODE.PROJECT_NOT_FOUND,
-  GIT_ERROR: EXIT_CODE.GIT_ERROR,
-  INVALID_INPUT: EXIT_CODE.INVALID_INPUT,
-  ALREADY_LINKED: EXIT_CODE.ALREADY_LINKED,
-  SERVER_ERROR: EXIT_CODE.SERVER_ERROR,
-  ABORTED: EXIT_CODE.ABORTED,
-  UNAUTHORIZED: EXIT_CODE.UNAUTHORIZED,
-  TIMEOUT: EXIT_CODE.TIMEOUT,
-  INTERACTIVE_REQUIRED: EXIT_CODE.INTERACTIVE_REQUIRED
-};
-var CliError = class extends Error {
-  constructor(code, message, options = {}) {
-    super(message);
-    this.name = "CliError";
-    this.code = code;
-    this.exitCode = options.exitCode ?? EXIT_CODE_FOR[code];
-    this.remediation = options.remediation;
-  }
-};
-
-// src/cli/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 {
-  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) {
-  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;
-}
-
-// src/cli/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);
-}
-var AUTH_FILE_NAME = "auth.json";
-var PROJECT_FILE_NAME = "project.json";
-var PROJECT_DIR_NAME = ".cimplify";
-var ENV_XDG_CONFIG_HOME = "XDG_CONFIG_HOME";
-var APP_CONFIG_DIR_NAME = "cimplify";
-var HOME_CONFIG_DIR_NAME = ".config";
-var ENCODING_UTF8 = "utf8";
-function authConfigDir() {
-  const xdg = process.env[ENV_XDG_CONFIG_HOME];
-  return xdg ? path.join(xdg, APP_CONFIG_DIR_NAME) : path.join(os.homedir(), HOME_CONFIG_DIR_NAME, APP_CONFIG_DIR_NAME);
-}
-function authConfigPath() {
-  return path.join(authConfigDir(), AUTH_FILE_NAME);
-}
-function projectConfigDir(cwd = process.cwd()) {
-  return path.join(cwd, PROJECT_DIR_NAME);
-}
-function projectConfigPath(cwd = process.cwd()) {
-  return path.join(projectConfigDir(cwd), PROJECT_FILE_NAME);
-}
-async function readJsonFile(filePath) {
-  try {
-    const raw = await promises.readFile(filePath, ENCODING_UTF8);
-    return JSON.parse(raw);
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    throw err;
-  }
-}
-async function readAuth() {
-  const data = await readJsonFile(authConfigPath());
-  if (!data) {
-    throw new CliError(
-      CLI_ERROR_CODE.NOT_LOGGED_IN,
-      "Not logged in. Run `cimplify login` first."
-    );
-  }
-  return data;
-}
-async function readProjectLink(cwd = process.cwd()) {
-  const data = await readJsonFile(projectConfigPath(cwd));
-  if (!data) {
-    throw new CliError(
-      CLI_ERROR_CODE.NOT_LINKED,
-      "No project linked. Run `cimplify link <project-id>` first."
-    );
-  }
-  return data;
-}
-
-// src/cli/output.ts
-var RESET = "\x1B[0m";
-var BOLD_OPEN = "\x1B[1m";
-var DIM_OPEN = "\x1B[2m";
-var GREEN_OPEN = "\x1B[32m";
-var PREFIX_SUCCESS = "\u2713";
-var ENV_JSON = "CIMPLIFY_JSON";
-var ENV_YES = "CIMPLIFY_YES";
-function envFlag(name) {
-  const v = process.env[name];
-  return v === "1" || v === "true";
-}
-function isJsonMode() {
-  return envFlag(ENV_JSON);
-}
-function isAutoYes() {
-  return envFlag(ENV_YES);
-}
-function isInteractive() {
-  return Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY);
-}
-function wrap(open, value) {
-  return `${open}${value}${RESET}`;
-}
-function bold(value) {
-  return isJsonMode() ? value : wrap(BOLD_OPEN, value);
-}
-function dim(value) {
-  return isJsonMode() ? value : wrap(DIM_OPEN, value);
-}
-function green(value) {
-  return isJsonMode() ? value : wrap(GREEN_OPEN, value);
-}
-function success(message) {
-  if (isJsonMode()) return;
-  console.log(`${green(PREFIX_SUCCESS)} ${message}`);
-}
-function info(message) {
-  if (isJsonMode()) return;
-  console.log(message);
-}
-var ENV_EMITTED = "__CIMPLIFY_RESULT_EMITTED";
-function result(data) {
-  if (!isJsonMode()) return;
-  if (process.env[ENV_EMITTED] === "1") return;
-  process.env[ENV_EMITTED] = "1";
-  process.stdout.write(`${JSON.stringify({ ok: true, data })}
-`);
-}
-async function promptLine(question) {
-  if (!isInteractive()) {
-    throw new CliError(
-      CLI_ERROR_CODE.INTERACTIVE_REQUIRED,
-      "this operation needs interactive input but stdin is not a TTY",
-      { remediation: "run interactively, or supply the value via a flag" }
-    );
-  }
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  try {
-    return await new Promise((resolve) => {
-      rl.question(question, (answer) => resolve(answer));
-    });
-  } finally {
-    rl.close();
-  }
-}
-async function promptYesNo(question, defaultNo = true) {
-  if (isAutoYes()) return true;
-  if (!isInteractive()) {
-    throw new CliError(
-      CLI_ERROR_CODE.INTERACTIVE_REQUIRED,
-      `this operation needs confirmation: ${question}`,
-      { remediation: "re-run with --yes to accept, or run interactively" }
-    );
-  }
-  const suffix = defaultNo ? " [y/N] " : " [Y/n] ";
-  const answer = (await promptLine(`${question}${suffix}`)).trim().toLowerCase();
-  if (answer === "") return !defaultNo;
-  return answer === "y" || answer === "yes";
-}
-
-// src/cli/types.ts
-var ENV_SCOPE = {
-  DEVELOPMENT: "development",
-  PREVIEW: "preview",
-  STAGING: "staging",
-  PRODUCTION: "production"
-};
-var DOMAIN_TYPE = {
-  CUSTOM: "custom",
-  CIMPLIFY: "cimplify"
-};
-var REPO_PROVIDER = {
-  FREESTYLE: "freestyle",
-  GITHUB: "github",
-  GITEA: "gitea",
-  EXTERNAL: "external"
-};
-new Set(Object.values(REPO_PROVIDER));
-
-// src/cli/commands/domains.ts
-var SUB_LS = "ls";
-var SUB_LIST = "list";
-var SUB_ADD = "add";
-var SUB_VERIFY = "verify";
-var SUB_RM = "rm";
-var SUB_REMOVE = "remove";
-var SUB_ATTACH = "attach";
-var SUB_DETACH = "detach";
-var SUB_PRIMARY = "primary";
-var FLAG_TYPE = "type";
-var FLAG_YES = "yes";
-var FLAG_ENV = "env";
-var FLAG_PRIMARY = "primary";
-var FLAG_ATTACHED = "attached";
-var ENV_SCOPE_VALUES = new Set(Object.values(ENV_SCOPE));
-function resolveEnvScope(value, fallback = ENV_SCOPE.PRODUCTION) {
-  if (value === void 0) return fallback;
-  if (!ENV_SCOPE_VALUES.has(value)) {
-    throw new CliError(
-      CLI_ERROR_CODE.INVALID_INPUT,
-      `Invalid env "${value}". Choose: ${[...ENV_SCOPE_VALUES].join(", ")}.`
-    );
-  }
-  return value;
-}
-function projectDomainsEndpoint(businessId, projectId) {
-  return `/v1/businesses/${encodeURIComponent(businessId)}/projects/${encodeURIComponent(projectId)}/domains`;
-}
-function projectDomainItemEndpoint(businessId, projectId, attachmentId) {
-  return `${projectDomainsEndpoint(businessId, projectId)}/${encodeURIComponent(attachmentId)}`;
-}
-function projectDomainPrimaryEndpoint(businessId, projectId, attachmentId) {
-  return `${projectDomainItemEndpoint(businessId, projectId, attachmentId)}/primary`;
-}
-var COL_GAP = "  ";
-var COL_DOMAIN = "DOMAIN";
-var COL_TYPE = "TYPE";
-var COL_VERIFIED = "VERIFIED";
-var COL_PRIMARY = "PRIMARY";
-var COL_CREATED = "CREATED";
-var DNS_COL_TYPE = "Type";
-var DNS_COL_NAME = "Name";
-var DNS_COL_VALUE = "Value";
-var VALID_DOMAIN_TYPES = new Set(Object.values(DOMAIN_TYPE));
-function domainsEndpoint(businessId) {
-  return `/v1/businesses/${encodeURIComponent(businessId)}/domains`;
-}
-function domainItemEndpoint(businessId, id) {
-  return `${domainsEndpoint(businessId)}/${encodeURIComponent(id)}`;
-}
-function domainVerifyEndpoint(businessId, id) {
-  return `${domainItemEndpoint(businessId, id)}/verify`;
-}
-function dnsRecordsEndpoint(domain) {
-  return `/v1/hosting/domains/${encodeURIComponent(domain)}/dns-records`;
-}
-function resolveDomainType(value) {
-  if (value === void 0) return DOMAIN_TYPE.CUSTOM;
-  if (!VALID_DOMAIN_TYPES.has(value)) {
-    throw new CliError(
-      CLI_ERROR_CODE.INVALID_INPUT,
-      `Invalid domain type "${value}". Choose: ${[...VALID_DOMAIN_TYPES].join(", ")}.`
-    );
-  }
-  return value;
-}
-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 domains <${SUB_LS}|${SUB_ADD}|${SUB_VERIFY}|${SUB_RM}|${SUB_ATTACH}|${SUB_DETACH}|${SUB_PRIMARY}>`
-    );
-  }
-  const auth = await readAuth();
-  const client = ApiClient.fromAuth(auth);
-  if (sub === SUB_LS || sub === SUB_LIST) {
-    if (flagBool(args, FLAG_ATTACHED)) {
-      await listAttachedForCurrentProject(client, auth.businessId);
-    } else {
-      await listDomains(client, auth.businessId);
-    }
-    return;
-  }
-  if (sub === SUB_ADD) {
-    await addDomain(client, auth.businessId, args);
-    return;
-  }
-  if (sub === SUB_VERIFY) {
-    await verifyDomain(client, auth.businessId, args);
-    return;
-  }
-  if (sub === SUB_RM || sub === SUB_REMOVE) {
-    await removeDomain(client, auth.businessId, args);
-    return;
-  }
-  if (sub === SUB_ATTACH) {
-    await attachDomain(client, auth.businessId, args);
-    return;
-  }
-  if (sub === SUB_DETACH) {
-    await detachDomain(client, auth.businessId, args);
-    return;
-  }
-  if (sub === SUB_PRIMARY) {
-    await setPrimaryAttachment(client, auth.businessId, args);
-    return;
-  }
-  throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `Unknown domains subcommand "${sub}"`);
-}
-async function listDomains(client, businessId) {
-  const domains = await client.get(domainsEndpoint(businessId));
-  if (domains.length === 0) {
-    info(dim("No domains. Add one: cimplify domains add <domain>"));
-    result({ domains: [] });
-    return;
-  }
-  const domainWidth = Math.max(COL_DOMAIN.length, ...domains.map((d) => d.domain.length));
-  const typeWidth = Math.max(COL_TYPE.length, ...domains.map((d) => String(d.domain_type).length));
-  const verifiedWidth = COL_VERIFIED.length;
-  const primaryWidth = COL_PRIMARY.length;
-  info(
-    bold(
-      [
-        COL_DOMAIN.padEnd(domainWidth),
-        COL_TYPE.padEnd(typeWidth),
-        COL_VERIFIED.padEnd(verifiedWidth),
-        COL_PRIMARY.padEnd(primaryWidth),
-        COL_CREATED
-      ].join(COL_GAP)
-    )
-  );
-  for (const d of domains) {
-    info(
-      [
-        d.domain.padEnd(domainWidth),
-        String(d.domain_type).padEnd(typeWidth),
-        (d.is_verified ? "yes" : "no").padEnd(verifiedWidth),
-        (d.is_primary ? "yes" : "no").padEnd(primaryWidth),
-        d.created_at ?? ""
-      ].join(COL_GAP)
-    );
-  }
-  result({
-    domains: domains.map((d) => ({
-      id: d.id,
-      domain: d.domain,
-      domain_type: d.domain_type,
-      is_verified: d.is_verified,
-      is_primary: d.is_primary,
-      created_at: d.created_at ?? null
-    }))
-  });
-}
-async function addDomain(client, businessId, args) {
-  const domain = args.positional[1];
-  if (!domain) {
-    throw new CliError(
-      CLI_ERROR_CODE.INVALID_INPUT,
-      `Usage: cimplify domains add <domain> [--type=custom|cimplify]`
-    );
-  }
-  const domainType = resolveDomainType(flagString(args, FLAG_TYPE));
-  const body = { domain, domain_type: domainType };
-  const created = await client.post(domainsEndpoint(businessId), body);
-  success(`Added ${created.domain} (${created.domain_type})`);
-  let dnsRecords = null;
-  if (domainType === DOMAIN_TYPE.CUSTOM) {
-    try {
-      const dns = await client.get(dnsRecordsEndpoint(domain));
-      dnsRecords = Array.isArray(dns) ? dns : dns.records;
-      printDnsRecords(domain, dnsRecords);
-    } catch (err) {
-      info(dim(`(Could not fetch DNS records: ${err instanceof Error ? err.message : String(err)})`));
-    }
-  }
-  result({
-    domain: {
-      id: created.id,
-      domain: created.domain,
-      domain_type: created.domain_type,
-      is_verified: created.is_verified
-    },
-    dns_records: dnsRecords
-  });
-}
-function printDnsRecords(domain, records) {
-  if (!records || records.length === 0) {
-    info(dim("No DNS records returned."));
-    return;
-  }
-  const typeWidth = Math.max(DNS_COL_TYPE.length, ...records.map((r) => r.type.length));
-  const nameWidth = Math.max(DNS_COL_NAME.length, ...records.map((r) => r.name.length));
-  const valueWidth = Math.max(DNS_COL_VALUE.length, ...records.map((r) => r.value.length));
-  info("");
-  info("Add the following DNS records:");
-  info("");
-  info(
-    `  ${bold(DNS_COL_TYPE.padEnd(typeWidth))}   ${bold(DNS_COL_NAME.padEnd(nameWidth))}   ${bold(DNS_COL_VALUE)}`
-  );
-  info(
-    `  ${"\u2500".repeat(typeWidth)}   ${"\u2500".repeat(nameWidth)}   ${"\u2500".repeat(Math.min(valueWidth, 40))}`
-  );
-  for (const r of records) {
-    info(`  ${r.type.padEnd(typeWidth)}   ${r.name.padEnd(nameWidth)}   ${r.value}`);
-  }
-  info("");
-  info(`Then run: ${bold(`cimplify domains verify ${domain}`)}`);
-}
-async function verifyDomain(client, businessId, args) {
-  const domain = args.positional[1];
-  if (!domain) {
-    throw new CliError(
-      CLI_ERROR_CODE.INVALID_INPUT,
-      `Usage: cimplify domains verify <domain>`
-    );
-  }
-  const target = await findDomain(client, businessId, domain);
-  const verified = await client.post(domainVerifyEndpoint(businessId, target.id));
-  if (verified.is_verified) {
-    success(`Verified ${verified.domain}`);
-  } else {
-    info(dim(`Not yet verified \u2014 DNS may still be propagating. Try again in a few minutes.`));
-  }
-  result({ domain: verified.domain, verified: verified.is_verified });
-}
-async function removeDomain(client, businessId, args) {
-  const domain = args.positional[1];
-  if (!domain) {
-    throw new CliError(
-      CLI_ERROR_CODE.INVALID_INPUT,
-      `Usage: cimplify domains rm <domain> [--yes]`
-    );
-  }
-  const target = await findDomain(client, businessId, domain);
-  if (!flagBool(args, FLAG_YES)) {
-    const confirmed = await promptYesNo(`Remove ${domain}?`, true);
-    if (!confirmed) {
-      throw new CliError(CLI_ERROR_CODE.ABORTED, "Aborted by user.");
-    }
-  }
-  await client.delete(domainItemEndpoint(businessId, target.id));
-  success(`Removed ${domain}`);
-  result({ removed: true, domain });
-}
-async function findDomain(client, businessId, domain) {
-  const domains = await client.get(domainsEndpoint(businessId));
-  const match = domains.find((d) => d.domain === domain);
-  if (!match) {
-    throw new CliError(
-      CLI_ERROR_CODE.PROJECT_NOT_FOUND,
-      `Domain "${domain}" not found. List domains: cimplify domains ls`
-    );
-  }
-  return match;
-}
-async function attachDomain(client, businessId, args) {
-  const domain = args.positional[1];
-  if (!domain) {
-    throw new CliError(
-      CLI_ERROR_CODE.INVALID_INPUT,
-      `Usage: cimplify domains ${SUB_ATTACH} <domain> [--env=preview|production] [--primary]`
-    );
-  }
-  const link = await readProjectLink();
-  const target = await findDomain(client, businessId, domain);
-  if (!target.is_verified) {
-    throw new CliError(
-      CLI_ERROR_CODE.INVALID_INPUT,
-      `Domain "${domain}" is not verified. Run: cimplify domains verify ${domain}`
-    );
-  }
-  const envScope = resolveEnvScope(flagString(args, FLAG_ENV));
-  const isPrimary = flagBool(args, FLAG_PRIMARY);
-  const body = {
-    business_domain_id: target.id,
-    env_scope: envScope,
-    is_primary: isPrimary
-  };
-  await client.post(
-    projectDomainsEndpoint(businessId, link.projectId),
-    body
-  );
-  success(`Attached ${domain} to project for ${envScope}${isPrimary ? " (primary)" : ""}`);
-  info(dim("Next deploy will bind this domain. Run: cimplify deploy"));
-  result({ attached: true, domain, env: envScope, primary: isPrimary });
-}
-async function detachDomain(client, businessId, args) {
-  const domain = args.positional[1];
-  if (!domain) {
-    throw new CliError(
-      CLI_ERROR_CODE.INVALID_INPUT,
-      `Usage: cimplify domains ${SUB_DETACH} <domain> [--env=preview|production] [--yes]`
-    );
-  }
-  const link = await readProjectLink();
-  const envScope = resolveEnvScope(flagString(args, FLAG_ENV));
-  const attachment = await findAttachmentForCurrentProject(client, businessId, link.projectId, domain, envScope);
-  if (!flagBool(args, FLAG_YES)) {
-    const confirmed = await promptYesNo(`Detach ${domain} from this project (${envScope})?`, true);
-    if (!confirmed) {
-      throw new CliError(CLI_ERROR_CODE.ABORTED, "Aborted by user.");
-    }
-  }
-  await client.delete(projectDomainItemEndpoint(businessId, link.projectId, attachment.id));
-  success(`Detached ${domain} (${envScope})`);
-  info(dim("Next deploy will not bind this domain. Existing deployments continue serving until redeploy."));
-  result({ detached: true, domain, env: envScope });
-}
-async function setPrimaryAttachment(client, businessId, args) {
-  const domain = args.positional[1];
-  if (!domain) {
-    throw new CliError(
-      CLI_ERROR_CODE.INVALID_INPUT,
-      `Usage: cimplify domains ${SUB_PRIMARY} <domain> [--env=preview|production]`
-    );
-  }
-  const link = await readProjectLink();
-  const envScope = resolveEnvScope(flagString(args, FLAG_ENV));
-  const attachment = await findAttachmentForCurrentProject(client, businessId, link.projectId, domain, envScope);
-  await client.post(
-    projectDomainPrimaryEndpoint(businessId, link.projectId, attachment.id)
-  );
-  success(`Set ${domain} as primary for ${envScope}`);
-  result({ primary: true, domain, env: envScope });
-}
-async function listAttachedForCurrentProject(client, businessId) {
-  const link = await readProjectLink();
-  const attachments = await client.get(
-    projectDomainsEndpoint(businessId, link.projectId)
-  );
-  if (attachments.length === 0) {
-    info(dim("No domains attached to this project. Attach one: cimplify domains attach <domain>"));
-    result({ attached: [] });
-    return;
-  }
-  const domains = await client.get(domainsEndpoint(businessId));
-  const domainById = new Map(domains.map((d) => [d.id, d]));
-  info(bold(["DOMAIN", "ENV", "PRIMARY", "ATTACHED"].join(COL_GAP)));
-  for (const a of attachments) {
-    const bd = domainById.get(a.business_domain_id);
-    info(
-      [
-        bd?.domain ?? `<unknown:${a.business_domain_id}>`,
-        String(a.env_scope),
-        a.is_primary ? "yes" : "no",
-        a.attached_at
-      ].join(COL_GAP)
-    );
-  }
-  result({
-    attached: attachments.map((a) => ({
-      attachment_id: a.id,
-      business_domain_id: a.business_domain_id,
-      domain: domainById.get(a.business_domain_id)?.domain ?? null,
-      env: a.env_scope,
-      primary: a.is_primary,
-      attached_at: a.attached_at
-    }))
-  });
-}
-async function findAttachmentForCurrentProject(client, businessId, projectId, domain, envScope) {
-  const target = await findDomain(client, businessId, domain);
-  const attachments = await client.get(projectDomainsEndpoint(businessId, projectId));
-  const match = attachments.find(
-    (a) => a.business_domain_id === target.id && a.env_scope === envScope
-  );
-  if (!match) {
-    throw new CliError(
-      CLI_ERROR_CODE.PROJECT_NOT_FOUND,
-      `${domain} is not attached to this project for env "${envScope}". List attached: cimplify domains ls --attached`
-    );
-  }
-  return match;
-}
-
-export { run as default, printDnsRecords };