@indigoai-us/hq-cli 5.345.92 → 5.345.93

package/dist/lib/capacity/lane-login.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Vendor sign-in for `hq capacity login`.
+ *
+ * Home creation, the vendor command, and the registry write are
+ * `runAccountsLogin` from the lanes account command. This file only
+ * builds the context that command already expects.
+ */
+import type { Ctx } from "../../commands/lanes-shared.js";
+export interface LaneLoginInput {
+    provider: string;
+    accountId: string;
+    hqRoot?: string;
+    hostname?: string;
+    homedir?: () => string;
+    env?: NodeJS.ProcessEnv;
+    spawnLogin?: Ctx["spawnLogin"];
+    /**
+     * Runs `claude auth status` after login. On macOS Claude Code keeps the
+     * credential in the Keychain, so there is no credentials file and the lane
+     * login confirms sign-in through this probe. Defaults to the lanes probe.
+     */
+    probeProvider?: Ctx["probeProvider"];
+}
+export interface LaneLoginResult {
+    id: string;
+    home: string;
+}
+export declare function loginLaneAccount(input: LaneLoginInput): Promise<LaneLoginResult>;
+//# sourceMappingURL=lane-login.d.ts.map

package/dist/lib/capacity/lane-login.js

@@ -0,0 +1,91 @@
+/**
+ * Vendor sign-in for `hq capacity login`.
+ *
+ * Home creation, the vendor command, and the registry write are
+ * `runAccountsLogin` from the lanes account command. This file only
+ * builds the context that command already expects.
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { createLaneAccountsHandlers } from "../../commands/lanes-accounts.js";
+import { resolveLanesHqRoot } from "../lanes/hq-root.js";
+import { defaultProbe } from "../lanes/models.js";
+const ACCOUNT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const RESERVED_ACCOUNT_IDS = new Set(["a", "default"]);
+export async function loginLaneAccount(input) {
+    if (!ACCOUNT_ID_PATTERN.test(input.accountId) || RESERVED_ACCOUNT_IDS.has(input.accountId)) {
+        throw new Error(`Refusing account id ${input.accountId}. Use letters, numbers, dots, underscores, or hyphens, and not a reserved id.`);
+    }
+    const hqRoot = input.hqRoot ?? resolveLanesHqRoot({ env: input.env });
+    let captured;
+    const handlers = createLaneAccountsHandlers(handlerDeps((value) => {
+        captured = value;
+    }));
+    // One registry write. capacityOnly stores enabled:false and the capacity-only
+    // reason in that write, re-checking whether lanes already use the account.
+    await handlers.runAccountsLogin(loginCtx(input, hqRoot), input.provider, input.accountId, {
+        capacityOnly: true,
+    });
+    const account = captured?.account;
+    if (!account?.id || !account.home) {
+        throw new Error(`lanes accounts login did not register ${input.provider} ${input.accountId}`);
+    }
+    return { id: account.id, home: account.home };
+}
+function handlerDeps(printJson) {
+    return {
+        automaticBalanceMoveHistoryReason: () => unused("automaticBalanceMoveHistoryReason"),
+        ensureDir: (dir) => {
+            fs.mkdirSync(dir, { recursive: true });
+        },
+        laneWithRecoveredProviderSession: () => unused("laneWithRecoveredProviderSession"),
+        loadClaudeBalanceHostSnapshots: () => unused("loadClaudeBalanceHostSnapshots"),
+        parseRemoteJson: () => unused("parseRemoteJson"),
+        prepareAccountMove: () => unused("prepareAccountMove"),
+        printJson,
+        readClaudeAccountBalanceSignalsEnabled: () => unused("readClaudeAccountBalanceSignalsEnabled"),
+        reconcileHostFromCtx: () => unused("reconcileHostFromCtx"),
+        resolveCallerPath: (callerCwd, filePath) => path.resolve(callerCwd, filePath),
+    };
+}
+function loginCtx(input, hqRoot) {
+    const fields = {
+        hqRoot: () => hqRoot,
+        callerCwd: () => hqRoot,
+        cwd: () => hqRoot,
+        env: input.env ?? process.env,
+        hostname: () => input.hostname ?? os.hostname(),
+        homedir: input.homedir ?? os.homedir,
+        existsSync: (target) => fs.existsSync(target),
+        spawnLogin: input.spawnLogin ?? defaultSpawnLogin,
+        probeProvider: input.probeProvider ?? defaultProbe,
+    };
+    return new Proxy(fields, {
+        get(target, prop) {
+            if (prop in target)
+                return target[prop];
+            return () => {
+                throw new Error(`capacity login does not use lanes ctx.${String(prop)}`);
+            };
+        },
+    });
+}
+function defaultSpawnLogin(opts) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(opts.command, opts.args, {
+            env: opts.env,
+            cwd: opts.cwd,
+            stdio: "inherit",
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            resolve({ status: code ?? 1 });
+        });
+    });
+}
+function unused(name) {
+    throw new Error(`capacity login does not use ${name}`);
+}
+//# sourceMappingURL=lane-login.js.map

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

@@ -0,0 +1,399 @@
+/**
+ * Personal capacity ledger under ~/.hq/capacity/.
+ *
+ * Daily files events-YYYY-MM-DD.jsonl are the append-only event log (one
+ * O_APPEND write under 4 KB). rebuildNow() replays those files, plus a
+ * legacy events.jsonl if a fixture dropped one, into now.json. The now.json
+ * rewrite holds a TTL lock reclaimed after 30 seconds.
+ *
+ * Root is HQ_CAPACITY_ROOT, or an explicit option, so tests never touch the
+ * real home directory. No network, child process, or provider call.
+ */
+export declare const CAPACITY_DIRNAME = "capacity";
+export declare const CAPACITY_LOCK_TTL_MS = 30000;
+export declare const CAPACITY_LOCK_NAME = "now.lock";
+export declare const NOW_FILE_NAME = "now.json";
+export declare const COLLECTOR_FILE_NAME = "collector.json";
+export declare const LEGACY_EVENTS_NAME = "events.jsonl";
+export declare const MAX_APPEND_BYTES = 4096;
+export declare const EVENT_RETENTION_DAYS = 14;
+export declare const BURN_WINDOW_MS: number;
+export declare const DIR_MODE = 448;
+export declare const FILE_MODE = 384;
+/** US-001 redaction shapes: Claude OAuth, and Codex / Grok bearer JWTs. */
+export declare const PROVIDER_TOKEN_LEAK: RegExp;
+export declare const READING_SOURCES: readonly ["statusline", "oauth-usage", "codex-jsonl", "codex-app-server", "grok-billing", "refusal"];
+export type ReadingSource = (typeof READING_SOURCES)[number];
+export declare const LIMIT_KINDS: readonly ["session", "weekly_all", "weekly_scoped", "credits", "prepaid", "on_demand", "unknown"];
+export type LimitKind = (typeof LIMIT_KINDS)[number];
+export declare const CONFIDENCE_VALUES: readonly ["observed", "fetched", "inferred", "unknown"];
+export type ReadingConfidence = (typeof CONFIDENCE_VALUES)[number];
+export declare const CAPACITY_STATES: readonly ["ok", "warn", "exhausted", "unknown", "reset-pending"];
+export type CapacityState = (typeof CAPACITY_STATES)[number];
+export declare class LedgerMissing extends Error {
+    readonly code: "LEDGER_MISSING";
+    constructor();
+}
+export declare class LedgerCorrupt extends Error {
+    readonly code: "LEDGER_CORRUPT";
+    constructor();
+}
+export declare class LedgerBusy extends Error {
+    readonly code: "LEDGER_BUSY";
+    constructor();
+}
+export declare class LedgerRejected extends Error {
+    readonly code: "LEDGER_REJECTED";
+    constructor(message: string);
+}
+export interface ReadingLimit {
+    limitId: string;
+    kind: LimitKind;
+    scope: string | null;
+    usedPercent: number | null;
+    windowMinutes: number | null;
+    resetsAt: string | null;
+    balance: string | number | null;
+    planType: string | null;
+    /** Present on credits readings. Omitted for window readings. */
+    hasCredits?: boolean | null;
+    /** Present on credits readings. Omitted for window readings. */
+    unlimited?: boolean | null;
+    /** Claude weekly_scoped_shares allowance. Omitted for other readings. */
+    allowancePercentOfWeekly?: number | null;
+}
+export interface ReadingLimitInput extends Omit<ReadingLimit, "resetsAt"> {
+    resetsAt: string | number | null;
+}
+export interface Reading {
+    readingId: string;
+    observedAt: string;
+    provider: string;
+    accountId: string;
+    source: ReadingSource;
+    cliVersion: string;
+    limit: ReadingLimit;
+    confidence: ReadingConfidence;
+    parserVersion: string;
+    error?: string;
+    /** Codex snapshot flag. Omitted when the source did not report it. */
+    rateLimitReachedType?: string | null;
+    /** Codex snapshot flag. Omitted when the source did not report it. */
+    spendControlReached?: boolean | null;
+    /** Lane account id, or `default` for the implicit provider home. */
+    accountLabel?: string;
+    /** Every label that resolved to this reading's account. */
+    accountLabels?: string[];
+    /** Organization or plan name. Emails are dropped and never stored. */
+    organization?: string | null;
+    /** Provider home this reading was collected from. */
+    accountHome?: string;
+}
+export interface ReadingInput extends Omit<Reading, "limit"> {
+    limit: ReadingLimitInput;
+}
+export interface ParserFailureEvent {
+    event: "parser_failure";
+    observedAt: string;
+    provider: string;
+    source: ReadingSource;
+    error: string;
+    accountId?: string;
+    cliVersion?: string;
+    parserVersion?: string;
+    limitId?: string;
+    accountLabel?: string;
+    accountLabels?: string[];
+    organization?: string | null;
+    accountHome?: string;
+}
+export interface RateLimitResetCredit {
+    id: string;
+    resetType: string | null;
+    status: string | null;
+    grantedAt: number | null;
+    expiresAt: number | null;
+    title: string | null;
+    description: string | null;
+}
+export interface RateLimitResetCredits {
+    availableCount: number | null;
+    credits: RateLimitResetCredit[];
+}
+/** Codex fields that belong on the provider entry, not on one limit row. */
+export interface ProviderMetaEvent {
+    event: "provider_meta";
+    observedAt: string;
+    provider: string;
+    source: ReadingSource;
+    ordinaryUsageAllowed: boolean | null;
+    rateLimitResetCredits: RateLimitResetCredits | null;
+    accountId?: string;
+    cliVersion?: string;
+    parserVersion?: string;
+}
+export type LedgerEvent = Reading | ParserFailureEvent | ProviderMetaEvent;
+export interface NowLimit {
+    limitId: string;
+    accountId: string;
+    kind: LimitKind;
+    scope: string | null;
+    usedPercent: number | null;
+    windowMinutes: number | null;
+    resetsAt: string | null;
+    secondsToReset: number | null;
+    burnRatePercentPerHour: number | null;
+    balance: string | number | null;
+    planType: string | null;
+    state: CapacityState;
+    source: ReadingSource;
+    confidence: ReadingConfidence;
+    observedAt: string;
+    readingId: string;
+    cliVersion: string;
+    parserVersion: string;
+    lastError: string | null;
+    hasCredits?: boolean | null;
+    unlimited?: boolean | null;
+    /** Claude weekly_scoped_shares allowance. Omitted for other limits. */
+    allowancePercentOfWeekly?: number | null;
+    rateLimitReachedType?: string | null;
+    spendControlReached?: boolean | null;
+}
+export type AccountAuthState = "ok" | "expired" | "signed_out" | "unknown";
+export interface NowAccount {
+    accountId: string;
+    labels: string[];
+    organization: string | null;
+    homes: string[];
+    state: CapacityState;
+    /** False when the credential exists but the access token is past expiry. */
+    signedOut: boolean;
+    authState: AccountAuthState;
+    /** Latest reading or failure time. Null on views written before US-012. */
+    observedAt?: string | null;
+    reason: string | null;
+    fixCommand: string | null;
+    limits: NowLimit[];
+}
+export interface NowProvider {
+    provider: string;
+    state: CapacityState;
+    lastError: string | null;
+    limits: NowLimit[];
+    /** Set only after a Codex app-server read stored provider meta. */
+    ordinaryUsageAllowed?: boolean | null;
+    rateLimitResetCredits?: RateLimitResetCredits | null;
+    /** Present when a reading or signed-out failure named an account. */
+    accounts?: NowAccount[];
+}
+export interface NowView {
+    machineId: string;
+    hqCliVersion: string;
+    generatedAt: string;
+    providers: NowProvider[];
+}
+/** On/off mark for the resident collector. The directory alone is not the mark. */
+export interface CollectorMark {
+    enabled: boolean;
+    updatedAt: string;
+}
+export declare const readingJsonSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "hq-capacity-reading.v1";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["readingId", "observedAt", "provider", "accountId", "source", "cliVersion", "limit", "confidence", "parserVersion"];
+    readonly properties: {
+        readonly readingId: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly observedAt: {
+            readonly type: "string";
+            readonly pattern: string;
+        };
+        readonly provider: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly accountId: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly source: {
+            readonly type: "string";
+            readonly enum: readonly ["statusline", "oauth-usage", "codex-jsonl", "codex-app-server", "grok-billing", "refusal"];
+        };
+        readonly cliVersion: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly limit: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["limitId", "kind", "scope", "usedPercent", "windowMinutes", "resetsAt", "balance", "planType"];
+            readonly properties: {
+                readonly limitId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly kind: {
+                    readonly type: "string";
+                    readonly enum: readonly ["session", "weekly_all", "weekly_scoped", "credits", "prepaid", "on_demand", "unknown"];
+                };
+                readonly scope: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly usedPercent: {
+                    readonly type: readonly ["number", "null"];
+                };
+                readonly windowMinutes: {
+                    readonly type: readonly ["number", "null"];
+                };
+                readonly resetsAt: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly balance: {
+                    readonly type: readonly ["string", "number", "null"];
+                };
+                readonly planType: {
+                    readonly type: readonly ["string", "null"];
+                };
+                readonly hasCredits: {
+                    readonly type: readonly ["boolean", "null"];
+                };
+                readonly unlimited: {
+                    readonly type: readonly ["boolean", "null"];
+                };
+                readonly allowancePercentOfWeekly: {
+                    readonly type: readonly ["number", "null"];
+                };
+            };
+        };
+        readonly confidence: {
+            readonly type: "string";
+            readonly enum: readonly ["observed", "fetched", "inferred", "unknown"];
+        };
+        readonly parserVersion: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly error: {
+            readonly type: "string";
+        };
+        readonly rateLimitReachedType: {
+            readonly type: readonly ["string", "null"];
+        };
+        readonly spendControlReached: {
+            readonly type: readonly ["boolean", "null"];
+        };
+        readonly accountLabel: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly accountLabels: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+        readonly organization: {
+            readonly type: readonly ["string", "null"];
+        };
+        readonly accountHome: {
+            readonly type: "string";
+        };
+    };
+};
+export declare const nowViewJsonSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "hq-capacity-now-view.v1";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["machineId", "hqCliVersion", "generatedAt", "providers"];
+    readonly properties: {
+        readonly machineId: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly hqCliVersion: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly generatedAt: {
+            readonly type: "string";
+        };
+        readonly providers: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["provider", "state", "lastError", "limits"];
+                readonly properties: {
+                    readonly provider: {
+                        readonly type: "string";
+                    };
+                    readonly state: {
+                        readonly type: "string";
+                        readonly enum: readonly ["ok", "warn", "exhausted", "unknown", "reset-pending"];
+                    };
+                    readonly lastError: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly limits: {
+                        readonly type: "array";
+                    };
+                    readonly ordinaryUsageAllowed: {
+                        readonly type: readonly ["boolean", "null"];
+                    };
+                    readonly rateLimitResetCredits: {
+                        readonly type: readonly ["object", "null"];
+                    };
+                    readonly accounts: {
+                        readonly type: "array";
+                    };
+                };
+            };
+        };
+    };
+};
+export interface LedgerOptions {
+    root?: string;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    machineId?: string;
+    hqCliVersion?: string;
+    pid?: number;
+    lockTtlMs?: number;
+}
+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";
+export declare function isExpiredReason(reason: string | null | undefined): boolean;
+export declare function isAccountFailureReason(reason: string): boolean;
+/** Exact command for an account that has no usable credential. */
+export declare function capacityLoginCommand(provider: string, label: string): string;
+/** Open the vendor CLI so it can refresh its own token. Does not refresh anything. */
+export declare function claudeOpenCommand(home: string | null, userHome?: string): string;
+export declare function redactProviderTokens(text: string): string;
+export declare function ledgerSentryPayload(error: unknown): {
+    name: string;
+    message: string;
+};
+export declare function appendReading(input: ReadingInput, options?: LedgerOptions): NowView;
+/**
+ * Write every reading, parser failure, and optional provider meta, then
+ * rebuild now.json once. appendReading stays the single-reading path.
+ */
+export declare function appendReadings(readings: readonly ReadingInput[], failures?: readonly ParserFailureEvent[], meta?: ProviderMetaEvent | null, options?: LedgerOptions): NowView;
+export declare function appendParserFailure(input: ParserFailureEvent, options?: LedgerOptions): NowView;
+export declare function appendProviderMeta(input: ProviderMetaEvent, options?: LedgerOptions): NowView;
+export declare function readNow(options?: LedgerOptions): NowView;
+export declare function readLedgerEvents(options?: LedgerOptions): LedgerEvent[];
+export declare function readCollectorMark(options?: LedgerOptions): CollectorMark | null;
+export declare function setCollectorEnabled(enabled: boolean, options?: LedgerOptions): CollectorMark;
+export declare function rebuildNow(options?: LedgerOptions): NowView;
+//# sourceMappingURL=ledger.d.ts.map