@indigoai-us/hq-cli 5.345.162 → 5.345.164

package/dist/commands/billing.d.ts

@@ -25,6 +25,17 @@
  * pricing: the flat-plan checkout is closed, so the CLI never opens it.
  */
 import { Command } from "commander";
+/** Shape of `GET /v1/billing/summary` we render. */
+interface BillingSummary {
+    subscriptionStatus: string | null;
+    defaultPaymentMethod: {
+        present: boolean;
+        brand: string | null;
+        last4: string | null;
+    };
+    databases?: DatabaseBilling | null;
+    [key: string]: unknown;
+}
 interface DatabaseBilling {
     period: string;
     activeApps: number;
@@ -37,6 +48,29 @@ interface DatabaseBilling {
     }>;
 }
 export declare function formatDatabaseBilling(db: DatabaseBilling | null | undefined): string[];
+/**
+ * The plan a person can act on, in words. The summary's `billingStatus.plan`
+ * is the Stripe webhook's label and says "usage" for ANY non-Workforce
+ * subscription (a metered usage subscription on a company that still prices
+ * as a flat plan reads "usage" there, hq-pro summary.ts). The plan the server
+ * actually prices by is `billingState.kind` (hq-pro #5088) or, on an older
+ * server, `pricingPlan`; `billingStatus.plan` only separates Workforce from
+ * the rest. DEV-5179: a reporter read "usage" off the status JSON while
+ * `hq billing usage` said "flat plan"; both were right about different fields.
+ */
+export declare function describePlan(summary: BillingSummary): string;
+export declare const PLAN_UNAVAILABLE = "unavailable right now";
+/**
+ * A scheduled switch to usage pricing (hq-pro US-014 `GET
+ * /v1/billing/usage-switch`), or null. The route is owner-only and absent on
+ * older servers. A refusal (403, 404) reads as "nothing scheduled"; any other
+ * failure is "unreadable" so the status view can say so instead of implying
+ * no switch. The status view never fails on it.
+ */
+export declare function fetchScheduledUsageSwitch(token: string, companyUid: string): Promise<{
+    switchDate: string;
+    phase: "scheduled" | "preview";
+} | "unreadable" | null>;
 export declare function registerBillingCommand(program: Command): void;
 export {};
 //# sourceMappingURL=billing.d.ts.map

package/dist/commands/billing.js

@@ -30,8 +30,9 @@ import { vaultApiFetch, getCompanyUid } from "../utils/vault-api.js";
 import { mintPaymentLink } from "../utils/billing-gate.js";
 import { openUsageSwitch } from "../utils/team-upgrade.js";
 import { registerBillingSponsorCommands } from "./billing-sponsor.js";
-import { fetchCompanyPricingPlan, isUsageOnly, usageOnlyUpgradeLines, } from "../lib/billing/usage-only.js";
+import { fetchCompanyPricingPlan, isUsageOnly, pricingPlanFromBody, readBillingState, usageOnlyUpgradeLines, } from "../lib/billing/usage-only.js";
 import { fetchUsageCard } from "../lib/billing/usage-card.js";
