@indigoai-us/hq-cli 5.345.162 → 5.345.163

package/dist/commands/deploy-domains.js

@@ -0,0 +1,787 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createInterface } from "node:readline/promises";
+import { domainToASCII } from "node:url";
+import { deployApiRequest } from "../lib/deploy-api.js";
+import { listDeployApps } from "../lib/deploy-apps.js";
+import { DEFAULT_HQ_ROOT, ensureCognitoToken } from "../utils/cognito-session.js";
+import { getCompanyUid, vaultApiFetch, vaultApiFetchPublic } from "../utils/vault-api.js";
+import { displayText, safeJson } from "./deploy-comments.js";
+import { readActiveCompanySlug } from "./skill.js";
+/**
+ * `hq deploy domains` manages an app's custom domains and buys new domains.
+ *
+ * list/add/refresh/remove call hq-deploy's /api/apps/:id/domains routes, the
+ * same routes the desktop Deployments panel uses (hq-desktop-app #1734). The
+ * add-on gate (the billing.custom-domain-addon flag, the card check and the
+ * admin check) runs on the server, so this command shows the same answers the
+ * panel shows.
+ *
+ * search/buy call hq-pro's /v1/billing/companies/:uid/domain-purchase routes
+ * (hq-pro #5133, #5156). The server gates them on the same flag and charges
+ * the price it publishes in GET /v1/pricing (usage.domains.purchase). Buying
+ * needs the Name.com credentials on the server; until those exist the server
+ * answers REGISTRAR_UNAVAILABLE and nothing is charged.
+ *
+ * Project: hq-deploy-custom-domain-tiers, US-014.
+ */
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,62}$/;
+/** hq-deploy app ids: UUIDs today, `app_…` in older records and tests. */
+const APP_ID_PATTERN = /^(?:app_[A-Za-z0-9_-]+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+const IDEMPOTENCY_KEY_PATTERN = /^[A-Za-z0-9_-]{16,64}$/;
+const BINDING_FILES = [path.join(".hq", "project.json"), "hq-deploy.json"];
+const PRICING_TIMEOUT_MS = 5000;
+/** Exit code for `refresh` when the domain is not serving yet, so scripts can poll. */
+export const REFRESH_NOT_SERVING_EXIT_CODE = 2;
+export class DeployDomainsError extends Error {
+    code;
+    status;
+    extra;
+    constructor(message, code, status, extra = {}) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.extra = extra;
+    }
+}
+/**
+ * Terminal hooks for the confirmation prompt. Tests replace these; production
+ * reads the real TTY state and asks on stdin.
+ */
+export const deployDomainsPrompt = {
+    // The prompt writes to stderr so `--json` on stdout stays parseable.
+    isInteractive: () => Boolean(process.stdin.isTTY && process.stderr.isTTY),
+    ask: async (question) => {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        try {
+            return await rl.question(question);
+        }
+        finally {
+            rl.close();
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Messages
+/** Plain wording for hq-deploy domain error codes. Billing codes prefer the server's text. */
+const DEPLOY_MESSAGES = {
+    DOMAIN_NOT_ENTITLED: "Custom domains are not enabled for this company yet.",
+    BILLING_ADMIN_REQUIRED: "Only a company owner or admin can add or remove custom domains, because each one is billed to the company. Ask an admin to do it.",
+    PAID_PLAN_REQUIRED: "Custom domains are a usage add-on and need a card on file for the company.",
+    PAYMENT_METHOD_REQUIRED: "Custom domains need a card on file for the company. Add a card on the company billing page, then run the add again.",
+    BILLING_UNAVAILABLE: "Domain billing is temporarily unavailable. Try again in a minute.",
+    DOMAIN_ALREADY_CLAIMED: "That domain is already linked to another app.",
+    DOMAIN_CROSS_TENANT: "That domain belongs to another company.",
+    DOMAIN_INVALID: "That is not a valid domain name.",
+    VALIDATION_ERROR: "That is not a valid domain name.",
+    DOMAIN_RESERVED: "That domain is reserved by HQ and cannot be added.",
+    DOMAIN_NOT_FOUND: "That domain is not linked to this app. Run 'hq deploy domains list' to see its domains.",
+    DOMAIN_TARGET_AMBIGUOUS: "That domain points at more than one environment. Pass --env <name>.",
+    ENVIRONMENT_NOT_SERVED: "Only the production environment can have a custom domain.",
+    DOMAIN_PROVISIONING_FAILED: "HQ could not finish setting up the domain. Run 'hq deploy domains refresh <domain>' to try again.",
+};
+const SERVER_WORDED_CODES = new Set(["PAID_PLAN_REQUIRED", "PAYMENT_METHOD_REQUIRED", "BILLING_UNAVAILABLE"]);
+/** Buy codes the server returns before any hold or order, so `buy` says nothing was charged. */
+const NOT_CHARGED_CODES = new Set(["REGISTRAR_UNAVAILABLE"]);
+/**
+ * Buy codes with a settled outcome: the order was refused, failed without a
+ * charge, or belongs to another order. Any other answer (a network error, a
+ * 5xx, BILLING_UNAVAILABLE, PURCHASE_PENDING, an unknown code) may have left
+ * this order held or registered, so `buy` prints the order's key and says to
+ * re-run with it instead of starting a new order (hq-cli#2160 review).
+ */
+const SETTLED_PURCHASE_CODES = new Set([
+    "DOMAIN_PURCHASE_NOT_ENABLED",
+    "REGISTRAR_UNAVAILABLE",
+    "BILLING_ADMIN_REQUIRED",
+    "FORBIDDEN",
+    "AUTH_REQUIRED",
+    "COMPANY_NOT_FOUND",
+    "PAYMENT_METHOD_REQUIRED",
+    "BILLING_PAST_DUE",
+    "PAYMENT_FAILED",
+    "PRICE_CHANGED",
+    "DOMAIN_NOT_AVAILABLE",
+    "DOMAIN_ALREADY_PURCHASED",
+    "PURCHASE_IN_PROGRESS",
+    "PURCHASE_ALREADY_FAILED",
+    "REGISTRATION_FAILED",
+    "IDEMPOTENCY_KEY_REUSED",
+    "INVALID_DOMAIN",
+    "INVALID_EXPECTED_PRICE",
+    "INVALID_IDEMPOTENCY_KEY",
+    "INVALID_REGISTRANT",
+]);
+/** The sentence `buy` adds when the order's outcome is not known. */
+export function resumeOrderSentence(idempotencyKey) {
+    return `The order may still be in progress. Run the same command again with --idempotency-key ${idempotencyKey} to finish or check it. Do not start a new order.`;
+}
+/** The registrant fields hq-pro accepts; nothing else from the file is sent. */
+const REGISTRANT_FIELDS = [
+    "firstName", "lastName", "companyName", "address1", "address2",
+    "city", "state", "zip", "country", "email", "phone",
+];
+/** Plain wording for hq-pro domain purchase error codes. */
+const PURCHASE_MESSAGES = {
+    DOMAIN_PURCHASE_NOT_ENABLED: "Buying domains is not enabled for this company yet.",
+    REGISTRAR_UNAVAILABLE: "Buying domains is not available right now. Try again later.",
+    BILLING_ADMIN_REQUIRED: "Only a company owner or admin can buy a domain.",
+    FORBIDDEN: "You are not a member of that company.",
+    AUTH_REQUIRED: "HQ rejected your sign-in. Run 'hq login' and retry.",
+    COMPANY_NOT_FOUND: "That company was not found.",
+    BILLING_UNAVAILABLE: "Billing is temporarily unavailable. Try again in a minute.",
+    PAYMENT_METHOD_REQUIRED: "Buying a domain needs a card on file for the company. Add a card, then run buy again.",
+    BILLING_PAST_DUE: "The company's billing is past due. Update billing, then run buy again.",
+    PAYMENT_FAILED: "The card was declined. Update the card, then run buy again.",
+    DOMAIN_NOT_AVAILABLE: "That domain is not available to buy.",
+    DOMAIN_ALREADY_PURCHASED: "Your company already bought that domain.",
+    PURCHASE_IN_PROGRESS: "An order for that domain is already in progress. Wait a minute, then check again.",
+    PURCHASE_ALREADY_FAILED: "This order already failed and was not charged. Run buy again without --idempotency-key to start a new order.",
+    REGISTRATION_FAILED: "The registrar refused the registration. The card was not charged.",
+    IDEMPOTENCY_KEY_REUSED: "That --idempotency-key belongs to another order (a different domain or price). Run buy again without it.",
+    INVALID_DOMAIN: "Name one domain to buy, for example example.com.",
+    INVALID_DOMAIN_QUERY: "That search is not valid. Use a name like example or example.com.",
+    INVALID_EXPECTED_PRICE: "--price must be the first-year price shown by 'hq deploy domains search'.",
+    INVALID_IDEMPOTENCY_KEY: "--idempotency-key must be 16 to 64 letters, digits, '-' or '_'.",
+    INVALID_REGISTRANT: "The registrant details are missing or invalid. The file needs firstName, lastName, address1, city, state, zip, a 2-letter country, email, and phone in +15551234567 form.",
+};
+function apiCode(body, status) {
+    const nested = body.error && typeof body.error === "object" ? body.error.code : undefined;
+    const raw = typeof body.code === "string" ? body.code : nested;
+    return typeof raw === "string" && /^[A-Z0-9_]+$/.test(raw) ? raw : `HTTP_${status}`;
+}
+function apiField(body, key) {
+    if (key in body)
+        return body[key];
+    const nested = body.error && typeof body.error === "object" ? body.error : undefined;
+    return nested?.[key];
+}
+function httpsUrl(value) {
+    if (typeof value !== "string")
+        return undefined;
+    try {
+        return new URL(value).protocol === "https:" ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readBody(response) {
+    const body = await response.json().catch(() => null);
+    return body && typeof body === "object" && !Array.isArray(body) ? body : {};
+}
+async function deployError(response, orgSlug) {
+    const body = await readBody(response);
+    const code = apiCode(body, response.status);
+    const billingUrl = httpsUrl(apiField(body, "billingUrl"));
+    const serverMessage = apiField(body, "message");
+    let message;
+    if (SERVER_WORDED_CODES.has(code) && typeof serverMessage === "string" && serverMessage.trim()) {
+        message = displayText(serverMessage);
+    }
+    else if (DEPLOY_MESSAGES[code]) {
+        message = DEPLOY_MESSAGES[code];
+    }
+    else if (response.status === 401) {
+        message = "hq-deploy rejected your sign-in. Run 'hq login' and retry.";
+    }
+    else if (response.status === 403) {
+        message = `You need to be the app owner or a company admin in '${orgSlug}' to manage its domains.`;
+    }
+    else if (response.status === 404) {
+        message = `App not found in '${orgSlug}'.`;
+    }
+    else {
+        message = `The domain request failed (HTTP ${response.status}).`;
+    }
+    if (code === "PAYMENT_METHOD_REQUIRED" && billingUrl && !message.includes(billingUrl)) {
+        message = `${message} Add a card here: ${billingUrl}`;
+    }
+    return new DeployDomainsError(message, code, response.status, billingUrl ? { billingUrl } : {});
+}
+async function purchaseError(response, idempotencyKey) {
+    const body = await readBody(response);
+    const code = apiCode(body, response.status);
+    const billingUrl = httpsUrl(apiField(body, "billingUrl"));
+    const extra = {};
+    if (billingUrl)
+        extra.billingUrl = billingUrl;
+    let message = PURCHASE_MESSAGES[code] ?? `The domain purchase request failed (HTTP ${response.status}).`;
+    if (code === "PRICE_CHANGED") {
+        const price = apiField(body, "priceUsd");
+        if (typeof price === "number")
+            extra.priceUsd = price;
+        message = typeof price === "number"
+            ? `The price changed to ${usd(price)} for the first year. Nothing was charged. Check it with 'hq deploy domains search', then run buy with --price ${price}.`
+            : "The price changed. Nothing was charged. Run 'hq deploy domains search' and buy at the new price.";
+    }
+    if (idempotencyKey) {
+        extra.idempotencyKey = idempotencyKey;
+        if (NOT_CHARGED_CODES.has(code))
+            message = `${message} Nothing was charged.`;
+        if (code === "PURCHASE_PENDING") {
+            message = `The registrar has not confirmed the registration yet. The card is held, not charged. Run the same command again with --idempotency-key ${idempotencyKey} to finish this order.`;
+        }
+        else if (!SETTLED_PURCHASE_CODES.has(code)) {
+            message = `${message} ${resumeOrderSentence(idempotencyKey)}`;
+        }
+    }
+    if (billingUrl)
+        message = `${message} Billing: ${billingUrl}`;
+    return new DeployDomainsError(message, code, response.status, extra);
+}
+function usd(value) {
+    return Number.isInteger(value) ? `$${value}` : `$${value.toFixed(2)}`;
+}
+// ---------------------------------------------------------------------------
+// Target resolution
+function resolveSlug(companyFlag, bindingSlug) {
+    const slug = companyFlag ?? bindingSlug ?? readActiveCompanySlug(DEFAULT_HQ_ROOT);
+    if (slug === undefined)
+        throw new DeployDomainsError("No active company. Pass --company <slug>.", "NO_COMPANY");
+    if (!SLUG_PATTERN.test(slug))
+        throw new DeployDomainsError("The company slug is not valid.", "INVALID_COMPANY");
+    return slug;
+}
+/** Read the app id from the folder's project link (.hq/project.json, or the older hq-deploy.json). */
+export function readLinkedApp(dir) {
+    for (const name of BINDING_FILES) {
+        const file = path.join(dir, name);
+        if (!fs.existsSync(file))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            throw new DeployDomainsError(`${name} is not valid JSON. Re-link the folder, or pass --app <app>.`, "BINDING_INVALID");
+        }
+        const record = parsed && typeof parsed === "object" ? parsed : {};
+        const appId = typeof record.appId === "string" && APP_ID_PATTERN.test(record.appId) ? record.appId : null;
+        if (!appId) {
+            throw new DeployDomainsError(`${name} has no app id. Re-link the folder, or pass --app <app>.`, "BINDING_INVALID");
+        }
+        const orgSlug = typeof record.orgSlug === "string" && SLUG_PATTERN.test(record.orgSlug) ? record.orgSlug : undefined;
+        return { appId, ...(orgSlug ? { orgSlug } : {}) };
+    }
+    return null;
+}
+async function request(token, orgSlug, route, method, body) {
+    try {
+        return await deployApiRequest(token, route, method, body, { "X-Org-Slug": orgSlug });
+    }
+    catch {
+        throw new DeployDomainsError("Could not reach hq-deploy.", "NETWORK");
+    }
+}
+async function resolveAppId(token, orgSlug, app) {
+    if (APP_ID_PATTERN.test(app))
+        return app;
+    const apps = await listDeployApps(async (cursor) => {
+        const route = cursor ? `/api/apps?cursor=${encodeURIComponent(cursor)}` : "/api/apps";
+        const response = await request(token, orgSlug, route, "GET");
+        if (!response.ok)
+            throw await deployError(response, orgSlug);
+        return readBody(response);
+    });
+    const needle = app.toLowerCase();
+    const ids = [...new Set(apps
+            .filter((item) => typeof item === "object" && item !== null)
+            .filter((item) => [item.id, item.subdomain, item.name].some((field) => typeof field === "string" && field.toLowerCase() === needle))
+            .map((item) => item.id)
+            .filter((id) => typeof id === "string"))];
+    if (ids.length === 0)
+        throw new DeployDomainsError(`No deploy app '${displayText(app)}' in '${orgSlug}'.`, "APP_NOT_FOUND");
+    if (ids.length > 1) {
+        throw new DeployDomainsError(`'${displayText(app)}' matches ${ids.length} apps in '${orgSlug}'. Use the app id.`, "APP_AMBIGUOUS");
+    }
+    return ids[0];
+}
+async function resolveTarget(token, options) {
+    if (options.app) {
+        const orgSlug = resolveSlug(options.company, undefined);
+        return { appId: await resolveAppId(token, orgSlug, options.app), orgSlug, appLabel: options.app };
+    }
+    const binding = readLinkedApp(path.resolve(options.path ?? process.cwd()));
+    if (!binding) {
+        throw new DeployDomainsError("This folder is not linked to a deployment. Pass --app <name or id>, or run the command in the linked app folder.", "APP_NOT_LINKED");
+    }
+    // The link names its own company. Never pair its app with a different
+    // company silently: refuse a mismatch, and a link that names no company.
+    if (!binding.orgSlug && options.company === undefined) {
+        throw new DeployDomainsError("The folder's link does not name a company. Pass --company <slug>, or re-link the folder.", "COMPANY_REQUIRED");
+    }
+    if (binding.orgSlug && options.company !== undefined && options.company !== binding.orgSlug) {
+        throw new DeployDomainsError(`This folder is linked to an app in '${binding.orgSlug}', not '${displayText(options.company)}'. Drop --company, or pass --app <name or id>.`, "COMPANY_MISMATCH");
+    }
+    return {
+        appId: binding.appId,
+        orgSlug: resolveSlug(options.company, binding.orgSlug),
+        appLabel: binding.appId,
+    };
+}
+const HOSTNAME_LABEL = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+/**
+ * Normalize a domain to the ASCII form the server stores, using the same
+ * hostname rule hq-deploy's validateAppHostname enforces: at least two
+ * labels, each letters/digits/hyphens, 1 to 63 characters, no leading or
+ * trailing hyphen. A unicode name is converted to punycode first.
+ *
+ * The rule also keeps a domain from ever being a URL path segment such as
+ * "." or "..": fetch resolves those, so `remove ...` would otherwise send
+ * DELETE /api/apps/<id>/, next to the delete-app route (hq-cli#2160 review).
+ */
+export function normalizeDomain(raw) {
+    const trimmed = raw.trim().toLowerCase().replace(/\.$/, "");
+    const invalid = () => new DeployDomainsError(DEPLOY_MESSAGES.DOMAIN_INVALID, "DOMAIN_INVALID");
+    if (!trimmed || /[\s/\\:?#@%]/.test(trimmed))
+        throw invalid();
+    const domain = domainToASCII(trimmed);
+    if (!domain || domain.length > 253)
+        throw invalid();
+    const labels = domain.split(".");
+    if (labels.length < 2 || labels.some((label) => label.length > 63 || !HOSTNAME_LABEL.test(label))) {
+        throw invalid();
+    }
+    return domain;
+}
+function domainRoute(appId, domain, suffix = "") {
+    const base = `/api/apps/${encodeURIComponent(appId)}/domains`;
+    return domain ? `${base}/${encodeURIComponent(domain)}${suffix}` : base;
+}
+// ---------------------------------------------------------------------------
+// Pricing (GET /v1/pricing, the published source the server charges from)
+async function fetchPricingBody() {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), PRICING_TIMEOUT_MS);
+        timer.unref?.();
+    });
+    const read = (async () => {
+        const res = await vaultApiFetchPublic({ path: "/v1/pricing" });
+        if (!res.ok)
+            return null;
+        const body = await res.json().catch(() => null);
+        return body && typeof body === "object" ? body : null;
+    })().catch(() => null);
+    try {
+        return await Promise.race([read, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function domainsBlock(pricing) {
+    const usage = pricing?.usage;
+    const domains = usage && typeof usage === "object" ? usage.domains : undefined;
+    return domains && typeof domains === "object" ? domains : null;
+}
+/** "This custom domain adds $20/month." from the published add-on price. */
+export function addOnPriceLine(pricing) {
+    const standard = domainsBlock(pricing)?.standardUsd;
+    return typeof standard === "number" && standard > 0
+        ? `This custom domain adds ${usd(standard)}/month to the company bill.`
+        : "This custom domain is billed to the company as a monthly add-on.";
+}
+/** The approval question for `add`, with the published add-on price. */
+export function addOnConfirmQuestion(domain, environment, target, pricing) {
+    const standard = domainsBlock(pricing)?.standardUsd;
+    const company = `'${target.orgSlug}'`;
+    const price = typeof standard === "number" && standard > 0
+        ? `Each custom domain costs ${usd(standard)}/month, billed to ${company}, unless its plan includes custom domains.`
+        : `Each custom domain is a monthly add-on billed to ${company}, unless its plan includes custom domains.`;
+    return `Add ${displayText(domain)} to ${displayText(environment)} of app '${displayText(target.appLabel)}' in ${company}? ${price}`;
+}
+/** Shown in the buy prompt when GET /v1/pricing does not answer. */
+export const PURCHASE_TERMS_UNAVAILABLE = "The renewal and refund terms could not be loaded. Check them on the HQ pricing page before you buy.";
+/** The purchase terms published as usage.domains.purchase. Null when not published. */
+export function purchaseTermsLine(pricing) {
+    const purchase = domainsBlock(pricing)?.purchase;
+    if (!purchase || typeof purchase !== "object")
+        return null;
+    const p = purchase;
+    const markup = typeof p.markupUsdPerYear === "number" ? p.markupUsdPerYear : null;
+    const grace = typeof p.refundGraceDays === "number" ? p.refundGraceDays : null;
+    if (markup === null || grace === null)
+        return null;
+    const renewal = p.renewal === "yearly" ? "yearly" : String(p.renewal ?? "yearly");
+    const before = p.chargedBeforeRenewal === true ? ", charged before each renewal" : "";
+    return `It renews ${renewal} at the registrar's renewal price plus ${usd(markup)}${before}. There are no refunds after a ${grace}-day grace period.`;
+}
+// ---------------------------------------------------------------------------
+// Output
+function printDnsRecords(records) {
+    if (records.length === 0)
+        return;
+    console.log("Create these DNS records at your DNS host:");
+    for (const record of records) {
+        console.log(`  ${displayText(record.type)}  ${displayText(record.name)}  ->  ${displayText(record.value)}`);
+    }
+}
+function dnsRecords(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((item) => typeof item === "object" && item !== null)
+        .filter((item) => typeof item.type === "string" && typeof item.name === "string" && typeof item.value === "string")
+        .map((item) => ({ type: item.type, name: item.name, value: item.value }));
+}
+function emitError(error, json) {
+    if (error instanceof DeployDomainsError) {
+        if (json) {
+            console.log(safeJson({
+                ok: false,
+                code: error.code,
+                message: error.message,
+                ...(error.status === undefined ? {} : { status: error.status }),
+                ...error.extra,
+            }));
+        }
+        else {
+            console.error(error.message);
+        }
+    }
+    else {
+        const detail = error instanceof Error ? `${error.name}: ${displayText(error.message)}` : "unknown error";
+        if (json) {
+            console.log(safeJson({ ok: false, code: "UNEXPECTED", message: `Deploy domains command failed: ${detail}` }));
+        }
+        else {
+            console.error(`Deploy domains command failed: ${detail}`);
+        }
+    }
+    process.exitCode = 1;
+}
+async function run(json, action) {
+    try {
+        await action();
+    }
+    catch (error) {
+        emitError(error, json === true);
+    }
+}
+async function confirm(question, yes, what) {
+    if (yes)
+        return;
+    if (!deployDomainsPrompt.isInteractive()) {
+        throw new DeployDomainsError(`Pass --yes to ${what}. Nothing was changed.`, "CONFIRMATION_REQUIRED");
+    }
+    const answer = (await deployDomainsPrompt.ask(`${question} Type 'yes' to continue: `)).trim().toLowerCase();
+    if (answer !== "yes")
+        throw new DeployDomainsError("Cancelled. Nothing was changed.", "CANCELLED");
+}
+// ---------------------------------------------------------------------------
+// Actions
+async function listAction(options) {
+    const token = await ensureCognitoToken();
+    const target = await resolveTarget(token, options);
+    const response = await request(token, target.orgSlug, domainRoute(target.appId), "GET");
+    if (!response.ok)
+        throw await deployError(response, target.orgSlug);
+    const body = await readBody(response);
+    const domains = Array.isArray(body.domains)
+        ? body.domains.filter((item) => typeof item === "object" && item !== null)
+        : [];
+    if (options.json) {
+        console.log(safeJson({ ok: true, appId: target.appId, domains }));
+        return;
+    }
+    if (domains.length === 0) {
+        console.log("No custom domains on this app.");
+        return;
+    }
+    for (const domain of domains) {
+        console.log([
+            displayText(domain.domain),
+            displayText(domain.environment ?? "production"),
+            displayText(domain.validationState ?? "unknown"),
+        ].join("  |  "));
+    }
+}
+async function addAction(domainArg, options) {
+    const domain = normalizeDomain(domainArg);
+    const token = await ensureCognitoToken();
+    const target = await resolveTarget(token, options);
+    const environment = options.env ?? "production";
+    // The add can start a monthly charge, so the price is shown and approved first.
+    const pricing = await fetchPricingBody();
+    await confirm(addOnConfirmQuestion(domain, environment, target, pricing), options.yes, "add the domain");
+    const response = await request(token, target.orgSlug, domainRoute(target.appId), "POST", { domain, environment });
+    if (!response.ok)
+        throw await deployError(response, target.orgSlug);
+    const body = await readBody(response);
+    const records = dnsRecords(body.dnsInstructions);
+    const apex = body.apex === true;
+    const apexGuidance = typeof body.apexGuidance === "string" ? body.apexGuidance : undefined;
+    const paid = body.billingBasis === "paid";
+    const priceLine = paid ? addOnPriceLine(pricing) : undefined;
+    if (options.json) {
+        console.log(safeJson({
+            ok: true,
+            appId: target.appId,
+            domain,
+            environment,
+            validationState: body.domain?.validationState ?? "pending",
+            serving: body.serving === true,
+            dnsInstructions: records,
+            apex,
+            ...(apexGuidance ? { apexGuidance } : {}),
+            ...(typeof body.billingBasis === "string" ? { billingBasis: body.billingBasis } : {}),
+            ...(priceLine ? { billingMessage: priceLine } : {}),
+        }));
+        return;
+    }
+    console.log(`Added ${displayText(domain)} to ${displayText(environment)}. It is not live yet.`);
+    if (priceLine)
+        console.log(priceLine);
+    printDnsRecords(records);
+    if (apex) {
+        console.log(apexGuidance
+            ? displayText(apexGuidance)
+            : "This is a bare domain, so most DNS hosts cannot take a CNAME for it. Use an ALIAS or ANAME record, or CNAME flattening, for the traffic record.");
+    }
+    console.log(`When the records are in place, run: hq deploy domains refresh ${displayText(domain)}`);
+}
+async function refreshAction(domainArg, options) {
+    const domain = normalizeDomain(domainArg);
+    const token = await ensureCognitoToken();
+    const target = await resolveTarget(token, options);
+    const response = await request(token, target.orgSlug, domainRoute(target.appId, domain, "/refresh"), "POST");
+    if (!response.ok)
+        throw await deployError(response, target.orgSlug);
+    const body = await readBody(response);
+    const serving = body.serving === true;
+    const records = dnsRecords(body.dnsInstructions);
+    if (!serving)
+        process.exitCode = REFRESH_NOT_SERVING_EXIT_CODE;
+    if (options.json) {
+        console.log(safeJson({ ok: true, appId: target.appId, ...body, domain, serving, dnsInstructions: records }));
+        return;
+    }
+    if (serving) {
+        console.log(`${displayText(domain)} is live.`);
+        return;
+    }
+    const certStatus = typeof body.certStatus === "string" ? ` (certificate ${displayText(body.certStatus)})` : "";
+    console.log(`${displayText(domain)} is waiting for DNS validation${certStatus}.`);
+    printDnsRecords(records);
+    if (body.apex === true && typeof body.apexGuidance === "string")
+        console.log(displayText(body.apexGuidance));
+    console.log(`Run this again once the records are in place: hq deploy domains refresh ${displayText(domain)}`);
+}
+async function removeAction(domainArg, options) {
+    const domain = normalizeDomain(domainArg);
+    const token = await ensureCognitoToken();
+    const target = await resolveTarget(token, options);
+    await confirm(`Remove ${displayText(domain)} from app '${displayText(target.appLabel)}' in '${target.orgSlug}'? It stops serving, and if it is billed, its monthly charge stops.`, options.yes, "remove the domain");
+    const query = options.env ? `?env=${encodeURIComponent(options.env)}` : "";
+    const response = await request(token, target.orgSlug, domainRoute(target.appId, domain, query), "DELETE");
+    if (!response.ok)
+        throw await deployError(response, target.orgSlug);
+    const body = await readBody(response);
+    const billingRemovalPending = body.billingRemovalPending === true;
+    const warning = typeof body.warning === "string" ? body.warning : undefined;
+    if (options.json) {
+        console.log(safeJson({
+            ok: true,
+            appId: target.appId,
+            domain,
+            billingRemovalPending,
+            ...(typeof body.remaining === "number" ? { remaining: body.remaining } : {}),
+            ...(warning ? { warning } : {}),
+        }));
+        return;
+    }
+    console.log(`Removed ${displayText(domain)}.`);
+    if (billingRemovalPending) {
+        console.log("Its charge could not be stopped right away. HQ keeps retrying until the charge is removed.");
+    }
+    else if (warning) {
+        console.log(displayText(warning));
+    }
+}
+async function purchaseRequest(token, companyUid, suffix, body) {
+    try {
+        return await vaultApiFetch({
+            token,
+            path: `/v1/billing/companies/${encodeURIComponent(companyUid)}/domain-purchase${suffix}`,
+            method: "POST",
+            body,
+        });
+    }
+    catch {
+        throw new DeployDomainsError("Could not reach HQ.", "NETWORK");
+    }
+}
+/** The company that pays: --company, else the active company. */
+function purchaseSlug(companyFlag) {
+    const slug = companyFlag ?? readActiveCompanySlug(DEFAULT_HQ_ROOT);
+    if (slug === undefined)
+        throw new DeployDomainsError("No active company. Pass --company <slug>.", "NO_COMPANY");
+    if (!SLUG_PATTERN.test(slug))
+        throw new DeployDomainsError("The company slug is not valid.", "INVALID_COMPANY");
+    return slug;
+}
+async function purchaseCompanyUid(token, slug) {
+    try {
+        return await getCompanyUid(token, slug);
+    }
+    catch (error) {
+        const cause = error instanceof Error ? displayText(error.message) : "";
+        if (/was not found/i.test(cause)) {
+            throw new DeployDomainsError(`Could not find the company '${displayText(slug)}'.`, "COMPANY_NOT_FOUND");
+        }
+        throw new DeployDomainsError(`Could not look up the company '${displayText(slug)}'${cause ? `: ${cause}` : "."}`, "COMPANY_LOOKUP_FAILED");
+    }
+}
+async function searchAction(query, options) {
+    const token = await ensureCognitoToken();
+    const companyUid = await purchaseCompanyUid(token, purchaseSlug(options.company));
+    const response = await purchaseRequest(token, companyUid, "/search", { query });
+    if (!response.ok)
+        throw await purchaseError(response);
+    const body = await readBody(response);
+    const results = Array.isArray(body.results)
+        ? body.results.filter((item) => typeof item === "object" && item !== null)
+        : [];
+    if (options.json) {
+        console.log(safeJson({ ok: true, results }));
+        return;
+    }
+    if (results.length === 0) {
+        console.log("No domains found.");
+        return;
+    }
+    for (const result of results) {
+        if (result.available !== true || typeof result.priceUsd !== "number") {
+            console.log(`${displayText(result.domain)}  |  not available`);
+            continue;
+        }
+        const renewal = typeof result.renewalPriceUsd === "number" ? `, renews at ${usd(result.renewalPriceUsd)}/year` : "";
+        console.log(`${displayText(result.domain)}  |  ${usd(result.priceUsd)} for the first year${renewal}`);
+    }
+    console.log("To buy one: hq deploy domains buy <domain> --price <first-year price> --registrant-file <contact.json>");
+}
+function readRegistrant(file) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(path.resolve(file), "utf8"));
+    }
+    catch {
+        throw new DeployDomainsError("Could not read the registrant file as JSON.", "INVALID_REGISTRANT");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new DeployDomainsError(PURCHASE_MESSAGES.INVALID_REGISTRANT, "INVALID_REGISTRANT");
+    }
+    const source = parsed;
+    const registrant = {};
+    for (const field of REGISTRANT_FIELDS) {
+        if (source[field] !== undefined)
+            registrant[field] = source[field];
+    }
+    return registrant;
+}
+export function parsePrice(raw) {
+    const trimmed = raw.trim().replace(/^\$/, "");
+    const value = /^\d+(\.\d{1,2})?$/.test(trimmed) ? Number(trimmed) : Number.NaN;
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new DeployDomainsError(PURCHASE_MESSAGES.INVALID_EXPECTED_PRICE, "INVALID_EXPECTED_PRICE");
+    }
+    return value;
+}
+async function buyAction(domainArg, options) {
+    const domain = normalizeDomain(domainArg);
+    const expectedPriceUsd = parsePrice(options.price);
+    if (options.idempotencyKey !== undefined && !IDEMPOTENCY_KEY_PATTERN.test(options.idempotencyKey)) {
+        throw new DeployDomainsError(PURCHASE_MESSAGES.INVALID_IDEMPOTENCY_KEY, "INVALID_IDEMPOTENCY_KEY");
+    }
+    const registrant = readRegistrant(options.registrantFile);
+    const idempotencyKey = options.idempotencyKey ?? `cli_${randomUUID().replace(/-/g, "")}`;
+    // Resolve the paying company before the prompt so the approval names it.
+    const slug = purchaseSlug(options.company);
+    const token = await ensureCognitoToken();
+    const companyUid = await purchaseCompanyUid(token, slug);
+    const terms = purchaseTermsLine(await fetchPricingBody());
+    await confirm(`Buy ${displayText(domain)} for ${usd(expectedPriceUsd)} for the first year, charged to the card on file for '${slug}'? ${terms ?? PURCHASE_TERMS_UNAVAILABLE}`, options.yes, "buy the domain");
+    let response;
+    try {
+        response = await purchaseRequest(token, companyUid, "", { domain, expectedPriceUsd, idempotencyKey, registrant });
+    }
+    catch (error) {
+        // The request may have reached hq-pro, so the order's key is the only safe retry.
+        const reason = error instanceof DeployDomainsError ? error.message : "Could not reach HQ.";
+        throw new DeployDomainsError(`${reason} ${resumeOrderSentence(idempotencyKey)}`, "NETWORK", undefined, { idempotencyKey });
+    }
+    if (!response.ok)
+        throw await purchaseError(response, idempotencyKey);
+    const body = await readBody(response);
+    if (options.json) {
+        console.log(safeJson({ ok: true, idempotencyKey, ...body }));
+        return;
+    }
+    const expires = typeof body.expiresAt === "string" ? ` It is registered until ${displayText(body.expiresAt)}.` : "";
+    if (body.replayed === true) {
+        console.log(`${displayText(domain)} was already bought by this order.${expires}`);
+    }
+    else if (body.paymentCaptured === false) {
+        // hq-pro registered the name, but capturing the card authorization failed.
+        console.log(`Registered ${displayText(domain)}.${expires} The card was authorized for ${usd(expectedPriceUsd)}, ` +
+            `but the charge has not completed yet. HQ billing follows up on it. Do not buy the domain again.`);
+    }
+    else {
+        console.log(`Bought ${displayText(domain)} for ${usd(expectedPriceUsd)}.${expires}`);
+    }
+    if (terms)
+        console.log(terms);
+    console.log(`To serve an app on it: hq deploy domains add ${displayText(domain)} --app <app>`);
+}
+// ---------------------------------------------------------------------------
+// Registration
+function targetOptions(command) {
+    return command
+        .option("--app <app>", "app id, subdomain or name (default: the app linked to this folder)")
+        .option("--path <dir>", "folder linked to the app (default: current folder)")
+        .option("--company <slug>", "use this company instead of the linked or active company")
+        .option("--json", "print machine-readable JSON");
+}
+export function registerDeployDomainsCommand(deploy) {
+    const domains = deploy
+        .command("domains")
+        .description("Manage custom domains on your deployed apps, and buy domains")
+        .addHelpText("after", "\nadd, remove and buy ask for approval in an interactive terminal. Without one (a script, CI, " +
+        "or a Windows shell that does not report a terminal, such as Git Bash under mintty), pass --yes.");
+    targetOptions(domains.command("list").description("List the custom domains on an app"))
+        .action((options) => run(options.json, () => listAction(options)));
+    targetOptions(domains
+        .command("add <domain>")
+        .description("Link a custom domain to an app and print the DNS records to create")
+        .option("--env <name>", "environment to serve", "production")
+        .option("--yes", "add without a prompt (the domain can add a monthly charge)")).action((domain, options) => run(options.json, () => addAction(domain, options)));
+    targetOptions(domains
+        .command("refresh <domain>")
+        .description(`Check DNS validation and start serving once the certificate is issued (exits ${REFRESH_NOT_SERVING_EXIT_CODE} while not live)`)).action((domain, options) => run(options.json, () => refreshAction(domain, options)));
+    targetOptions(domains
+        .command("remove <domain>")
+        .description("Unlink a custom domain from an app")
+        .option("--env <name>", "pick the environment when the domain points at more than one")
+        .option("--yes", "remove without a prompt")).action((domain, options) => run(options.json, () => removeAction(domain, options)));
+    domains
+        .command("search <query>")
+        .description("Check whether a domain can be bought, and its price")
+        .option("--company <slug>", "use this company instead of the active company")
+        .option("--json", "print machine-readable JSON")
+        .action((query, options) => run(options.json, () => searchAction(query, options)));
+    domains
+        .command("buy <domain>")
+        .description("Buy a domain for the company (owner or admin)")
+        .requiredOption("--price <usd>", "first-year price shown by 'hq deploy domains search'")
+        .requiredOption("--registrant-file <path>", "JSON file with the registrant contact")
+        .option("--idempotency-key <key>", "retry an earlier order that did not finish")
+        .option("--company <slug>", "use this company instead of the active company")
+        .option("--yes", "buy without a prompt")
+        .option("--json", "print machine-readable JSON")
+        .action((domain, options) => run(options.json, () => buyAction(domain, options)));
+}
+//# sourceMappingURL=deploy-domains.js.map