ask-pro 0.1.71 → 0.2.80

package/dist/src/browser/profileMigration.js

@@ -0,0 +1,299 @@
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { askProBrowserProfileDirForAgentId, askProBrowserProfileDirUnder, askProStateDir, isResolvedAskProAgentId, legacyAskProStateDirs, } from "./profilePaths.js";
+import { acquireProfileRunLock, isBrowserProfileInUse, isProcessAlive, releaseProfileRunLock, } from "./profileState.js";
+// Coordination files live in the current state folder: the migration lock, records of runs that
+// still use an old profile, unfinished copies and the profiles already reported as leftovers.
+const MIGRATION_DIR = ".migration";
+const PROFILE_LOCK_FILENAME = "ask-pro-automation.lock";
+const MIGRATION_LOCK_TIMEOUT_MS = 15 * 60_000;
+const TRASH_PREFIX = ".ask-pro-trash-";
+/**
+ * Moves browser profiles left by earlier versions into the current state folder. A profile that
+ * is in use stays where it is and moves on a later run. Never fails the caller.
+ */
+export async function migrateLegacyAskProProfiles(options = {}) {
+    const env = options.env ?? process.env;
+    const stateDir = askProStateDir(env);
+    try {
+        const profiles = await findLegacyProfiles(env);
+        if (profiles.length === 0)
+            return;
+        if (await someMissing(profiles.map((profile) => profile.target))) {
+            await withMigrationLock(stateDir, options.lockTimeoutMs, async () => {
+                // Only the newest old copy of each profile moves, even if it must wait for a later run.
+                const claimed = new Set();
+                for (const profile of profiles) {
+                    if (claimed.has(profile.target))
+                        continue;
+                    claimed.add(profile.target);
+                    if (!(await exists(profile.target)))
+                        await moveProfile(profile, stateDir);
+                }
+            });
+        }
+        await reportLeftovers(profiles, stateDir, options.log);
+        await removeEmptyFolders(profiles);
+    }
+    catch {
+        // retried on a later run
+    }
+}
+/**
+ * The browser profile this run uses: the current one, or an earlier version's profile that is
+ * still in use and has not moved yet. The old location is then kept for the whole run.
+ */
+export async function prepareAskProBrowserProfile(agentId, options = {}) {
+    const env = options.env ?? process.env;
+    await migrateLegacyAskProProfiles(options);
+    const target = askProBrowserProfileDirForAgentId(agentId, env);
+    if (await exists(target))
+        return target;
+    const stateDir = askProStateDir(env);
+    const pick = async (record) => {
+        if (await exists(target))
+            return target;
+        for (const root of legacyAskProStateDirs(env)) {
+            const legacy = askProBrowserProfileDirUnder(root, agentId);
+            if (!(await exists(legacy)))
+                continue;
+            if (record)
+                await recordLegacyUse(stateDir, legacy);
+            return legacy;
+        }
+        return target;
+    };
+    // The record keeps a concurrent migration from moving the profile out from under this run.
+    return withMigrationLock(stateDir, MIGRATION_LOCK_TIMEOUT_MS, () => pick(true)).catch(() => pick(false));
+}
+async function findLegacyProfiles(env) {
+    const stateDir = askProStateDir(env);
+    const profiles = [];
+    for (const root of legacyAskProStateDirs(env)) {
+        const entries = await fs.readdir(root).catch(() => []);
+        if (entries.length === 0)
+            continue;
+        for (const entry of entries.filter((name) => name.startsWith(TRASH_PREFIX))) {
+            await fs.rm(path.join(root, entry), { recursive: true, force: true }).catch(() => undefined);
+        }
+        const agentIds = entries.includes("agents")
+            ? (await fs.readdir(path.join(root, "agents")).catch(() => [])).filter(isResolvedAskProAgentId)
+            : [];
+        for (const agentId of [null, ...agentIds]) {
+            const legacy = askProBrowserProfileDirUnder(root, agentId);
+            if (await isRealFolder(legacy)) {
+                profiles.push({ root, legacy, target: askProBrowserProfileDirUnder(stateDir, agentId) });
+            }
+        }
+    }
+    return profiles;
+}
+async function moveProfile(profile, stateDir) {
+    const { legacy, target } = profile;
+    if (await hasLiveLegacyUse(stateDir, legacy))
+        return;
+    let lock;
+    try {
+        // Holding the profile's run lock keeps other ask-pro runs, old versions included, from
+        // opening it mid-move.
+        lock = await acquireProfileRunLock(legacy, { timeoutMs: 1, pollMs: 1 });
+    }
+    catch {
+        return;
+    }
+    if (!lock)
+        return;
+    let lockPath = lock.path;
+    try {
+        if (await isBrowserProfileInUse(legacy, { ignoreLockId: lock.lockId }))
+            return;
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        try {
+            await fs.rename(legacy, target);
+            lockPath = path.join(target, PROFILE_LOCK_FILENAME);
+            await linkOldPath(legacy, target);
+            return;
+        }
+        catch (error) {
+            // Anything but a move across volumes (on Windows: a profile Chrome still has open) is
+            // retried on a later run.
+            if (error.code !== "EXDEV")
+                return;
+        }
+        await copyProfile(legacy, target, stateDir);
+        await removeFolder(legacy, profile.root, () => linkOldPath(legacy, target));
+    }
+    catch {
+        // retried on a later run
+    }
+    finally {
+        await releaseProfileRunLock(lockPath, lock.lockId);
+    }
+}
+async function copyProfile(legacy, target, stateDir) {
+    const staging = path.join(stateDir, MIGRATION_DIR, `copy-${randomUUID()}`);
+    const ownLock = path.join(legacy, PROFILE_LOCK_FILENAME);
+    try {
+        await fs.cp(legacy, staging, {
+            recursive: true,
+            errorOnExist: true,
+            force: false,
+            verbatimSymlinks: true,
+            filter: (source) => source !== ownLock,
+        });
+        const [expected, copied] = await Promise.all([listTree(legacy), listTree(staging)]);
+        expected.delete(PROFILE_LOCK_FILENAME);
+        if (expected.size !== copied.size ||
+            [...expected].some(([name, kind]) => copied.get(name) !== kind)) {
+            throw new Error("ask-pro browser profile copy is incomplete.");
+        }
+        await fs.rename(staging, target);
+    }
+    finally {
+        await fs.rm(staging, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+// Relative path -> entry kind, with file sizes.
+async function listTree(root) {
+    const tree = new Map();
+    const walk = async (dir) => {
+        for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            const name = path.relative(root, full);
+            if (entry.isDirectory()) {
+                tree.set(name, "dir");
+                await walk(full);
+            }
+            else if (entry.isSymbolicLink()) {
+                tree.set(name, `link:${await fs.readlink(full)}`);
+            }
+            else {
+                tree.set(name, `file:${(await fs.lstat(full)).size}`);
+            }
+        }
+    };
+    await walk(root);
+    return tree;
+}
+// An older ask-pro install that has not been updated yet keeps opening the old path. A link
+// there sends it to the moved profile, so it stays signed in and shares the same run lock.
+async function linkOldPath(legacy, target) {
+    const type = process.platform === "win32" ? "junction" : "dir";
+    await fs.symlink(target, legacy, type).catch(() => undefined);
+}
+// Moves the folder aside in one step, so a partly deleted profile is never left behind, and runs
+// `afterMove` before the slow delete. A folder that cannot be moved stays and is reported as a
+// leftover.
+async function removeFolder(folder, root, afterMove) {
+    const trash = path.join(root, `${TRASH_PREFIX}${randomUUID()}`);
+    try {
+        await fs.rename(folder, trash);
+    }
+    catch {
+        return;
+    }
+    await afterMove();
+    await fs.rm(trash, { recursive: true, force: true }).catch(() => undefined);
+}
+async function withMigrationLock(stateDir, timeoutMs = MIGRATION_LOCK_TIMEOUT_MS, action) {
+    const dir = path.join(stateDir, MIGRATION_DIR);
+    const lock = await acquireProfileRunLock(dir, {
+        timeoutMs,
+        pollMs: 200,
+    });
+    try {
+        // Copies left by an interrupted migration; none can be in progress while the lock is held.
+        for (const entry of await fs.readdir(dir)) {
+            if (entry.startsWith("copy-")) {
+                await fs.rm(path.join(dir, entry), { recursive: true, force: true }).catch(() => undefined);
+            }
+        }
+        return await action();
+    }
+    finally {
+        await lock?.release();
+    }
+}
+async function recordLegacyUse(stateDir, legacy) {
+    const record = path.join(stateDir, MIGRATION_DIR, `in-use-${process.pid}-${randomUUID()}.json`);
+    await fs.writeFile(record, JSON.stringify({ pid: process.pid, profile: legacy }));
+    process.once("exit", () => rmSync(record, { force: true }));
+}
+async function hasLiveLegacyUse(stateDir, legacy) {
+    const dir = path.join(stateDir, MIGRATION_DIR);
+    let inUse = false;
+    for (const entry of await fs.readdir(dir).catch(() => [])) {
+        if (!entry.startsWith("in-use-"))
+            continue;
+        const record = path.join(dir, entry);
+        const { pid, profile } = await fs
+            .readFile(record, "utf8")
+            .then((raw) => JSON.parse(raw))
+            .catch(() => ({ pid: undefined, profile: undefined }));
+        if (!pid || !isProcessAlive(pid)) {
+            await fs.rm(record, { force: true }).catch(() => undefined);
+        }
+        else if (profile && samePath(profile, legacy)) {
+            inUse = true;
+        }
+    }
+    return inUse;
+}
+// Reports once per folder an old profile that stays behind because a current one already exists.
+async function reportLeftovers(profiles, stateDir, log) {
+    if (!log)
+        return;
+    const leftovers = [];
+    for (const profile of profiles) {
+        if ((await isRealFolder(profile.legacy)) && (await exists(profile.target))) {
+            leftovers.push(profile);
+        }
+    }
+    if (leftovers.length === 0)
+        return;
+    const file = path.join(stateDir, MIGRATION_DIR, "reported-leftovers.json");
+    const reported = await fs
+        .readFile(file, "utf8")
+        .then((raw) => JSON.parse(raw))
+        .catch(() => []);
+    const fresh = leftovers.filter((profile) => !reported.includes(profile.legacy));
+    if (fresh.length === 0)
+        return;
+    for (const { legacy, target } of fresh) {
+        log(`ask-pro now uses ${target}. Once no Chrome window or older ask-pro uses ${legacy}, you can delete it.`);
+    }
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, JSON.stringify([...reported, ...fresh.map((profile) => profile.legacy)]));
+}
+// Removes old state folders the migration emptied. Folders that still hold anything stay.
+async function removeEmptyFolders(profiles) {
+    for (const root of new Set(profiles.map((profile) => profile.root))) {
+        const agents = path.join(root, "agents");
+        for (const agentId of await fs.readdir(agents).catch(() => [])) {
+            if (isResolvedAskProAgentId(agentId)) {
+                await fs.rmdir(path.join(agents, agentId)).catch(() => undefined);
+            }
+        }
+        await fs.rmdir(agents).catch(() => undefined);
+        await fs.rmdir(root).catch(() => undefined);
+    }
+}
+async function someMissing(paths) {
+    for (const candidate of paths)
+        if (!(await exists(candidate)))
+            return true;
+    return false;
+}
+// Not the link an earlier move leaves at the old path.
+async function isRealFolder(candidate) {
+    return fs.lstat(candidate).then((info) => info.isDirectory(), () => false);
+}
+async function exists(candidate) {
+    return fs.stat(candidate).then((info) => info.isDirectory(), () => false);
+}
+function samePath(left, right) {
+    const normalize = (value) => process.platform === "win32" ? path.resolve(value).toLowerCase() : path.resolve(value);
+    return normalize(left) === normalize(right);
+}

package/dist/src/browser/profilePaths.js

@@ -1,148 +1,17 @@
-import { createHash, randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
+import { createHash } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
-import { acquireProfileRunLock, isBrowserProfileInUse, isProcessAlive, releaseProfileRunLock, } from "./profileState.js";
 const RESOLVED_AGENT_ID_PATTERN = /^[a-z0-9._-]+-[a-f0-9]{10}$/;
-const MIGRATION_MARKER = ".ask-pro-profile-migration";
 export function defaultAskProBrowserProfileDir() {
     return askProBrowserProfileDirForAgentId(null);
 }
 export function askProBrowserProfileDirForAgentId(agentId, env = process.env) {
-    return profileDirUnder(askProStateDir(env), agentId);
+    return askProBrowserProfileDirUnder(askProStateDir(env), agentId);
 }
-export function legacyAskProBrowserProfileDirForAgentId(agentId, homeDir = os.homedir()) {
-    return profileDirUnder(path.join(homeDir, ".agents", "skills", "ask-pro"), agentId);
-}
-export async function ensureAskProBrowserProfileDir(agentId, options = {}) {
-    const target = askProBrowserProfileDirForAgentId(agentId, options.env);
-    const legacy = legacyAskProBrowserProfileDirForAgentId(agentId, options.homeDir);
-    const [targetExists, legacyExists] = await Promise.all([exists(target), exists(legacy)]);
-    if (targetExists && legacyExists) {
-        const recordedIdentity = await retainedLegacyIdentity(target);
-        if (recordedIdentity) {
-            const currentIdentity = await legacyProfileIdentity(legacy);
-            if (currentIdentity && sameLegacyIdentity(currentIdentity, recordedIdentity)) {
-                if (await waitForConcurrentMigration(target, legacy))
-                    return target;
-                if (await isBrowserProfileInUse(legacy)) {
-                    throw new Error("Legacy ask-pro browser profile is in use; retry after its browser run exits.");
-                }
-                return target;
-            }
-            throw new Error(`Both current and legacy ask-pro browser profiles exist; refusing to merge ${legacy} into ${target}.`);
-        }
-        if (await waitForConcurrentMigration(target, legacy))
-            return target;
-        if ((await exists(target)) && !(await exists(legacy)))
-            return target;
-        throw new Error(`Both current and legacy ask-pro browser profiles exist; refusing to merge ${legacy} into ${target}.`);
-    }
-    if (targetExists || !legacyExists)
-        return target;
-    if (await isBrowserProfileInUse(legacy)) {
-        throw new Error("Legacy ask-pro browser profile is in use; retry after its browser run exits.");
-    }
-    let migrationLock;
-    try {
-        migrationLock = await acquireProfileRunLock(legacy, {
-            timeoutMs: 300_000,
-            pollMs: 100,
-            requireExistingProfile: true,
-            staleLockMode: "fail",
-        });
-    }
-    catch (error) {
-        if ((await exists(target)) && !(await exists(legacy)))
-            return target;
-        throw new Error("Legacy ask-pro browser profile could not be claimed; retry after other browser runs exit.", { cause: error });
-    }
-    if (!migrationLock)
-        throw new Error("Could not claim the legacy ask-pro browser profile.");
-    let releasePath = migrationLock.path;
-    try {
-        if (await matchesRetainedLegacy(target, legacy))
-            return target;
-        if (await isBrowserProfileInUse(legacy, { ignoreLockId: migrationLock.lockId })) {
-            throw new Error("Legacy ask-pro browser profile is in use; retry after its browser run exits.");
-        }
-        await fs.mkdir(path.dirname(target), { recursive: true });
-        let identityRequired = false;
-        try {
-            await fs.rename(legacy, target);
-            releasePath = path.join(target, path.basename(migrationLock.path));
-            return target;
-        }
-        catch (error) {
-            const code = error.code;
-            if (code !== "EXDEV" && !isSharingDenied(error)) {
-                if ((await exists(target)) && !(await exists(legacy)))
-                    return target;
-                throw error;
-            }
-            identityRequired = code !== "EXDEV";
-        }
-        const legacyIdentity = await legacyProfileIdentity(legacy);
-        if (identityRequired && !legacyIdentity) {
-            throw new Error("Legacy ask-pro browser profile identity is unavailable; refusing to copy.");
-        }
-        const staging = `${target}.migrating-${process.pid}-${randomUUID()}`;
-        try {
-            await fs.cp(legacy, staging, { recursive: true, errorOnExist: true });
-            await fs.writeFile(path.join(staging, MIGRATION_MARKER), JSON.stringify({
-                pid: process.pid,
-                createdAt: Date.now(),
-                migrationLockId: migrationLock.lockId,
-                ...(legacyIdentity ? { legacyIdentity } : {}),
-            }));
-            await fs.rename(staging, target);
-            releasePath = path.join(target, path.basename(migrationLock.path));
-        }
-        catch (error) {
-            await fs.rm(staging, { recursive: true, force: true }).catch(() => undefined);
-            if ((await exists(target)) && !(await exists(legacy)))
-                return target;
-            if (await matchesRetainedLegacy(target, legacy))
-                return target;
-            if (await waitForConcurrentMigration(target, legacy))
-                return target;
-            if ((await exists(target)) && !(await exists(legacy)))
-                return target;
-            throw error;
-        }
-        try {
-            await fs.rm(legacy, { recursive: true });
-        }
-        catch (error) {
-            await releaseProfileRunLock(migrationLock.path, migrationLock.lockId);
-            if (isSharingDenied(error) && legacyIdentity)
-                return target;
-            await fs.rm(path.join(target, MIGRATION_MARKER), { force: true });
-            if (isSharingDenied(error)) {
-                throw new Error("Legacy ask-pro browser profile could not be removed and has no reliable identity; refusing to retain it.", { cause: error });
-            }
-            throw error;
-        }
-        await fs.rm(path.join(target, MIGRATION_MARKER), { force: true });
-        return target;
-    }
-    finally {
-        await releaseProfileRunLock(releasePath, migrationLock.lockId);
-    }
-}
-export function askProAgentIdForLegacyBrowserProfileDir(profileDir) {
-    return agentIdForProfileDir(profileDir, path.join(os.homedir(), ".agents", "skills", "ask-pro"));
-}
-export function isLegacyAskProManagedBrowserProfileDir(profileDir) {
-    const resolved = normalizeProfilePath(profileDir);
-    if (resolved === normalizeProfilePath(legacyAskProBrowserProfileDirForAgentId(null)))
-        return true;
-    return askProAgentIdForLegacyBrowserProfileDir(profileDir) !== null;
-}
-function profileDirUnder(root, agentId) {
+export function askProBrowserProfileDirUnder(root, agentId) {
     if (!agentId)
         return path.join(root, "browser-profile");
-    if (!RESOLVED_AGENT_ID_PATTERN.test(agentId)) {
+    if (!isResolvedAskProAgentId(agentId)) {
         throw new Error("Stored ask-pro agent id is invalid.");
     }
     return path.join(root, "agents", agentId, "browser-profile");
@@ -173,90 +42,35 @@ function agentIdForProfileDir(profileDir, stateRoot) {
     if (parts.length !== 2 || parts[1] !== "browser-profile")
         return null;
     const agentId = parts[0];
-    return RESOLVED_AGENT_ID_PATTERN.test(agentId) ? agentId : null;
+    return isResolvedAskProAgentId(agentId) ? agentId : null;
 }
-function askProStateDir(env = process.env) {
-    const codexHome = env.CODEX_HOME?.trim();
-    return path.join(codexHome ? path.resolve(codexHome) : path.join(os.homedir(), ".codex"), "state", "ask-pro");
-}
-async function exists(filePath) {
-    return fs
-        .stat(filePath)
-        .then(() => true)
-        .catch((error) => {
-        if (error.code === "ENOENT")
-            return false;
-        throw error;
-    });
-}
-async function legacyProfileIdentity(profileDir) {
-    const info = await fs.stat(profileDir, { bigint: true }).catch(() => null);
-    if (!info?.isDirectory() || info.dev <= 0n || info.ino <= 0n || info.birthtimeNs <= 0n) {
-        return null;
-    }
-    return {
-        dev: info.dev.toString(),
-        ino: info.ino.toString(),
-        birthtimeNs: info.birthtimeNs.toString(),
-    };
-}
-async function retainedLegacyIdentity(target) {
-    const recorded = await fs
-        .readFile(path.join(target, MIGRATION_MARKER), "utf8")
-        .then((raw) => JSON.parse(raw).legacyIdentity)
-        .catch(() => null);
-    if (!recorded ||
-        ![recorded.dev, recorded.ino, recorded.birthtimeNs].every((value) => /^[1-9]\d*$/.test(value))) {
-        return null;
-    }
-    return recorded;
-}
-async function matchesRetainedLegacy(target, legacy) {
-    const [recorded, current] = await Promise.all([
-        retainedLegacyIdentity(target),
-        legacyProfileIdentity(legacy),
-    ]);
-    return recorded !== null && current !== null && sameLegacyIdentity(recorded, current);
+export function isResolvedAskProAgentId(agentId) {
+    return RESOLVED_AGENT_ID_PATTERN.test(agentId);
 }
-function sameLegacyIdentity(left, right) {
-    return left.dev === right.dev && left.ino === right.ino && left.birthtimeNs === right.birthtimeNs;
+export function askProStateDir(env = process.env) {
+    const override = env.ASK_PRO_STATE_DIR?.trim();
+    return override ? path.resolve(override) : path.join(os.homedir(), ".agents", "state", "ask-pro");
 }
-function isSharingDenied(error) {
-    return ["EACCES", "EBUSY", "EPERM"].includes(error.code ?? "");
+// State folders of earlier versions, in the order profiles are migrated from them.
+export function legacyAskProStateDirs(env = process.env) {
+    const codexHome = env.CODEX_HOME?.trim();
+    const current = normalizeProfilePath(askProStateDir(env));
+    return [
+        path.join(codexHome ? path.resolve(codexHome) : path.join(os.homedir(), ".codex"), "state", "ask-pro"),
+        path.join(os.homedir(), ".agents", "skills", "ask-pro"),
+    ].filter((dir) => normalizeProfilePath(dir) !== current);
 }
-async function waitForConcurrentMigration(target, legacy) {
-    const marker = path.join(target, MIGRATION_MARKER);
-    const owner = await fs
-        .readFile(marker, "utf8")
-        .then((raw) => JSON.parse(raw))
-        .catch(() => null);
-    if (!owner?.pid ||
-        !Number.isFinite(owner.pid) ||
-        !owner.createdAt ||
-        !Number.isFinite(owner.createdAt) ||
-        !owner.migrationLockId) {
-        return false;
-    }
-    while (isProcessAlive(owner.pid) &&
-        Date.now() - owner.createdAt < 300_000 &&
-        (await legacyHasMigrationLock(legacy, owner.migrationLockId))) {
-        if (!(await exists(legacy))) {
-            await fs.rm(marker, { force: true }).catch(() => undefined);
-            return true;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 250));
+export function askProAgentIdForLegacyBrowserProfileDir(profileDir) {
+    for (const root of legacyAskProStateDirs()) {
+        const agentId = agentIdForProfileDir(profileDir, root);
+        if (agentId)
+            return agentId;
     }
-    if (await exists(legacy))
-        return false;
-    await fs.rm(marker, { force: true }).catch(() => undefined);
-    return exists(target);
+    return null;
 }
-async function legacyHasMigrationLock(legacy, lockId) {
-    const activeLockId = await fs
-        .readFile(path.join(legacy, "ask-pro-automation.lock"), "utf8")
-        .then((raw) => JSON.parse(raw).lockId)
-        .catch(() => null);
-    return activeLockId === lockId;
+export function isLegacyAskProManagedBrowserProfileDir(profileDir) {
+    const resolved = normalizeProfilePath(profileDir);
+    return (legacyAskProStateDirs().some((root) => normalizeProfilePath(askProBrowserProfileDirUnder(root, null)) === resolved) || askProAgentIdForLegacyBrowserProfileDir(profileDir) !== null);
 }
 export function resolveAskProAgentId(env = process.env) {
     const value = env.ASK_PRO_AGENT_ID;

package/dist/src/browser/profileState.js

@@ -168,32 +168,30 @@ function parseProfileRunLock(payload) {
         return null;
     }
 }
+// True while an ask-pro run holds the profile or a Chrome process may still have it open. An
+// unanswerable process scan counts as in use.
 export async function isBrowserProfileInUse(userDataDir, options = {}) {
-    const lockPath = path.join(userDataDir, ASK_PRO_PROFILE_LOCK_FILENAME);
-    let lockPayload;
+    let raw = null;
     try {
-        lockPayload = await readFile(lockPath, "utf8");
+        raw = await readFile(path.join(userDataDir, ASK_PRO_PROFILE_LOCK_FILENAME), "utf8");
     }
     catch (error) {
         if (error.code !== "ENOENT")
             return true;
-        lockPayload = null;
-    }
-    let lock = parseProfileRunLock(lockPayload);
-    if (lockPayload !== null && !lock) {
-        await delay(200);
-        try {
-            lockPayload = await readFile(lockPath, "utf8");
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                return true;
-            lockPayload = null;
-        }
-        lock = parseProfileRunLock(lockPayload);
     }
+    const lock = parseProfileRunLock(raw);
     if (lock && lock.lockId !== options.ignoreLockId && isProcessAlive(lock.pid))
         return true;
+    try {
+        const leases = await readdir(path.join(userDataDir, ASK_PRO_RUN_LEASE_DIRNAME));
+        if (leases.some((name) => name.endsWith(".lease") && isProcessAlive(Number(name.match(/^(\d+)-/)?.[1])))) {
+            return true;
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            return true;
+    }
     const pid = await readChromePid(userDataDir);
     const port = await readDevToolsPort(userDataDir);
     const [owner, devTools] = await Promise.all([
@@ -204,6 +202,19 @@ export async function isBrowserProfileInUse(userDataDir, options = {}) {
         return true;
     return owner === null;
 }
+// Call while holding the profile's launch lock; only disposable caches are removed.
+export async function clearIdleBrowserProfileCaches(userDataDir, options = {}) {
+    try {
+        if (await isBrowserProfileInUse(userDataDir, options))
+            return;
+        for (const name of ["Cache", "Code Cache"]) {
+            await rm(path.join(userDataDir, "Default", name), { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+    catch {
+        // Cache maintenance must never prevent a browser run.
+    }
+}
 export async function acquireProfileRunLock(userDataDir, options) {
     const timeoutMs = options.timeoutMs;
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
@@ -224,12 +235,7 @@ export async function acquireProfileRunLock(userDataDir, options) {
                 createdAt: new Date().toISOString(),
                 sessionId: options.sessionId,
             };
-            if (options.requireExistingProfile) {
-                await stat(userDataDir);
-            }
-            else {
-                await mkdir(path.dirname(lockPath), { recursive: true });
-            }
+            await mkdir(path.dirname(lockPath), { recursive: true });
             await writeFile(lockPath, JSON.stringify(payload), { encoding: "utf8", flag: "wx" });
             options.logger?.(`Acquired ask-pro profile lock at ${lockPath}`);
             return {
@@ -249,18 +255,12 @@ export async function acquireProfileRunLock(userDataDir, options) {
                 await delay(200);
                 existing = parseProfileRunLock(await readFile(lockPath, "utf8").catch(() => null));
                 if (!existing) {
-                    if (options.staleLockMode === "fail") {
-                        throw new Error("ask-pro profile lock is unreadable; refusing stale lock removal.");
-                    }
                     options.logger?.("ask-pro profile lock unreadable; deleting lockfile.");
                     await rm(lockPath, { force: true }).catch(() => undefined);
                     continue;
                 }
             }
             if (!existing || !isProcessAlive(existing.pid)) {
-                if (options.staleLockMode === "fail") {
-                    throw new Error("ask-pro profile lock owner is not alive; refusing stale lock removal.");
-                }
                 await rm(lockPath, { force: true }).catch(() => undefined);
                 continue;
             }

package/dist/src/browser/reattach.js

@@ -355,7 +355,9 @@ async function resumeBrowserSessionViaNewChrome(runtime, config, logger, deps) {
         if (!reusedChrome) {
             await seedChromeProfileLanguage(userDataDir, resolved.acceptLanguage, logger);
         }
-        chrome = reusedChrome ?? (await launchChrome(resolved, userDataDir, logger));
+        chrome =
+            reusedChrome ??
+                (await launchChrome(resolved, userDataDir, logger, { ignoreLockId: launchLock?.lockId }));
         if (manualLogin) {
             reattachRunLease = {
                 userDataDir,