camofox-browser 2.1.1 → 2.4.3

package/dist/src/services/session.js

@@ -1,16 +1,43 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_TABS_PER_SESSION = exports.MAX_SESSIONS = exports.SESSION_TIMEOUT_MS = void 0;
 exports.__getUserConcurrencyStateForTests = __getUserConcurrencyStateForTests;
+exports.__getSessionsMapForTests = __getSessionsMapForTests;
 exports.withUserLimit = withUserLimit;
+exports.cleanupSessionsForUserId = cleanupSessionsForUserId;
 exports.normalizeUserId = normalizeUserId;
 exports.getSessionMapKey = getSessionMapKey;
+exports.getEstablishedSessionProfile = getEstablishedSessionProfile;
+exports.hasDefaultSessionProfileRuntime = hasDefaultSessionProfileRuntime;
+exports.claimDefaultSessionProfileRuntime = claimDefaultSessionProfileRuntime;
+exports.clearDefaultSessionProfileClaim = clearDefaultSessionProfileClaim;
+exports.getSessionProfileLaunchSettings = getSessionProfileLaunchSettings;
+exports.getCanonicalProfile = getCanonicalProfile;
+exports.hasCanonicalProfile = hasCanonicalProfile;
+exports.acquireFirstCreateMutex = acquireFirstCreateMutex;
+exports.commitCanonicalProfile = commitCanonicalProfile;
+exports.rollbackCanonicalMutex = rollbackCanonicalMutex;
+exports.createCanonicalProfile = createCanonicalProfile;
+exports.clearCanonicalProfile = clearCanonicalProfile;
+exports.establishSessionProfile = establishSessionProfile;
+exports.clearSessionProfile = clearSessionProfile;
+exports.acquireSessionProfileCreateMutex = acquireSessionProfileCreateMutex;
+exports.waitForSessionProfileCreate = waitForSessionProfileCreate;
+exports.rollbackSessionProfileRuntime = rollbackSessionProfileRuntime;
 exports.getSessionsForUser = getSessionsForUser;
 exports.getAllSessions = getAllSessions;
 exports.countTotalTabsForSessions = countTotalTabsForSessions;
+exports.getLifecycleSessionSnapshot = getLifecycleSessionSnapshot;
+exports.getSessionsSnapshot = getSessionsSnapshot;
 exports.getTabGroup = getTabGroup;
 exports.unindexSessionTabs = unindexSessionTabs;
 exports.findTabById = findTabById;
+exports.createStagedSession = createStagedSession;
+exports.commitStagedFirstUse = commitStagedFirstUse;
+exports.rollbackStagedFirstUse = rollbackStagedFirstUse;
 exports.getSession = getSession;
 exports.indexTab = indexTab;
 exports.unindexTab = unindexTab;
@@ -19,9 +46,12 @@ exports.closeSessionsForUser = closeSessionsForUser;
 exports.closeAllSessions = closeAllSessions;
 exports.startCleanupInterval = startCleanupInterval;
 exports.stopCleanupInterval = stopCleanupInterval;
+exports.runLifecycleIdleCleanup = runLifecycleIdleCleanup;
+const node_crypto_1 = __importDefault(require("node:crypto"));
 const logging_1 = require("../middleware/logging");
 const tab_1 = require("./tab");
 const config_1 = require("../utils/config");
+const presets_1 = require("../utils/presets");
 const context_pool_1 = require("./context-pool");
 const download_1 = require("./download");
 const health_1 = require("./health");
@@ -31,12 +61,25 @@ const CONFIG = (0, config_1.loadConfig)();
 // userId -> { context, tabGroups: Map<sessionKey, Map<tabId, TabState>>, lastAccess }
 // Note: sessionKey was previously called listItemId - both are accepted for backward compatibility
 const sessions = new Map();
+const sessionOwners = new Map();
 // sessionKey -> in-flight session creation promise
 // Avoids storing partially-initialized sessions (e.g., context: null cast) and dedupes concurrent creates.
 const launchingSessions = new Map();
+const launchingSessionOwners = new Map();
+const lifecycleIdleClosures = new Map();
 // tabId -> sessions map key
 // Persistent profiles are keyed only by userId, while tab endpoints only get tabId.
 const tabSessionIndex = new Map();
