@indigoai-us/hq-cli 5.162.0 → 5.163.0

package/dist/utils/plan-gate-error.d.ts

@@ -1,30 +1,44 @@
-export type PlanGateCode = "PLAN_LIMIT_EXCEEDED" | "PLAN_REQUIRED"
-/**
- * US-054: a PERSONAL scope asked for a feature the paid Individual plan
- * includes and the free tier does not. A different plan, a different price
- * and a different remedy from the company codes above, so it is its own
- * code rather than a reuse of `PLAN_REQUIRED` with company copy.
- */
- | "PERSONAL_PLAN_REQUIRED";
+export type PlanGateCode = "PLAN_LIMIT_EXCEEDED" | "PLAN_REQUIRED" | "MEETING_PLAN_REQUIRED"
+/** A PERSONAL scope asked for a feature the paid Individual plan includes. */
+ | "PERSONAL_PLAN_REQUIRED"
+/** External agent enrollment was denied by the company plan. */
+ | "BILLING_REQUIRED";
 export interface PlanGateDetails {
     resource?: string;
-    /** The refused feature, on a `PERSONAL_PLAN_REQUIRED` denial. */
     feature?: string;
     used?: number;
     limit?: number;
     upgradeUrl?: string;
-    /** Best-effort target captured by the shared HTTP client for interactive checkout. */
+    reason?: string;
+    /** Company target from request context or the server's UID-keyed billing URL. */
     companyUid?: string;
 }
+/** One renderer for server-selected upgrade links across CLI plan refusals. */
+export declare function formatUpgradeRefusal(reason: string, upgradeUrl: string | undefined, options?: {
+    urlOnly?: boolean;
+}): string;
+/** Recover a company UID only from the server's UID-keyed billing callback. */
+export declare function companyUidFromPlanUpgradeUrl(value: unknown): string | undefined;
 export declare class PlanGateError extends Error {
     readonly code: PlanGateCode;
     readonly details: PlanGateDetails;
     constructor(code: PlanGateCode, details: PlanGateDetails);
 }
 export declare function isPlanGateError(err: unknown): err is PlanGateError;
-export declare function formatPlanGateError(err: PlanGateError): string;
+/** Plain, stable CLI copy for plan-gated resource creation. */
+export declare function formatPlanGateError(err: PlanGateError, options?: {
+    urlOnly?: boolean;
+}): string;
 export declare function canOfferTeamUpgrade(argv?: readonly string[]): boolean;
