@cortexkit/opencode-openai-auth 1.2.0 → 1.4.0

package/src/tui-compiled/runtime/shared/375d9cca2def037d-private-files.js

@@ -184,19 +184,25 @@ export async function replaceWindowsFile(from, to, options = {}) {
     to = resolve(to);
     const now = options.now ?? (() => performance.now());
     const start = now();
-    const deadline = Math.min(start + 500, options.deadline ?? Infinity);
+    const leaseDeadline = options.deadline ?? Infinity;
+    let retryDeadline;
     const delays = [0, 10, 20, 40, 80, 100];
     let original;
     let attempts = 0;
     for (const delay of delays) {
+        const deadline = Math.min(retryDeadline ?? Infinity, leaseDeadline);
         if (now() >= deadline)
             break;
         if (delay)
             await (options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))))(Math.min(delay, Math.max(0, deadline - now())));
         if (now() >= deadline)
             break;
+        const fenceStart = now();
         await options.beforeRename?.();
-        if (now() >= deadline)
+        // Ownership checks fence every attempt but do not spend the sharing-retry budget.
+        if (retryDeadline !== undefined)
+            retryDeadline += now() - fenceStart;
+        if (now() >= leaseDeadline)
             break;
         attempts++;
         try {
@@ -212,6 +218,8 @@ export async function replaceWindowsFile(from, to, options = {}) {
                     !detail.reason;
             if (!candidate)
                 break;
+            // Start the retry window only once a rename has actually failed.
+            retryDeadline ??= now() + 500;
         }
     }
     const error = new PrivateFileError(to, 'rename', original ??

package/src/tui-compiled/runtime/shared/39c3cb05738fcf6d-projection.js

@@ -6,7 +6,7 @@
 // scope, orders the result the way the primitives expect, and carries each
 // entry's (scope, label) so a decision names the limit it judged rather than
 // the position it occupied.
-import { ALL_SCOPE, readQuotaCounters, } from "./905bffc0220f43d0-map.js";
+import { ALL_SCOPE, isQuotaCredits, readQuotaCounters, } from "./905bffc0220f43d0-map.js";
 function project(entry) {
     if (entry.kind === 'retired') {
         return {
@@ -95,12 +95,14 @@ export function projectQuota(map, scope = ALL_SCOPE) {
         : undefined;
     const budget = map?.budget?.kind === 'reading' ? projectBudget(map.budget) : undefined;
     const counters = readQuotaCounters(map?.counters);
+    const credits = isQuotaCredits(map?.credits) ? map.credits : undefined;
     return {
         scope,
         limits,
         ...(checkedAt === undefined ? {} : { checkedAt }),
         ...(budget === undefined ? {} : { budget }),
         ...(counters === undefined ? {} : { counters }),
+        ...(credits === undefined ? {} : { credits }),
     };
 }
 /**

package/src/tui-compiled/runtime/shared/42ae93ab554fcec2-open-url.js

@@ -1,8 +1,5 @@
-import {
-  execFileSync as defaultExecFileSync,
-  spawn as defaultSpawn
-} from "node:child_process";
-export function openUrl(url, platform = process.platform, execFileSync = defaultExecFileSync, spawn = defaultSpawn) {
+import { spawn as defaultSpawn } from "node:child_process";
+export function openUrl(url, platform = process.platform, spawn = defaultSpawn) {
   try {
     if (platform === "win32") {
       const command = `Start-Process '${url.replaceAll("'", "''")}'`, encodedCommand = Buffer.from(command, "utf16le").toString("base64"), child = spawn("powershell.exe", [
@@ -17,11 +14,12 @@ export function openUrl(url, platform = process.platform, execFileSync = default
       child.unref();
       return child.pid !== void 0;
     }
-    execFileSync(platform === "darwin" ? "open" : "xdg-open", [url], {
-      stdio: "ignore",
-      timeout: 3000
+    const child = spawn(platform === "darwin" ? "open" : "xdg-open", [url], {
+      stdio: "ignore"
     });
-    return !0;
+    child.on("error", () => {});
+    child.unref();
+    return child.pid !== void 0;
   } catch {
     return !1;
   }

package/src/tui-compiled/runtime/shared/4825e03209d6ae3e-with-lock.js

@@ -21,6 +21,7 @@ export class LockOwnershipError extends Error {
 export async function withLock(target, options, fn) {
     const started = performance.now();
     for (;;) {
+        options.signal?.throwIfAborted();
         const lock = await acquireRefreshFileLock({
             path: target,
             name: options.name,
@@ -33,6 +34,7 @@ export async function withLock(target, options, fn) {
         });
         if (lock) {
             try {
+                options.signal?.throwIfAborted();
                 return await fn(lock);
             }
             finally {

package/src/tui-compiled/runtime/shared/4f36d333d081d040-merge.js

@@ -11,7 +11,7 @@
 // no entry gets an absence record. A pair outside the coverage is never
 // touched, so a header-shaped partial observation (which covers only what it
 // carries) cannot erase a family limit or the budget.
-import { ALL_SCOPE, decodeQuotaMap, entryTime, isQuotaCounters, limitKey, } from "./905bffc0220f43d0-map.js";
+import { ALL_SCOPE, decodeQuotaMap, entryTime, isQuotaCounters, isQuotaCredits, limitKey, } from "./905bffc0220f43d0-map.js";
 /** Thrown by `mergeQuotaObservation` when either argument is malformed. */
 export class QuotaCodecError extends TypeError {
     constructor(message) {
@@ -84,7 +84,8 @@ export function isQuotaObservation(value) {
     if (!coverage.every(isObservedPair))
         return false;
     return ((value.budget === undefined || isObservedBudget(value.budget)) &&
-        (value.counters === undefined || isQuotaCounters(value.counters)));
+        (value.counters === undefined || isQuotaCounters(value.counters)) &&
+        (value.credits === undefined || isQuotaCredits(value.credits)));
 }
 function compareEntries(left, right) {
     if (left.scope !== right.scope)
@@ -110,6 +111,17 @@ function mergeCounters(stored, observed) {
     }
     return counters.size === 0 ? undefined : Object.fromEntries(counters);
 }
+// Credits merge like a single counter: the newer record wins, an equal time
+// applies (the observation applied last wins), and an observation without
+// credits leaves the stored record alone.
+function mergeCredits(stored, observed) {
+    if (observed === undefined)
+        return stored;
+    if (stored !== undefined && observed.checkedAt < stored.checkedAt) {
+        return stored;
+    }
+    return { ...observed };
+}
 /**
  * Applies `observation` to `stored` (undefined for a row with no map yet) and
  * returns the new map. Pure: neither argument is modified. Throws
@@ -166,13 +178,15 @@ export function mergeQuotaObservation(stored, observation) {
             : { scope, label: pair.label, kind: 'retired', retiredAt: at });
     }
     // Keys this module does not recognise are carried over untouched.
-    const { limits: _limits, budget: _budget, counters: _counters, ...unknownKeys } = base;
+    const { limits: _limits, budget: _budget, counters: _counters, credits: _credits, ...unknownKeys } = base;
     const budget = mergeBudget(base.budget, observation.budget, at);
     const counters = mergeCounters(base.counters, observation.counters);
+    const credits = mergeCredits(base.credits, observation.credits);
     return {
         ...unknownKeys,
         limits: [...entries.values()].sort(compareEntries),
         ...(budget === undefined ? {} : { budget }),
         ...(counters === undefined ? {} : { counters }),
+        ...(credits === undefined ? {} : { credits }),
     };
 }

package/src/tui-compiled/runtime/shared/81dddd203f1b92a3-quota-writer.js

@@ -0,0 +1,253 @@
+import { resolve } from "node:path";
+import { createLogger } from "./cc9e0702a752cea7-index.js";
+import { isQuotaObservation } from "./d5a8f1061ee2f114-index.js";
+import { applyVaultQuota, mutateVaultRoster, } from "./30f5bc480f31f51c-roster.js";
+// Every consumer of the same file shares one mailbox and one lock waiter.
+const writers = new Map();
+const logger = createLogger('claustrum');
+const COALESCE_MS = 100;
+function writerFor(path) {
+    const key = resolve(path);
+    let writer = writers.get(key);
+    if (!writer) {
+        writer = {
+            path: key,
+            pending: new Map(),
+            listeners: new Set(),
+            wake: new Set(),
+            abort: new AbortController(),
+            failures: 0,
+            draining: false,
+            order: 0,
+        };
+        writers.set(key, writer);
+    }
+    return writer;
+}
+/** Retain the shared writer; the last consumer's close drains it. */
+export function retainVaultQuotaWriter(path, listener) {
+    const writer = writerFor(path);
+    writer.listeners.add(listener);
+    let released;
+    return () => (released ??= (() => {
+        writer.listeners.delete(listener);
+        return writer.listeners.size ? Promise.resolve() : drainVaultQuota(path);
+    })());
+}
+// Split one observation into its independently dated parts: each rate-limit
+// window (scope and label), each covered-but-unread window, the budget, each
+// counter and the credits record. The mailbox keeps the newest of each part on
+// its own, so a later observation that carries only some parts can't erase an
+// older but still newest reading of another part, which is how
+// mergeQuotaObservation treats them on disk. Each key also carries the
+// receipt's identity, so the identity fence still applies to every part.
+function fields(publication) {
+    const result = new Map();
+    const { observation } = publication;
+    const witness = JSON.stringify([
+        publication.routeId,
+        publication.receipt?.credentialId,
+        publication.receipt?.accountIdentitySource,
+        publication.receipt?.expectedAccountIdentity,
+    ]);
+    const add = (key, at, part) => result.set(`${witness}:${key}`, {
+        at,
+        order: 0,
+        publication: { ...publication, observation: part },
+    });
+    const keyFor = (scope, label) => JSON.stringify([scope ?? 'all', label]);
+    const read = new Set();
+    for (const reading of observation.readings ?? []) {
+        const key = keyFor(reading.scope, reading.label);
+        read.add(key);
+        add(key, observation.checkedAt, {
+            checkedAt: observation.checkedAt,
+            readings: [{ ...reading }],
+        });
+    }
+    for (const pair of observation.coverage ?? []) {
+        const key = keyFor(pair.scope, pair.label);
+        if (!read.has(key))
+            add(key, observation.checkedAt, {
+                checkedAt: observation.checkedAt,
+                coverage: [{ ...pair }],
+            });
+    }
+    if (observation.budget)
+        add('budget', observation.checkedAt, {
+            checkedAt: observation.checkedAt,
+            budget: { ...observation.budget },
+        });
+    for (const [name, counter] of Object.entries(observation.counters ?? {})) {
+        add(`counter:${name}`, counter.checkedAt, {
+            checkedAt: observation.checkedAt,
+            counters: { [name]: { ...counter } },
+        });
+    }
+    if (observation.credits)
+        add('credits', observation.credits.checkedAt, {
+            checkedAt: observation.checkedAt,
+            credits: { ...observation.credits },
+        });
+    // Even an empty observation can bind an account proved by its receipt.
+    if (!result.size)
+        add('empty', observation.checkedAt, { checkedAt: observation.checkedAt });
+    return result;
+}
+/** Enqueue without filesystem work; each quota field retains its own receipt fence. */
+export function enqueueVaultQuota(path, publication) {
+    if (!isQuotaObservation(publication.observation))
+        return Promise.resolve(false);
+    const writer = writerFor(path);
+    const account = JSON.stringify([
+        publication.accountIdentity ?? null,
+        publication.accountIdentity === undefined ? publication.routeId : null,
+    ]);
+    const pending = writer.pending.get(account) ?? new Map();
+    for (const [key, field] of fields(publication)) {
+        const previous = pending.get(key);
+        if (!previous || field.at >= previous.at) {
+            field.order = ++writer.order;
+            // A covered disappearance after an unflushed reading is a retirement,
+            // not an absence. Retain just enough history to preserve that distinction.
+            if (field.publication.observation.coverage)
+                field.priorReading = previous?.publication.observation.readings
+                    ? previous.publication
+                    : previous?.priorReading;
+            pending.set(key, field);
+        }
+    }
+    if (pending.size)
+        writer.pending.set(account, pending);
+    for (const listener of writer.listeners)
+        listener(publication);
+    schedule(writer, COALESCE_MS);
+    return Promise.resolve(true);
+}
+function orderedFields(pending) {
+    // Equal observation times are last-enqueue-wins even across different
+    // credentials or account-only readings. Map insertion order cannot prove it.
+    return [...pending.values()]
+        .flatMap((account) => [...account.values()])
+        .sort((a, b) => a.order - b.order);
+}
+/** Overlay uncommitted observations when a consumer reloads the durable roster. */
+export function pendingVaultQuota(path, roster) {
+    const writer = writers.get(resolve(path));
+    if (writer) {
+        for (const field of orderedFields(writer.pending)) {
+            if (field.priorReading)
+                roster = applyVaultQuota(roster, field.priorReading).roster;
+            roster = applyVaultQuota(roster, field.publication).roster;
+        }
+    }
+    return roster;
+}
+function schedule(writer, delay) {
+    if (writer.running ||
+        writer.timer ||
+        !writer.pending.size ||
+        writer.abort.signal.aborted)
+        return;
+    writer.timer = setTimeout(() => {
+        writer.timer = undefined;
+        flush(writer);
+    }, delay);
+    if (!writer.draining)
+        writer.timer.unref?.();
+}
+function flush(writer) {
+    if (writer.running || writer.abort.signal.aborted)
+        return;
+    const batch = new Map([...writer.pending].map(([account, pending]) => [
+        account,
+        new Map(pending),
+    ]));
+    writer.running = (async () => {
+        try {
+            await mutateVaultRoster(writer.path, (current) => {
+                let next = current;
+                for (const field of orderedFields(batch)) {
+                    if (field.priorReading)
+                        next = applyVaultQuota(next, field.priorReading).roster;
+                    next = applyVaultQuota(next, field.publication).roster;
+                }
+                return { ...(next !== current && { next }), result: undefined };
+            }, { signal: writer.abort.signal });
+            for (const [account, fields] of batch) {
+                const pending = writer.pending.get(account);
+                for (const [key, field] of fields) {
+                    // A newer enqueue must survive completion of an older flush.
+                    if (pending?.get(key) === field)
+                        pending.delete(key);
+                }
+                if (!pending?.size)
+                    writer.pending.delete(account);
+            }
+            writer.failures = 0;
+        }
+        catch (error) {
+            if (!writer.abort.signal.aborted && writer.failures++ === 0) {
+                logger.warn('vault quota publication delayed; retrying', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            // Keep the batch in the mailbox, including any fresher fields enqueued meanwhile.
+        }
+        finally {
+            writer.running = undefined;
+            for (const wake of writer.wake)
+                wake();
+            const backoff = writer.failures
+                ? Math.min(5_000, 100 * 2 ** Math.min(writer.failures, 6)) *
+                    (0.5 + Math.random())
+                : COALESCE_MS;
+            schedule(writer, backoff);
+        }
+    })();
+}
+/** Wait at most timeoutMs for detached publication; shutdown loss is acceptable. */
+export async function drainVaultQuota(path, timeoutMs = 1_000) {
+    const key = resolve(path);
+    const writer = writers.get(key);
+    if (!writer)
+        return;
+    writer.draining = true;
+    clearTimeout(writer.timer);
+    writer.timer = undefined;
+    let deadline;
+    let wake;
+    const drained = new Promise((done) => {
+        wake = () => {
+            if (!writer.pending.size || writer.abort.signal.aborted)
+                done();
+        };
+        writer.wake.add(wake);
+        wake();
+    });
+    try {
+        if (writer.pending.size)
+            flush(writer);
+        await Promise.race([
+            drained,
+            new Promise((done) => {
+                deadline = setTimeout(done, Math.max(0, timeoutMs));
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(deadline);
+        if (wake)
+            writer.wake.delete(wake);
+        writer.draining = false;
+        // A still-open consumer owns the mailbox, so another consumer's disposal
+        // must not discard its observations or stop its retries.
+        if (!writer.listeners.size) {
+            writer.abort.abort();
+            clearTimeout(writer.timer);
+            writer.pending.clear();
+            if (writers.get(key) === writer)
+                writers.delete(key);
+        }
+    }
+}

package/src/tui-compiled/runtime/shared/905bffc0220f43d0-map.js

@@ -14,6 +14,9 @@
 // reset clock. It is a tri-state: absent (never reported), a reading, or
 // cleared (the provider reported that no budget exists).
 //
+// Provider-named counters and the prepaid credits record sit beside them too,
+// each judged by its own observation time rather than the limits'.
+//
 // The map is plain JSON so the store can persist it without interpreting it.
 /** The scope of a limit that binds every request regardless of model. */
 export const ALL_SCOPE = 'all';
@@ -93,6 +96,18 @@ function isQuotaCounter(value) {
 export function isQuotaCounters(value) {
     return isRecord(value) && Object.values(value).every(isQuotaCounter);
 }
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+/** True when `value` is a well-formed prepaid-credits record. */
+export function isQuotaCredits(value) {
+    return (isRecord(value) &&
+        typeof value.hasCredits === 'boolean' &&
+        typeof value.unlimited === 'boolean' &&
+        optional(value, 'balance', isFiniteNumber) &&
+        optional(value, 'overageLimitReached', isBoolean) &&
+        isFiniteNumber(value.checkedAt));
+}
 /** Keep usable counters without letting one malformed count hide a quota map. */
 export function readQuotaCounters(value) {
     if (!isRecord(value))
@@ -102,20 +117,29 @@ export function readQuotaCounters(value) {
         ? undefined
         : Object.fromEntries(entries);
 }
-/** Decode persisted quota, dropping malformed counters but not limit evidence. */
+/**
+ * Decode persisted quota, dropping malformed counters or a malformed credits
+ * record but not limit or budget evidence.
+ */
 export function decodeQuotaMap(value) {
     // A valid map is returned as the same object, so stored quota keeps the
-    // identity it had before counters existed; only a map with a malformed
-    // counter is copied without it.
+    // identity it had before counters and credits existed. A map with a
+    // malformed counter or credits record is copied with those malformed
+    // fields left out.
     if (isQuotaMap(value))
         return value;
     if (!isRecord(value))
         return undefined;
-    const { counters: rawCounters, ...rest } = value;
+    const { counters: rawCounters, credits: rawCredits, ...rest } = value;
     if (!isQuotaMap(rest))
         return undefined;
     const counters = readQuotaCounters(rawCounters);
-    return { ...rest, ...(counters === undefined ? {} : { counters }) };
+    const credits = isQuotaCredits(rawCredits) ? rawCredits : undefined;
+    return {
+        ...rest,
+        ...(counters === undefined ? {} : { counters }),
+        ...(credits === undefined ? {} : { credits }),
+    };
 }
 /**
  * True when `value` is a well-formed quota map. Unrecognised top-level keys
@@ -136,5 +160,6 @@ export function isQuotaMap(value) {
         seen.add(key);
     }
     return (optional(value, 'budget', isCreditBudgetEntry) &&
-        optional(value, 'counters', isQuotaCounters));
+        optional(value, 'counters', isQuotaCounters) &&
+        optional(value, 'credits', isQuotaCredits));
 }

package/src/tui-compiled/runtime/shared/94f53cfd572ba4bb-availability.js

@@ -0,0 +1,106 @@
+import { ClaustrumCredentialError } from "@cortexkit/claustrum-client";
+import { SocketClosedError, SocketTimeoutError, SubcCallError, } from "@cortexkit/subc-client";
+import { ClaustrumConsumerError } from "./ca0fccaba1d87af4-errors.js";
+/**
+ * Codes from claustrum-client's decoder and its subc transport. A retry action
+ * alone is not evidence of an outage: even transient vault refusals must win
+ * over a previously served credential. New codes fail closed until reviewed.
+ */
+export const VAULT_FAILURE_CLASSES = Object.freeze({
+    ECONNREFUSED: 'unreachable',
+    ENOENT: 'unreachable',
+    ECONNRESET: 'unreachable',
+    EPIPE: 'unreachable',
+    ETIMEDOUT: 'unreachable',
+    transport_error: 'unreachable',
+    unavailable: 'unreachable',
+    timeout: 'unreachable',
+    route_closed: 'unreachable',
+    daemon_draining: 'unreachable',
+    connection_closed: 'unreachable',
+    connection_dropped: 'unreachable',
+    request_deadline: 'unreachable',
+    deadline_exceeded_no_drop_observed: 'unreachable',
+    module_reloading: 'unreachable',
+    module_warming: 'unreachable',
+    target_unavailable: 'unreachable',
+    module_timeout: 'unreachable',
+    invalid_response: 'answered',
+    invalid_record_version: 'answered',
+    invalid_expiry: 'answered',
+    invalid_status: 'answered',
+    invalid_params: 'answered',
+    ttl_unsatisfiable: 'answered',
+    not_found: 'answered',
+    enrollment_revoked: 'answered',
+    enrollment_invalid: 'answered',
+    grant_denied: 'answered',
+    credential_unavailable: 'answered',
+    needs_reauth: 'answered',
+    declined: 'answered',
+    disabled: 'answered',
+    identity_changed: 'answered',
+    closed: 'answered',
+    client_closed: 'answered',
+    pending_exists: 'answered',
+    pending_queue_full: 'answered',
+    already_consumed: 'answered',
+    superseded: 'answered',
+    stale_generation: 'answered',
+    missing_identity: 'answered',
+    invalid_control_body: 'answered',
+    unknown_module: 'answered',
+    module_removed: 'answered',
+    capability_denied: 'answered',
+    unknown_channel: 'unreachable',
+    stale_route_epoch: 'unreachable',
+    capability_forbidden: 'answered',
+    capability_unprovided: 'answered',
+    capability_ambiguous: 'answered',
+    invalid_capability_identifier: 'answered',
+    binary_body_required: 'answered',
+    binary_call_requires_call_binary: 'answered',
+    corr_exhausted: 'answered',
+    late_route_cleanup_failed: 'answered',
+    reverse_request_capability_not_declared: 'answered',
+    stale_route_handle: 'answered',
+    reverse_request_unhandled: 'answered',
+    handler_error: 'answered',
+    health_error: 'answered',
+    duplicate_module_id: 'answered',
+    route_rejected: 'answered',
+    lock_busy: 'answered',
+    owner_invalid: 'answered',
+    renewal_failed: 'answered',
+    unsupported_platform: 'answered',
+    EACCES: 'answered',
+    EPERM: 'answered',
+    ERR_PRIVATE_FILES_SECURITY: 'answered',
+});
+/**
+ * An injected adapter may throw this ONLY when its connection/transport is
+ * unreachable, including a failed connect before getScoped. Do not wrap an
+ * adapter shutdown, cancellation, validation error or vault refusal in it.
+ * Its fixed message cannot echo enrollment or credential material, and its
+ * kind stays `unavailable` for callers handling ClaustrumConsumerError.
+ */
+export class ClaustrumUnreachableError extends ClaustrumConsumerError {
+    constructor() {
+        super('unavailable', 'Claustrum scoped operation unavailable');
+        this.name = 'ClaustrumUnreachableError';
+    }
+}
+export function classifyVaultFailure(error) {
+    if (error instanceof ClaustrumUnreachableError ||
+        error instanceof SocketClosedError ||
+        error instanceof SocketTimeoutError)
+        return 'unreachable';
+    const code = error instanceof ClaustrumCredentialError || error instanceof SubcCallError
+        ? error.code
+        : error instanceof Error && 'code' in error
+            ? error.code
+            : undefined;
+    if (typeof code !== 'string' || !Object.hasOwn(VAULT_FAILURE_CLASSES, code))
+        return 'answered';
+    return VAULT_FAILURE_CLASSES[code];
+}