+// Canonical per-user profile: stores resolved overrides from the first core POST /tabs.
+// Survives passive context eviction; cleared only on explicit session close/cleanup.
+const canonicalProfiles = new Map();
+// Session profiles keyed by userId::sessionKey to track separate proxy/geo profiles per session
+const sessionProfiles = new Map();
+const defaultSessionProfileClaims = new Map();
+// Per-user mutex covering the entire first-create lifecycle (establishment -> tab commit).
+// Prevents sibling requests from observing provisional canonical state.
+const firstCreateMutexes = new Map();
+const sessionProfileCreateMutexes = new Map();
 const userConcurrency = new Map();
 function __getUserConcurrencyStateForTests(userId) {
     const key = String(userId).toLowerCase().trim();
@@ -45,6 +88,43 @@ function __getUserConcurrencyStateForTests(userId) {
         return null;
     return { active: state.active, queueLength: state.queue.length };
 }
+function __getSessionsMapForTests() {
+    return sessions;
+}
+function beginLifecycleIdleClosure(userId) {
+    const key = normalizeUserId(userId);
+    let state = lifecycleIdleClosures.get(key);
+    if (!state) {
+        let resolve;
+        const promise = new Promise((r) => {
+            resolve = r;
+        });
+        state = { pending: 0, promise, resolve };
+        lifecycleIdleClosures.set(key, state);
+    }
+    state.pending++;
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        const current = lifecycleIdleClosures.get(key);
+        if (!current)
+            return;
+        current.pending--;
+        if (current.pending <= 0) {
+            lifecycleIdleClosures.delete(key);
+            current.resolve();
+        }
+    };
+}
+async function waitForLifecycleIdleClosure(userId) {
+    const key = normalizeUserId(userId);
+    const pending = lifecycleIdleClosures.get(key);
+    if (pending) {
+        await pending.promise;
+    }
+}
 async function withUserLimit(userId, maxConcurrent, operation, operationTimeoutMs) {
     const key = String(userId).toLowerCase().trim();
     let state = userConcurrency.get(key);
@@ -96,52 +176,371 @@ async function withUserLimit(userId, maxConcurrent, operation, operationTimeoutM
         }
     }
 }