+import { accountStatusLines } from "../lib/billing/billing-status-lines.js";
 import { registerBillingUsageCommand } from "./billing-usage.js";
 const CHARGED_ON = {
     team: "the Team subscription",
@@ -62,6 +63,94 @@ export function formatDatabaseBilling(db) {
     }
     return lines;
 }
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+/**
+ * The plan a person can act on, in words. The summary's `billingStatus.plan`
+ * is the Stripe webhook's label and says "usage" for ANY non-Workforce
+ * subscription (a metered usage subscription on a company that still prices
+ * as a flat plan reads "usage" there, hq-pro summary.ts). The plan the server
+ * actually prices by is `billingState.kind` (hq-pro #5088) or, on an older
+ * server, `pricingPlan`; `billingStatus.plan` only separates Workforce from
+ * the rest. DEV-5179: a reporter read "usage" off the status JSON while
+ * `hq billing usage` said "flat plan"; both were right about different fields.
+ */
+export function describePlan(summary) {
+    const state = readBillingState(summary);
+    if (state) {
+        switch (state.kind) {
+            case "usage":
+                return "usage pricing";
+            case "usage-trial":
+                return state.trial
+                    ? `usage pricing (trial, ${state.trial.daysLeft} days left)`
+                    : "usage pricing (trial)";
+            case "legacy-payer":
+                // legacy-payer also covers invoice-billed companies, which have no
+                // Workforce subscription behind them.
+                return asRecord(summary.billingStatus)?.plan === "team"
+                    ? "Workforce (flat plan)"
+                    : "flat plan (billed by invoice)";
+            case "legacy-free":
+                return "Starter (free)";
+            case "enterprise":
+                return "Enterprise";
+            case "comped":
+                return "comped (not billed)";
+        }
+    }
+    if (pricingPlanFromBody(summary) === "usage-only")
+        return "usage pricing";
+    if (pricingPlanFromBody(summary) === "current") {
+        // An older server says "flat plan" but not which one: only a Workforce
+        // subscription is visible here, so anything else is named no further.
+        return asRecord(summary.billingStatus)?.plan === "team" ? "Workforce (flat plan)" : "flat plan";
+    }
+    // The server did not say which plan prices this company. Naming one here
+    // would guess, and a guess of "Starter (free)" told a paying company it was
+    // on the free plan.
+    return PLAN_UNAVAILABLE;
+}
+export const PLAN_UNAVAILABLE = "unavailable right now";
+/** True when the plan description already says the company prices by usage. */
+function isUsagePricingLabel(label) {
+    return label.startsWith("usage pricing");
+}
+/**
+ * A scheduled switch to usage pricing (hq-pro US-014 `GET
+ * /v1/billing/usage-switch`), or null. The route is owner-only and absent on
+ * older servers. A refusal (403, 404) reads as "nothing scheduled"; any other
+ * failure is "unreadable" so the status view can say so instead of implying
+ * no switch. The status view never fails on it.
+ */
+export async function fetchScheduledUsageSwitch(token, companyUid) {
+    try {
+        const res = await vaultApiFetch({
+            token,
+            path: "/v1/billing/usage-switch",
+            query: { companyUid },
+        });
+        if (res.status === 403 || res.status === 404)
+            return null;
+        if (!res.ok)
+            return "unreadable";
+        const body = asRecord(await res.json());
+        const phase = body?.phase;
+        const switchDate = body?.switchDate;
+        if ((phase === "scheduled" || phase === "preview") &&
+            typeof switchDate === "string" &&
+            Number.isFinite(Date.parse(switchDate))) {
+            return { switchDate, phase };
+        }
+        return null;
+    }
+    catch {
+        return "unreadable";
+    }
+}
 function fail(err) {
     console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
     process.exit(1);
@@ -101,6 +190,18 @@ export function registerBillingCommand(program) {
             }
             const sub = summary.subscriptionStatus ?? "none";
             console.log(`${chalk.bold("Subscription")}: ${sub}`);
+            const planLabel = describePlan(summary);
+            console.log(`${chalk.bold("Plan")}: ${planLabel}`);
+            if (!isUsagePricingLabel(planLabel) && planLabel !== PLAN_UNAVAILABLE) {
+                const scheduled = await fetchScheduledUsageSwitch(token, companyUid);
+                if (scheduled === "unreadable") {
+                    console.log("  Switch to usage pricing: could not be read right now.");
+                }
+                else if (scheduled) {
+                    console.log(`  Switch to usage pricing scheduled for ${scheduled.switchDate.slice(0, 10)}` +
+                        (scheduled.phase === "preview" ? " (preview window open)." : "."));
+                }
+            }
             const pm = summary.defaultPaymentMethod;
             if (pm?.present) {
                 const detail = pm.brand && pm.last4 ? `${pm.brand} ••••${pm.last4}` : "on file";
@@ -110,6 +211,12 @@ export function registerBillingCommand(program) {
                 console.log(`${chalk.bold("Card")}: ${chalk.yellow("no card on file")} — ` +
                     `run \`hq billing checkout\` to add one before provisioning paid resources.`);
             }
+            const state = readBillingState(summary);
+            if (state && (state.kind === "usage" || state.kind === "usage-trial")) {
+                const { card } = await fetchUsageCard();
+                for (const line of accountStatusLines(state, card))
+                    console.log(line);
+            }
             for (const line of formatDatabaseBilling(summary.databases))
                 console.log(line);
         }

package/dist/commands/deploy-domains.d.ts

@@ -0,0 +1,53 @@
+import { Command } from "commander";
+/** Exit code for `refresh` when the domain is not serving yet, so scripts can poll. */
+export declare const REFRESH_NOT_SERVING_EXIT_CODE = 2;
+export declare class DeployDomainsError extends Error {
+    readonly code: string;
+    readonly status?: number | undefined;
+    readonly extra: Record<string, unknown>;
+    constructor(message: string, code: string, status?: number | undefined, extra?: Record<string, unknown>);
+}
+/**
+ * Terminal hooks for the confirmation prompt. Tests replace these; production
+ * reads the real TTY state and asks on stdin.
+ */
+export declare const deployDomainsPrompt: {
+    isInteractive: () => boolean;
+    ask: (question: string) => Promise<string>;
+};
+/** The sentence `buy` adds when the order's outcome is not known. */
+export declare function resumeOrderSentence(idempotencyKey: string): string;
+/** Shown when hq-pro registered the domain but could not capture the card charge. */
+export declare function retryChargeSentence(idempotencyKey: string): string;
+interface Binding {
+    appId: string;
+    orgSlug?: string;
+}
+/** Read the app id from the folder's project link (.hq/project.json, or the older hq-deploy.json). */
+export declare function readLinkedApp(dir: string): Binding | null;
+/**
+ * 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 declare function normalizeDomain(raw: string): string;
+/** "This custom domain adds $20/month." from the published add-on price. */
+export declare function addOnPriceLine(pricing: Record<string, unknown> | null): string;
+/** The approval question for `add`, with the published add-on price. */
+export declare function addOnConfirmQuestion(domain: string, environment: string, target: {
+    appLabel: string;
+    orgSlug: string;
+}, pricing: Record<string, unknown> | null): string;
+/** Shown in the buy prompt when GET /v1/pricing does not answer. */
+export declare 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 declare function purchaseTermsLine(pricing: Record<string, unknown> | null): string | null;
+export declare function parsePrice(raw: string): number;
+export declare function registerDeployDomainsCommand(deploy: Command): void;
+export {};
+//# sourceMappingURL=deploy-domains.d.ts.map