camofox-browser 2.4.6 → 2.4.7

package/dist/src/services/context-pool.js

@@ -3,11 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.contextPool = exports.ContextPool = void 0;
+exports.contextPool = exports.ContextPool = exports.spawnXvfbForTests = void 0;
 exports.getDisplayForUser = getDisplayForUser;
-const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = __importDefault(require("node:fs"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_child_process_1 = require("node:child_process");
 const camoufox_js_1 = require("camoufox-js");
 const fingerprints_js_1 = require("camoufox-js/dist/fingerprints.js");
@@ -17,18 +17,12 @@ const fingerprints_js_1 = require("camoufox-js/dist/fingerprints.js");
 const pkgman_js_1 = require("camoufox-js/dist/pkgman.js");
 const playwright_core_1 = require("playwright-core");
 const config_1 = require("../utils/config");
+const platform_support_1 = require("../utils/platform-support");
+const profile_path_1 = require("../utils/profile-path");
 const sidecar_version_1 = require("../utils/sidecar-version");
 const logging_1 = require("../middleware/logging");
 const CONFIG = (0, config_1.loadConfig)();
 const MAX_CONTEXTS = CONFIG.maxSessions;
-function getHostOS() {
-    const platform = node_os_1.default.platform();
-    if (platform === 'darwin')
-        return 'macos';
-    if (platform === 'win32')
-        return 'windows';
-    return 'linux';
-}
 function buildProxyConfig(proxy) {
     if (!proxy) {
         // Fallback to configured server proxy
@@ -55,43 +49,6 @@ function getInstalledCamoufoxVersion() {
         return 'unknown';
     }
 }
-function decodeDefaultProfileUserId(profileKey) {
-    if (!profileKey.startsWith('u:') || profileKey.indexOf(':', 2) !== -1)
-        return null;
-    try {
-        const encoded = profileKey.slice(2);
-        const bytes = Buffer.from(encoded, 'base64url');
-        if (bytes.length % 2 !== 0)
-            return null;
-        const decoded = bytes.toString('utf16le');
-        if (/^(?:u|s|p|o):/.test(decoded))
-            return null;
-        for (let i = 0; i < decoded.length; i += 1) {
-            const code = decoded.charCodeAt(i);
-            if (code >= 0xd800 && code <= 0xdbff) {
-                if (i + 1 >= decoded.length)
-                    return null;
-                const next = decoded.charCodeAt(i + 1);
-                if (next < 0xdc00 || next > 0xdfff)
-                    return null;
-                i += 1;
-            }
-            else if (code >= 0xdc00 && code <= 0xdfff) {
-                return null;
-            }
-        }
-        return `u:${Buffer.from(decoded, 'utf16le').toString('base64url')}` === profileKey ? decoded : null;
-    }
-    catch {
-        return null;
-    }
-}
-function profileDirForProfileKey(profileKey) {
-    // Avoid path traversal from untrusted route params.
-    const defaultUserId = decodeDefaultProfileUserId(String(profileKey));
-    const safe = encodeURIComponent(defaultUserId ?? String(profileKey));
-    return node_path_1.default.join(CONFIG.profilesDir, safe);
-}
 function pickSeedOptions(opts) {
     if (!opts)
         return undefined;
@@ -117,59 +74,263 @@ function hasUsableLinuxDisplay() {
     return node_fs_1.default.existsSync(lockFile);
 }
 async function spawnXvfb(resolution = '1920x1080x24') {
-    let displayNum = 99;
-    while (node_fs_1.default.existsSync(`/tmp/.X${displayNum}-lock`)) {
-        displayNum++;
-    }
-    const display = `:${displayNum}`;
+    // Use -displayfd so Xvfb itself picks a free display number atomically.
+    // This avoids the userspace race condition where multiple concurrent
+    // spawnXvfb() calls all see the same absence of a lock file and pick
+    // the same display number — only the first to create the lock succeeds,
+    // the others exit with code 1.
+    //
+    // Xvfb writes "<display>\n" to fd 3 (e.g. "99\n"), which we read to
+    // determine the assigned display. This is the same approach used by
+    // camoufox-js's VirtualDisplay class (apify/camoufox-js#273).
+    //
+    // The fd3 output is line-delimited. We buffer until a newline is
+    // received and parse the complete record, rather than matching
+    // digits greedily — chunked writes could deliver a partial number
+    // (e.g. "9" then "9\n") that would be accepted prematurely.
     const xvfbProcess = (0, node_child_process_1.spawn)('Xvfb', [
-        display,
-        '-screen',
-        '0',
-        resolution,
-        '-ac',
-        '-nolisten',
-        'tcp',
-    ], { stdio: 'pipe' });
-    await new Promise((resolve, reject) => {
+        '-displayfd', '3',
+        '-screen', '0', resolution,
+        '-ac', '-nolisten', 'tcp',
+    ], {
+        stdio: ['ignore', 'pipe', 'pipe', 'pipe'],
+    });
+    // Idempotent child cleanup — safe to call multiple times from any
+    // error path (timeout, spawn error, fd3 error/close).
+    // SIGTERM first, then SIGKILL after 3s if still alive.
+    // When the child has already exited (childExited=true), cleanupChild()
+    // is a no-op — no SIGTERM to a dead process, no new escalation timer.
+    let childCleaned = false;
+    let childExited = false;
+    let sigkillTimer = null;
+    const cleanupChild = () => {
+        if (childCleaned)
+            return;
+        childCleaned = true;
+        if (childExited)
+            return;
+        try {
+            xvfbProcess.kill('SIGTERM');
+        }
+        catch {
+            // already dead
+        }
+        sigkillTimer = setTimeout(() => {
+            sigkillTimer = null;
+            try {
+                xvfbProcess.kill('SIGKILL');
+            }
+            catch {
+                // already dead
+            }
+        }, 3000);
+        sigkillTimer.unref();
+    };
+    // Mark child as exited and cancel any pending SIGKILL escalation timer.
+    // Called from the exit handler and the error handler (error often
+    // precedes or accompanies exit). After this, cleanupChild() will not
+    // send signals to the already-dead process.
+    const onChildExit = () => {
+        childExited = true;
+        if (sigkillTimer) {
+            clearTimeout(sigkillTimer);
+            sigkillTimer = null;
+        }
+    };
+    const display = await new Promise((resolve, reject) => {
         let settled = false;
-        const finalizeResolve = () => {
+        const finalize = (fn) => {
             if (settled)
                 return;
             settled = true;
-            clearInterval(check);
             clearTimeout(timeout);
-            resolve();
-        };
-        const finalizeReject = (err) => {
-            if (settled)
-                return;
-            settled = true;
-            clearInterval(check);
-            clearTimeout(timeout);
-            reject(err);
+            fn();
         };
         const timeout = setTimeout(() => {
-            finalizeReject(new Error('Xvfb start timeout'));
+            cleanupChild();
+            finalize(() => reject(new Error('Xvfb start timeout')));
         }, 5000);
-        const check = setInterval(() => {
-            if (node_fs_1.default.existsSync(`/tmp/.X${displayNum}-lock`)) {
-                finalizeResolve();
+        const fd3 = xvfbProcess.stdio[3];
+        let buf = '';
+        fd3.on('data', (chunk) => {
+            buf += chunk.toString();
+            // Process ALL complete newline-delimited records currently in
+            // the buffer. A single data event may contain multiple records
+            // (e.g. "\n44\n" or "invalid\n44\n"). We loop through each
+            // complete record, skip malformed/blank lines, and resolve on
+            // the first valid display number. Any remaining incomplete data
+            // stays in buf for the next data event.
+            for (;;) {
+                const newlineIdx = buf.indexOf('\n');
+                if (newlineIdx === -1)
+                    break;
+                const line = buf.slice(0, newlineIdx).trim();
+                buf = buf.slice(newlineIdx + 1);
+                // Skip blank or malformed records — Xvfb may emit leading
+                // newlines or debug output before the display number.
+                const match = line.match(/^(\d+)$/);
+                if (match) {
+                    finalize(() => resolve(`:${match[1]}`));
+                    return;
+                }
             }
-        }, 100);
+        });
         xvfbProcess.once('error', (err) => {
-            finalizeReject(err);
+            cleanupChild();
+            onChildExit();
+            finalize(() => reject(err));
         });
         xvfbProcess.once('exit', (code, signal) => {
-            finalizeReject(new Error(`Xvfb exited early (code=${code ?? 'null'}, signal=${signal ?? 'null'})`));
+            onChildExit();
+            finalize(() => reject(new Error(`Xvfb exited early (code=${code ?? 'null'}, signal=${signal ?? 'null'})`)));
+        });
+        // fd3 may close before data arrives (e.g. Xvfb exits immediately).
+        fd3.once('end', () => {
+            if (!settled) {
+                cleanupChild();
+                finalize(() => reject(new Error('Xvfb fd3 closed before writing display number')));
+            }
+        });
+        // fd3 stream error — route through the same finalizer to avoid
+        // unhandled stream errors. Guard with `!settled` so that a late
+        // fd3 error after successful startup does not terminate a healthy
+        // Xvfb child (same guard as the end/close handlers).
+        fd3.once('error', (err) => {
+            if (!settled) {
+                cleanupChild();
+                finalize(() => reject(new Error(`Xvfb fd3 stream error: ${err instanceof Error ? err.message : String(err)}`)));
+            }
+        });
+        // fd3 closed without end event — the pipe is fully destroyed.
+        // Reject immediately rather than waiting for the 5s timeout.
+        fd3.once('close', () => {
+            if (!settled) {
+                cleanupChild();
+                finalize(() => reject(new Error('Xvfb fd3 stream closed before writing display number')));
+            }
         });
     });
     return { display, process: xvfbProcess };
 }
+// Test-only export of spawnXvfb for unit testing the fd3 parser and
+// child cleanup logic without a real Xvfb binary. Not part of the
+// public API; consumed by tests/unit/spawn-xvfb-displayfd.test.js.
+exports.spawnXvfbForTests = spawnXvfb;
 class ContextPool {
     pool = new Map();
     headlessOverrides = new Map();
     onEvictCallbacks = [];
+    activeAdmissions = 0;
+    activeAdmissionsByUser = new Map();
+    lifecycleEpoch = 0;
+    lifecycleEpochByUser = new Map();
+    globalClosure = null;
+    userClosures = new Map();
+    createClosureState() {
+        let resolve;
+        let resolveDrained;
+        return {
+            pending: 0,
+            promise: new Promise((r) => { resolve = r; }),
+            resolve,
+            drained: new Promise((r) => { resolveDrained = r; }),
+            resolveDrained,
+        };
+    }
+    releaseAdmission(userId) {
+        this.activeAdmissions--;
+        const remainingForUser = (this.activeAdmissionsByUser.get(userId) ?? 1) - 1;
+        if (remainingForUser <= 0) {
+            this.activeAdmissionsByUser.delete(userId);
+            this.userClosures.get(userId)?.resolveDrained();
+        }
+        else {
+            this.activeAdmissionsByUser.set(userId, remainingForUser);
+        }
+        if (this.activeAdmissions <= 0)
+            this.globalClosure?.resolveDrained();
+    }
+    async acquireAdmission(userId) {
+        const normalized = String(userId);
+        for (;;) {
+            const globalFence = this.globalClosure;
+            const userFence = this.userClosures.get(normalized);
+            if (globalFence)
+                await globalFence.promise;
+            if (userFence)
+                await userFence.promise;
+            this.activeAdmissions++;
+            this.activeAdmissionsByUser.set(normalized, (this.activeAdmissionsByUser.get(normalized) ?? 0) + 1);
+            if (!this.globalClosure && !this.userClosures.has(normalized)) {
+                let released = false;
+                const release = () => {
+                    if (released)
+                        return;
+                    released = true;
+                    this.releaseAdmission(normalized);
+                };
+                return {
+                    release,
+                    globalEpoch: this.lifecycleEpoch,
+                    userEpoch: this.lifecycleEpochByUser.get(normalized) ?? 0,
+                };
+            }
+            this.releaseAdmission(normalized);
+        }
+    }
+    async beginUserClosure(userId) {
+        const normalized = String(userId);
+        let state = this.userClosures.get(normalized);
+        if (!state) {
+            this.lifecycleEpochByUser.set(normalized, (this.lifecycleEpochByUser.get(normalized) ?? 0) + 1);
+            state = this.createClosureState();
+            this.userClosures.set(normalized, state);
+            if ((this.activeAdmissionsByUser.get(normalized) ?? 0) === 0)
+                state.resolveDrained();
+        }
+        state.pending++;
+        await state.drained;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const current = this.userClosures.get(normalized);
+            if (!current)
+                return;
+            current.pending--;
+            if (current.pending <= 0) {
+                this.userClosures.delete(normalized);
+                current.resolve();
+            }
+        };
+    }
+    async beginGlobalClosure() {
+        let state = this.globalClosure;
+        if (!state) {
+            this.lifecycleEpoch++;
+            state = this.createClosureState();
+            this.globalClosure = state;
+            if (this.activeAdmissions === 0)
+                state.resolveDrained();
+        }
+        state.pending++;
+        await state.drained;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            const current = this.globalClosure;
+            if (!current)
+                return;
+            current.pending--;
+            if (current.pending <= 0) {
+                this.globalClosure = null;
+                current.resolve();
+            }
+        };
+    }
     onEvict(callback) {
         this.onEvictCallbacks.push(callback);
     }
@@ -250,10 +411,11 @@ class ContextPool {
         }
     }
     async launchPersistentContext(userId, profileKey, contextOptions, resolvedProxy) {
-        const hostOS = getHostOS();
+        const hostOS = (0, platform_support_1.getHostOS)();
         const proxy = buildProxyConfig(resolvedProxy);
         const headless = this.headlessOverrides.get(userId) ?? CONFIG.headless;
-        const profileDir = profileDirForProfileKey(profileKey);
+        (0, platform_support_1.assertBrowserPlatformSupported)(hostOS, (0, platform_support_1.getHostArchitecture)(), headless);
+        const profileDir = (0, profile_path_1.resolveProfileDirForProfileKey)(CONFIG.profilesDir, profileKey);
         node_fs_1.default.mkdirSync(profileDir, { recursive: true });
         const compatPath = node_path_1.default.join(profileDir, 'compatibility.json');
         try {
@@ -436,7 +598,7 @@ class ContextPool {
             return;
         let lru = null;
         for (const entry of this.pool.values()) {
-            if (entry.launching || entry.staged)
+            if (entry.launching || entry.closing || entry.staged)
                 continue;
             if (!lru || entry.lastAccess < lru.lastAccess)
                 lru = entry;
@@ -448,9 +610,33 @@ class ContextPool {
         await this.closeContext(lru.profileKey);
     }
     async ensureContext(profileKey, userId, options, resolvedProxy, staged = false, stagedGeneration) {
+        const admission = await this.acquireAdmission(userId);
+        try {
+            const entry = await this.ensureContextAdmitted(profileKey, userId, options, resolvedProxy, staged, stagedGeneration);
+            const normalized = String(userId);
+            if (admission.globalEpoch !== this.lifecycleEpoch ||
+                admission.userEpoch !== (this.lifecycleEpochByUser.get(normalized) ?? 0)) {
+                await this.closeContextIfMatches(profileKey, entry.generation).catch(() => { });
+                throw new Error('Context admission superseded by session closure');
+            }
+            return entry;
+        }
+        finally {
+            admission.release();
+        }
+    }
+    async ensureContextAdmitted(profileKey, userId, options, resolvedProxy, staged = false, stagedGeneration) {
         const normalized = String(userId);
         let entry = this.pool.get(profileKey);
         const seed = pickSeedOptions(options);
+        if (entry?.closing) {
+            // Never hand out a context once shutdown has started. A request can
+            // pass the lifecycle idle-closure check immediately before cleanup
+            // begins closing the pool entry; wait for that exact close to finish,
+            // then re-read the pool and relaunch if needed.
+            await entry.closing;
+            entry = this.pool.get(profileKey);
+        }
         if (entry) {
             if (staged) {
                 entry.staged = true;
@@ -484,7 +670,7 @@ class ContextPool {
             entry.lastAccess = Date.now();
             return entry;
         }
-        const profileDir = profileDirForProfileKey(profileKey);
+        const profileDir = (0, profile_path_1.resolveProfileDirForProfileKey)(CONFIG.profilesDir, profileKey);
         const newEntry = {
             context: null,
             userId: normalized,
@@ -492,6 +678,7 @@ class ContextPool {
             profileDir,
             lastAccess: Date.now(),
             createdAt: Date.now(),
+            generation: node_crypto_1.default.randomUUID(),
             staged,
             stagedGeneration,
             proxyConfig: resolvedProxy || null,
@@ -506,13 +693,17 @@ class ContextPool {
             context.on('close', () => {
                 this.cleanupVirtualDisplay(newEntry);
                 (0, logging_1.log)('info', 'persistent context closed', { userId: normalized, profileKey, profileDir });
-                this.pool.delete(profileKey);
+                if (this.pool.get(profileKey) === newEntry) {
+                    this.pool.delete(profileKey);
+                }
             });
             return context;
         })
             .catch((err) => {
             this.cleanupVirtualDisplay(newEntry);
-            this.pool.delete(profileKey);
+            if (this.pool.get(profileKey) === newEntry) {
+                this.pool.delete(profileKey);
+            }
             const message = err instanceof Error ? err.message : String(err);
             (0, logging_1.log)('error', 'persistent context launch failed', { userId: normalized, profileKey, profileDir, error: message });
             throw err;
@@ -527,32 +718,147 @@ class ContextPool {
         const entry = this.pool.get(normalized);
         if (!entry || entry.staged)
             return;
-        try {
-            if (entry.launching) {
-                await entry.launching.catch(() => { });
-                entry.launching = undefined;
-            }
-            await entry.context?.close().catch(() => { });
+        if (entry.closing) {
+            await entry.closing;
+            return;
         }
-        finally {
-            this.cleanupVirtualDisplay(entry);
-            // Only delete if this entry is still in the pool (avoid deleting a newer entry with same key)
-            const currentEntry = this.pool.get(normalized);
-            if (currentEntry === entry) {
-                this.pool.delete(normalized);
-                (0, logging_1.log)('info', 'persistent context removed from pool', { userId: entry.userId, profileKey: normalized, profileDir: entry.profileDir });
+        entry.closing = (async () => {
+            try {
+                if (entry.launching) {
+                    await entry.launching.catch(() => { });
+                    entry.launching = undefined;
+                }
+                await entry.context?.close().catch(() => { });
             }
-            else {
-                (0, logging_1.log)('info', 'persistent context closed but newer entry exists', { userId: entry.userId, profileKey: normalized, profileDir: entry.profileDir });
+            finally {
+                this.cleanupVirtualDisplay(entry);
+                // Only delete if this entry is still in the pool (avoid deleting a newer entry with same key)
+                const currentEntry = this.pool.get(normalized);
+                if (currentEntry === entry) {
+                    this.pool.delete(normalized);
+                    (0, logging_1.log)('info', 'persistent context removed from pool', { userId: entry.userId, profileKey: normalized, profileDir: entry.profileDir });
+                }
+                else {
+                    (0, logging_1.log)('info', 'persistent context closed but newer entry exists', { userId: entry.userId, profileKey: normalized, profileDir: entry.profileDir });
+                }
+            }
+        })();
+        await entry.closing;
+    }
+    /**
+     * Close the context backing a specific session/profile for a user, but
+     * only that one — never unrelated sessions belonging to the same user.
+     *
+     * This is the blast-radius fix for nav recovery: a single failing tab's
+     * session is torn down without terminating the user's other sessions.
+     * The `profileKey` is the pool key (which is the sessionMapKey for
+     * established session profiles).
+     *
+     * Fail-closed semantics: when an explicit `profileKey` is provided but
+     * does not map to a matching context owned by this user, the call is a
+     * no-op — it does NOT fall back to user-wide close. A stale route key
+     * must never close every sibling session. User-wide fallback is reserved
+     * for genuinely legacy callers that pass no profile key at all.
+     */
+    async closeContextBySession(userId, profileKey) {
+        const normalizedUser = String(userId);
+        if (profileKey !== undefined && profileKey !== null && profileKey !== '') {
+            const normalizedProfile = String(profileKey);
+            // Capture the current pool entry's immutable generation before
+            // any await. This prevents the replacement race: if a new entry
+            // with the same key appears during teardown, the generation check
+            // below will NOT close the newer
+            // healthy context.
+            const entry = this.pool.get(normalizedProfile);
+            // HIGH A — Foreign owner: the pool entry exists but is owned by
+            // a different user. This is a fail-closed no-op. A foreign key
+            // must never tear down another user's session/context.
+            if (entry && entry.userId !== normalizedUser) {
+                (0, logging_1.log)('warn', 'closeContextBySession: foreign owner, no-op', {
+                    requestedUser: normalizedUser,
+                    actualOwner: entry.userId,
+                    profileKey: normalizedProfile,
+                });
+                return;
             }
+            // Staged entries are not eligible for recovery teardown.
+            if (entry && entry.staged) {
+                (0, logging_1.log)('warn', 'closeContextBySession: staged entry, no-op', {
+                    profileKey: normalizedProfile,
+                });
+                return;
+            }
+            // If the pool entry exists and the owner matches, capture its
+            // immutable opaque generation for safe teardown.
+            // If the pool entry is missing, generation is undefined — meaning
+            // "clean stale session/tab index records only; do NOT close any
+            // context, because a new context may have appeared during the
+            // await and must not be destroyed" (HIGH B).
+            const generation = entry?.generation;
+            // Resolve session.ts lazily to avoid the top-level circular dependency,
+            // but do it synchronously so the durable session snapshot is captured
+            // before this method's first await.
+            const { getSessionSnapshot, teardownSessionByKey } = require('./session');
+            // Capture the durable session identity (owner + session generation)
+            // synchronously, before teardownSessionByKey's internal await
+            // (HIGH round 8). This prevents the replacement race where a new
+            // session with the same key appears during the context-close await
+            // inside teardownSessionByKey. The snapshot's opaque generation is
+            // authoritative for session identity; the snapshot's owner is
+            // validated against the requesting user for the pool-missing path.
+            const sessionSnapshot = getSessionSnapshot(normalizedProfile);
+            // Foreign ownership check for the pool-missing path (HIGH round 8):
+            // When the pool entry is already gone, the pool-level owner check
+            // above could not fire. The durable session snapshot's owner tells
+            // us who the session belongs to. If the snapshot owner doesn't
+            // match the requesting user, this is a foreign call — fail closed.
+            // A foreign user must not delete another user's indexed session
+            // records when the pool entry is missing.
+            if (generation === undefined && sessionSnapshot.owner !== undefined && sessionSnapshot.owner !== normalizedUser) {
+                (0, logging_1.log)('warn', 'closeContextBySession: pool entry missing and session owner is foreign, no-op', {
+                    requestedUser: normalizedUser,
+                    sessionOwner: sessionSnapshot.owner,
+                    profileKey: normalizedProfile,
+                });
+                return;
+            }
+            // Full session teardown: unindex tabs, delete session entry,
+            // AND close the backing context (only when generation is known).
+            // When the pool entry is missing, session/tab records are still
+            // cleaned up so findTabById stops returning stale Page objects,
+            // but no context close is attempted (HIGH B).
+            //
+            // The session snapshot is passed through so teardownSessionByKey
+            // can validate the session owner (foreign-ownership fail-closed)
+            // and the session generation (replacement race prevention).
+            await teardownSessionByKey(normalizedProfile, generation, sessionSnapshot);
+            return;
         }
+        // No profile key provided — legacy caller without session identity.
+        // Only in this case do we fall back to user-wide close.
+        await this.closeContextByUserId(normalizedUser);
     }
-    async closeContextIfMatches(profileKey, expectedCreatedAt, expectedLastAccess) {
+    /**
+     * Close all non-staged contexts for a user (user-wide recovery fallback).
+     */
+    async closeContextByUserId(userId) {
+        const normalized = String(userId);
+        const entriesToClose = [];
+        for (const [profileKey, entry] of this.pool.entries()) {
+            if (entry.userId === normalized && !entry.staged) {
+                entriesToClose.push(profileKey);
+            }
+        }
+        for (const profileKey of entriesToClose) {
+            await this.closeContext(profileKey);
+        }
+    }
+    async closeContextIfMatches(profileKey, expectedGeneration, expectedLastAccess) {
         const normalized = String(profileKey);
         const entry = this.pool.get(normalized);
         if (!entry)
             return;
-        if (entry.createdAt !== expectedCreatedAt)
+        if (entry.generation !== expectedGeneration)
             return;
         // If lastAccess was provided and has changed, the context was reused - don't close
         if (expectedLastAccess !== undefined && entry.lastAccess !== expectedLastAccess)
@@ -573,19 +879,6 @@ class ContextPool {
         entry.stagedGeneration = undefined;
         await this.closeContext(normalized);
     }
-    async closeContextByUserId(userId) {
-        const normalized = String(userId);
-        // Close all contexts for this userId
-        const entriesToClose = [];
-        for (const [profileKey, entry] of this.pool.entries()) {
-            if (entry.userId === normalized && !entry.staged) {
-                entriesToClose.push(profileKey);
-            }
-        }
-        for (const profileKey of entriesToClose) {
-            await this.closeContext(profileKey);
-        }
-    }
     async closeStagedContextByUserId(userId, generation) {
         const normalized = String(userId);
         // Close all staged contexts for this userId