@cortexkit/opencode-openai-auth 0.11.1 → 1.0.1

package/src/tui-compiled/raw/shared/a910277ac43a8626-pull.js

@@ -0,0 +1,143 @@
+import { recordQuota } from "./a62a27a204266acd-attribution.js";
+import { PoolOperationError } from "./04a6357627de5ed0-errors.js";
+import { toFailure, withTransaction } from "./458b934e92490331-mutate.js";
+import { LockStack } from "./43fc9e6b994519c7-refresh-lock.js";
+import { requireBound } from "./83bc3ba9d0fe2761-runtime.js";
+/**
+ * Fires quota pulls without ever making a caller wait for one. A pull first
+ * gives a row without a per-row entry its entry at epoch 1 (its own locked
+ * config write), then captures the credential and the attribution tuple in
+ * one locked read, requests the observation, and records it only if
+ * attribution still holds. Failures go to the store's pull failure hook.
+ */
+export class PullScheduler {
+    rt;
+    hook;
+    onFailure;
+    firedAtLoad;
+    logger;
+    inflight = new Set();
+    constructor(rt, hook, onFailure, 
+    /** Rows a load-time pull has fired for in this process. */
+    firedAtLoad, logger) {
+        this.rt = rt;
+        this.hook = hook;
+        this.onFailure = onFailure;
+        this.firedAtLoad = firedAtLoad;
+        this.logger = logger;
+    }
+    fire(id, reason) {
+        if (!this.hook)
+            return;
+        if (reason === 'load') {
+            if (this.firedAtLoad.has(id))
+                return;
+            this.firedAtLoad.add(id);
+        }
+        const run = this.run(id, reason);
+        this.inflight.add(run);
+        void run.finally(() => this.inflight.delete(run));
+    }
+    /** Resolves once every pull fired so far has settled. */
+    async settled() {
+        while (this.inflight.size > 0)
+            await Promise.allSettled([...this.inflight]);
+    }
+    async run(id, reason) {
+        const rt = this.rt();
+        const { ctx } = rt;
+        const locks = new LockStack(ctx.lockDefaults, ctx.lockEnv);
+        const progress = { writes: 0 };
+        try {
+            const request = await withTransaction(ctx, locks, progress, { operation: 'pull', rowId: id }, async (tx) => {
+                // Even a skipped capture must not repair another row on a reserved
+                // row's behalf. Decide reservation before pool-wide torn repair.
+                if (tx.reservation(id) !== undefined)
+                    return undefined;
+                await tx.completeTorn();
+                const row = tx.row(id);
+                // A row that would pull but for its unbound credential refuses, so
+                // the failure hook hears of it instead of the pull vanishing.
+                if (row?.unbound &&
+                    row.enabled &&
+                    row.type === 'oauth' &&
+                    row.credential &&
+                    !row.invalid)
+                    requireBound('pull', row);
+                // Disabled, API-key and credential-less rows never pull.
+                if (!row?.candidate || row.type !== 'oauth')
+                    return undefined;
+                if (!row.hasEntry) {
+                    tx.setEntry(id, { credentialEpoch: 1, needsFirstReading: true });
+                    await tx.commitConfig();
+                }
+                const current = tx.row(id);
+                if (!current?.credential || current.credentialEpoch === undefined)
+                    return undefined;
+                return {
+                    id,
+                    credential: current.credential,
+                    credentialEpoch: current.credentialEpoch,
+                    ...(current.identity !== undefined
+                        ? { identity: current.identity }
+                        : {}),
+                    reason,
+                };
+            }, { completeTorn: false });
+            await locks.releaseAll();
+            if (!request) {
+                this.firedAtLoad.delete(id);
+                return;
+            }
+            await ctx.hold?.('pull-before-request', id);
+            let observation;
+            try {
+                observation = await this.hook?.(request);
+            }
+            catch (cause) {
+                throw new PoolOperationError({
+                    operation: 'pull',
+                    rowId: id,
+                    phase: 'pull',
+                    retryable: true,
+                    kind: 'pull',
+                    message: 'the quota pull rejected',
+                    cause,
+                });
+            }
+            await recordQuota(rt, id, {
+                credentialEpoch: request.credentialEpoch,
+                ...(request.identity !== undefined
+                    ? { identity: request.identity }
+                    : {}),
+            }, observation);
+        }
+        catch (error) {
+            // Needs-first-reading stays set; a later load may fire again.
+            this.firedAtLoad.delete(id);
+            const failure = toFailure(error, 'pull', id, progress);
+            if (this.onFailure) {
+                try {
+                    await this.onFailure(id, failure);
+                }
+                catch (hookError) {
+                    this.logger?.warn('pull failure hook threw', {
+                        rowId: id,
+                        error: hookError instanceof Error
+                            ? hookError.message
+                            : String(hookError),
+                    });
+                }
+            }
+            else {
+                this.logger?.warn('quota pull failed', {
+                    rowId: id,
+                    kind: failure.kind,
+                });
+            }
+        }
+        finally {
+            await locks.releaseAll();
+        }
+    }
+}

