@cortexkit/opencode-openai-auth 1.0.5 → 1.2.0

package/src/tui-compiled/raw/shared/bfbdd0f9aae56b47-pool-quota.js

@@ -0,0 +1,85 @@
+import {
+  isQuotaMap,
+  projectQuota
+} from "./d5a8f1061ee2f114-index.js";
+export const POOL_QUOTA_LABELS = ["primary", "secondary"];
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function readingFor(label, window) {
+  if (!isRecord(window))
+    return;
+  const usedPercent = window.usedPercent;
+  if (!finite(usedPercent) || usedPercent < 0 || usedPercent > 100)
+    return;
+  return {
+    label,
+    usedPercent,
+    ...typeof window.resetsAt === "string" ? { resetsAt: window.resetsAt } : {},
+    ...finite(window.windowMinutes) && window.windowMinutes > 0 ? { windowMinutes: window.windowMinutes } : {}
+  };
+}
+function budgetFor(snapshot) {
+  const spend = snapshot.spendControl;
+  if (isRecord(spend) && typeof spend.reached === "boolean") {
+    const optionalNumber = (key) => finite(spend[key]) ? { [key]: spend[key] } : {};
+    return {
+      kind: "reading",
+      reached: spend.reached,
+      ...optionalNumber("remainingPercent"),
+      ...optionalNumber("usedPercent"),
+      ...optionalNumber("limit"),
+      ...optionalNumber("used"),
+      ...optionalNumber("remaining"),
+      ...typeof spend.resetsAt === "string" ? { resetsAt: spend.resetsAt } : {},
+      ...typeof spend.unit === "string" ? { unit: spend.unit } : {}
+    };
+  }
+  if (snapshot.spendControlCleared === !0)
+    return { kind: "cleared" };
+  return;
+}
+export function observationFromSnapshot(snapshot, checkedAt, complete) {
+  if (!isRecord(snapshot) || !finite(checkedAt))
+    return;
+  const readings = [], coverage = [];
+  for (const label of POOL_QUOTA_LABELS) {
+    const reading = readingFor(label, snapshot[label]);
+    if (reading)
+      readings.push(reading);
+    else if (complete)
+      coverage.push({ label });
+  }
+  const budget = budgetFor(snapshot), credits = snapshot.resetCreditsAvailable, counters = typeof credits === "number" && Number.isSafeInteger(credits) && credits >= 0 ? { resetCredits: { value: credits, checkedAt } } : void 0;
+  if (readings.length === 0 && coverage.length === 0 && !budget && !counters)
+    return;
+  return {
+    checkedAt,
+    ...readings.length > 0 ? { readings } : {},
+    ...coverage.length > 0 ? { coverage } : {},
+    ...budget ? { budget } : {},
+    ...counters ? { counters } : {}
+  };
+}
+export function windowsFromQuotaMap(map) {
+  if (!isQuotaMap(map))
+    return;
+  const projection = projectQuota(map), out = {};
+  for (const label of POOL_QUOTA_LABELS) {
+    const limit = projection.limits.find((entry) => entry.label === label && entry.kind === "reading");
+    if (!limit || !finite(limit.usedPercent))
+      continue;
+    const window = {
+      usedPercent: limit.usedPercent,
+      remainingPercent: 100 - limit.usedPercent,
+      checkedAt: limit.checkedAt,
+      ...limit.resetsAt !== void 0 ? { resetsAt: limit.resetsAt } : {},
+      ...limit.windowMinutes !== void 0 ? { windowMinutes: limit.windowMinutes } : {}
+    };
+    out[label] = window;
+  }
+  return out.primary || out.secondary ? out : void 0;
+}

package/src/tui-compiled/raw/shared/c852a15cfe489d12-pool.js

