@indigoai-us/hq-cli 5.345.107 → 5.345.109

package/dist/hq-cloud-sync-runner/package.json

@@ -1 +1 @@
-{"name":"hq-cli-daemon-sync-runner","type":"module","version":"6.18.66","bundleSha256":"d72d8dca5874f0b3e2c7051842495dd9109b2191f822a1fc7c8f92fd21f04436","formatVersion":1}
+{"name":"hq-cli-daemon-sync-runner","type":"module","version":"6.18.67","bundleSha256":"6d94ad9a9dbfa34fd81040eff69d68a1da68ab0d1318566832fe19393bffe589","formatVersion":1}

package/dist/index.d.ts

@@ -5,13 +5,21 @@ import { isVersionRequest } from "./version-request.js";
 import { isFastCoreRequest } from "./fast-scaffold.js";
 type PackageUseLeaseLoader = () => Promise<void>;
 type PackageUseUpdateProbe = () => Promise<boolean>;
+/** Resolves true once the command was re-run (exit code already set). */
+type PackageUseUpdateReexec = () => Promise<boolean>;
+/**
+ * Wait (bounded) for a live updater to finish, then re-run this command from
+ * the new install via the same bin path. Guarded against loops by an env flag.
+ */
+declare function waitForUpdateThenReexec(argv?: readonly string[], env?: NodeJS.ProcessEnv, waitForUpdate?: () => Promise<boolean>, run?: (command: string, args: string[], childEnv: NodeJS.ProcessEnv) => Promise<number>): Promise<boolean>;
 declare function isNpmPackageEntry(entryUrl: string): boolean;
-declare function dispatchWithPackageUseLease(entryUrl: string, dispatch: () => void, loadLease?: PackageUseLeaseLoader, updateRequestPending?: PackageUseUpdateProbe): void | Promise<void>;
+declare function dispatchWithPackageUseLease(entryUrl: string, dispatch: () => void, loadLease?: PackageUseLeaseLoader, updateRequestPending?: PackageUseUpdateProbe, waitThenReexec?: PackageUseUpdateReexec): void | Promise<void>;
 declare function runCliEntry(entryUrl: string, dispatch: () => void, loadLease?: PackageUseLeaseLoader): void | Promise<void>;
 export declare const __test__: {
     isVersionRequest: typeof isVersionRequest;
     isFastCoreRequest: typeof isFastCoreRequest;
     dispatchWithPackageUseLease: typeof dispatchWithPackageUseLease;
+    waitForUpdateThenReexec: typeof waitForUpdateThenReexec;
     runCliEntry: typeof runCliEntry;
     isNpmPackageEntry: typeof isNpmPackageEntry;
     acquirePackageUseLease: (prefix: string, version: string, stateDirectory?: string) => Promise<import("./utils/package-use-lease.js").PackageUseLease>;

package/dist/index.js

@@ -230,6 +230,36 @@ function dispatchCliEntry() {
         void runMainWithInstallTreeRecovery();
     }
 }
+const REEXEC_ENV = "HQ_CLI_UPDATE_REEXEC";
+/**
+ * Wait (bounded) for a live updater to finish, then re-run this command from
+ * the new install via the same bin path. Guarded against loops by an env flag.
+ */
+async function waitForUpdateThenReexec(argv = process.argv, env = process.env, waitForUpdate = async () => {
+    const { waitForCurrentPackageUseUpdate } = await import("./utils/package-use-lease.js");
+    return waitForCurrentPackageUseUpdate();
+}, run = async (command, args, childEnv) => {
+    const { spawn } = await import("node:child_process");
+    return await new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: "inherit", env: childEnv });
+        child.on("error", () => resolve(1));
+        child.on("exit", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
+    });
+}) {
+    if (env[REEXEC_ENV] === "1" || !argv[1])
+        return false;
+    let finished = false;
+    try {
+        finished = await waitForUpdate();
+    }
+    catch {
+        return false;
+    }
+    if (!finished)
+        return false;
+    process.exitCode = await run(process.execPath, argv.slice(1), { ...env, [REEXEC_ENV]: "1" });
+    return true;
+}
 function isNpmPackageEntry(entryUrl) {
     return /\/node_modules\/@indigoai-us\/hq-cli\/dist\/index\.js$/i.test(entryUrl);
 }
