@cortexkit/common-auth 0.9.5 → 0.10.0

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.10.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",