@@ -57,7 +57,6 @@ export function openPoolStore(options) {
         ],
         lockDefaults,
         lockEnv: {
-            now: options.now ?? Date.now,
             ...(options.onLockEvent ? { onLockEvent: options.onLockEvent } : {}),
             ...(options.onLockStep ? { onLockStep: options.onLockStep } : {}),
             ...(options.onRenewalTimer

package/src/tui-compiled/raw/shared/ca0fccaba1d87af4-errors.js

@@ -0,0 +1,8 @@
+export class ClaustrumConsumerError extends Error {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.name = 'ClaustrumConsumerError';
+        this.kind = kind;
+    }
+}

package/src/tui-compiled/raw/shared/d0f0b6be200311af-insula.js

@@ -0,0 +1,152 @@
+import { resolve } from "node:path";
+import { storeIdentity } from "@cortexkit/claustrum-client";
+// A static import: claustrum-client already loads subc-client whenever
+// /claustrum is imported, so loading it lazily saves nothing, and a dynamic
+// import makes bundlers emit a separate chunk that a running host loses when
+// its dist folder is rebuilt underneath it.
+import { SubcClient } from "@cortexkit/subc-client";
+/** Constructing this transport opens no connection; getUsage opens one per call. */
+export function insulaUsageTransport(options) {
+    const identity = options.identity ??
+        storeIdentity(options.projectRoot ?? process.cwd(), options.storagePath ?? process.cwd());
+    return {
+        connectionFile: options.connectionFile,
+        async getUsage() {
+            let client;
+            let expired = false;
+            let timer;
+            const timeout = new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error('insula usage timeout')), 3_000);
+                timer.unref?.();
+            });
+            const request = (async () => {
+                client = options.connector
+                    ? await options.connector({
+                        connectionFile: options.connectionFile,
+                        handshakeTimeoutMs: Math.min(options.handshakeTimeoutMs ?? 3_000, 3_000),
+                    })
+                    : await SubcClient.connect({
+                        connectionFile: options.connectionFile,
+                        handshakeTimeoutMs: Math.min(options.handshakeTimeoutMs ?? 3_000, 3_000),
+                    });
+                // A slow connector may resolve after the whole-call deadline. It still
+                // owns a socket, which must not survive or open a route after fallback.
+                if (expired) {
+                    client.close();
+                    throw new Error('insula usage timeout');
+                }
+                // Managed call() retries warming routes. A single routeOpen/request
+                // instead lets the plugin fall back as soon as the daemon refuses.
+                const route = await client.routeOpen({ kind: 'management_surface', module_id: 'insula' }, identity);
+                return await client.request(route, { method: 'usage.get', params: {} });
+            })();
+            try {
+                return await Promise.race([request, timeout]);
+            }
+            finally {
+                expired = true;
+                clearTimeout(timer);
+                client?.close();
+            }
+        },
+    };
+}
+const MINUTE = 60_000;
+const MAX_AGE = 4 * MINUTE;
+const sources = new Map();
+// Keep only the minute budget after the last owner closes, so project churn
+// cannot reset the bound. Expired budgets are pruned on the next tick.
+const attempts = new Map();
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export class InsulaQuotaSource {
+    transport;
+    key;
+    #entries = [];
+    #pending;
+    constructor(transport, key) {
+        this.transport = transport;
+        this.key = key;
+    }
+    refresh(now) {
+        if (this.#pending)
+            return this.#pending;
+        for (const [key, time] of attempts) {
+            if (now - time >= MINUTE)
+                attempts.delete(key);
+        }
+        const lastAttempt = attempts.get(this.key);
+        if (lastAttempt !== undefined && now - lastAttempt < MINUTE)
+            return Promise.resolve();
+        // Reserve the minute before I/O, so concurrent projects cannot each poll.
+        attempts.set(this.key, now);
+        this.#pending = (async () => {
+            try {
+                const reply = await this.transport.getUsage();
+                if (!record(reply) ||
+                    !Array.isArray(reply.result) ||
+                    reply.error !== undefined)
+                    throw new Error('unavailable insula usage');
+                // Each response is a snapshot, not a delta. Missing accounts fall back;
+                // neither pending nor the entry count asserts provider completeness.
+                this.#entries = reply.result.filter((entry) => record(entry) && typeof entry.provider === 'string');
+            }
+            catch {
+                // Refusal is absence, even if the previous reading was still young.
+                this.#entries = [];
+            }
+        })().finally(() => {
+            this.#pending = undefined;
+        });
+        return this.#pending;
+    }
+    current(provider, accountId, now) {
+        for (const entry of this.#entries) {
+            if (entry.provider !== provider ||
+                typeof entry.account !== 'string' ||
+                entry.account.trim() !== accountId)
+                continue;
+            if (entry.stale !== undefined ||
+                entry.errorClass !== undefined ||
+                !record(entry.usage))
+                continue;
+            const fetchedAt = typeof entry.fetchedAt === 'string'
+                ? Date.parse(entry.fetchedAt)
+                : Number.NaN;
+            if (!Number.isFinite(fetchedAt) || now - fetchedAt >= MAX_AGE)
+                continue;
+            return {
+                entry,
+                context: {
+                    fetchedAt,
+                    ...(typeof entry.source === 'string' && { source: entry.source }),
+                },
+            };
+        }
+        return undefined;
+    }
+}
+export function acquireInsulaQuotaSource(transport, tokenPath) {
+    const key = JSON.stringify([
+        resolve(transport.connectionFile),
+        resolve(tokenPath),
+    ]);
+    let shared = sources.get(key);
+    if (!shared) {
+        shared = { source: new InsulaQuotaSource(transport, key), refs: 0 };
+        sources.set(key, shared);
+    }
+    shared.refs++;
+    let released = false;
+    return {
+        source: shared.source,
+        release() {
+            if (released)
+                return;
+            released = true;
+            if (--shared.refs === 0)
+                sources.delete(key);
+        },
+    };
+}

