@cortexkit/common-auth 0.9.5 → 0.11.0

package/dist/auth-menu/ansi.d.ts

@@ -12,8 +12,10 @@ export declare const ANSI: {
     readonly dim: '\u001B[2m';
     readonly reset: '\u001B[0m';
 };
-export type KeyAction = 'up' | 'down' | 'enter' | 'escape' | 'escape-start' | null;
-/** Convert terminal key bytes into the small action set the menu accepts. */
+export type KeyAction = 'up' | 'down' | 'left' | 'right' | 'enter' | 'escape' | 'escape-start' | 'char' | null;
+/** Tokenize complete keys in one read; incomplete escape sequences are ignored. */
+export declare function parseKeys(data: Buffer | string): KeyAction[];
+/** Preserve the single-key parser for callers that only need the first token. */
 export declare function parseKey(data: Buffer | string): KeyAction;
 /** Remove colour codes, leaving the text an operator sees. */
 export declare function stripAnsi(input: string): string;

package/dist/auth-menu/ansi.js

@@ -12,20 +12,51 @@ export const ANSI = {
     dim: '\x1b[2m',
     reset: '\x1b[0m',
 };
-/** Convert terminal key bytes into the small action set the menu accepts. */
-export function parseKey(data) {
+/** Tokenize complete keys in one read; incomplete escape sequences are ignored. */
+export function parseKeys(data) {
     const value = data.toString();
-    if (value === '\x1b[A' || value === '\x1bOA')
-        return 'up';
-    if (value === '\x1b[B' || value === '\x1bOB')
-        return 'down';
-    if (value === '\r' || value === '\n')
-        return 'enter';
-    if (value === '\x03')
-        return 'escape';
-    if (value === '\x1b')
-        return 'escape-start';
-    return null;
+    const keys = [];
+    for (let index = 0; index < value.length;) {
+        const char = value[index];
+        if (char === '\x1b') {
+            const sequence = value.slice(index, index + 3);
+            const arrow = sequence[1] === '[' || sequence[1] === 'O' ? sequence[2] : undefined;
+            if (arrow && 'ABCD'.includes(arrow)) {
+                const action = { A: 'up', B: 'down', C: 'right', D: 'left' };
+                const parsed = action[arrow];
+                if (parsed)
+                    keys.push(parsed);
+                index += 3;
+            }
+            else if (index + 1 === value.length) {
+                // Only a chunk consisting solely of ESC gets the legacy Escape timeout.
+                if (index === 0)
+                    keys.push('escape-start');
+                index += 1;
+            }
+            else if ((value[index + 1] === '[' || value[index + 1] === 'O') &&
+                index + 2 >= value.length) {
+                // An incomplete escape prefix at the chunk boundary is not a key.
+                break;
+            }
+            else {
+                index += 1;
+            }
+            continue;
+        }
+        if (char === '\r' || char === '\n')
+            keys.push('enter');
+        else if (char === '\x03')
+            keys.push('escape');
+        else if (char && char >= ' ')
+            keys.push('char');
+        index += 1;
+    }
+    return keys;
+}
+/** Preserve the single-key parser for callers that only need the first token. */
+export function parseKey(data) {
+    return parseKeys(data)[0] ?? null;
 }
 const ANSI_PATTERN = `${String.fromCharCode(27)}\\[[0-9;]*m`;
 const ANSI_REGEX = new RegExp(ANSI_PATTERN, 'g');

package/dist/auth-menu/index.d.ts

@@ -1,7 +1,7 @@
 export type { AccountMenuOptions } from './accounts.js';
 export { accountMenuActions, addAccountAction, checkQuotasAction, deleteAllAction, listAccountsAction, MENU_DISABLE_REASON, poolHasCredential, quotaLines, reauthenticateAction, removeAccountAction, runAccountMenu, toggleAccountAction, } from './accounts.js';
 export type { KeyAction } from './ansi.js';
-export { ANSI, parseKey, stripAnsi, truncateAnsi } from './ansi.js';
+export { ANSI, parseKey, parseKeys, stripAnsi, truncateAnsi } from './ansi.js';
 export { confirm } from './confirm.js';
 export type { DoctorActionOptions, DoctorCheck, DoctorFinding, DoctorRepair, DoctorReport, RepairOutcome, } from './doctor.js';
 export { applyChosenRepairs, DOCTOR_CHECK_FAILED, doctorAction, formatDoctorReport, runDoctorChecks, } from './doctor.js';

package/dist/auth-menu/index.js

@@ -2,7 +2,7 @@
 // runtime, the OpenCode v1 `authorize` contract around it, and the account
 // actions built over the `/store` pool.
 export { accountMenuActions, addAccountAction, checkQuotasAction, deleteAllAction, listAccountsAction, MENU_DISABLE_REASON, poolHasCredential, quotaLines, reauthenticateAction, removeAccountAction, runAccountMenu, toggleAccountAction, } from './accounts.js';
-export { ANSI, parseKey, stripAnsi, truncateAnsi } from './ansi.js';
+export { ANSI, parseKey, parseKeys, stripAnsi, truncateAnsi } from './ansi.js';
 export { confirm } from './confirm.js';
 export { applyChosenRepairs, DOCTOR_CHECK_FAILED, doctorAction, formatDoctorReport, runDoctorChecks, } from './doctor.js';
 export { openBrowserForMenu, runMenuLogin } from './login.js';

package/dist/auth-menu/select.js

@@ -1,4 +1,4 @@
-import { ANSI, parseKey, truncateAnsi } from './ansi.js';
+import { ANSI, parseKeys, truncateAnsi } from './ansi.js';
 import { isInteractive } from './terminal.js';
 /** How long a lone Escape byte waits for the rest of an arrow-key sequence. */
 const ESCAPE_TIMEOUT_MS = 50;
@@ -109,30 +109,36 @@ export async function select(terminal, items, options) {
         };
         const onSignal = () => finish(null);
         const onKey = (data) => {
-            if (escapeTimeout) {
-                clearTimeout(escapeTimeout);
-                escapeTimeout = null;
-            }
-            switch (parseKey(data)) {
-                case 'up':
-                    cursor = (cursor - 1 + items.length) % items.length;
-                    render();
-                    break;
-                case 'down':
-                    cursor = (cursor + 1) % items.length;
-                    render();
-                    break;
-                case 'enter':
-                    finish(items[cursor]?.value ?? null);
-                    break;
-                case 'escape':
-                    finish(null);
-                    break;
-                case 'escape-start':
-                    // A bare Escape byte is also the start of an arrow-key sequence
-                    // that may arrive split across reads; only a lone one cancels.
-                    escapeTimeout = setTimeout(() => finish(null), ESCAPE_TIMEOUT_MS);
+            for (const key of parseKeys(data)) {
+                if (cleaned)
                     break;
+                if (escapeTimeout) {
+                    clearTimeout(escapeTimeout);
+                    escapeTimeout = null;
+                }
+                switch (key) {
+                    case 'up':
+                        cursor = (cursor - 1 + items.length) % items.length;
+                        render();
+                        break;
+                    case 'down':
+                        cursor = (cursor + 1) % items.length;
+                        render();
+                        break;
+                    case 'enter':
+                        finish(items[cursor]?.value ?? null);
+                        break;
+                    case 'escape':
+                        finish(null);
+                        break;
+                    case 'escape-start':
+                        // A bare Escape byte is also the start of an arrow-key sequence
+                        // that may arrive split across reads; only a lone one cancels.
+                        escapeTimeout = setTimeout(() => finish(null), ESCAPE_TIMEOUT_MS);
+                        break;
+                    default:
+                        break;
+                }
             }
         };
         signals?.once('SIGINT', onSignal);

package/dist/fs/refresh-file-lock.d.ts

@@ -25,5 +25,9 @@ export declare function acquireRefreshFileLock(options: {
     now?: () => number;
     renew?: boolean;
     renewIntervalMs?: number;
-    onStep?: (step: 'stale-marker-stat' | 'stale-marker-claimed' | 'stale-lock-confirmed' | 'eviction-marker-acquired' | 'renewal-owner-confirmed' | 'renewal-marker-unavailable' | 'renewal-write-fenced' | 'renewal-write-ready' | 'relinquish-read' | 'renewal-finished' | 'release-owner-confirmed') => void | Promise<void>;
+    /** Notifies a live-owner refusal without awaiting; observer failures are ignored. */
+    onContended?: () => void;
+    /** Synchronous, never awaited; throws and returned promise/thenable rejections are isolated. */
+    onRenewalTimer?: (event: 'scheduled' | 'cancelled') => void;
+    onStep?: (step: 'stale-marker-stat' | 'stale-marker-claimed' | 'stale-lock-observed' | 'stale-lock-confirmed' | 'stale-lock-removed' | 'stale-lock-recreated' | 'eviction-marker-acquired' | 'renewal-owner-confirmed' | 'renewal-marker-unavailable' | 'renewal-write-fenced' | 'renewal-write-ready' | 'relinquish-read' | 'renewal-finished' | 'release-owner-confirmed') => void | Promise<void>;
 }): Promise<RefreshFileLock | null>;

package/dist/fs/refresh-file-lock.js

@@ -24,6 +24,27 @@ export async function acquireRefreshFileLock(options) {
     const lostPromise = new Promise((resolve) => {
         resolveLoss = resolve;
     });
+    function notifyTimerStep(event) {
+        try {
+            const result = options.onRenewalTimer?.(event);
+            if (result &&
+                (typeof result === 'object' || typeof result === 'function') &&
+                'then' in result &&
+                typeof result.then === 'function') {
+                void Promise.resolve(result).catch(() => { });
+            }
+        }
+        catch {
+            // Timer observer failures must not replace the lock operation result.
+        }
+    }
+    function cancelRenewalTimer() {
+        if (!renewTimer)
+            return;
+        clearRefreshLockRenewalTimeout(renewTimer);
+        renewTimer = null;
+        notifyTimerStep('cancelled');
+    }
     function recordLoss(reason, owner) {
         if (loss || released)
             return;
@@ -37,10 +58,7 @@ export async function acquireRefreshFileLock(options) {
                 ? { observedExpiresAt: owner.expiresAt }
                 : {}),
         });
-        if (renewTimer) {
-            clearRefreshLockRenewalTimeout(renewTimer);
-            renewTimer = null;
-        }
+        cancelRenewalTimer();
         resolveLoss(loss);
     }
     let renewalInFlight = null;
@@ -211,9 +229,10 @@ export async function acquireRefreshFileLock(options) {
         }
         return true;
     }