@@ -260,7 +290,7 @@ function dispatchWithPackageUseLease(entryUrl, dispatch, loadLease = async () =>
 }, updateRequestPending = async () => {
     const { currentPackageUseUpdatePending } = await import("./utils/package-use-lease.js");
     return currentPackageUseUpdatePending();
-}) {
+}, waitThenReexec = waitForUpdateThenReexec) {
     if (!isNpmPackageEntry(entryUrl)) {
         dispatch();
         return;
@@ -270,6 +300,12 @@ function dispatchWithPackageUseLease(entryUrl, dispatch, loadLease = async () =>
             throw error;
         try {
             if (await updateRequestPending()) {
+                // The install tree is being replaced under this process, so the lease
+                // module (or a dependency) failed to load. Wait for the updater, then
+                // run the command again from the freshly installed package instead of
+                // failing a running session's command outright.
+                if (await waitThenReexec())
+                    return;
                 const pending = new Error("The HQ CLI package is being updated; retry after the update finishes");
                 pending.name = "PackageUseUpdatePendingError";
                 throw pending;
@@ -311,6 +347,7 @@ export const __test__ = {
     isVersionRequest,
     isFastCoreRequest,
     dispatchWithPackageUseLease,
+    waitForUpdateThenReexec,
     runCliEntry,
     isNpmPackageEntry,
     acquirePackageUseLease: async (prefix, version, stateDirectory) => {

package/dist/lib/capacity/ledger.d.ts

@@ -369,6 +369,7 @@ export interface LedgerOptions {
     pid?: number;
     lockTtlMs?: number;
 }
+export declare function capacityOptionsFromEnv(env?: NodeJS.ProcessEnv): LedgerOptions;
 export declare function capacityRoot(env?: NodeJS.ProcessEnv, home?: string): string;
 /** Shown for a credential that exists and is past expiry. Never a login. */
 export declare const EXPIRED_REASON = "expired: refreshes the next time Claude Code is used with this account";

package/dist/lib/capacity/ledger.js

@@ -169,6 +169,16 @@ export const nowViewJsonSchema = {
         },
     },
 };
+export function capacityOptionsFromEnv(env = process.env) {
+    const raw = env.HQ_CAPACITY_NOW?.trim();
+    if (!raw)
+        return { env };
+    const parsed = Date.parse(raw);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`HQ_CAPACITY_NOW must be a UTC timestamp, got '${raw}'`);
+    }
+    return { env, now: () => new Date(raw) };
+}
 export function capacityRoot(env = process.env, home = os.homedir()) {
     const override = env.HQ_CAPACITY_ROOT?.trim();
     if (override)

package/dist/lib/capacity/route.d.ts

@@ -0,0 +1,146 @@
+import type { LaneRecord, LaneState, LanesConfig } from "../lanes/types.js";
+import { type LaneProvider } from "../lanes/types.js";
+import type { NowLimit, NowView } from "./ledger.js";
+/** All lane providers, in the stable order boss-route uses for ranking ties. */
+export declare const ROUTE_PROVIDERS: readonly LaneProvider[];
+/** Lane states that count against an account's live load. */
+export declare const LIVE_STATES: ReadonlySet<LaneState>;
+/** Limit kinds the router scores against. */
+export declare const LIMIT_KINDS: Set<string>;
+/** A reading older than this is treated as no reading at all. */
+export declare const STALE_SKIP_MS: number;
+/** Headroom below this percent is "nearly used up"; the account is skipped. */
+export declare const NEARLY_OUT = 5;
+/** Score penalty per live lane already on the account. */
+export declare const LANE_PENALTY = 3;
+/** Weekly reset within this window boosts an otherwise idle account. */
+export declare const RESET_SOON_MS: number;
+/** Score bonus for a weekly that resets within RESET_SOON_MS. */
+export declare const RESET_SOON_BONUS = 10;
+/** A limit reading older than this is dropped as unknown until its window resets. */
+export declare const LIMIT_STALE_MS: number;
+/** Readings older than this rank below fresh ones by OLD_READING_PENALTY. */
+export declare const FRESH_MS: number;
+/** Score penalty for an account whose binding limit reading is not fresh. */
+export declare const OLD_READING_PENALTY = 10;
+/** Default --floor applied by the CLI (percent headroom to clear). */
+export declare const DEFAULT_FLOOR = 15;
+/** Default --prefer order applied by the CLI. */
+export declare const DEFAULT_PREFER: readonly LaneProvider[];
+/** Sign-in states a lane can still run on. */
+export declare const RUNNABLE_AUTH: Set<string>;
+/** Map a model id to its lane provider, or null when the model is unmapped. */
+export declare function providerForModel(model: string): LaneProvider | null;
+/** True when the limit should factor into the pick for this request. */
+export declare function limitApplies(provider: LaneProvider, limit: NowLimit, model: string): boolean;
+/** Human label for the limit a reason or binding row quotes. */
+export declare function labelLimit(limit: NowLimit): string;
+/** Lane account whose canonical home matches one of the ledger account's homes. */
+export declare function laneAccountFor(provider: LaneProvider, homes: readonly string[] | undefined, lanesConfig: LanesConfig): {
+    id: string;
+    enabled: boolean;
+} | null;
+/** Request payload echoed in the output. */
+export interface RouteRequest {
+    providers: LaneProvider[];
+    model: string | null;
+    prefer: LaneProvider[];
+    floor: number;
+}
+export interface RouteBindingSummary {
+    limit: string;
+    used_percent: number;
+    resets_at: string | null;
+}
+/** One account the router could not route to, with the reason the operator sees. */
+export interface RouteSkipped {
+    provider: LaneProvider;
+    account: string | null;
+    label: string;
+    organization: string | null;
+    reason: string;
+    fix?: string | null;
+    resets_at?: string | null;
+}
+/** One account the router scored, in rank order after sorting. */
+export interface RouteRanked {
+    provider: LaneProvider;
+    account: string;
+    label: string;
+    organization: string | null;
+    headroom: number;
+    score: number;
+    live_lanes: number;
+    reset_soon: boolean;
+    token_expired: boolean;
+    reading_age_h: number;
+    binding: RouteBindingSummary;
+    weekly_resets_at: string | null;
+    why: string;
+    lane_flags: string;
+}
+/** Live lane on an account the router would avoid; command names a replacement. */
+export interface RouteMove {
+    lane_id: string;
+    provider: LaneProvider;
+    from: string | null;
+    reason: string;
+    to: string | null;
+    command: string | null;
+}
+export interface RouteCapacityMeta {
+    generated_at: string | null;
+    stale: boolean;
+    collector_enabled: boolean | null;
+}
+export interface RouteResult {
+    ok: boolean;
+    at: string;
+    request: RouteRequest;
+    pick: RouteRanked | null;
+    ranked: RouteRanked[];
+    skipped: RouteSkipped[];
+    moves: RouteMove[];
+    next_reset: string | null;
+    capacity: RouteCapacityMeta;
+    lanes_error: string | null;
+}
+export interface PickAccountInput {
+    view: NowView;
+    lanes: readonly LaneRecord[];
+    lanesConfig: LanesConfig;
+    /** Requested providers; "any" expands to the model's provider or every provider. */
+    providers?: readonly string[];
+    model?: string | null;
+    prefer?: readonly string[];
+    floor?: number;
+    now: Date;
+    /** Reserved for future use; routing today does not read env. */
+    env?: NodeJS.ProcessEnv;
+    /** Collector enabled flag threaded from the mark file. */
+    collectorEnabled?: boolean | null;
+    /** Overall ledger freshness flag threaded from AdvisoryNow. */
+    capacityStale?: boolean;
+    /** Error summary when the lanes list could not be read. */
+    lanesError?: string | null;
+}
+export declare class RouteUsageError extends Error {
+    readonly code = "route_usage";
+    constructor(message: string);
+}
+/** Parse `--provider any|claude|codex|grok[,..]` honouring the model expansion rule. */
+export declare function resolveRequestedProviders(raw: readonly string[] | undefined, model: string): LaneProvider[];
+/** Parse `--prefer claude,codex,grok`. */
+export declare function resolvePreferOrder(raw: readonly string[] | undefined): LaneProvider[];
+/** Parse `--floor <n>`; 0..100 inclusive, default DEFAULT_FLOOR when missing. */
+export declare function resolveFloor(raw: string | number | undefined): number;
+/**
+ * Pure routing decision over a snapshot: scores every signed-in lane account,
+ * applies the --prefer order under the --floor headroom, returns the pick (or
+ * null when nothing has room), and the lane-move suggestions for live lanes
+ * sitting on bad accounts.
+ */
+export declare function pickAccount(input: PickAccountInput): RouteResult;
+/** One-line text output used by `--text` and by `--account auto` admission messages. */
+export declare function formatRouteText(result: RouteResult): string;
+//# sourceMappingURL=route.d.ts.map