@cortexkit/opencode-openai-auth 0.11.1 → 1.0.0

package/src/tui-compiled/runtime/shared/04a6357627de5ed0-errors.js

@@ -0,0 +1,38 @@
+/**
+ * The single failure value of every store operation. `committed` is present
+ * only when the operation had already written a credential to the state file
+ * before it failed (a partial rotation or refresh): it is the credential now
+ * on disk, so a caller never has to re-read the files to learn it.
+ */
+export class PoolOperationError extends Error {
+    operation;
+    rowId;
+    phase;
+    retryable;
+    kind;
+    committed;
+    constructor(details) {
+        super(details.message ??
+            `${details.operation} failed (${details.kind}, ${details.phase})`, details.cause === undefined ? undefined : { cause: details.cause });
+        this.name = 'PoolOperationError';
+        this.operation = details.operation;
+        this.rowId = details.rowId;
+        this.phase = details.phase;
+        this.retryable = details.retryable;
+        this.kind = details.kind;
+        this.committed = details.committed;
+    }
+}
+/**
+ * Thrown when a row operation or a refresh is called from inside a hook of a
+ * lock-holding operation (or from any continuation created inside one). It is
+ * thrown before any lock is taken or waited for.
+ */
+export class PoolReentryError extends Error {
+    operation;
+    constructor(operation) {
+        super(`${operation} was called from inside a store hook; hand it to the caller's continuation instead`);
+        this.name = 'PoolReentryError';
+        this.operation = operation;
+    }
+}

package/src/tui-compiled/runtime/shared/053cc17b5419261e-codec.js

@@ -0,0 +1,12 @@
+import { isQuotaMap } from "./905bffc0220f43d0-map.js";
+import { mergeQuotaObservation } from "./4f36d333d081d040-merge.js";
+/**
+ * The quota codec the account-pool store (the `/store` subpath) takes when it
+ * is opened: `validate` checks a stored per-row quota map and `merge` applies
+ * an observation to one, so the store persists the map without interpreting
+ * it.
+ */
+export const quotaCodec = Object.freeze({
+    validate: isQuotaMap,
+    merge: mergeQuotaObservation,
+});

package/src/tui-compiled/runtime/shared/0766d78c6f481f18-watcher.js

@@ -0,0 +1,157 @@
+import { readFileSync, realpathSync, statSync, watch, } from "node:fs";
+import { readFile, stat } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { clearTimeout, setTimeout } from "node:timers";
+function canonicalPath(file) {
+    const path = resolve(file);
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        // Resolve existing ancestors even when the preferences file is not yet present.
+        const parent = dirname(path);
+        return parent === path ? path : join(canonicalPath(parent), basename(path));
+    }
+}
+function identity(info) {
+    return info && `${info.dev}:${info.ino}:${info.mtimeMs}:${info.size}`;
+}
+/**
+ * Share one directory watcher and metadata poll per canonical path, including
+ * across bundled copies. Native events use a 150 ms debounce; missed events
+ * recover through a 1,000 ms stat probe (formerly a 100 ms full-file poll).
+ * Watching the directory preserves atomic replacement and missing-file recovery.
+ * Only changed raw text notifies; each subscriber is isolated and independently
+ * disposable. The last unsubscribe stops both the native watcher and the poll.
+ */
+export function watchTuiPreferences(file, onChange, options = {}) {
+    const globals = globalThis;
+    const key = Symbol.for('cortexkit.common-auth.tui-prefs.watchers.v1');
+    const registry = globals[key] ?? new Map();
+    globals[key] = registry;
+    const path = canonicalPath(file);
+    const shared = registry.get(path);
+    if (shared)
+        return shared.subscribe(onChange);
+    const name = basename(path);
+    const read = options.fs?.readFile ?? ((file) => readFile(file, 'utf8'));
+    const probe = options.fs?.stat ?? stat;
+    let timer = null;
+    let pollTimer = null;
+    let lastMetadata = null;
+    let lastSeen = null;
+    // Seed synchronously so an immediate write cannot be absorbed as the baseline.
+    // The metadata is recorded only together with contents that were read, as in
+    // the probe below: if the first read fails, the probe keeps trying.
+    try {
+        const metadata = identity((options.fs?.statSync ?? statSync)(path));
+        lastSeen = (options.fs?.readFileSync ?? ((file) => readFileSync(file, 'utf8')))(path);
+        lastMetadata = metadata;
+    }
+    catch {
+        // Missing or unreadable files are picked up by the probe later.
+    }
+    let disposed = false;
+    const subscribers = new Set();
+    let checking = Promise.resolve();
+    const checkForChange = (native) => {
+        // Serialize native and poll checks so an older read cannot roll back state.
+        checking = checking.then(async () => {
+            if (disposed)
+                return;
+            const metadata = identity(await probe(path).catch(() => null));
+            if (!native && metadata === lastMetadata)
+                return;
+            // A missing file has nothing to read; remember that so the probe stays
+            // quiet until it reappears.
+            if (metadata === null) {
+                lastMetadata = null;
+                return;
+            }
+            const text = await read(path).catch(() => null);
+            if (disposed)
+                return;
+            // Record the metadata only once its contents were read. A failed read
+            // leaves the old value, so the next probe sees a change and retries
+            // instead of skipping a file whose new contents were never observed.
+            if (text === null)
+                return;
+            lastMetadata = metadata;
+            if (text === lastSeen)
+                return;
+            lastSeen = text;
+            for (const subscriber of [...subscribers]) {
+                if (!subscribers.has(subscriber))
+                    continue;
+                try {
+                    subscriber.notify();
+                }
+                catch {
+                    // A broken subscriber must not prevent the others from observing a change.
+                }
+            }
+        });
+        return checking;
+    };
+    const scheduleCheck = () => {
+        if (disposed)
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = null;
+            void checkForChange(true);
+        }, 150);
+    };
+    let watcher = null;
+    try {
+        watcher = (options.watchDirectory ?? watch)(dirname(path), (_event, filename) => {
+            const eventName = filename?.toString();
+            const isOurs = eventName === name ||
+                (eventName?.startsWith(`${name}.`) && eventName.endsWith('.tmp'));
+            if (eventName != null && !isOurs)
+                return;
+            scheduleCheck();
+        });
+        watcher.on('error', () => {
+            // Polling continues if the native watcher fails after construction.
+            watcher?.close();
+            watcher = null;
+        });
+    }
+    catch {
+        // The probe still recovers a later creation, even with no native watcher.
+    }
+    const schedulePoll = () => {
+        if (disposed || pollTimer)
+            return;
+        pollTimer = setTimeout(() => {
+            pollTimer = null;
+            if (disposed)
+                return;
+            void checkForChange(false).finally(schedulePoll);
+        }, 1_000);
+        pollTimer.unref();
+    };
+    const entry = {
+        subscribe: (notify) => {
+            const subscriber = { notify };
+            subscribers.add(subscriber);
+            return () => {
+                if (!subscribers.delete(subscriber) || subscribers.size > 0)
+                    return;
+                disposed = true;
+                if (timer)
+                    clearTimeout(timer);
+                if (pollTimer)
+                    clearTimeout(pollTimer);
+                watcher?.close();
+                if (registry.get(path) === entry)
+                    registry.delete(path);
+            };
+        },
+    };
+    registry.set(path, entry);
+    schedulePoll();
+    return entry.subscribe(onChange);
+}

package/src/tui-compiled/runtime/shared/08eef45626a94992-reserved.js

@@ -0,0 +1,13 @@
+import { PoolOperationError } from "./04a6357627de5ed0-errors.js";
+/** A stored marker reserves the row even when the rest of its entry is invalid. */
+export function assertNotReserved(operation, id, reservation) {
+    if (reservation !== undefined)
+        throw new PoolOperationError({
+            operation,
+            rowId: id,
+            kind: 'row-staged',
+            phase: operation === 'pull' ? 'pull' : 'before-first-write',
+            retryable: false,
+            message: `row ${id} is reserved for roster publication`,
+        });
+}

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

@@ -0,0 +1,134 @@
+// Projection of a keyed quota map onto one request scope.
+//
+// The selection primitives carried from openai-auth judge an account by a
+// short list of windows; the keyed map can hold many (scope, label) keys. The
+// projection resolves exactly one entry per window label for the request's
+// 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, } from "./905bffc0220f43d0-map.js";
+function project(entry) {
+    if (entry.kind === 'retired') {
+        return {
+            scope: entry.scope,
+            label: entry.label,
+            kind: 'retired',
+            checkedAt: entry.retiredAt,
+        };
+    }
+    if (entry.kind === 'absent') {
+        return {
+            scope: entry.scope,
+            label: entry.label,
+            kind: 'absent',
+            checkedAt: entry.checkedAt,
+        };
+    }
+    return {
+        scope: entry.scope,
+        label: entry.label,
+        kind: 'reading',
+        checkedAt: entry.checkedAt,
+        usedPercent: entry.usedPercent,
+        remainingPercent: 100 - entry.usedPercent,
+        ...(entry.windowMinutes === undefined
+            ? {}
+            : { windowMinutes: entry.windowMinutes }),
+        ...(entry.resetsAt === undefined ? {} : { resetsAt: entry.resetsAt }),
+    };
+}
+function compareLimits(left, right) {
+    const leftKnown = left.windowMinutes !== undefined;
+    const rightKnown = right.windowMinutes !== undefined;
+    if (leftKnown !== rightKnown)
+        return leftKnown ? -1 : 1;
+    if (leftKnown && rightKnown && left.windowMinutes !== right.windowMinutes) {
+        return (right.windowMinutes ?? 0) - (left.windowMinutes ?? 0);
+    }
+    if (left.label !== right.label)
+        return left.label < right.label ? -1 : 1;
+    return 0;
+}
+function projectBudget(budget) {
+    return {
+        checkedAt: budget.checkedAt,
+        reached: budget.reached,
+        ...(budget.remainingPercent === undefined
+            ? {}
+            : { remainingPercent: budget.remainingPercent }),
+        ...(budget.resetsAt === undefined ? {} : { resetsAt: budget.resetsAt }),
+    };
+}
+/**
+ * Resolves `map` for a request in `scope` (`all` or a model family). A family
+ * request sees only its own family's keys and the `all` keys.
+ *
+ * The label decides how a family limit relates to a general one. Under the
+ * same label, the family reading replaces the `all` reading: use this only
+ * when the provider's family figure is a more specific view of the same cap.
+ * Under different labels both limits are projected and every consumer judges
+ * both, so a family cap that applies on top of a general cap must be stored
+ * under its own label; otherwise the general cap is hidden from a family
+ * request. A family tombstone or absence record says only that no
+ * family-specific limit exists, so it does not hide an `all` entry for the
+ * same label and is used only when there is none.
+ */
+export function projectQuota(map, scope = ALL_SCOPE) {
+    const byLabel = new Map();
+    for (const entry of map?.limits ?? []) {
+        if (entry.scope !== scope && entry.scope !== ALL_SCOPE)
+            continue;
+        const current = byLabel.get(entry.label);
+        if (current === undefined) {
+            byLabel.set(entry.label, entry);
+            continue;
+        }
+        const family = entry.scope === ALL_SCOPE ? current : entry;
+        const general = entry.scope === ALL_SCOPE ? entry : current;
+        byLabel.set(entry.label, family.kind === 'reading' ? family : general);
+    }
+    const limits = [...byLabel.values()].map(project).sort(compareLimits);
+    const readings = limits.filter((limit) => limit.kind === 'reading');
+    const stamped = readings.length > 0 ? readings : limits;
+    const checkedAt = stamped.length > 0
+        ? Math.min(...stamped.map((limit) => limit.checkedAt))
+        : undefined;
+    const budget = map?.budget?.kind === 'reading' ? projectBudget(map.budget) : undefined;
+    return {
+        scope,
+        limits,
+        ...(checkedAt === undefined ? {} : { checkedAt }),
+        ...(budget === undefined ? {} : { budget }),
+    };
+}
+/**
+ * The credit budget's own exhaustion signal. Admission and the sticky
+ * routing decision to move a session off its pinned row both use it, so the
+ * two agree on what "spent" means. `reached` is the provider's
+ * verdict (the percentage is only a display value), and the check fails open
+ * on a missing, unparsable or already-passed reset.
+ */
+export function budgetExhaustedResetAt(quota, now) {
+    const budget = quota?.budget;
+    if (budget?.reached !== true || typeof budget.resetsAt !== 'string') {
+        return undefined;
+    }
+    const resetAtMs = Date.parse(budget.resetsAt);
+    if (!Number.isFinite(resetAtMs) || resetAtMs <= now)
+        return undefined;
+    return { resetsAt: budget.resetsAt, resetAtMs };
+}
+/** True for a reading at or beyond its whole window. */
+export function readsExhausted(limit) {
+    return (limit.kind === 'reading' &&
+        typeof limit.usedPercent === 'number' &&
+        Number.isFinite(limit.usedPercent) &&
+        limit.usedPercent >= 100);
+}
+/** The reset time of a limit when it parses and lies after `now`. */
+export function futureResetAt(limit, now) {
+    if (typeof limit.resetsAt !== 'string')
+        return undefined;
+    const resetAtMs = Date.parse(limit.resetsAt);
+    return Number.isFinite(resetAtMs) && resetAtMs > now ? resetAtMs : undefined;
+}

package/src/tui-compiled/runtime/shared/3c2d4169d00f907e-tui-support.js

@@ -0,0 +1,5 @@
+export * from "./d669d72c40e9e116-logger.js";
+export * from "./b85c5301fddcb98a-paths.js";
+export * from "./e4acc4cb713f300c-protocol.js";
+export * from "./f37fcefc7aedbf25-error.js";
+export * from "./42ae93ab554fcec2-open-url.js";

package/src/tui-compiled/runtime/shared/3e7d45a77c6ad4d5-index.js

@@ -0,0 +1,4 @@
+export { admit, exclusionFor } from "./45bf5343bbbf9add-admission.js";
+export { DEFAULT_FORMER_MAIN_ID, nextOrderedAttempt, orderForPlacement, resolveRoutingMode, routeOrdered, } from "./9020c407ce64f672-ordered.js";
+export { isPinValid, pendingBytesForPins } from "./c6b176708c446d6d-pins.js";
+export { decideStickyBreak, defaultStickyStatusClass, MIN_RESET_HOURS, MIN_WEIGHT, QUOTA_STALENESS_MS, routeSticky, selectStickyCandidate, snapshotCheckedAt, sustainableWindowWeight, } from "./901e149c5a0dbbff-sticky.js";

package/src/tui-compiled/runtime/shared/415792e85d80819e-capture-sink.js

@@ -0,0 +1,13 @@
+export function createCaptureSink() {
+    const records = [];
+    const sink = (record) => {
+        records.push(record);
+    };
+    return {
+        records,
+        sink,
+        clear: () => {
+            records.length = 0;
+        },
+    };
+}

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

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

package/src/tui-compiled/runtime/shared/43fc9e6b994519c7-refresh-lock.js

@@ -0,0 +1,136 @@
+import { acquireRefreshFileLock } from "./e8cd4929507508d8-refresh-file-lock.js";
+import { LockContentionError } from "./4825e03209d6ae3e-with-lock.js";
+/**
+ * Store lock defaults: a 15 000 ms bounded wait retried every 50 ms plus
+ * jitter, and a renewed 10 000 ms lease.
+ */
+export const POOL_LOCK_DEFAULTS = Object.freeze({
+    ttlMs: 10_000,
+    timeoutMs: 15_000,
+    retryMs: 50,
+    renew: true,
+});
+/**
+ * Takes one lock, retrying while a live holder has it until `timeoutMs` has
+ * passed on the real clock, then throws `LockContentionError`. The lease is
+ * asserted as owned once acquired, so a caller never proceeds on a lease that
+ * expired during the wait.
+ */
+export async function acquirePoolLock(spec, defaults, env) {
+    const emit = (type) => {
+        try {
+            const result = env.onLockEvent?.({
+                type,
+                name: spec.name,
+                path: spec.path,
+            });
+            if (result &&
+                (typeof result === 'object' || typeof result === 'function') &&
+                'then' in result &&
+                typeof result.then === 'function') {
+                void Promise.resolve(result).catch(() => { });
+            }
+        }
+        catch {
+            // Lock observers must not affect acquisition or release.
+        }
+    };
+    const options = { ...defaults, ...definedOnly(spec) };
+    const started = performance.now();
+    for (;;) {
+        const lock = await acquireRefreshFileLock({
+            name: spec.name,
+            path: spec.path,
+            ttlMs: options.ttlMs,
+            now: env.now,
+            renew: options.renew,
+            onContended: () => emit('contended'),
+            ...(options.renewIntervalMs !== undefined
+                ? { renewIntervalMs: options.renewIntervalMs }
+                : {}),
+            ...(env.onLockStep
+                ? {
+                    onStep: (step) => env.onLockStep?.({ name: spec.name, path: spec.path }, step),
+                }
+                : {}),
+        });
+        if (lock) {
+            emit('acquired');
+            const held = {
+                name: spec.name,
+                path: spec.path,
+                assertOwned: () => lock.assertOwned(),
+                release: async () => {
+                    await lock.release();
+                    emit('released');
+                },
+            };
+            try {
+                await held.assertOwned();
+            }
+            catch (error) {
+                await held.release();
+                throw error;
+            }
+            return held;
+        }
+        const remaining = options.timeoutMs - (performance.now() - started);
+        if (remaining <= 0) {
+            throw new LockContentionError({
+                target: spec.path,
+                name: spec.name,
+                timeoutMs: options.timeoutMs,
+            });
+        }
+        const jitter = Math.floor(Math.random() * (options.retryMs + 1));
+        await new Promise((resolve) => setTimeout(resolve, Math.min(options.retryMs + jitter, remaining)));
+    }
+}
+function definedOnly(spec) {
+    const out = {};
+    if (spec.ttlMs !== undefined)
+        out.ttlMs = spec.ttlMs;
+    if (spec.timeoutMs !== undefined)
+        out.timeoutMs = spec.timeoutMs;
+    if (spec.retryMs !== undefined)
+        out.retryMs = spec.retryMs;
+    if (spec.renew !== undefined)
+        out.renew = spec.renew;
+    if (spec.renewIntervalMs !== undefined)
+        out.renewIntervalMs = spec.renewIntervalMs;
+    return out;
+}
+/**
+ * Locks taken in order and released in reverse. Every acquisition re-asserts
+ * the leases already held, because a wait is exactly when an earlier lease
+ * can expire unnoticed.
+ */
+export class LockStack {
+    defaults;
+    env;
+    held = [];
+    constructor(defaults, env) {
+        this.defaults = defaults;
+        this.env = env;
+    }
+    async acquire(spec) {
+        const lock = await acquirePoolLock(spec, this.defaults, this.env);
+        this.held.push(lock);
+        await this.assertAll();
+        return lock;
+    }
+    async assertAll() {
+        for (const lock of this.held)
+            await lock.assertOwned();
+    }
+    /** Releases every lock taken after `mark` (a length of `held`), newest first. */
+    async releaseTo(mark) {
+        while (this.held.length > mark) {
+            const lock = this.held.pop();
+            await lock?.release().catch(() => { });
+        }
+    }
+    async releaseAll() {
+        await this.releaseTo(0);
+    }
+}