@indigoai-us/hq-cli 5.345.92 → 5.345.93

package/dist/lib/capacity/collectors/codex.js

@@ -0,0 +1,1134 @@
+/**
+ * Codex capacity collector for the resident daemon (US-008 calls these;
+ * this module does not start the daemon).
+ *
+ * The session JSONL tail is the primary feed: server-reported token_count
+ * rate limits, resumed by byte offset. The app-server read is a live
+ * account/rateLimits/read after initialize. That method does not refresh
+ * tokens. Starting the app-server process can still rewrite
+ * ~/.codex/auth.json for a managed ChatGPT login, so the read stays
+ * idle-gated. It never starts a thread, never sends a prompt, and never
+ * opens the Codex credential file.
+ */
+import * as crypto from "node:crypto";
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { appendReadings, BURN_WINDOW_MS, redactProviderTokens, } from "../ledger.js";
+export const CODEX_PARSER_VERSION = "codex.1";
+export const CODEX_IDLE_MS = 30 * 60 * 1000;
+export const CODEX_APP_SERVER_TIMEOUT_MS = 20_000;
+export const CODEX_APP_SERVER_BACKOFF_MS = 60 * 60 * 1000;
+export const CODEX_PROVIDER = "codex";
+const ALLOWED_METHODS = new Set(["initialize", "initialized", "account/rateLimits/read"]);
+const LOCAL_ACCOUNT = "codex-local";
+/** Bytes before the cursor offset that identify the file content. */
+const CURSOR_MARK_BYTES = 64;
+export function hashAccountId(raw) {
+    const digest = crypto.createHash("sha256").update(raw, "utf8").digest("hex").slice(0, 16);
+    return `acct_${digest}`;
+}
+export function hashCreditId(raw) {
+    const digest = crypto.createHash("sha256").update(`credit\0${raw}`, "utf8").digest("hex").slice(0, 16);
+    return `credit_${digest}`;
+}
+export function parseCodexCliVersion(text) {
+    const match = /\b(\d+\.\d+\.\d+)\b/.exec(text);
+    return match?.[1] ?? null;
+}
+/** Idle at least 30 minutes and no codex process. A missing session write counts as idle. */
+export function shouldReadAppServer(input) {
+    if (input.codexProcessRunning)
+        return false;
+    if (input.lastSessionWriteAt === null)
+        return true;
+    return input.now - input.lastSessionWriteAt >= CODEX_IDLE_MS;
+}
+/** True when a process listing shows a `codex` executable, not a directory named codex. */
+export function isCodexProcessRunning(psOutput) {
+    return psOutput.split("\n").some((line) => /(?:^|[\s/])codex(?:\s|$)/.test(line.trim()));
+}
+export function latestCodexSessionWriteAt(sessionsDir, recentDays) {
+    let latest = null;
+    for (const file of listSessionFiles(sessionsDir, recentDays)) {
+        if (latest === null || file.mtimeMs > latest)
+            latest = file.mtimeMs;
+    }
+    return latest;
+}
+export function defaultCodexSpawn(command, args, env) {
+    const child = spawn(command, [...args], { stdio: ["pipe", "pipe", "ignore"], env });
+    child.on("error", () => undefined);
+    child.stdin?.on("error", () => undefined);
+    if (!child.stdin || !child.stdout) {
+        child.kill("SIGTERM");
+        throw new Error("codex stdio unavailable");
+    }
+    return {
+        stdin: child.stdin,
+        stdout: child.stdout,
+        pid: child.pid,
+        kill(signal = "SIGTERM") {
+            child.kill(signal);
+        },
+        once(event, listener) {
+            if (event === "exit") {
+                child.once("exit", (code, signal) => listener(code, signal));
+                return;
+            }
+            child.once("error", (error) => listener(error));
+        },
+    };
+}
+export async function readInstalledCodexVersion(spawnImpl = defaultCodexSpawn) {
+    let child;
+    try {
+        child = spawnImpl("codex", ["--version"]);
+    }
+    catch {
+        return "unknown";
+    }
+    const text = await new Promise((resolve) => {
+        let buf = "";
+        let done = false;
+        const timer = setTimeout(finish, 5_000);
+        timer.unref();
+        function finish() {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve(buf);
+        }
+        child.stdout.on("data", (chunk) => {
+            buf += String(chunk);
+        });
+        child.once?.("error", () => finish());
+        child.once?.("exit", () => finish());
+    });
+    shutdownChild(child);
+    return parseCodexCliVersion(text) ?? "unknown";
+}
+export function tailCodexSessions(options) {
+    const now = options.now ?? new Date();
+    const windowStart = now.getTime() - BURN_WINDOW_MS;
+    const recentDays = options.recentDays;
+    const previous = options.state?.files ?? {};
+    const cursorExists = Object.keys(previous).length > 0;
+    const candidates = listSessionFiles(options.sessionsDir, recentDays)
+        .sort((a, b) => b.mtimeMs - a.mtimeMs || a.file.localeCompare(b.file));
+    const next = {};
+    const readings = [];
+    const failures = [];
+    const latest = new Map();
+    const emittedAt = new Map();
+    let bestEventMs = Number.NEGATIVE_INFINITY;
+    const accountId = hashAccountId(options.accountId ?? (options.accountHome ? `home:${path.resolve(options.accountHome)}` : LOCAL_ACCOUNT));
+    const consider = (parsed, emit) => {
+        if (emit) {
+            readings.push(...parsed.readings);
+            failures.push(...parsed.failures);
+        }
+        for (const reading of parsed.readings) {
+            const at = Date.parse(reading.observedAt);
+            if (Number.isNaN(at))
+                continue;
+            if (at > bestEventMs)
+                bestEventMs = at;
+            const prev = latest.get(reading.limit.limitId);
+            if (!prev || at >= prev.at)
+                latest.set(reading.limit.limitId, { reading, at });
+            if (emit) {
+                const seen = emittedAt.get(reading.limit.limitId) ?? Number.NEGATIVE_INFINITY;
+                if (at >= seen)
+                    emittedAt.set(reading.limit.limitId, at);
+            }
+        }
+    };
+    for (const cand of candidates) {
+        const prior = previous[cand.file];
+        const sameInode = Boolean(prior && prior.ino === cand.ino && prior.dev === cand.dev && cand.size >= prior.offset);
+        const olderThanWindow = cand.mtimeMs < windowStart;
+        const latestSettled = bestEventMs > Number.NEGATIVE_INFINITY && bestEventMs >= cand.mtimeMs;
+        if (olderThanWindow && (cursorExists || latestSettled)) {
+            // Not read this pass, so the cursor is carried forward unverified.
+            if (sameInode && prior) {
+                next[cand.file] = { ...prior, ino: cand.ino, dev: cand.dev };
+            }
+            continue;
+        }
+        const hasCursor = Boolean(prior && sameInode && cursorMarkMatches(cand.file, prior));
+        if (hasCursor && prior && cand.size === prior.offset) {
+            next[cand.file] = { ...prior, ino: cand.ino, dev: cand.dev };
+            continue;
+        }
+        const bootstrap = !hasCursor;
+        const chunk = bootstrap
+            ? readBootstrapSlice(cand.file, cand.size, {
+                stopBeforeMs: olderThanWindow ? null : windowStart,
+                newestTokenOnly: olderThanWindow,
+            })
+            : readCompleteLines(cand.file, prior?.offset ?? 0, cand.size);
+        next[cand.file] = {
+            offset: chunk.nextOffset,
+            ino: cand.ino,
+            dev: cand.dev,
+            mark: cursorMark(cand.file, chunk.nextOffset),
+        };
+        const mtimeIso = new Date(cand.mtimeMs).toISOString();
+        for (const line of chunk.lines) {
+            const parsed = parseSessionLine(line.text, {
+                source: "codex-jsonl",
+                cliVersion: options.cliVersion,
+                observedAt: mtimeIso,
+                accountId,
+                readingSalt: `${cand.file}\0${line.byteOffset}`,
+                accountLabel: options.accountLabel,
+                accountLabels: options.accountLabels,
+                accountHome: options.accountHome,
+            });
+            if (!parsed)
+                continue;
+            if (!bootstrap) {
+                consider(parsed, true);
+                continue;
+            }
+            const at = resultAt(parsed);
+            consider(parsed, at !== null && at >= windowStart);
+        }
+    }
+    for (const [limitId, item] of latest) {
+        const emitted = emittedAt.get(limitId);
+        if (emitted === undefined || item.at > emitted)
+            readings.push(item.reading);
+    }
+    return { readings, failures, providerMeta: null, state: { files: next } };
+}
+/** Map an account/rateLimits/read result. Does not spawn. */
+export function mapCodexAppServerBody(body, options) {
+    const now = options.now ?? new Date();
+    const observedAt = now.toISOString();
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+        return {
+            readings: [],
+            failures: [failureEvent({
+                    observedAt,
+                    source: "codex-app-server",
+                    cliVersion: options.cliVersion,
+                    accountId: hashAccountId(options.accountId ?? LOCAL_ACCOUNT),
+                    error: "codex app-server rate limit payload drifted",
+                })],
+            providerMeta: null,
+        };
+    }
+    const record = body;
+    const rawAccount = typeof record.accountId === "string" && record.accountId.trim()
+        ? record.accountId
+        : options.accountId ?? (options.accountHome ? `home:${path.resolve(options.accountHome)}` : LOCAL_ACCOUNT);
+    const accountId = hashAccountId(rawAccount);
+    const mapped = mapRateLimitCarrier(record, {
+        source: "codex-app-server",
+        cliVersion: options.cliVersion,
+        observedAt,
+        accountId,
+        readingSalt: `app-server\0${observedAt}`,
+        accountLabel: options.accountLabel,
+        accountLabels: options.accountLabels,
+        accountHome: options.accountHome,
+    }, { missingLimitsAreDrift: true });
+    const ordinary = pickBool(record, ["ordinaryUsageAllowed"]);
+    const reset = mapResetCredits(record.rateLimitResetCredits ?? record.rate_limit_reset_credits);
+    if (ordinary.drifted) {
+        mapped.failures.push(failureEvent({
+            observedAt,
+            source: "codex-app-server",
+            cliVersion: options.cliVersion,
+            accountId,
+            error: "codex field drift: ordinaryUsageAllowed",
+        }));
+    }
+    if (reset.drifted) {
+        mapped.failures.push(failureEvent({
+            observedAt,
+            source: "codex-app-server",
+            cliVersion: options.cliVersion,
+            accountId,
+            error: "codex field drift: rateLimitResetCredits",
+        }));
+    }
+    return {
+        readings: mapped.readings,
+        failures: mapped.failures,
+        providerMeta: {
+            observedAt,
+            source: "codex-app-server",
+            cliVersion: options.cliVersion,
+            accountId,
+            ordinaryUsageAllowed: ordinary.drifted ? null : ordinary.value,
+            rateLimitResetCredits: reset.drifted ? null : reset.value,
+        },
+    };
+}
+export async function readCodexAppServer(options) {
+    const timeoutMs = options.timeoutMs ?? CODEX_APP_SERVER_TIMEOUT_MS;
+    const accountId = options.accountId ?? (options.home ? `home:${path.resolve(options.home)}` : undefined);
+    const spawnImpl = options.spawn ?? defaultCodexSpawn;
+    const command = options.command ?? "codex";
+    let child = null;
+    try {
+        try {
+            const env = options.home ? { ...process.env, CODEX_HOME: options.home } : undefined;
+            child = spawnImpl(command, ["app-server", "--stdio"], env);
+        }
+        catch {
+            return transportFailure("spawn-failed", options);
+        }
+        const rpc = await exchangeRateLimits(child, timeoutMs, options.signal);
+        if (!rpc.ok)
+            return transportFailure(rpc.reason, options);
+        const mapped = mapCodexAppServerBody(rpc.result, {
+            cliVersion: options.cliVersion,
+            now: options.now,
+            accountId,
+            accountLabel: options.accountLabel,
+            accountLabels: options.accountLabels,
+            accountHome: options.accountHome ?? options.home,
+        });
+        return { ok: true, ...mapped };
+    }
+    finally {
+        if (child)
+            shutdownChild(child);
+    }
+}
+export function ingestCodexResult(result, options) {
+    if (result.readings.length === 0 && result.failures.length === 0 && !result.providerMeta)
+        return null;
+    const meta = result.providerMeta
+        ? {
+            event: "provider_meta",
+            observedAt: result.providerMeta.observedAt,
+            provider: CODEX_PROVIDER,
+            source: result.providerMeta.source,
+            ordinaryUsageAllowed: result.providerMeta.ordinaryUsageAllowed,
+            rateLimitResetCredits: result.providerMeta.rateLimitResetCredits,
+            accountId: result.providerMeta.accountId,
+            cliVersion: result.providerMeta.cliVersion,
+            parserVersion: CODEX_PARSER_VERSION,
+        }
+        : null;
+    return appendReadings(result.readings, result.failures, meta, options);
+}
+function transportFailure(reason, options) {
+    const raw = options?.accountId ?? (options?.home ? `home:${path.resolve(options.home)}` : undefined);
+    const failures = [];
+    if (raw && options?.cliVersion) {
+        failures.push(failureEvent({
+            observedAt: (options.now ?? new Date()).toISOString(),
+            source: "codex-app-server",
+            cliVersion: options.cliVersion,
+            accountId: hashAccountId(raw),
+            error: `unavailable: ${reason}`,
+            accountLabel: options.accountLabel,
+            accountLabels: options.accountLabels,
+            accountHome: options.accountHome ?? options.home,
+        }));
+    }
+    return {
+        ok: false,
+        reason,
+        backoffMs: CODEX_APP_SERVER_BACKOFF_MS,
+        readings: [],
+        failures,
+        providerMeta: null,
+    };
+}
+function exchangeRateLimits(child, timeoutMs, signal) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let buffer = "";
+        let pumping = false;
+        const finish = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        const timer = setTimeout(() => finish({ ok: false, reason: "timeout" }), timeoutMs);
+        if (signal) {
+            if (signal.aborted)
+                finish({ ok: false, reason: "timeout" });
+            else
+                signal.addEventListener("abort", () => finish({ ok: false, reason: "timeout" }), { once: true });
+        }
+        const handle = (line) => {
+            if (settled)
+                return;
+            let message;
+            try {
+                const parsed = JSON.parse(line);
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                    return;
+                message = parsed;
+            }
+            catch {
+                return;
+            }
+            if (message.id === 1) {
+                if (message.error)
+                    finish({ ok: false, reason: "rpc-error" });
+                else {
+                    writeRpc(child, { jsonrpc: "2.0", method: "initialized", params: {} });
+                    writeRpc(child, {
+                        jsonrpc: "2.0",
+                        id: 2,
+                        method: "account/rateLimits/read",
+                        params: {},
+                    });
+                }
+                return;
+            }
+            if (message.id === 2) {
+                if (message.error)
+                    finish({ ok: false, reason: "rpc-error" });
+                else
+                    finish({ ok: true, result: message.result });
+            }
+        };
+        const pump = () => {
+            if (pumping)
+                return;
+            pumping = true;
+            try {
+                while (!settled) {
+                    const nl = buffer.indexOf("\n");
+                    if (nl < 0)
+                        break;
+                    const line = buffer.slice(0, nl).trim();
+                    buffer = buffer.slice(nl + 1);
+                    if (line)
+                        handle(line);
+                }
+            }
+            finally {
+                pumping = false;
+            }
+        };
+        child.stdout.on("data", (chunk) => {
+            buffer += String(chunk);
+            pump();
+        });
+        child.once?.("error", () => finish({ ok: false, reason: "spawn-failed" }));
+        child.once?.("exit", () => finish({ ok: false, reason: "exited" }));
+        try {
+            writeRpc(child, {
+                jsonrpc: "2.0",
+                id: 1,
+                method: "initialize",
+                params: {
+                    clientInfo: { name: "hq-capacity", title: "HQ capacity", version: "1" },
+                    capabilities: { experimentalApi: true },
+                },
+            });
+        }
+        catch {
+            finish({ ok: false, reason: "spawn-failed" });
+        }
+    });
+}
+function writeRpc(child, message) {
+    const method = message.method;
+    if (typeof method !== "string" || !ALLOWED_METHODS.has(method)) {
+        throw new Error("codex app-server method is not a rate-limit read");
+    }
+    child.stdin.on?.("error", () => undefined);
+    try {
+        child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    catch {
+        // EPIPE is reported on the error event. A closed pipe is not a daemon crash.
+    }
+}
+function shutdownChild(child) {
+    try {
+        child.stdin.end();
+    }
+    catch {
+        // The child may already have closed stdin.
+    }
+    try {
+        child.kill("SIGTERM");
+    }
+    catch {
+        // The child may already have exited.
+    }
+    if (typeof child.pid !== "number")
+        return;
+    const timer = setTimeout(() => {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch {
+            // Already gone.
+        }
+    }, 500);
+    timer.unref();
+}
+const TAIL_CHUNK_BYTES = 64 * 1024;
+const TIMESTAMP_PREFIX = /^\{"timestamp":"(\d{4}-\d{2}-\d{2}T[^"]+)"/;
+function listSessionFiles(dir, recentDays) {
+    if (!dir || !fs.existsSync(dir))
+        return [];
+    const out = [];
+    const stack = [dir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isSymbolicLink())
+                continue;
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                if (recentDays !== undefined && skipOldSessionDir(entry.name, full, recentDays))
+                    continue;
+                stack.push(full);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+                continue;
+            try {
+                const stat = fs.statSync(full);
+                out.push({ file: full, mtimeMs: stat.mtimeMs, size: stat.size, ino: stat.ino, dev: stat.dev });
+            }
+            catch {
+                // The file disappeared between readdir and stat.
+            }
+        }
+    }
+    return out;
+}
+function skipOldSessionDir(name, full, recentDays) {
+    if (/^\d{4}$/.test(name) && Number(name) < new Date().getUTCFullYear() - 1)
+        return true;
+    const match = /[/\\](\d{4})[/\\](\d{2})[/\\](\d{2})$/.exec(full);
+    if (!match)
+        return false;
+    const day = Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+    const today = new Date();
+    const start = Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate());
+    return day < start - (recentDays - 1) * 24 * 60 * 60 * 1000;
+}
+function resultAt(parsed) {
+    const stamp = parsed.readings[0]?.observedAt ?? parsed.failures[0]?.observedAt;
+    if (!stamp)
+        return null;
+    const at = Date.parse(stamp);
+    return Number.isNaN(at) ? null : at;
+}
+function lineFacts(text) {
+    const token = text.includes('"type":"token_count"');
+    const match = TIMESTAMP_PREFIX.exec(text);
+    if (!match?.[1])
+        return { ts: null, token };
+    const ts = Date.parse(match[1]);
+    return { ts: Number.isNaN(ts) ? null : ts, token };
+}
+/** Byte offset just past the last complete line, or 0 when the file has no newline. */
+function completeEndOffset(fd, size) {
+    if (size <= 0)
+        return 0;
+    const last = Buffer.alloc(1);
+    if (fs.readSync(fd, last, 0, 1, size - 1) !== 1)
+        return 0;
+    if (last[0] === 0x0a)
+        return size;
+    let pos = size - 1;
+    while (pos > 0) {
+        const start = Math.max(0, pos - TAIL_CHUNK_BYTES);
+        const buf = Buffer.alloc(pos - start);
+        fs.readSync(fd, buf, 0, buf.length, start);
+        const nl = buf.lastIndexOf(0x0a);
+        if (nl >= 0)
+            return start + nl + 1;
+        if (start === 0)
+            return 0;
+        pos = start;
+    }
+    return 0;
+}
+function splitCompleteLines(region, regionOffset) {
+    const lines = [];
+    let rel = 0;
+    for (let i = 0; i < region.length; i += 1) {
+        if (region[i] !== 0x0a)
+            continue;
+        lines.push({
+            text: region.subarray(rel, i).toString("utf8"),
+            byteOffset: regionOffset + rel,
+        });
+        rel = i + 1;
+    }
+    return lines;
+}
+/**
+ * Start offset of the oldest line a first-run read must see: events inside
+ * the burn-rate window, or the newest token_count when the file is older.
+ * The cursor still advances to EOF; this only limits how much history is parsed.
+ */
+function oldestKeptOffset(fd, end, mode) {
+    let pos = end;
+    let span = TAIL_CHUNK_BYTES;
+    let kept = end;
+    let sawToken = false;
+    while (pos > 0) {
+        const readStart = Math.max(0, pos - span);
+        const buf = Buffer.alloc(pos - readStart);
+        fs.readSync(fd, buf, 0, buf.length, readStart);
+        const nl = readStart === 0 ? -1 : buf.indexOf(0x0a);
+        if (readStart > 0 && nl < 0) {
+            const grown = Math.min(span * 2, pos);
+            if (grown === span)
+                break;
+            span = grown;
+            continue;
+        }
+        span = TAIL_CHUNK_BYTES;
+        const lineStart = readStart === 0 ? 0 : nl + 1;
+        const regionOffset = readStart + lineStart;
+        const lines = splitCompleteLines(buf.subarray(lineStart), regionOffset);
+        let stop = false;
+        for (let i = lines.length - 1; i >= 0; i -= 1) {
+            const line = lines[i];
+            if (!line || !line.text.trim())
+                continue;
+            const facts = lineFacts(line.text);
+            if (mode.newestTokenOnly) {
+                if (!facts.token)
+                    continue;
+                kept = line.byteOffset;
+                stop = true;
+                break;
+            }
+            const older = mode.stopBeforeMs !== null && facts.ts !== null && facts.ts < mode.stopBeforeMs;
+            if (older && (sawToken || facts.token)) {
+                if (facts.token)
+                    kept = line.byteOffset;
+                stop = true;
+                break;
+            }
+            if (older)
+                continue;
+            kept = line.byteOffset;
+            if (facts.token)
+                sawToken = true;
+        }
+        if (stop || readStart === 0)
+            break;
+        if (regionOffset >= pos)
+            break;
+        pos = regionOffset;
+    }
+    return kept;
+}
+function locateBootstrapSlice(file, size, mode) {
+    const fd = fs.openSync(file, "r");
+    try {
+        const nextOffset = completeEndOffset(fd, size);
+        if (nextOffset <= 0)
+            return null;
+        return { start: oldestKeptOffset(fd, nextOffset, mode), nextOffset };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function readBootstrapSlice(file, size, mode) {
+    if (size <= 0)
+        return { lines: [], nextOffset: 0 };
+    const located = locateBootstrapSlice(file, size, mode);
+    if (!located || located.start >= located.nextOffset) {
+        return { lines: [], nextOffset: located?.nextOffset ?? 0 };
+    }
+    const chunk = readCompleteLines(file, located.start, size);
+    return { lines: chunk.lines, nextOffset: chunk.nextOffset };
+}
+/** Hash of the bytes before `offset`, or undefined when they cannot be read. */
+function cursorMark(file, offset) {
+    const start = Math.max(0, offset - CURSOR_MARK_BYTES);
+    const buf = Buffer.alloc(offset - start);
+    try {
+        const fd = fs.openSync(file, "r");
+        try {
+            if (fs.readSync(fd, buf, 0, buf.length, start) !== buf.length)
+                return undefined;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return crypto.createHash("sha256").update(buf).digest("hex").slice(0, 16);
+}
+function cursorMarkMatches(file, cursor) {
+    if (cursor.mark === undefined)
+        return true;
+    return cursorMark(file, cursor.offset) === cursor.mark;
+}
+function readCompleteLines(file, offset, size) {
+    if (size < offset)
+        offset = 0;
+    if (size === offset)
+        return { lines: [], nextOffset: offset };
+    const length = size - offset;
+    const buf = Buffer.alloc(length);
+    const fd = fs.openSync(file, "r");
+    try {
+        fs.readSync(fd, buf, 0, length, offset);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    let end = buf.length;
+    if (buf[buf.length - 1] !== 0x0a) {
+        const nl = buf.lastIndexOf(0x0a);
+        if (nl < 0)
+            return { lines: [], nextOffset: offset };
+        end = nl + 1;
+    }
+    const lines = [];
+    let start = 0;
+    for (let i = 0; i < end; i += 1) {
+        if (buf[i] !== 0x0a)
+            continue;
+        lines.push({
+            text: buf.subarray(start, i).toString("utf8"),
+            byteOffset: offset + start,
+        });
+        start = i + 1;
+    }
+    return { lines, nextOffset: offset + end };
+}
+function parseSessionLine(text, ctx) {
+    const trimmed = text.trim();
+    if (!trimmed || !trimmed.includes('"type":"token_count"'))
+        return null;
+    let value;
+    try {
+        value = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const payload = record.payload && typeof record.payload === "object" && !Array.isArray(record.payload)
+        ? record.payload
+        : record;
+    const type = payload.type ?? record.type;
+    if (type !== "token_count")
+        return null;
+    const timed = eventTimeIso(record);
+    const observedAt = timed ?? ctx.observedAt;
+    const next = { ...ctx, observedAt };
+    if (!timed)
+        next.confidence = "inferred";
+    return mapRateLimitCarrier(payload, next, { missingLimitsAreDrift: false });
+}
+function mapRateLimitCarrier(payload, ctx, mode) {
+    const readings = [];
+    const failures = [];
+    const byId = payload.rateLimitsByLimitId ?? payload.rate_limits_by_limit_id;
+    const single = payload.rateLimits ?? payload.rate_limits;
+    if (byId == null && single == null) {
+        if (mode.missingLimitsAreDrift) {
+            failures.push(failureEvent({
+                ...ctx,
+                error: "codex field drift: rateLimits missing",
+            }));
+        }
+        return { readings, failures, providerMeta: null };
+    }
+    const snapshots = new Map();
+    if (byId != null) {
+        if (typeof byId !== "object" || Array.isArray(byId)) {
+            failures.push(failureEvent({ ...ctx, error: "codex field drift: rateLimitsByLimitId" }));
+        }
+        else {
+            for (const [key, value] of Object.entries(byId)) {
+                const snap = asSnapshot(value, key);
+                if (!snap) {
+                    failures.push(failureEvent({
+                        ...ctx,
+                        limitId: key,
+                        error: `codex field drift: rate limit ${key}`,
+                    }));
+                    continue;
+                }
+                snapshots.set(snap.limitId, snap);
+            }
+        }
+    }
+    if (single != null && (typeof single !== "object" || Array.isArray(single))) {
+        failures.push(failureEvent({ ...ctx, error: "codex field drift: rate_limits" }));
+    }
+    else if (single != null) {
+        const snap = asSnapshot(single, "codex");
+        if (!snap) {
+            failures.push(failureEvent({ ...ctx, error: "codex field drift: rate_limits" }));
+        }
+        else if (!snapshots.has(snap.limitId)) {
+            snapshots.set(snap.limitId, snap);
+        }
+    }
+    for (const snap of snapshots.values()) {
+        emitSnapshot(snap, ctx, readings, failures);
+    }
+    return { readings, failures, providerMeta: null };
+}
+function emitSnapshot(snap, ctx, readings, failures) {
+    if (snap.reached.drifted) {
+        failures.push(failureEvent({
+            ...ctx,
+            limitId: snap.limitId,
+            error: `codex field drift: rate_limit_reached_type on ${snap.limitId}`,
+        }));
+    }
+    if (snap.spend.drifted) {
+        failures.push(failureEvent({
+            ...ctx,
+            limitId: snap.limitId,
+            error: `codex field drift: spend_control_reached on ${snap.limitId}`,
+        }));
+    }
+    for (const which of ["primary", "secondary"]) {
+        const window = which === "primary" ? snap.primary : snap.secondary;
+        const emitted = emitWindow(snap, which, window, ctx);
+        if (!emitted)
+            continue;
+        if ("event" in emitted)
+            failures.push(emitted);
+        else
+            readings.push(emitted);
+    }
+    const credits = emitCredits(snap, ctx);
+    if (credits) {
+        if ("event" in credits)
+            failures.push(credits);
+        else
+            readings.push(credits);
+    }
+    const individual = emitIndividual(snap, ctx);
+    if (individual) {
+        if ("event" in individual)
+            failures.push(individual);
+        else
+            readings.push(individual);
+    }
+}
+function emitWindow(snap, which, window, ctx) {
+    if (window == null)
+        return null;
+    const limitId = `${snap.limitId}:${which}`;
+    if (typeof window !== "object" || Array.isArray(window)) {
+        return failureEvent({
+            ...ctx,
+            limitId,
+            error: `codex field drift: ${limitId} shape`,
+        });
+    }
+    const record = window;
+    const used = pickNumber(record, ["usedPercent", "used_percent"]);
+    const resets = pickNumber(record, ["resetsAt", "resets_at"]);
+    const minutes = pickNumber(record, ["windowDurationMins", "window_minutes", "windowMinutes"]);
+    const missing = [];
+    if (used.value === undefined || used.presentNull)
+        missing.push("usedPercent");
+    if (resets.value === undefined || resets.presentNull)
+        missing.push("resetsAt");
+    if (missing.length > 0) {
+        return failureEvent({
+            ...ctx,
+            limitId,
+            error: `codex field drift: missing ${missing.join(" and ")} on ${limitId}`,
+        });
+    }
+    return makeReading(ctx, snap, {
+        limitId,
+        kind: kindForMinutes(minutes.value ?? null),
+        scope: scopeFor(snap),
+        usedPercent: used.value ?? null,
+        windowMinutes: minutes.value ?? null,
+        resetsAt: resets.value ?? null,
+        balance: null,
+        planType: snap.planType,
+    });
+}
+function emitCredits(snap, ctx) {
+    if (snap.credits == null)
+        return null;
+    const limitId = `${snap.limitId}:credits`;
+    if (typeof snap.credits !== "object" || Array.isArray(snap.credits)) {
+        return failureEvent({ ...ctx, limitId, error: `codex field drift: ${limitId} shape` });
+    }
+    const record = snap.credits;
+    const hasCredits = pickBool(record, ["hasCredits", "has_credits"]);
+    const unlimited = pickBool(record, ["unlimited"]);
+    const balance = pickBalance(record);
+    if (!hasCredits.set && !unlimited.set && !balance.set) {
+        return failureEvent({ ...ctx, limitId, error: `codex field drift: ${limitId}` });
+    }
+    return makeReading(ctx, snap, {
+        limitId,
+        kind: "credits",
+        scope: scopeFor(snap),
+        usedPercent: null,
+        windowMinutes: null,
+        resetsAt: null,
+        balance: balance.value,
+        planType: snap.planType,
+        hasCredits: hasCredits.value,
+        unlimited: unlimited.value,
+    });
+}
+function emitIndividual(snap, ctx) {
+    if (snap.individual == null)
+        return null;
+    const limitId = `${snap.limitId}:individual`;
+    if (typeof snap.individual !== "object" || Array.isArray(snap.individual)) {
+        return failureEvent({ ...ctx, limitId, error: `codex field drift: ${limitId} shape` });
+    }
+    const record = snap.individual;
+    const used = pickNumber(record, ["used", "usedPercent", "used_percent"]);
+    const limit = pickNumber(record, ["limit"]);
+    const resets = pickNumber(record, ["resetsAt", "resets_at"]);
+    if (used.value === undefined && limit.value === undefined && resets.value === undefined) {
+        return failureEvent({ ...ctx, limitId, error: `codex field drift: ${limitId}` });
+    }
+    let usedPercent = null;
+    if (typeof used.value === "number" && typeof limit.value === "number" && limit.value > 0) {
+        usedPercent = (used.value / limit.value) * 100;
+    }
+    else if (typeof used.value === "number") {
+        usedPercent = used.value;
+    }
+    return makeReading(ctx, snap, {
+        limitId,
+        kind: "unknown",
+        scope: scopeFor(snap),
+        usedPercent,
+        windowMinutes: null,
+        resetsAt: resets.value ?? null,
+        balance: limit.value ?? null,
+        planType: snap.planType,
+    });
+}
+function makeReading(ctx, snap, limit) {
+    const reading = {
+        readingId: makeReadingId([ctx.source, ctx.readingSalt, ctx.accountId, limit.limitId, ctx.observedAt]),
+        observedAt: ctx.observedAt,
+        provider: CODEX_PROVIDER,
+        accountId: ctx.accountId,
+        source: ctx.source,
+        cliVersion: ctx.cliVersion,
+        confidence: ctx.confidence ?? confidenceFor(ctx.source),
+        parserVersion: CODEX_PARSER_VERSION,
+        limit,
+    };
+    if (snap.reached.set && !snap.reached.drifted)
+        reading.rateLimitReachedType = snap.reached.value;
+    if (snap.spend.set && !snap.spend.drifted)
+        reading.spendControlReached = snap.spend.value;
+    if (ctx.accountLabel) {
+        reading.accountLabel = ctx.accountLabel;
+        reading.accountLabels = ctx.accountLabels ? [...ctx.accountLabels] : [ctx.accountLabel];
+        if (ctx.accountHome)
+            reading.accountHome = ctx.accountHome;
+    }
+    return reading;
+}
+function asSnapshot(value, fallbackId) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const limitId = stringField(record, ["limitId", "limit_id"]) ?? fallbackId;
+    if (!limitId.trim())
+        return null;
+    return {
+        limitId,
+        limitName: stringField(record, ["limitName", "limit_name"]),
+        planType: stringField(record, ["planType", "plan_type"]),
+        reached: pickString(record, ["rateLimitReachedType", "rate_limit_reached_type"]),
+        spend: pickBool(record, ["spendControlReached", "spend_control_reached"]),
+        primary: record.primary,
+        secondary: record.secondary,
+        credits: record.credits,
+        individual: record.individualLimit ?? record.individual_limit,
+    };
+}
+function mapResetCredits(value) {
+    if (value == null)
+        return { value: null, drifted: false };
+    if (typeof value !== "object" || Array.isArray(value))
+        return { value: null, drifted: true };
+    const record = value;
+    const available = pickNumber(record, ["availableCount"]);
+    if (available.presentNull)
+        return { value: null, drifted: true };
+    const rows = record.credits;
+    const credits = [];
+    if (rows != null && !Array.isArray(rows))
+        return { value: null, drifted: true };
+    if (Array.isArray(rows)) {
+        for (const row of rows) {
+            if (!row || typeof row !== "object" || Array.isArray(row))
+                continue;
+            const item = row;
+            const rawId = typeof item.id === "string" && item.id.trim() ? item.id : "missing";
+            credits.push({
+                id: hashCreditId(rawId),
+                resetType: stringField(item, ["resetType"]),
+                status: stringField(item, ["status"]),
+                grantedAt: pickNumber(item, ["grantedAt"]).value ?? null,
+                expiresAt: pickNumber(item, ["expiresAt"]).value ?? null,
+                title: redactText(stringField(item, ["title"])),
+                description: redactText(stringField(item, ["description"])),
+            });
+        }
+    }
+    return {
+        value: { availableCount: available.value ?? null, credits },
+        drifted: false,
+    };
+}
+function failureEvent(input) {
+    const event = {
+        event: "parser_failure",
+        observedAt: input.observedAt,
+        provider: CODEX_PROVIDER,
+        source: input.source,
+        error: input.error,
+        accountId: input.accountId,
+        cliVersion: input.cliVersion,
+        parserVersion: CODEX_PARSER_VERSION,
+    };
+    if (input.limitId)
+        event.limitId = input.limitId;
+    if (input.accountLabel) {
+        event.accountLabel = input.accountLabel;
+        event.accountLabels = input.accountLabels ? [...input.accountLabels] : [input.accountLabel];
+        if (input.accountHome)
+            event.accountHome = input.accountHome;
+    }
+    return event;
+}
+function eventTimeIso(record) {
+    const ts = record.timestamp;
+    let ms = null;
+    if (typeof ts === "string") {
+        const parsed = Date.parse(ts);
+        ms = Number.isNaN(parsed) ? null : parsed;
+    }
+    else if (typeof ts === "number" && Number.isFinite(ts)) {
+        ms = Math.abs(ts) < 1e12 ? ts * 1000 : ts;
+    }
+    if (ms === null)
+        return null;
+    const date = new Date(ms);
+    if (Number.isNaN(date.getTime()))
+        return null;
+    return date.toISOString();
+}
+function kindForMinutes(mins) {
+    if (mins === null)
+        return "unknown";
+    if (mins <= 24 * 60)
+        return "session";
+    if (mins <= 10 * 24 * 60)
+        return "weekly_all";
+    return "unknown";
+}
+function scopeFor(snap) {
+    return snap.limitName;
+}
+function confidenceFor(source) {
+    return source === "codex-jsonl" ? "observed" : "fetched";
+}
+function makeReadingId(parts) {
+    const digest = crypto.createHash("sha256").update(parts.join("\0"), "utf8").digest("hex").slice(0, 20);
+    return `rdg_${digest}`;
+}
+function stringField(record, keys) {
+    for (const key of keys) {
+        if (!(key in record))
+            continue;
+        const value = record[key];
+        if (typeof value === "string" && value.trim())
+            return value;
+        return null;
+    }
+    return null;
+}
+function pickNumber(record, keys) {
+    for (const key of keys) {
+        if (!(key in record))
+            continue;
+        const value = record[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return { value, presentNull: false };
+        return { value: undefined, presentNull: true };
+    }
+    return { value: undefined, presentNull: false };
+}
+function pickBool(record, keys) {
+    for (const key of keys) {
+        if (!(key in record))
+            continue;
+        const value = record[key];
+        if (typeof value === "boolean")
+            return { set: true, value, drifted: false };
+        if (value === null)
+            return { set: true, value: null, drifted: false };
+        return { set: true, value: null, drifted: true };
+    }
+    return { set: false, value: null, drifted: false };
+}
+function pickString(record, keys) {
+    for (const key of keys) {
+        if (!(key in record))
+            continue;
+        const value = record[key];
+        if (typeof value === "string")
+            return { set: true, value, drifted: false };
+        if (value === null)
+            return { set: true, value: null, drifted: false };
+        return { set: true, value: null, drifted: true };
+    }
+    return { set: false, value: null, drifted: false };
+}
+function pickBalance(record) {
+    if (!("balance" in record))
+        return { set: false, value: null };
+    const value = record.balance;
+    if (typeof value === "string" || (typeof value === "number" && Number.isFinite(value))) {
+        return { set: true, value };
+    }
+    return { set: true, value: null };
+}
+function redactText(value) {
+    if (value === null)
+        return null;
+    return redactProviderTokens(value);
+}
+//# sourceMappingURL=codex.js.map