package/src/tui-compiled/raw/shared/b85c5301fddcb98a-paths.js

@@ -0,0 +1,5 @@
+import { basename, dirname, join } from "node:path";
+export const ACCOUNT_FILE_NAME = "openai-auth.json", ACCOUNT_STATE_FILE_NAME = "openai-auth-state.json";
+export function deriveStatePath(configPath) {
+  return basename(configPath) === ACCOUNT_FILE_NAME ? join(dirname(configPath), ACCOUNT_STATE_FILE_NAME) : `${configPath}.state.json`;
+}

package/src/tui-compiled/raw/shared/c14988621dc60a75-port-file.js

@@ -0,0 +1,217 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, mkdir, open, readdir, readFile, rename, rmdir, stat, unlink, } from "node:fs/promises";
+import { join, resolve } from "node:path";
+/**
+ * A PID a liveness probe may address. `process.kill(0 | negative, 0)` signals
+ * a process group rather than a process, and an unsafe integer cannot name a
+ * real process, so neither is ever probed.
+ */
+function isProbeablePid(pid) {
+    return typeof pid === 'number' && Number.isSafeInteger(pid) && pid > 0;
+}
+function pidAlive(pid) {
+    if (!isProbeablePid(pid))
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+export function createManagedRpcStateDirPredicate(directoryPrefix) {
+    return (name) => isManagedRpcStateDir(name, directoryPrefix);
+}
+export function isManagedRpcStateDir(name, directoryPrefix) {
+    if (/^[0-9a-f]{16}$/.test(name))
+        return true;
+    return (name.startsWith(directoryPrefix) &&
+        /^[0-9a-f]{16}$/.test(name.slice(directoryPrefix.length)));
+}
+export function getRpcDir(rpcRoot, directoryPrefix, projectDirectory) {
+    return join(rpcRoot, directoryPrefix +
+        createHash('sha256').update(projectDirectory).digest('hex').slice(0, 16));
+}
+/** The PID a port file's name claims, or undefined for a malformed name. */
+function filenamePid(name) {
+    const match = /^port-(\d+)\.json$/.exec(name);
+    return match ? Number(match[1]) : undefined;
+}
+/**
+ * An entry a client may connect to: its PID is probeable and matches the PID
+ * in its file name (a mismatch means the file was not written by the server
+ * it names), its port is a real TCP port, and its token is non-empty (an
+ * absent token would otherwise be sent as `Bearer undefined`).
+ */
+function isUsablePortFileEntry(value, name) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const { pid, port, token } = value;
+    return (isProbeablePid(pid) &&
+        filenamePid(name) === pid &&
+        typeof port === 'number' &&
+        Number.isInteger(port) &&
+        port >= 1 &&
+        port <= 65_535 &&
+        typeof token === 'string' &&
+        token.length > 0);
+}
+async function removeCorruptPortFile(portFile, log) {
+    log?.debug('rpc corrupt port file', { pid: process.pid, portFile });
+    await unlink(portFile).catch(() => { });
+}
+export async function writePortFile(dir, entry, options = {}) {
+    // The directory can be removed by another project's sweep between our
+    // mkdir and the first open/rename, so the whole create-then-rename
+    // unit is retried once on ENOENT. The retry recreates the directory; a
+    // persistent ENOENT (e.g. permission, read-only parent) will surface on
+    // the second attempt — failing fast beats an unbounded loop.
+    const writeOnce = async () => {
+        await mkdir(dir, {
+            recursive: true,
+            mode: options.secureDir ? 0o700 : undefined,
+        });
+        if (options.secureDir)
+            await chmod(dir, 0o700);
+        await options.beforeWrite?.();
+        const full = { ...entry, startedAt: Date.now() };
+        const target = join(dir, `port-${entry.pid}.json`);
+        const tmp = `${target}.${(options.stageName ?? randomUUID)()}.tmp`;
+        let handle;
+        let created = false;
+        try {
+            handle = await open(tmp, 'wx', 0o600);
+            created = true;
+            await handle.writeFile(JSON.stringify(full), 'utf8');
+            await handle.chmod(0o600);
+            await handle.close();
+            handle = undefined;
+            await rename(tmp, target);
+            created = false;
+        }
+        finally {
+            await handle?.close().catch(() => { });
+            // Remove token-bearing staging bytes only if this call created them.
+            if (created)
+                await unlink(tmp).catch(() => { });
+        }
+        return target;
+    };
+    try {
+        return await writeOnce();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return await writeOnce();
+        }
+        throw error;
+    }
+}
+export async function sweepRpcState(root, activeDir, isManagedDir, log) {
+    let projectDirs;
+    try {
+        projectDirs = await readdir(root, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    const active = resolve(activeDir);
+    for (const projectDir of projectDirs) {
+        if (!projectDir.isDirectory() || !isManagedDir(projectDir.name)) {
+            continue;
+        }
+        const dir = join(root, projectDir.name);
+        let names;
+        try {
+            names = await readdir(dir);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        for (const name of names) {
+            if (!name.startsWith('port-') || !name.endsWith('.json'))
+                continue;
+            const portFile = join(dir, name);
+            let raw;
+            try {
+                raw = await readFile(portFile, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            if (raw === undefined)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch {
+                await removeCorruptPortFile(portFile, log);
+                continue;
+            }
+            if (!isUsablePortFileEntry(parsed, name)) {
+                await removeCorruptPortFile(portFile, log);
+                continue;
+            }
+            const entry = parsed;
+            if (!pidAlive(entry.pid))
+                await unlink(portFile).catch(() => { });
+        }
+        if (resolve(dir) !== active)
+            await rmdir(dir).catch(() => { });
+    }
+}
+/** Internal cache validation: probe only the selected file and its PID. */
+export async function portFileIdentity(dir, entry) {
+    if (!pidAlive(entry.pid))
+        return null;
+    const path = join(resolve(dir), `port-${entry.pid}.json`);
+    try {
+        const info = await stat(path);
+        return `${path}:${info.dev}:${info.ino}:${info.mtimeMs}:${info.size}`;
+    }
+    catch {
+        return null;
+    }
+}
+export async function discoverPortFile(dir, expectedPid, options = {}) {
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return null;
+    }
+    const live = [];
+    for (const name of names) {
+        if (!name.startsWith('port-') || !name.endsWith('.json'))
+            continue;
+        try {
+            const parsed = JSON.parse(await readFile(join(dir, name), 'utf8'));
+            if (isUsablePortFileEntry(parsed, name)) {
+                if (pidAlive(parsed.pid))
+                    live.push(parsed);
+                else
+                    await unlink(join(dir, name)).catch(() => { });
+            }
+        }
+        catch { }
+    }
+    if (live.length === 0)
+        return null;
+    const candidates = expectedPid !== undefined && expectedPid >= 1
+        ? live.filter((entry) => entry.pid === expectedPid)
+        : [];
+    if (options.exactPid === true && candidates.length === 0)
+        return null;
+    const entries = candidates.length > 0 ? candidates : live;
+    const sortTime = (entry) => typeof entry.startedAt === 'number' && Number.isFinite(entry.startedAt)
+        ? entry.startedAt
+        : -Infinity;
+    return entries.sort((a, b) => sortTime(b) - sortTime(a))[0] ?? null;
+}

package/src/tui-compiled/raw/shared/c64d7afbc14ca125-sidebar-file.js

@@ -0,0 +1,157 @@
+import { chmod, mkdir, readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { LockContentionError, LockOwnershipError, WRITER_LOCK_CONSTANTS, withLock, writeJsonAtomic, } from "./ec971142548df90e-index.js";
+/** Binds generic persistence to a caller's path and normalization policy. */
+export function createSidebarFile(options) {
+    const { path, defaultValue, normalize } = options;
+    let chain = Promise.resolve();
+    const parse = (raw) => {
+        if (raw === '')
+            return defaultValue;
+        try {
+            return normalize(JSON.parse(raw));
+        }
+        catch {
+            return defaultValue;
+        }
+    };
+    const readRaw = async () => {
+        try {
+            return await readFile(path, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return '';
+            throw error;
+        }
+    };
+    const read = async () => {
+        try {
+            return parse(await readRaw());
+        }
+        catch {
+            return defaultValue;
+        }
+    };
+    const enqueue = (operation, writeOptions) => {
+        const result = chain
+            .then(operation)
+            .then((outcome) => writeOptions?.onResult?.(outcome));
+        // Keep the next operation runnable without hiding this caller's rejection.
+        chain = result.catch(() => { });
+        return result;
+    };
+    const lockOptions = {
+        ...WRITER_LOCK_CONSTANTS.sidebar,
+        name: options.lockName ?? WRITER_LOCK_CONSTANTS.sidebar.name,
+        timeoutMs: options.timeoutMs ?? WRITER_LOCK_CONSTANTS.sidebar.timeoutMs,
+    };
+    /**
+     * Rename `value` into place under `lock`, then report whether the lock was
+     * still held. The fence before the rename stops a write whose lock is
+     * already gone; the check after it catches a lock lost while the rename
+     * itself was in flight, which no check before it can see.
+     */
+    const commitUnder = async (lock, value, hooks) => {
+        await writeJsonAtomic(path, value, {
+            serialize: JSON.stringify,
+            beforeRename: async () => {
+                await hooks?.beforeCommit?.();
+                await lock.assertOwned();
+            },
+        });
+        await hooks?.afterRename?.();
+        try {
+            await lock.assertOwned();
+            return true;
+        }
+        catch (error) {
+            if (error instanceof LockOwnershipError)
+                return false;
+            throw error;
+        }
+    };
+    /**
+     * One repair, under a new lock, of a write that lost its lock during the
+     * rename. Bounded to a single attempt: if the repair loses its lock too,
+     * the newer holder is writing and its state stands.
+     */
+    const repairLostWrite = async (repair, written, hooks) => {
+        options.logger?.warn('sidebar lock lost after rename; repairing write', {
+            path,
+        });
+        try {
+            const outcome = await withLock(path, lockOptions, async (lock) => {
+                const next = repair(await read(), written);
+                if (next === undefined)
+                    return 'skipped';
+                return (await commitUnder(lock, next, hooks))
+                    ? 'written'
+                    : 'lost-again';
+            });
+            if (outcome === 'lost-again') {
+                options.logger?.warn('sidebar repair lost its lock after rename', {
+                    path,
+                });
+            }
+            return { status: 'lost-after-rename', repair: outcome };
+        }
+        catch (error) {
+            if (!(error instanceof LockContentionError))
+                throw error;
+            options.logger?.warn('sidebar repair lock unavailable; repair skipped', {
+                path,
+            });
+            return { status: 'lost-after-rename', repair: 'lock-unavailable' };
+        }
+    };
+    const persist = async (merge, writeOptions) => {
+        const hooks = writeOptions;
+        const parent = dirname(path);
+        const secureDir = options.secureDir ?? true;
+        await mkdir(parent, { recursive: true, mode: 0o700 });
+        if (secureDir) {
+            await chmod(parent, 0o700).catch((error) => {
+                options.logger?.warn('sidebar directory permission remediation failed', { error: error instanceof Error ? error.message : String(error) });
+            });
+        }
+        const committed = await withLock(path, lockOptions, async (lock) => {
+            const commit = async (value) => ({
+                value,
+                held: await commitUnder(lock, value, hooks),
+            });
+            // Older processes may ignore the lock; remerge if their bytes changed.
+            for (let attempt = 0; attempt < 3; attempt += 1) {
+                const raw = await readRaw();
+                const next = merge(parse(raw));
+                if (next === undefined)
+                    return undefined;
+                if (attempt === 0)
+                    await hooks?.beforeRecheck?.();
+                if ((await readRaw()) !== raw)
+                    continue;
+                return await commit(next);
+            }
+            const next = merge(await read());
+            return next === undefined ? undefined : await commit(next);
+        });
+        if (committed === undefined)
+            return { status: 'skipped' };
+        if (committed.held)
+            return { status: 'written' };
+        // The first lock is released by now; the repair takes its own.
+        const repair = writeOptions?.repair ?? options.repair;
+        if (!repair) {
+            options.logger?.warn('sidebar lock lost after rename; write not repaired', {
+                path,
+            });
+            return { status: 'lost-after-rename', repair: 'none' };
+        }
+        return await repairLostWrite(repair, committed.value, hooks);
+    };
+    return {
+        read,
+        write: (value, writeOptions) => enqueue(() => persist(() => value, writeOptions), writeOptions),
+        update: (merge, writeOptions) => enqueue(() => persist(merge, writeOptions), writeOptions),
+    };
+}

package/src/tui-compiled/raw/shared/c6b176708c446d6d-pins.js

@@ -0,0 +1,34 @@
+// Session pins for `sticky-balanced` routing.
+//
+// A pin records which row a session was placed on so its prompt cache stays
+// warm. The library persists no pin: the caller holds pins (in memory, or in
+// a cross-process file it owns) and passes the relevant ones in per call.
+/**
+ * A pin survives while its row id is in `validIds` and the row still holds
+ * the account it was placed on. Only two known, differing identities prove
+ * the account changed: an unknown identity on either side keeps the pin,
+ * because re-placing a session on missing evidence throws its cache away.
+ */
+export function isPinValid(pin, validIds, currentIdentity) {
+    if (!validIds.has(pin.accountId))
+        return false;
+    return !(typeof pin.wireIdentity === 'string' &&
+        typeof currentIdentity === 'string' &&
+        pin.wireIdentity !== currentIdentity);
+}
+/**
+ * Sums the request bytes of every other session's pin per row, as openai-auth
+ * does. A pin counts only while it was judged on the row's current
+ * projection time, so a fresh reading resets the row's pending load.
+ */
+export function pendingBytesForPins(pins, quotaCheckedAtById, excludedSessionKey) {
+    const pending = new Map();
+    for (const [sessionKey, pin] of pins) {
+        if (sessionKey === excludedSessionKey)
+            continue;
+        if (pin.quotaCheckedAt !== quotaCheckedAtById.get(pin.accountId))
+            continue;
+        pending.set(pin.accountId, (pending.get(pin.accountId) ?? 0) + (pin.inputBytes ?? 0));
+    }
+    return pending;
+}