@indigoai-us/hq-cli 5.345.92 → 5.345.94

package/dist/lib/capacity/refusal.js

@@ -0,0 +1,183 @@
+/**
+ * `hq capacity ingest refusal` — one inferred exhausted reading, then one
+ * now.json rebuild. No network and no provider call.
+ *
+ * A refusal stays exhausted until its resetsAt passes (then reset-pending).
+ * materialize keeps the newest observedAt, so a later fetched or observed
+ * reading below 100% replaces the inference before that reset.
+ */
+import { createHash } from "node:crypto";
+import { LedgerCorrupt, LedgerMissing, PROVIDER_TOKEN_LEAK, appendReading, readNow, rebuildNow, } from "./ledger.js";
+export const REFUSAL_PROVIDERS = ["claude", "codex", "grok"];
+export const REFUSAL_PARSER_VERSION = "capacity-refusal.1";
+export const REFUSAL_DEFAULT_LIMIT_ID = "weekly";
+export const REFUSAL_HELP = [
+    "workflow-runner and /conduct call this after a provider failure has been",
+    "classified as a rate-limit refusal (policy",
+    "indigo-provider-failures-classified-not-masked-as-timeout). Do not call it",
+    "for a timeout that was not classified as a rate-limit refusal:",
+    "",
+    "  hq capacity ingest refusal --provider <claude|codex|grok> [--limit-id <id>] [--resets-at <iso|epoch>] [--account <hash>]",
+    "",
+    "When --limit-id is omitted, the provider's weekly_all limit id in now.json",
+    "is used, or weekly when that view has none. This command does not wire",
+    "those callers.",
+].join("\n");
+export class CapacityUsageError extends Error {
+    exitCode = 2;
+    constructor(message) {
+        super(message);
+        this.name = "CapacityUsageError";
+    }
+}
+export function ingestRefusal(input, options) {
+    const provider = requireProvider(input.provider);
+    const accountArg = optionalTokenFree(input.accountId, "--account must be a non-empty hash");
+    const resetArg = input.resetsAt === undefined ? undefined : parseReset(input.resetsAt);
+    const limitArg = optionalTokenFree(input.limitId, "--limit-id must be a non-empty id");
+    const view = loadView(options);
+    const matched = selectLimit(view, provider, limitArg, accountArg);
+    const limitId = limitArg ?? matched?.limitId ?? REFUSAL_DEFAULT_LIMIT_ID;
+    const accountId = accountArg ?? matched?.accountId ?? "unknown";
+    const now = options?.now ? options.now() : new Date();
+    const observedAt = now.toISOString();
+    const resetsAt = resolveRefusalReset(resetArg, matched?.resetsAt, now);
+    const reading = buildReading({
+        provider,
+        accountId,
+        limitId,
+        observedAt,
+        resetsAt,
+        matched,
+    });
+    const rebuilt = appendReading(reading, options);
+    const row = rebuilt.providers
+        .find((entry) => entry.provider === provider)
+        ?.limits.find((limit) => limit.accountId === accountId && limit.limitId === limitId);
+    if (!row)
+        throw new Error("refusal reading was not materialized");
+    return {
+        provider,
+        accountId,
+        limitId,
+        source: "refusal",
+        confidence: "inferred",
+        observedAt,
+        state: row.state,
+        resetsAt: row.resetsAt,
+        readingId: row.readingId,
+        usedPercent: row.usedPercent,
+    };
+}
+const REFUSAL_DEFAULT_TTL_MS = 60 * 60 * 1000;
+/** Ignore an inherited reset that is already past. With none known, expire in one hour. */
+function resolveRefusalReset(explicit, inherited, now) {
+    if (explicit !== undefined)
+        return explicit;
+    if (inherited) {
+        const at = Date.parse(inherited);
+        if (!Number.isNaN(at) && at > now.getTime())
+            return inherited;
+    }
+    return new Date(now.getTime() + REFUSAL_DEFAULT_TTL_MS).toISOString();
+}
+function requireProvider(value) {
+    const provider = value?.trim() ?? "";
+    if (!provider)
+        throw new CapacityUsageError("--provider is required");
+    if (!REFUSAL_PROVIDERS.includes(provider)) {
+        throw new CapacityUsageError(`provider must be claude, codex, or grok, got '${provider}'`);
+    }
+    return provider;
+}
+function optionalTokenFree(value, emptyMessage) {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new CapacityUsageError(emptyMessage);
+    if (PROVIDER_TOKEN_LEAK.test(trimmed))
+        throw new CapacityUsageError("value was refused");
+    return trimmed;
+}
+function parseReset(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed || PROVIDER_TOKEN_LEAK.test(trimmed)) {
+        throw new CapacityUsageError("--resets-at must be a UTC timestamp or epoch");
+    }
+    if (/^\d+(\.\d+)?$/.test(trimmed)) {
+        const value = Number(trimmed);
+        if (!Number.isFinite(value))
+            throw new CapacityUsageError(`--resets-at must be a UTC timestamp or epoch, got '${trimmed}'`);
+        const ms = value < 1e12 ? value * 1000 : value;
+        const date = new Date(ms);
+        if (Number.isNaN(date.getTime())) {
+            throw new CapacityUsageError(`--resets-at must be a UTC timestamp or epoch, got '${trimmed}'`);
+        }
+        return date.toISOString();
+    }
+    const parsed = Date.parse(trimmed);
+    if (Number.isNaN(parsed)) {
+        throw new CapacityUsageError(`--resets-at must be a UTC timestamp or epoch, got '${trimmed}'`);
+    }
+    return new Date(parsed).toISOString();
+}
+function loadView(options) {
+    try {
+        return readNow(options);
+    }
+    catch (err) {
+        if (err instanceof LedgerMissing)
+            return null;
+        if (err instanceof LedgerCorrupt)
+            return rebuildNow(options);
+        throw err;
+    }
+}
+function selectLimit(view, provider, limitId, accountId) {
+    const limits = view?.providers.find((entry) => entry.provider === provider)?.limits ?? [];
+    const scoped = accountId ? limits.filter((limit) => limit.accountId === accountId) : limits;
+    if (limitId)
+        return scoped.find((limit) => limit.limitId === limitId) ?? null;
+    return scoped.find((limit) => limit.kind === "weekly_all") ?? null;
+}
+function buildReading(input) {
+    const matched = input.matched;
+    const kind = matched?.kind ?? (input.limitId === REFUSAL_DEFAULT_LIMIT_ID ? "weekly_all" : "unknown");
+    const reading = {
+        readingId: readingId(input.provider, input.accountId, input.limitId, input.observedAt, input.resetsAt),
+        observedAt: input.observedAt,
+        provider: input.provider,
+        accountId: input.accountId,
+        source: "refusal",
+        cliVersion: matched?.cliVersion ?? "unknown",
+        confidence: "inferred",
+        parserVersion: REFUSAL_PARSER_VERSION,
+        limit: {
+            limitId: input.limitId,
+            kind,
+            scope: matched?.scope ?? null,
+            usedPercent: null,
+            windowMinutes: matched?.windowMinutes ?? null,
+            resetsAt: input.resetsAt,
+            balance: matched?.balance ?? null,
+            planType: matched?.planType ?? null,
+        },
+    };
+    if (matched?.hasCredits !== undefined)
+        reading.limit.hasCredits = matched.hasCredits;
+    if (matched?.unlimited !== undefined)
+        reading.limit.unlimited = matched.unlimited;
+    if (matched?.allowancePercentOfWeekly !== undefined) {
+        reading.limit.allowancePercentOfWeekly = matched.allowancePercentOfWeekly;
+    }
+    return reading;
+}
+function readingId(provider, accountId, limitId, observedAt, resetsAt) {
+    const digest = createHash("sha256")
+        .update([provider, accountId, limitId, observedAt, resetsAt ?? ""].join("\0"), "utf8")
+        .digest("hex")
+        .slice(0, 20);
+    return `rdg_${digest}`;
+}
+//# sourceMappingURL=refusal.js.map

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