-/** Ask once, only on a real interactive terminal. */
+export interface UpgradeLinkOfferDependencies {
+    ask?: (question: string) => Promise<string>;
+    openUrl?: (url: string) => Promise<void>;
+    argv?: readonly string[];
+    interactive?: boolean;
+}
+/** Ask before opening the exact URL returned by the server. */
+export declare function offerUpgradeLink(url: string, deps?: UpgradeLinkOfferDependencies): Promise<boolean>;
+/** Legacy checkout callback retained for callers outside the shared refusal paths. */
 export declare function offerTeamUpgrade(onConfirm: () => Promise<void>, deps?: {
     ask?: (question: string) => Promise<string>;
     argv?: readonly string[];
@@ -33,7 +47,7 @@ export declare function offerTeamUpgrade(onConfirm: () => Promise<void>, deps?:
 /** Decode an already-read JSON envelope from either shared HTTP client. */
 export declare function planGateErrorFromPayload(status: number, body: unknown, companyUid?: string): PlanGateError | null;
 /**
- * Decode only the two deliberate plan-gate envelopes. Malformed, unrelated,
+ * Decode the supported plan-gate envelopes. Malformed, unrelated,
  * or non-402 responses retain their existing command-specific handling.
  */
 export declare function planGateErrorFromResponse(response: Response, companyUid?: string): Promise<{

package/dist/utils/plan-gate-error.js

@@ -4,19 +4,74 @@
  * message instead of every command parsing and printing a server response.
  */
 import { renderPersonalPlanFeatureNotice } from "../lib/plan-limit-nag.js";
-const TEAM_UPGRADE_HINT = "Run `hq billing upgrade` to move to HQ Workforce.";
+function planGateReason(code, details) {
+    if (details.reason?.trim())
+        return details.reason.trim();
+    if (code === "PLAN_LIMIT_EXCEEDED" &&
+        typeof details.resource === "string" &&
+        typeof details.used === "number" &&
+        typeof details.limit === "number") {
+        return `Starter plan limit reached: ${details.resource} ${details.used}/${details.limit} used.`;
+    }
+    if (code === "PERSONAL_PLAN_REQUIRED") {
+        return renderPersonalPlanFeatureNotice(details.feature ?? "this feature", null);
+    }
+    if (code === "MEETING_PLAN_REQUIRED") {
+        return "HQ Workforce plan required to invite a meeting bot.";
+    }
+    if (code === "BILLING_REQUIRED") {
+        return "Upgrade the company plan before enrolling an external agent.";
+    }
+    return "HQ Workforce plan required for this feature.";
+}
+/** One renderer for server-selected upgrade links across CLI plan refusals. */
+export function formatUpgradeRefusal(reason, upgradeUrl, options = {}) {
+    const safeUrl = safeUpgradeUrl(upgradeUrl);
+    if (options.urlOnly && safeUrl)
+        return safeUrl;
+    if (!safeUrl)
+        return reason;
+    return `${reason}\nUpgrade: ${safeUrl}`;
+}
+function safeUpgradeUrl(value) {
+    if (typeof value !== "string" ||
+        value.trim() !== value ||
+        !/^https:\/\//i.test(value)) {
+        return undefined;
+    }
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" ||
+            !url.hostname ||
+            url.username ||
+            url.password) {
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return value;
+}
+/** Recover a company UID only from the server's UID-keyed billing callback. */
+export function companyUidFromPlanUpgradeUrl(value) {
+    const safeUrl = safeUpgradeUrl(value);
+    if (!safeUrl)
+        return undefined;
+    const callbackUrl = new URL(safeUrl).searchParams.get("callbackUrl");
+    if (!callbackUrl)
+        return undefined;
+    const match = /^\/api\/companies\/(cmp_[A-Za-z0-9_-]+)\/billing\/upgrade\/?$/.exec(callbackUrl);
+    return match?.[1];
+}
+function formatPlanGateErrorText(code, details) {
+    return formatUpgradeRefusal(planGateReason(code, details), details.upgradeUrl);
+}
 export class PlanGateError extends Error {
     code;
     details;
     constructor(code, details) {
-        // Commands with their own expected-error boundary commonly print
-        // `err.message`. Keeping the friendly copy here means those boundaries
-        // retain the same plan-gate voice as main.ts without per-command handling.
-        // The HQ Workforce hint is company advice; a personal denial ends at its
-        // own notice, which already names the Individual plan and its checkout.
-        super(code === "PERSONAL_PLAN_REQUIRED"
-            ? formatPlanGateDetails(code, details)
-            : [formatPlanGateDetails(code, details), TEAM_UPGRADE_HINT].join("\n"));
+        super(formatPlanGateErrorText(code, details));
         this.code = code;
         this.details = details;
         this.name = "PlanGateError";
@@ -26,56 +81,52 @@ export function isPlanGateError(err) {
     return err instanceof PlanGateError;
 }
 /** Plain, stable CLI copy for plan-gated resource creation. */
-function formatPlanGateDetails(code, details) {
-    const existingResourcesNote = "Existing resources will keep working.";
-    if (code === "PLAN_LIMIT_EXCEEDED" &&
-        typeof details.resource === "string" &&
-        typeof details.used === "number" &&
-        typeof details.limit === "number") {
-        const upgrade = typeof details.upgradeUrl === "string"
-            ? `Upgrade to HQ Workforce ($500/mo) to remove limits: ${details.upgradeUrl}`
-            : "Upgrade to HQ Workforce ($500/mo) to remove limits.";
-        return [
-            `Starter plan limit reached: ${details.resource} ${details.used}/${details.limit} used.`,
-            upgrade,
-            existingResourcesNote,
-        ].join("\n");
-    }
-    // A personal scope is not a workspace: it has no members to trim, no $500
-    // tier to buy, and nothing of its own is paused. One line, the plan's own
-    // copy, and no company remedy.
-    if (code === "PERSONAL_PLAN_REQUIRED") {
-        return renderPersonalPlanFeatureNotice(details.feature ?? "this feature", details.upgradeUrl ?? null);
-    }
-    const upgrade = typeof details.upgradeUrl === "string"
-        ? `Upgrade to HQ Workforce ($500/mo) to remove limits: ${details.upgradeUrl}`
-        : "Upgrade to HQ Workforce ($500/mo) to remove limits.";
-    return [
-        "HQ Workforce plan required for this feature.",
-        upgrade,
-        existingResourcesNote,
-    ].join("\n");
-}
-export function formatPlanGateError(err) {
-    if (err.code === "PERSONAL_PLAN_REQUIRED") {
-        return formatPlanGateDetails(err.code, err.details);
-    }
-    return [
-        formatPlanGateDetails(err.code, err.details),
-        TEAM_UPGRADE_HINT,
-    ].join("\n");
+export function formatPlanGateError(err, options = {}) {
+    return formatUpgradeRefusal(planGateReason(err.code, err.details), err.details.upgradeUrl, options);
 }
 export function canOfferTeamUpgrade(argv = process.argv) {
     return Boolean(process.stdin.isTTY && process.stderr.isTTY) &&
         !process.env.CI &&
         !argv.includes("--json");
 }
-/** Ask once, only on a real interactive terminal. */
+/** Ask before opening the exact URL returned by the server. */
+export async function offerUpgradeLink(url, deps = {}) {
+    const safeUrl = safeUpgradeUrl(url);
+    if (!safeUrl)
+        return false;
+    if (!(deps.interactive ?? canOfferTeamUpgrade(deps.argv)))
+        return false;
+    let answer;
+    if (deps.ask) {
+        answer = await deps.ask("Open upgrade link now? [y/N] ");
+    }
+    else {
+        const { createInterface } = await import("node:readline/promises");
+        const readline = createInterface({ input: process.stdin, output: process.stderr });
+        try {
+            answer = await readline.question("Open upgrade link now? [y/N] ");
+        }
+        finally {
+            readline.close();
+        }
+    }
+    if (!/^y(?:es)?$/i.test(answer.trim()))
+        return false;
+    if (deps.openUrl) {
+        await deps.openUrl(safeUrl);
+    }
+    else {
+        const { default: open } = await import("open");
+        await open(safeUrl);
+    }
+    return true;
+}
+/** Legacy checkout callback retained for callers outside the shared refusal paths. */
 export async function offerTeamUpgrade(onConfirm, deps = {}) {
     if (!(deps.interactive ?? canOfferTeamUpgrade(deps.argv)))
         return false;
     if (deps.ask) {
-        const answer = await deps.ask("Upgrade to HQ Workforce ($500/mo) now? [y/N] ");
+        const answer = await deps.ask("Upgrade now? (opens checkout) [y/N] ");
         if (!/^y(?:es)?$/i.test(answer.trim()))
             return false;
         await onConfirm();
@@ -84,7 +135,7 @@ export async function offerTeamUpgrade(onConfirm, deps = {}) {
     const { createInterface } = await import("node:readline/promises");
     const readline = createInterface({ input: process.stdin, output: process.stderr });
     try {
-        const answer = await readline.question("Upgrade to HQ Workforce ($500/mo) now? [y/N] ");
+        const answer = await readline.question("Upgrade now? (opens checkout) [y/N] ");
         if (!/^y(?:es)?$/i.test(answer.trim()))
             return false;
         await onConfirm();
@@ -106,28 +157,52 @@ export function planGateErrorFromPayload(status, body, companyUid) {
     // through to the company path below (defensive consumer).
     if (payload.error === "plan_feature_unavailable" &&
         payload.scope === "personal") {
+        const upgradeUrl = safeUpgradeUrl(payload.upgradeUrl);
         return new PlanGateError("PERSONAL_PLAN_REQUIRED", {
             ...(typeof payload.feature === "string"
                 ? { feature: payload.feature }
                 : {}),
-            ...(typeof payload.upgradeUrl === "string"
-                ? { upgradeUrl: payload.upgradeUrl }
-                : {}),
+            ...(upgradeUrl ? { upgradeUrl } : {}),
         });
     }
-    if (payload.code !== "PLAN_LIMIT_EXCEEDED" && payload.code !== "PLAN_REQUIRED") {
+    const code = payload.code;
+    const upgradeUrl = safeUpgradeUrl(payload.upgradeUrl);
+    const targetCompanyUid = companyUid ?? companyUidFromPlanUpgradeUrl(upgradeUrl);
+    const planLimit = payload.planLimit !== null &&
+        typeof payload.planLimit === "object" &&
+        !Array.isArray(payload.planLimit)
+        ? payload.planLimit
+        : undefined;
+    const isTeamPlanBillingRequired = code === "BILLING_REQUIRED" && planLimit?.requiredPlan === "team";
+    if (code === "BILLING_REQUIRED") {
+        if (!isTeamPlanBillingRequired ||
+            !targetCompanyUid ||
+            !/^cmp_[A-Za-z0-9_-]+$/.test(targetCompanyUid)) {
+            return null;
+        }
+    }
+    else if (code !== "PLAN_LIMIT_EXCEEDED" &&
+        code !== "PLAN_REQUIRED" &&
+        code !== "MEETING_PLAN_REQUIRED") {
         return null;
     }
-    return new PlanGateError(payload.code, {
+    const reason = typeof payload.message === "string"
+        ? payload.message
+        : typeof payload.error === "string" && payload.error !== payload.code
+            ? payload.error
+            : undefined;
+    return new PlanGateError(code, {
         ...(typeof payload.resource === "string" ? { resource: payload.resource } : {}),
+        ...(typeof payload.feature === "string" ? { feature: payload.feature } : {}),
         ...(typeof payload.used === "number" ? { used: payload.used } : {}),
         ...(typeof payload.limit === "number" ? { limit: payload.limit } : {}),
-        ...(typeof payload.upgradeUrl === "string" ? { upgradeUrl: payload.upgradeUrl } : {}),
-        ...(companyUid ? { companyUid } : {}),
+        ...(upgradeUrl ? { upgradeUrl } : {}),
+        ...(reason ? { reason } : {}),
+        ...(targetCompanyUid ? { companyUid: targetCompanyUid } : {}),
     });
 }
 /**
- * Decode only the two deliberate plan-gate envelopes. Malformed, unrelated,
+ * Decode the supported plan-gate envelopes. Malformed, unrelated,
  * or non-402 responses retain their existing command-specific handling.
  */
 export async function planGateErrorFromResponse(response, companyUid) {

package/dist/utils/self-update.d.ts

@@ -83,6 +83,8 @@ export type SelfUpdateAction =
  | "update-ineffective"
 /** Updated and the command re-ran on the new version; exit with `reexecStatus`. */
  | "reexec"
+/** Updated with no re-exec (the `hq daemon` updater restarts the daemon instead). */
+ | "updated"
 /**
  * Unattended caller: replacing the CLI in place is unsafe here, so nothing
  * was attempted and the command runs on the current version. An attended
@@ -171,4 +173,11 @@ export declare function autoUpdateAndReexec(argv: readonly string[], latest: str
  * are preserved.
  */
 export declare function selfUpdateAndReexec(argv: readonly string[], deps?: SelfUpdateDeps): Promise<SelfUpdateOutcome>;
+/**
+ * `hq daemon` updater service: update to npm latest with nobody at a terminal
+ * and no re-exec. It runs as its own short-lived child of the daemon, so no
+ * user command is waiting on the package being replaced; after an "updated"
+ * outcome the daemon restarts itself onto the new version.
+ */
+export declare function daemonSelfUpdate(deps?: SelfUpdateDeps): Promise<SelfUpdateOutcome>;
 //# sourceMappingURL=self-update.d.ts.map

package/dist/utils/self-update.js

@@ -292,6 +292,10 @@ async function updateAndReexec(argv, flavor, known, deps) {
     catch {
         // Defensive only; the default helper already absorbs manager failures.
     }
+    if (!flavor.reexec) {
+        console.error(chalk.dim(`✓ hq-cli updated to ${latest}.`));
+        return { action: "updated", latest };
+    }
     const childEnv = { ...env, [REEXEC_GUARD_ENV]: "1" };
     const status = (deps.reexec ?? reexecHq)([...argv.slice(2)], childEnv);
     if (status === null) {
@@ -309,7 +313,7 @@ async function updateAndReexec(argv, flavor, known, deps) {
  * this resolve it from the registry.
  */
 export async function autoUpdateAndReexec(argv, latest, deps = {}) {
-    return updateAndReexec(argv, { noun: "command", verbose: false, lock: true, onlyWhenAttended: true }, latest, deps);
+    return updateAndReexec(argv, { noun: "command", verbose: false, lock: true, onlyWhenAttended: true, reexec: true }, latest, deps);
 }
 /**
  * Rescue path: update to npm latest and re-exec the rescue on the new version.
@@ -318,6 +322,15 @@ export async function autoUpdateAndReexec(argv, latest, deps = {}) {
  * are preserved.
  */
 export async function selfUpdateAndReexec(argv, deps = {}) {
-    return updateAndReexec(argv, { noun: "rescue", verbose: true, lock: true, onlyWhenAttended: false }, null, deps);
+    return updateAndReexec(argv, { noun: "rescue", verbose: true, lock: true, onlyWhenAttended: false, reexec: true }, null, deps);
+}
+/**
+ * `hq daemon` updater service: update to npm latest with nobody at a terminal
+ * and no re-exec. It runs as its own short-lived child of the daemon, so no
+ * user command is waiting on the package being replaced; after an "updated"
+ * outcome the daemon restarts itself onto the new version.
+ */
+export async function daemonSelfUpdate(deps = {}) {
+    return updateAndReexec([], { noun: "daemon update", verbose: false, lock: true, onlyWhenAttended: false, reexec: false }, null, deps);
 }
 //# sourceMappingURL=self-update.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.162.0",
+  "version": "5.163.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {