@cortexkit/opencode-openai-auth 0.11.0 → 1.0.0

package/src/tui-compiled/raw/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/raw/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/raw/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/raw/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/raw/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/raw/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/raw/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);
+    }
+}