@@ -0,0 +1,76 @@
+import { ingestCodexResult, isCodexProcessRunning, latestCodexSessionWriteAt, readCodexAppServer, readInstalledCodexVersion, shouldReadAppServer, tailCodexSessions } from "./collectors/codex.js";
+import { consumeClaudeStatuslineSpool } from "./collectors/claude-statusline.js";
+import { collectClaudeOAuth } from "./collectors/claude-oauth.js";
+import { collectGrok } from "./collectors/grok.js";
+export declare const ENABLE_TICK_MS = 60000;
+export declare const REBUILD_TICK_MS = 60000;
+export declare const POLL_TICK_MS: number;
+export declare const CODEX_DIR_POLL_MS = 15000;
+export declare const SPOOL_POLL_MS = 15000;
+export interface CapacityTimers {
+    setTimeout(fn: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+export interface CapacityWatch {
+    close(): void;
+    on?(event: "error", listener: (err: unknown) => void): unknown;
+}
+export type CapacityWatchFn = (target: string, options: {
+    persistent?: boolean;
+    recursive?: boolean;
+}, listener: (event: string, filename: string | Buffer | null) => void) => CapacityWatch;
+export interface CapacitySentryEvent {
+    provider: string;
+    source: string;
+    cliVersion: string;
+}
+export interface CapacityCollectors {
+    tailCodexSessions: typeof tailCodexSessions;
+    ingestCodexResult: typeof ingestCodexResult;
+    shouldReadAppServer: typeof shouldReadAppServer;
+    isCodexProcessRunning: typeof isCodexProcessRunning;
+    readCodexAppServer: typeof readCodexAppServer;
+    latestCodexSessionWriteAt: typeof latestCodexSessionWriteAt;
+    readInstalledCodexVersion: typeof readInstalledCodexVersion;
+    consumeClaudeStatuslineSpool: typeof consumeClaudeStatuslineSpool;
+    collectClaudeOAuth: typeof collectClaudeOAuth;
+    collectGrok: typeof collectGrok;
+    readInstalledClaudeVersion: () => string | Promise<string>;
+    readInstalledGrokVersion: () => string | Promise<string>;
+}
+export interface StartCapacitySchedulerOptions {
+    timers: CapacityTimers;
+    root: string;
+    collectors?: Partial<CapacityCollectors>;
+    now?: () => Date;
+    log?: (line: string) => void;
+    home?: string;
+    sessionsDir?: string;
+    watch?: CapacityWatchFn;
+    /** When omitted, recursive fs.watch is used on darwin and win32. */
+    recursive?: boolean;
+    ps?: () => string;
+    sentry?: (event: CapacitySentryEvent) => void;
+    selfTest?: (provider: string, version: string) => void | {
+        ok: boolean;
+    };
+    /**
+     * Production daemon sets this. Tests omit it and keep the single default
+     * home, so collector mocks stay one call per provider.
+     */
+    enumerateAccounts?: boolean;
+    /** HQ root that holds personal/lanes/config.json. */
+    hqRoot?: string;
+}
+export interface CapacitySchedulerHandle {
+    stop: () => void;
+    ticks: () => number;
+}
+export declare function defaultCodexSessionsDir(home?: string): string;
+export declare function capacityFixtureDir(): string;
+/** Parse the pinned fixtures once. Missing fixtures are a skip, not a failure. */
+export declare function runParserSelfTest(provider: string, version: string, fixturesDir?: string): {
+    ok: boolean;
+};
+export declare function startCapacityScheduler(options: StartCapacitySchedulerOptions): CapacitySchedulerHandle;
+//# sourceMappingURL=scheduler.d.ts.map