-    // Marker loss after a write may mean our record replaced a successor's.
-    // Delete only a record still owned by us; a concurrent successor write can
-    // then yield zero winners, never two.
+    // Marker loss after a write may mean another contender has taken over.
+    // Delete only a record still owned by us, so an already-installed
+    // successor is preserved. The owner read and the removal are not atomic:
+    // a successor record written between them can still be deleted.
     async function relinquishLockAfterMarkerLoss() {
         for (let attempt = 0; attempt < MAX_STEAL_ATTEMPTS; attempt++) {
             if (options.onStep)
@@ -241,6 +260,7 @@ export async function acquireRefreshFileLock(options) {
             return;
         const intervalMs = options.renewIntervalMs ?? Math.max(1_000, Math.floor(options.ttlMs / 3));
         renewTimer = setRefreshLockRenewalTimeout(() => {
+            renewTimer = null;
             const renewal = (async () => {
                 let shouldReschedule = !released;
                 try {
@@ -333,6 +353,22 @@ export async function acquireRefreshFileLock(options) {
         }, intervalMs);
         if ('unref' in renewTimer)
             renewTimer.unref();
+        notifyTimerStep('scheduled');
+    }
+    function contended() {
+        try {
+            const result = options.onContended?.();
+            if (result &&
+                (typeof result === 'object' || typeof result === 'function') &&
+                'then' in result &&
+                typeof result.then === 'function') {
+                void Promise.resolve(result).catch(() => { });
+            }
+        }
+        catch {
+            // Observers cannot change whether the lock is acquired.
+        }
+        return null;
     }
     let acquired = await tryAcquire();
     if (!acquired) {
@@ -341,7 +377,9 @@ export async function acquireRefreshFileLock(options) {
             if (acquired)
                 break;
             if (await lockIsLive())
-                return null;
+                return contended();
+            if (options.onStep)
+                await options.onStep('stale-lock-observed');
             try {
                 if (!(await tryAcquireEvictionMarker())) {
                     await backoff();
@@ -360,7 +398,7 @@ export async function acquireRefreshFileLock(options) {
             }
             try {
                 if (await lockIsLive())
-                    return null;
+                    return contended();
                 // Verify marker ownership before removing a lock found not live.
                 if (!(await ownsEvictionMarker()))
                     return null;
@@ -374,14 +412,18 @@ export async function acquireRefreshFileLock(options) {
                 // Fence check 3: re-verify ownership after removing the stale lock.
                 if (!(await ownsEvictionMarker()))
                     return null;
+                if (options.onStep)
+                    await options.onStep('stale-lock-removed');
                 acquired = await tryAcquire();
                 if (!acquired)
                     return null;
+                if (options.onStep)
+                    await options.onStep('stale-lock-recreated');
                 // Fence check 4: re-verify ownership after acquiring the lock. If the
                 // marker was stolen between tryAcquire and this check, release the
                 // just-acquired lock and return null (fail-closed).
                 if (!(await ownsEvictionMarker())) {
-                    await rm(lockPath, { recursive: true, force: true }).catch(() => { });
+                    await relinquishLockAfterMarkerLoss();
                     acquired = false;
                     return null;
                 }
@@ -429,10 +471,7 @@ export async function acquireRefreshFileLock(options) {
         },
         release: async () => {
             released = true;
-            if (renewTimer) {
-                clearRefreshLockRenewalTimeout(renewTimer);
-                renewTimer = null;
-            }
+            cancelRenewalTimer();
             await renewalInFlight;
             for (let attempt = 0; attempt < MAX_STEAL_ATTEMPTS; attempt++) {
                 try {

package/dist/rpc/rpc-server.js

@@ -24,20 +24,29 @@ export class RpcRequestError extends Error {
 const MAX_BODY_BYTES = 1_000_000;
 /** The request body exceeded the cap; answered 413. */
 class BodyTooLargeError extends Error {
+    declaredOversize;
+    constructor(declaredOversize) {
+        super('body too large');
+        this.declaredOversize = declaredOversize;
+    }
 }
 function readBody(req) {
     return new Promise((resolve, reject) => {
-        const tooLarge = () => {
-            // Keep reading and discarding the rest, so the client finishes sending
-            // and can read the 413 instead of seeing a reset connection.
+        const tooLarge = (declaredOversize = false) => {
+            // Streamed overflow drains without closing at response finish: doing so
+            // caused EPIPE on a Bun 1.4.2 uploader. Declared oversize also drains, but
+            // half-closes after the 413: Bun 1.3.14 reused refused fetch connections
+            // despite Connection: close. Half-close preserved complete 413 JSON for
+            // tested fetch and slow declared-length uploaders on both runtimes (see
+            // research/load-probe/RPC-413-CLOSE.md for the delivery/lifecycle samples).
             req.removeAllListeners('data');
             req.on('data', () => { });
             req.resume();
-            reject(new BodyTooLargeError('body too large'));
+            reject(new BodyTooLargeError(declaredOversize));
         };
         const declared = Number(req.headers['content-length']);
         if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
-            tooLarge();
+            tooLarge(true);
             return;
         }
         const chunks = [];
@@ -133,8 +142,21 @@ export async function startRpcServer(options) {
             catch (error) {
                 if (!(error instanceof BodyTooLargeError))
                     throw error;
-                // Close the connection after answering: the rest of the oversized
-                // body is not worth keeping the socket for.
+                if (error.declaredOversize) {
+                    const socket = req.socket;
+                    res.once('finish', () => {
+                        socket.end();
+                        // Bound an abandoned upload to two seconds, matching the server's
+                        // default request-delivery timeout. end() alone left Bun 1.3.14
+                        // compatibility sockets open.
+                        const timer = setTimeout(() => socket.destroy(), 2_000);
+                        timer.unref();
+                        req.once('end', () => socket.destroy());
+                        socket.once('close', () => clearTimeout(timer));
+                        if (req.complete)
+                            socket.destroy();
+                    });
+                }
                 return json(413, { error: 'body too large' }, { connection: 'close' });
             }
             let params;

package/dist/store/refresh-lock.d.ts

@@ -19,7 +19,7 @@ export interface PoolLockSpec extends Partial<PoolLockOptions> {
  */
 export declare const POOL_LOCK_DEFAULTS: Readonly<PoolLockOptions>;
 export type LockEvent = {
-    type: 'acquired' | 'released';
+    type: 'acquired' | 'released' | 'contended';
     name: string;
     path: string;
 };

package/dist/store/refresh-lock.js

@@ -17,6 +17,24 @@ export const POOL_LOCK_DEFAULTS = Object.freeze({
  * 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 (;;) {
@@ -26,6 +44,7 @@ export async function acquirePoolLock(spec, defaults, env) {
             ttlMs: options.ttlMs,
             now: env.now,
             renew: options.renew,
+            onContended: () => emit('contended'),
             ...(options.renewIntervalMs !== undefined
                 ? { renewIntervalMs: options.renewIntervalMs }
                 : {}),
@@ -36,22 +55,14 @@ export async function acquirePoolLock(spec, defaults, env) {
                 : {}),
         });
         if (lock) {
-            env.onLockEvent?.({
-                type: 'acquired',
-                name: spec.name,
-                path: spec.path,
-            });
+            emit('acquired');
             const held = {
                 name: spec.name,
                 path: spec.path,
                 assertOwned: () => lock.assertOwned(),
                 release: async () => {
                     await lock.release();
-                    env.onLockEvent?.({
-                        type: 'released',
-                        name: spec.name,
-                        path: spec.path,
-                    });
+                    emit('released');
                 },
             };
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/common-auth",
-  "version": "0.9.5",
+  "version": "0.11.0",
   "description": "Shared code for the CortexKit auth plugins: account pool, quota and routing, commands and auth menu, OpenCode 2 hooks, Claustrum custody, and plumbing (loopback RPC, file locks, logger, sidebar state, TUI preferences and build).",
   "license": "MIT",
   "repository": {
@@ -85,7 +85,7 @@
     "dist/"
   ],
   "scripts": {
-    "build": "bun scripts/check-installed-ranges.mjs && tsc -p tsconfig.build.json",
+    "build": "bun scripts/check-local-deps.mjs && bun scripts/check-installed-ranges.mjs && tsc -p tsconfig.build.json",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "types": "bun run typecheck",