-function cleanupSessionsForUserId(userId, reason) {
-    const prefix = normalizeUserId(userId);
+function cleanupSessionsForUserId(userId, reason, clearCanonical = true, options = {}) {
+    const key = normalizeUserId(userId);
+    const allowInternalSessionKey = options.allowInternalSessionKey ?? true;
+    const ownerKeys = new Set();
     // If a session is currently being created, drop our reference so callers don't keep a stale placeholder.
-    launchingSessions.delete(prefix);
-    void (0, vnc_1.stopVnc)(prefix).catch(() => { });
-    try {
-        (0, download_1.cleanupUserDownloads)(prefix);
+    for (const launchKey of Array.from(launchingSessions.keys())) {
+        if (isLaunchingSessionKeyForCleanupKey(launchKey, key, allowInternalSessionKey)) {
+            ownerKeys.add(launchingSessionOwners.get(launchKey) ?? key);
+            launchingSessions.delete(launchKey);
+            launchingSessionOwners.delete(launchKey);
+        }
+    }
+    for (const [sessionKey, session] of Array.from(sessions.entries())) {
+        if (!isSessionMapKeyForCleanupKey(sessionKey, key, allowInternalSessionKey))
+            continue;
+        ownerKeys.add(sessionOwners.get(sessionKey) ?? sessionKey);
+        unindexSessionTabs(session);
+        sessions.delete(sessionKey);
+        sessionOwners.delete(sessionKey);
+        (0, logging_1.log)('info', 'session cleaned up', { userId: key, sessionKey, reason });
     }
-    catch {
-        // ignore cleanup errors
+    if (ownerKeys.size === 0)
+        ownerKeys.add(key);
+    for (const ownerKey of ownerKeys) {
+        void (0, vnc_1.stopVnc)(ownerKey).catch(() => { });
+        try {
+            (0, download_1.cleanupUserDownloads)(ownerKey);
+        }
+        catch {
+            // ignore cleanup errors
+        }
+        (0, tracing_1.cleanupTracing)(ownerKey);
+        clearDefaultSessionProfileClaimsForUser(ownerKey);
     }
-    (0, tracing_1.cleanupTracing)(prefix);
-    for (const [key, session] of sessions) {
-        if (key === prefix || key.startsWith(prefix + ':')) {
-            unindexSessionTabs(session);
-            sessions.delete(key);
-            (0, logging_1.log)('info', 'session cleaned up', { userId: key, reason });
+    if (clearCanonical) {
+        canonicalProfiles.delete(key);
+        clearDefaultSessionProfileClaimsForUser(key);
+        const mutex = firstCreateMutexes.get(key);
+        if (mutex) {
+            mutex.resolve(false);
+            firstCreateMutexes.delete(key);
+        }
+        // Also clear all session profiles for this user
+        const profileKeysToDelete = [];
+        for (const [profileKey, profile] of sessionProfiles.entries()) {
+            if (profile.userId === key) {
+                profileKeysToDelete.push(profileKey);
+            }
+        }
+        for (const profileKey of profileKeysToDelete) {
+            sessionProfiles.delete(profileKey);
+        }
+        for (const [profileKey, mutex] of Array.from(sessionProfileCreateMutexes.entries())) {
+            if (mutex.userId === key) {
+                mutex.resolve(false);
+                sessionProfileCreateMutexes.delete(profileKey);
+            }
         }
     }
-    userConcurrency.delete(prefix);
+    userConcurrency.delete(key);
 }
 context_pool_1.contextPool.onEvict((userId) => {
-    cleanupSessionsForUserId(userId, 'context_evicted');
+    cleanupSessionsForUserId(userId, 'context_evicted', false);
     // Note: the pool will close the context; session cleanup only removes dead Page references.
 });
-exports.SESSION_TIMEOUT_MS = Math.max(60000, Number.parseInt(process.env.CAMOFOX_SESSION_TIMEOUT || '', 10) || 1800000);
-exports.MAX_SESSIONS = Math.max(1, Number.parseInt(process.env.CAMOFOX_MAX_SESSIONS || '', 10) || 50);
-exports.MAX_TABS_PER_SESSION = Math.max(1, Number.parseInt(process.env.CAMOFOX_MAX_TABS || '', 10) || 10);
+exports.SESSION_TIMEOUT_MS = CONFIG.sessionTimeoutMs;
+exports.MAX_SESSIONS = CONFIG.maxSessions;
+exports.MAX_TABS_PER_SESSION = CONFIG.maxTabsPerSession;
 function normalizeUserId(userId) {
     return String(userId);
 }
-function getSessionMapKey(userId, contextOverrides) {
-    // Persistent profiles are keyed only by userId; overrides are applied on first launch.
-    void contextOverrides;
-    return normalizeUserId(userId);
+function encodeKeyComponent(value) {
+    return Buffer.from(String(value), 'utf16le').toString('base64url');
+}
+function userSessionMapKey(userId) {
+    return `u:${encodeKeyComponent(normalizeUserId(userId))}`;
+}
+function sessionOverlayKey(userId, sessionKey) {
+    return `o:${encodeKeyComponent(normalizeUserId(userId))}:${encodeKeyComponent(sessionKey)}`;
+}
+function clearDefaultSessionProfileClaimsForUser(userId) {
+    const key = normalizeUserId(userId);
+    for (const [claimKey, claim] of Array.from(defaultSessionProfileClaims.entries())) {
+        if (claim.userId === key) {
+            defaultSessionProfileClaims.delete(claimKey);
+        }
+    }
+}
+function isSessionMapKeyForUser(sessionMapKey, userKey) {
+    return sessionMapKey === userSessionMapKey(userKey) || sessionOwners.get(sessionMapKey) === userKey;
+}
+function isSessionMapKeyForCleanupKey(sessionMapKey, cleanupKey, allowInternalSessionKey = true) {
+    return (allowInternalSessionKey && sessionMapKey === cleanupKey) || isSessionMapKeyForUser(sessionMapKey, cleanupKey);
+}
+function isLaunchingSessionKeyForCleanupKey(sessionMapKey, cleanupKey, allowInternalSessionKey = true) {
+    return ((allowInternalSessionKey && sessionMapKey === cleanupKey) ||
+        sessionMapKey === userSessionMapKey(cleanupKey) ||
+        launchingSessionOwners.get(sessionMapKey) === cleanupKey);
+}
+// Backward compatible version - takes contextOverrides instead of session profile  
+function getSessionMapKey(userId, contextOverridesOrSessionKey, profileSignature) {
+    // New signature: (userId, sessionKey, profileSignature)
+    if (typeof contextOverridesOrSessionKey === 'string') {
+        const sessionKey = contextOverridesOrSessionKey;
+        if (profileSignature) {
+            return `p:${encodeKeyComponent(normalizeUserId(userId))}:${encodeKeyComponent(sessionKey)}:${encodeKeyComponent(profileSignature)}`;
+        }
+        return `s:${encodeKeyComponent(normalizeUserId(userId))}:${encodeKeyComponent(sessionKey)}`;
+    }
+    // Old signature: (userId, contextOverrides) - backward compatibility
+    // This maintains the user-scoped behavior for existing routes
+    void contextOverridesOrSessionKey;
+    return userSessionMapKey(userId);
+}
+function getEstablishedSessionProfile(userId, sessionKey) {
+    return sessionProfiles.get(sessionOverlayKey(userId, sessionKey));
+}
+function hasDefaultSessionProfileRuntime(userId, sessionKey) {
+    const key = normalizeUserId(userId);
+    if (defaultSessionProfileClaims.has(sessionOverlayKey(key, sessionKey)))
+        return true;
+    const defaultSession = sessions.get(userSessionMapKey(key));
+    return defaultSession?.tabGroups.has(sessionKey) ?? false;
+}
+function claimDefaultSessionProfileRuntime(userId, sessionKey) {
+    if (getEstablishedSessionProfile(userId, sessionKey))
+        return false;
+    if (hasDefaultSessionProfileRuntime(userId, sessionKey))
+        return false;
+    const key = normalizeUserId(userId);
+    defaultSessionProfileClaims.set(sessionOverlayKey(key, sessionKey), { userId: key, sessionKey });
+    return true;
+}
+function clearDefaultSessionProfileClaim(userId, sessionKey) {
+    defaultSessionProfileClaims.delete(sessionOverlayKey(userId, sessionKey));
+}
+function contextOverridesFromProfile(profile) {
+    const overrides = {};
+    if (profile.locale !== undefined)
+        overrides.locale = profile.locale;
+    if (profile.timezoneId !== undefined)
+        overrides.timezoneId = profile.timezoneId;
+    if (profile.geolocation !== undefined)
+        overrides.geolocation = profile.geolocation;
+    if (profile.viewport !== undefined)
+        overrides.viewport = profile.viewport;
+    return Object.keys(overrides).length > 0 ? overrides : null;
+}
+function getSessionProfileLaunchSettings(userId, profileKey) {
+    const key = normalizeUserId(userId);
+    if (profileKey === userSessionMapKey(key)) {
+        const canonical = canonicalProfiles.get(key);
+        return canonical ? { contextOverrides: canonical.resolvedOverrides, proxy: null } : undefined;
+    }
+    for (const profile of sessionProfiles.values()) {
+        if (profile.userId !== key)
+            continue;
+        if (getSessionMapKey(key, profile.sessionKey, profile.signature) !== profileKey)
+            continue;
+        return {
+            contextOverrides: contextOverridesFromProfile(profile.resolvedProfile),
+            proxy: profile.resolvedProfile.proxy,
+        };
+    }
+    return undefined;
+}
+function resolveRuntimeSessionProfile(userId, sessionKey, contextOverrides) {
+    const userKey = normalizeUserId(userId);
+    if (!sessionKey) {
+        return {
+            sessionMapKey: userSessionMapKey(userKey),
+            profileKey: userSessionMapKey(userKey),
+            contextOverrides,
+            resolvedProxy: null,
+        };
+    }
+    const established = getEstablishedSessionProfile(userId, sessionKey);
+    if (!established) {
+        return {
+            sessionMapKey: userSessionMapKey(userKey),
+            profileKey: userSessionMapKey(userKey),
+            contextOverrides,
+            resolvedProxy: null,
+        };
+    }
+    const profileKey = getSessionMapKey(userId, sessionKey, established.signature);
+    return {
+        sessionMapKey: profileKey,
+        profileKey,
+        contextOverrides: contextOverridesFromProfile(established.resolvedProfile),
+        resolvedProxy: established.resolvedProfile.proxy,
+    };
+}
+function getCanonicalProfile(userId) {
+    return canonicalProfiles.get(normalizeUserId(userId));
+}
+function hasCanonicalProfile(userId) {
+    return canonicalProfiles.has(normalizeUserId(userId));
+}
+/**
+ * Try to acquire the first-create mutex for a user.
+ * Returns { acquired: true } if we are the first creator (mutex acquired).
+ * Returns { acquired: false, wait: Promise<boolean> } if another request is first-creating.
+ * The promise resolves to true (committed) or false (rolled back).
+ * If canonical already exists (committed), returns { acquired: false, wait: resolved-true }.
+ */
+function acquireFirstCreateMutex(userId) {
+    const key = normalizeUserId(userId);
+    if (canonicalProfiles.has(key)) {
+        return { acquired: false, wait: Promise.resolve(true) };
+    }
+    const existing = firstCreateMutexes.get(key);
+    if (existing) {
+        return { acquired: false, wait: existing.promise };
+    }
+    let resolve;
+    const promise = new Promise((r) => {
+        resolve = r;
+    });
+    firstCreateMutexes.set(key, { promise, resolve });
+    return { acquired: true };
+}
+/**
+ * Commit: store the canonical profile and release the mutex (signaling success to waiters).
+ */
+function commitCanonicalProfile(userId, resolved) {
+    const key = normalizeUserId(userId);
+    const profile = {
+        resolvedOverrides: resolved,
+        hash: (0, presets_1.contextHash)(resolved),
+        establishedAt: Date.now(),
+    };
+    canonicalProfiles.set(key, profile);
+    const mutex = firstCreateMutexes.get(key);
+    if (mutex) {
+        mutex.resolve(true);
+        firstCreateMutexes.delete(key);
+    }
+    (0, logging_1.log)('info', 'canonical profile committed', { userId: key, hash: profile.hash });
+    return profile;
+}
+/**
+ * Rollback: release the mutex (signaling failure to waiters). No canonical is stored.
+ */
+function rollbackCanonicalMutex(userId) {
+    const key = normalizeUserId(userId);
+    const mutex = firstCreateMutexes.get(key);
+    if (mutex) {
+        mutex.resolve(false);
+        firstCreateMutexes.delete(key);
+    }
+}
+/**
+ * Create a CanonicalProfile object without storing it (for hash comparison during first-create).
+ */
+function createCanonicalProfile(resolved) {
+    return {
+        resolvedOverrides: resolved,
+        hash: (0, presets_1.contextHash)(resolved),
+        establishedAt: Date.now(),
+    };
+}
+function clearCanonicalProfile(userId) {
+    const key = normalizeUserId(userId);
+    canonicalProfiles.delete(key);
+    const mutex = firstCreateMutexes.get(key);
+    if (mutex) {
+        mutex.resolve(false);
+        firstCreateMutexes.delete(key);
+    }
+}
+/**
+ * Store or validate a session profile for a specific userId + sessionKey combination.
+ * Returns the established profile if successful.
+ * Throws if a conflicting profile is already established for the same userId + sessionKey.
+ */
+function establishSessionProfile(userId, sessionKey, profile) {
+    const key = sessionOverlayKey(userId, sessionKey);
+    const existing = sessionProfiles.get(key);
+    if (existing) {
+        if (existing.signature !== profile.signature) {
+            throw new Error('Session profile conflict');
+        }
+        return existing;
+    }
+    const established = {
+        userId: normalizeUserId(userId),
+        sessionKey,
+        signature: profile.signature,
+        resolvedProfile: profile,
+        establishedAt: Date.now(),
+    };
+    sessionProfiles.set(key, established);
+    (0, logging_1.log)('info', 'session profile established', {
+        userId: established.userId,
+        sessionKey,
+        signature: profile.signature,
+    });
+    return established;
+}
+function clearSessionProfile(userId, sessionKey) {
+    const key = sessionOverlayKey(userId, sessionKey);
+    sessionProfiles.delete(key);
+}
+function acquireSessionProfileCreateMutex(userId, sessionKey, signature) {
+    const key = sessionOverlayKey(userId, sessionKey);
+    const existing = sessionProfileCreateMutexes.get(key);
+    if (existing) {
+        return { acquired: false, wait: existing.promise };
+    }
+    let resolve;
+    const promise = new Promise((r) => {
+        resolve = r;
+    });
+    const mutex = {
+        userId: normalizeUserId(userId),
+        sessionKey,
+        signature,
+        promise,
+        resolve,
+    };
+    sessionProfileCreateMutexes.set(key, mutex);
+    let released = false;
+    return {
+        acquired: true,
+        release: (committed) => {
+            if (released)
+                return;
+            released = true;
+            const current = sessionProfileCreateMutexes.get(key);
+            if (current === mutex) {
+                current.resolve(committed);
+                sessionProfileCreateMutexes.delete(key);
+            }
+        },
+    };
+}
+async function waitForSessionProfileCreate(userId, sessionKey) {
+    const pending = sessionProfileCreateMutexes.get(sessionOverlayKey(userId, sessionKey));
+    if (pending) {
+        await pending.promise.catch(() => false);
+    }
+}
+async function rollbackSessionProfileRuntime(userId, sessionKey, profileSignature) {
+    const overlayKey = sessionOverlayKey(userId, sessionKey);
+    const existingProfile = sessionProfiles.get(overlayKey);
+    if (existingProfile?.signature === profileSignature) {
+        sessionProfiles.delete(overlayKey);
+    }
+    const sessionMapKey = getSessionMapKey(userId, sessionKey, profileSignature);
+    const session = sessions.get(sessionMapKey);
+    if (session) {
+        unindexSessionTabs(session);
+        sessions.delete(sessionMapKey);
+    }
+    sessionOwners.delete(sessionMapKey);
+    launchingSessions.delete(sessionMapKey);
+    launchingSessionOwners.delete(sessionMapKey);
+    await context_pool_1.contextPool.closeContext(sessionMapKey).catch(() => { });
 }
 function getSessionsForUser(userId) {
     if (userId === undefined || userId === null)
         return [];
-    const prefix = normalizeUserId(userId);
-    const out = [];
-    for (const [key, session] of sessions) {
-        if (key === prefix || key.startsWith(prefix + ':'))
-            out.push([key, session]);
-    }
-    return out;
+    const key = normalizeUserId(userId);
+    return Array.from(sessions.entries()).filter(([sessionKey]) => isSessionMapKeyForUser(sessionKey, key));
 }
 function getAllSessions() {
     return sessions;
@@ -155,6 +554,16 @@ function countTotalTabsForSessions(sessionsForUser) {
     }
     return totalTabs;
 }
+function getLifecycleSessionSnapshot() {
+    return {
+        liveSessions: sessions.size,
+        liveTabs: countTotalTabsForSessions(),
+        stagedCreates: launchingSessions.size,
+    };
+}
+function getSessionsSnapshot() {
+    return new Map(sessions);
+}
 function getTabGroup(session, sessionKey) {
     let group = session.tabGroups.get(sessionKey);
     if (!group) {
@@ -187,10 +596,10 @@ function unindexSessionTabs(session) {
 function findTabById(tabId, userId) {
     if (userId === undefined || userId === null)
         return null;
-    const prefix = normalizeUserId(userId);
+    const key = normalizeUserId(userId);
     const indexedKey = tabSessionIndex.get(tabId);
     if (indexedKey) {
-        if (!(indexedKey === prefix || indexedKey.startsWith(prefix + ':'))) {
+        if (!isSessionMapKeyForUser(indexedKey, key)) {
             return null;
         }
         const session = sessions.get(indexedKey);
@@ -201,64 +610,125 @@ function findTabById(tabId, userId) {
         }
         tabSessionIndex.delete(tabId);
     }
-    for (const [sessionKey, session] of sessions) {
-        if (!(sessionKey === prefix || sessionKey.startsWith(prefix + ':')))
-            continue;
-        const found = findTab(session, tabId);
-        if (found) {
-            tabSessionIndex.set(tabId, sessionKey);
-            return { sessionKey, session, ...found };
-        }
+    const defaultSessionKey = userSessionMapKey(key);
+    const session = sessions.get(defaultSessionKey);
+    if (!session)
+        return null;
+    const found = findTab(session, tabId);
+    if (found) {
+        tabSessionIndex.set(tabId, defaultSessionKey);
+        return { sessionKey: defaultSessionKey, session, ...found };
     }
     return null;
 }
-async function getSession(userId, contextOverrides) {
-    const key = getSessionMapKey(userId, contextOverrides);
-    let session = sessions.get(key);
+function buildBrowserContextOptions(contextOverrides, hasSessionProxy = false) {
     const resolved = contextOverrides || {};
     const contextOptions = {
         viewport: resolved.viewport || { width: 1280, height: 720 },
         permissions: ['geolocation'],
     };
     const hasOverrides = !!(contextOverrides &&
-        (contextOverrides.locale !== undefined || contextOverrides.timezoneId !== undefined || contextOverrides.geolocation !== undefined));
+        (contextOverrides.locale !== undefined ||
+            contextOverrides.timezoneId !== undefined ||
+            contextOverrides.geolocation !== undefined));
     // With proxy+geoip, camoufox auto-configures locale/timezone/geo from proxy IP.
     // If caller explicitly supplies overrides, apply them even when proxy is active.
-    if (!CONFIG.proxy.host || hasOverrides) {
+    if ((!CONFIG.proxy.host && !hasSessionProxy) || hasOverrides) {
         contextOptions.locale = resolved.locale || 'en-US';
         contextOptions.timezoneId = resolved.timezoneId || 'America/Los_Angeles';
         contextOptions.geolocation = resolved.geolocation || { latitude: 37.7749, longitude: -122.4194 };
     }
+    return contextOptions;
+}
+async function createStagedSession(userId, contextOverrides, sessionKey) {
+    const runtimeProfile = resolveRuntimeSessionProfile(userId, sessionKey, contextOverrides);
+    if (context_pool_1.contextPool.size() >= exports.MAX_SESSIONS) {
+        throw new Error('Maximum concurrent sessions reached');
+    }
+    const generation = node_crypto_1.default.randomUUID();
+    const contextOptions = buildBrowserContextOptions(runtimeProfile.contextOverrides, !!runtimeProfile.resolvedProxy);
+    const entry = await context_pool_1.contextPool.ensureContext(runtimeProfile.profileKey, normalizeUserId(userId), contextOptions, runtimeProfile.resolvedProxy, true, generation);
+    const session = {
+        context: entry.context,
+        tabGroups: new Map(),
+        lastAccess: Date.now(),
+    };
+    return { session, contextEntry: entry, generation };
+}
+function commitStagedFirstUse(userId, session, contextOverrides, tabInfo, generation) {
+    const key = normalizeUserId(userId);
+    const entry = context_pool_1.contextPool.getEntry(tabInfo.sessionMapKey);
+    if (!entry || entry.stagedGeneration !== generation)
+        return false;
+    if (!firstCreateMutexes.has(key) || canonicalProfiles.has(key)) {
+        return false;
+    }
+    session.lastAccess = Date.now();
+    const group = getTabGroup(session, tabInfo.sessionKey);
+    group.set(tabInfo.tabId, tabInfo.tabState);
+    sessions.set(tabInfo.sessionMapKey, session);
+    sessionOwners.set(tabInfo.sessionMapKey, key);
+    entry.staged = false;
+    entry.stagedGeneration = undefined;
+    indexTab(tabInfo.tabId, tabInfo.sessionMapKey);
+    commitCanonicalProfile(userId, contextOverrides);
+    return true;
+}
+async function rollbackStagedFirstUse(userId, generation) {
+    const key = normalizeUserId(userId);
+    try {
+        try {
+            (0, download_1.cleanupUserDownloads)(key);
+        }
+        catch {
+            // ignore cleanup errors
+        }
+        await context_pool_1.contextPool.closeStagedContextByUserId(key, generation);
+    }
+    finally {
+        rollbackCanonicalMutex(userId);
+    }
+}
+async function getSession(userId, contextOverrides, sessionKey) {
+    const key = normalizeUserId(userId);
+    await waitForLifecycleIdleClosure(key);
+    const runtimeProfile = resolveRuntimeSessionProfile(userId, sessionKey, contextOverrides);
+    let session = sessions.get(runtimeProfile.sessionMapKey);
+    const contextOptions = buildBrowserContextOptions(runtimeProfile.contextOverrides, !!runtimeProfile.resolvedProxy);
     if (!session) {
-        const existingLaunch = launchingSessions.get(key);
+        const existingLaunch = launchingSessions.get(runtimeProfile.sessionMapKey);
         if (existingLaunch) {
             session = await existingLaunch;
             session.lastAccess = Date.now();
             return session;
         }
-        if (sessions.size + launchingSessions.size >= exports.MAX_SESSIONS) {
+        if (context_pool_1.contextPool.size() >= exports.MAX_SESSIONS) {
             throw new Error('Maximum concurrent sessions reached');
         }
         const launchPromise = (async () => {
-            const entry = await context_pool_1.contextPool.ensureContext(normalizeUserId(userId), contextOptions);
+            const entry = await context_pool_1.contextPool.ensureContext(runtimeProfile.profileKey, key, contextOptions, runtimeProfile.resolvedProxy);
             const created = { context: entry.context, tabGroups: new Map(), lastAccess: Date.now() };
-            sessions.set(key, created);
-            (0, logging_1.log)('info', 'session created', { userId: key });
+            sessions.set(runtimeProfile.sessionMapKey, created);
+            sessionOwners.set(runtimeProfile.sessionMapKey, key);
+            (0, logging_1.log)('info', 'session created', { userId: key, sessionMapKey: runtimeProfile.sessionMapKey });
             return created;
         })();
-        launchingSessions.set(key, launchPromise);
+        launchingSessionOwners.set(runtimeProfile.sessionMapKey, key);
+        launchingSessions.set(runtimeProfile.sessionMapKey, launchPromise);
         try {
             session = await launchPromise;
         }
         finally {
-            launchingSessions.delete(key);
+            launchingSessions.delete(runtimeProfile.sessionMapKey);
+            launchingSessionOwners.delete(runtimeProfile.sessionMapKey);
         }
     }
     else {
         // Re-resolve context on each access; ContextPool de-dupes launches and detects unexpected closes.
-        const entry = await context_pool_1.contextPool.ensureContext(normalizeUserId(userId), contextOptions);
+        const entry = await context_pool_1.contextPool.ensureContext(runtimeProfile.profileKey, key, contextOptions, runtimeProfile.resolvedProxy);
         session.context = entry.context;
         session.lastAccess = Date.now();
+        sessionOwners.set(runtimeProfile.sessionMapKey, key);
     }
     // For newly created sessions, lastAccess/context are already set.
     session.lastAccess = Date.now();
@@ -273,30 +743,59 @@ function unindexTab(tabId) {
 }
 function clearAllState() {
     sessions.clear();
+    sessionOwners.clear();
+    launchingSessions.clear();
+    launchingSessionOwners.clear();
     tabSessionIndex.clear();
+    canonicalProfiles.clear();
+    sessionProfiles.clear();
+    defaultSessionProfileClaims.clear();
+    for (const [, mutex] of sessionProfileCreateMutexes)
+        mutex.resolve(false);
+    sessionProfileCreateMutexes.clear();
+    for (const [, state] of lifecycleIdleClosures)
+        state.resolve();
+    lifecycleIdleClosures.clear();
+    for (const [, mutex] of firstCreateMutexes)
+        mutex.resolve(false);
+    firstCreateMutexes.clear();
     (0, tab_1.clearAllTabLocks)();
     userConcurrency.clear();
 }
-async function closeSessionsForUser(userId) {
-    const prefix = userId;
-    await context_pool_1.contextPool.closeContext(prefix).catch(() => { });
-    cleanupSessionsForUserId(prefix, 'explicit_close');
+async function closeSessionsForUser(userId, options = {}) {
+    const key = normalizeUserId(userId);
+    await context_pool_1.contextPool.closeStagedContextByUserId(key).catch(() => { });
+    await context_pool_1.contextPool.closeContextByUserId(key).catch(() => { });
+    cleanupSessionsForUserId(key, 'explicit_close', options.clearProfiles ?? true, { allowInternalSessionKey: false });
 }
 async function closeAllSessions() {
     await context_pool_1.contextPool.closeAll().catch(() => { });
-    for (const [userId, session] of sessions) {
-        void (0, vnc_1.stopVnc)(userId).catch(() => { });
+    for (const [sessionKey, session] of sessions) {
+        const ownerUserId = sessionOwners.get(sessionKey) ?? sessionKey;
+        void (0, vnc_1.stopVnc)(ownerUserId).catch(() => { });
         unindexSessionTabs(session);
-        sessions.delete(userId);
-        (0, tracing_1.cleanupTracing)(userId);
+        sessions.delete(sessionKey);
+        sessionOwners.delete(sessionKey);
+        (0, tracing_1.cleanupTracing)(ownerUserId);
         try {
-            (0, download_1.cleanupUserDownloads)(userId);
+            (0, download_1.cleanupUserDownloads)(ownerUserId);
         }
         catch {
             // ignore
         }
     }
     launchingSessions.clear();
+    launchingSessionOwners.clear();
+    sessionOwners.clear();
+    canonicalProfiles.clear();
+    sessionProfiles.clear();
+    defaultSessionProfileClaims.clear();
+    for (const [, mutex] of sessionProfileCreateMutexes)
+        mutex.resolve(false);
+    sessionProfileCreateMutexes.clear();
+    for (const [, mutex] of firstCreateMutexes)
+        mutex.resolve(false);
+    firstCreateMutexes.clear();
 }
 let cleanupInterval = null;
 function startCleanupInterval() {
@@ -306,12 +805,15 @@ function startCleanupInterval() {
         const now = Date.now();
         for (const [sessionKey, session] of sessions) {
             if (now - session.lastAccess > exports.SESSION_TIMEOUT_MS) {
+                const ownerUserId = sessionOwners.get(sessionKey) ?? sessionKey;
                 // Persistent profile is preserved on disk; closing the context frees resources.
                 context_pool_1.contextPool.closeContext(sessionKey).catch(() => { });
                 unindexSessionTabs(session);
+                clearDefaultSessionProfileClaimsForUser(ownerUserId);
                 sessions.delete(sessionKey);
-                (0, tracing_1.cleanupTracing)(sessionKey);
-                (0, logging_1.log)('info', 'session expired', { userId: sessionKey });
+                sessionOwners.delete(sessionKey);
+                (0, tracing_1.cleanupTracing)(ownerUserId);
+                (0, logging_1.log)('info', 'session expired', { userId: ownerUserId, sessionKey });
             }
         }
     }, 60_000);
@@ -323,4 +825,60 @@ function stopCleanupInterval() {
         cleanupInterval = null;
     }
 }
+/**
+ * Stage 1 idle cleanup: close runtime state (contexts, session data) for users with no tabs.
+ * Does NOT clear stored session profiles - they survive idle cleanup.
+ * Does NOT exit the daemon - that is Stage 2 (Task 4).
+ * @param sessionSnapshot Snapshot of sessions map taken before cleanup started
+ * @param contextSnapshot Snapshot of context pool entries taken before cleanup started
+ * @param cleanupStartedMs Timestamp when cleanup was triggered (used to avoid closing newly-created contexts)
+ */
+async function runLifecycleIdleCleanup(sessionSnapshot, contextSnapshot, cleanupStartedMs) {
+    const closedUsers = [];
+    // Use the provided snapshots to avoid race with new context creation
+    const sessionKeysToCleanup = new Set();
+    for (const [sessionKey, session] of sessionSnapshot.entries()) {
+        const tabCount = countTotalTabsForSessions([[sessionKey, session]]);
+        // Only cleanup sessions with zero tabs
+        if (tabCount === 0) {
+            sessionKeysToCleanup.add(sessionKey);
+        }
+    }
+    // Close only the specific contexts from the snapshot that were created before cleanup started
+    const contextsToClose = [];
+    for (const [profileKey, entry] of contextSnapshot.entries()) {
+        // Skip staged, launching, or newly-created contexts
+        if (sessionKeysToCleanup.has(profileKey) && !entry.staged && !entry.launching && entry.createdAt < cleanupStartedMs) {
+            contextsToClose.push({ profileKey, createdAt: entry.createdAt, lastAccess: entry.lastAccess });
+        }
+    }
+    // Close the specific contexts from the snapshot
+    const actuallyClosedSessionKeys = new Set();
+    for (const { profileKey, createdAt, lastAccess } of contextsToClose) {
+        const entry = contextSnapshot.get(profileKey);
+        const releaseIdleClosure = entry ? beginLifecycleIdleClosure(entry.userId) : null;
+        try {
+            await context_pool_1.contextPool.closeContextIfMatches(profileKey, createdAt, lastAccess);
+            // Verify the context was actually closed (not skipped due to reuse)
+            const stillExists = context_pool_1.contextPool.getEntry(profileKey);
+            if (!stillExists) {
+                // Context was actually closed, mark this exact session/profile key for cleanup.
+                actuallyClosedSessionKeys.add(profileKey);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            (0, logging_1.log)('error', 'idle cleanup failed to close context', { profileKey, error: message });
+        }
+        finally {
+            releaseIdleClosure?.();
+        }
+    }
+    // Clean up session data ONLY for session/profile keys whose contexts were actually closed.
+    for (const sessionKey of actuallyClosedSessionKeys) {
+        cleanupSessionsForUserId(sessionKey, 'idle_cleanup', false);
+        closedUsers.push(sessionKey);
+    }
+    return { closedUsers };
+}
 //# sourceMappingURL=session.js.map