package/src/tui-compiled/raw/shared/d5a8f1061ee2f114-index.js

@@ -1,5 +1,5 @@
 export { quotaCodec } from "./053cc17b5419261e-codec.js";
-export { formatQuota, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaTextParts, quotaWindowName, quotaWindowParts, } from "./0332701351b3eeec-format.js";
+export { formatQuota, isQuotaStale, NO_LIMITS_REPORTED, NO_QUOTA_READING, QUOTA_STALE_AFTER_MS, quotaTextParts, quotaWindowName, quotaWindowParts, } from "./0332701351b3eeec-format.js";
 export { ALL_SCOPE, DEFAULT_REQUIRED_LABELS, decodeQuotaMap, emptyQuotaMap, isQuotaMap, } from "./905bffc0220f43d0-map.js";
 export { isQuotaObservation, mergeQuotaObservation, QuotaCodecError, } from "./4f36d333d081d040-merge.js";
 export { budgetExhaustedResetAt, futureResetAt, projectQuota, readsExhausted, } from "./39c3cb05738fcf6d-projection.js";

package/src/tui-compiled/raw/shared/d9d2892a4c371301-host-slot.js

@@ -0,0 +1,72 @@
+import { ClaustrumConsumerError } from "./ca0fccaba1d87af4-errors.js";
+/**
+ * The host's own auth slot (OpenCode's stored login for the provider, Pi's
+ * equivalent) must hold something, or the host drops the provider. Under
+ * custody it holds this placeholder: an OAuth-shaped value that is never a
+ * credential. Its empty access token also makes the vault's sealer refuse it,
+ * should it ever be offered for import.
+ */
+export const CUSTODY_PLACEHOLDER_PREFIX = 'claustrum-tombstone:v1:';
+export function custodyPlaceholderKey(provider) {
+    return `${CUSTODY_PLACEHOLDER_PREFIX}${provider}`;
+}
+export function custodyPlaceholder(provider) {
+    return {
+        type: 'oauth',
+        access: '',
+        refresh: custodyPlaceholderKey(provider),
+        expires: 0,
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function isCustodyPlaceholderValue(value) {
+    return (typeof value === 'string' && value.startsWith(CUSTODY_PLACEHOLDER_PREFIX));
+}
+export function isCustodyPlaceholder(auth, provider) {
+    if (!isRecord(auth) || auth.type !== 'oauth')
+        return false;
+    return auth.refresh === custodyPlaceholderKey(provider);
+}
+export function classifyHostSlot(auth, provider) {
+    if (isCustodyPlaceholder(auth, provider))
+        return 'placeholder';
+    if (isRecord(auth) &&
+        auth.type === 'oauth' &&
+        typeof auth.refresh === 'string' &&
+        auth.refresh.length > 0 &&
+        !isCustodyPlaceholderValue(auth.refresh))
+        return 'login';
+    if (isRecord(auth) &&
+        auth.type === 'api' &&
+        typeof auth.key === 'string' &&
+        auth.key.length > 0)
+        return 'login';
+    return 'empty';
+}
+/**
+ * Check the host slot against the plugin's mode before serving anything.
+ *
+ * - Custody mode with a real login in the slot fails closed: someone signed in
+ *   through the host while the vault owns the accounts, and serving either the
+ *   login or the vault would silently pick one. The plugin surfaces the error
+ *   and the user chooses (leave custody, or remove the login).
+ * - Local mode with the placeholder in the slot also fails: there is no local
+ *   credential to serve, and the user has to sign in.
+ *
+ * Returns the slot content when the combination is consistent.
+ */
+export function assertHostSlotMatchesMode(input) {
+    const content = classifyHostSlot(input.auth, input.provider);
+    if (input.mode === 'custody' && content === 'login')
+        throw new ClaustrumConsumerError('host-slot-login', `${input.provider} has a host login while its accounts are vault-custodied; refusing to serve until one is removed`);
+    if (input.mode === 'local' && content === 'placeholder')
+        throw new ClaustrumConsumerError('host-slot-placeholder', `${input.provider} host slot holds the vault placeholder; sign in to use local accounts`);
+    return content;
+}
+/** Refuse to run a local token refresh with the placeholder as the refresh token. */
+export function assertNotCustodyPlaceholder(refreshToken, provider) {
+    if (isCustodyPlaceholderValue(refreshToken))
+        throw new ClaustrumConsumerError('placeholder-refresh', `${provider} credentials are vault-custodied; local token refresh is forbidden`);
+}