ask-pro 0.1.0

package/dist/src/browser/profilePaths.js

@@ -0,0 +1,282 @@
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+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);
+}
+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) {
+    if (!agentId)
+        return path.join(root, "browser-profile");
+    if (!RESOLVED_AGENT_ID_PATTERN.test(agentId)) {
+        throw new Error("Stored ask-pro agent id is invalid.");
+    }
+    return path.join(root, "agents", agentId, "browser-profile");
+}
+export function isAskProManagedBrowserProfileDir(profileDir) {
+    const resolved = normalizeProfilePath(profileDir);
+    const defaultProfile = normalizeProfilePath(askProBrowserProfileDirForAgentId(null));
+    if (resolved === defaultProfile)
+        return true;
+    return askProAgentIdForManagedBrowserProfileDir(profileDir) !== null;
+}
+export function isAskProStatePath(profileDir) {
+    const resolved = normalizeProfilePath(profileDir);
+    const stateRoot = normalizeProfilePath(askProStateDir());
+    const relative = path.relative(stateRoot, resolved);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+export function askProAgentIdForManagedBrowserProfileDir(profileDir) {
+    return agentIdForProfileDir(profileDir, askProStateDir());
+}
+function agentIdForProfileDir(profileDir, stateRoot) {
+    const resolved = normalizeProfilePath(profileDir);
+    const agentsRoot = normalizeProfilePath(path.join(stateRoot, "agents"));
+    const relative = path.relative(agentsRoot, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+        return null;
+    const parts = relative.split(path.sep);
+    if (parts.length !== 2 || parts[1] !== "browser-profile")
+        return null;
+    const agentId = parts[0];
+    return RESOLVED_AGENT_ID_PATTERN.test(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);
+}
+function sameLegacyIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino && left.birthtimeNs === right.birthtimeNs;
+}
+function isSharingDenied(error) {
+    return ["EACCES", "EBUSY", "EPERM"].includes(error.code ?? "");
+}
+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));
+    }
+    if (await exists(legacy))
+        return false;
+    await fs.rm(marker, { force: true }).catch(() => undefined);
+    return exists(target);
+}
+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 resolveAskProAgentId(env = process.env) {
+    const value = env.ASK_PRO_AGENT_ID;
+    if (value === undefined)
+        return null;
+    const raw = value.trim();
+    if (raw !== value) {
+        throw new Error("ASK_PRO_AGENT_ID must not start or end with whitespace.");
+    }
+    if (!raw) {
+        throw new Error("ASK_PRO_AGENT_ID must not be empty.");
+    }
+    if (!/^[a-z0-9._-]+$/.test(raw)) {
+        throw new Error("ASK_PRO_AGENT_ID must use only lowercase letters, numbers, '.', '_', or '-'.");
+    }
+    const hash = createHash("sha256").update(raw).digest("hex").slice(0, 10);
+    const prefix = raw.slice(0, 53).replace(/^[-_.]+|[-_.]+$/g, "") || "agent";
+    return `${prefix}-${hash}`;
+}
+function normalizeProfilePath(profileDir) {
+    const resolved = path.resolve(profileDir);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}

package/dist/src/browser/profileState.js

@@ -0,0 +1,413 @@
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { delay } from "./utils.js";
+const DEVTOOLS_ACTIVE_PORT_FILENAME = "DevToolsActivePort";
+const DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS = [
+    DEVTOOLS_ACTIVE_PORT_FILENAME,
+    path.join("Default", DEVTOOLS_ACTIVE_PORT_FILENAME),
+];
+const CHROME_PID_FILENAME = "chrome.pid";
+const CHROME_STARTING_FILENAME = "chrome-starting";
+const ASK_PRO_PROFILE_LOCK_FILENAME = "ask-pro-automation.lock";
+const ASK_PRO_RUN_LEASE_DIRNAME = "ask-pro-browser-runs";
+const execFileAsync = promisify(execFile);
+export function getDevToolsActivePortPaths(userDataDir) {
+    return DEVTOOLS_ACTIVE_PORT_RELATIVE_PATHS.map((relative) => path.join(userDataDir, relative));
+}
+export async function readDevToolsPort(userDataDir) {
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            const raw = await readFile(candidate, "utf8");
+            const firstLine = raw.split(/\r?\n/u)[0]?.trim();
+            const port = Number.parseInt(firstLine ?? "", 10);
+            if (Number.isFinite(port)) {
+                return port;
+            }
+        }
+        catch {
+            // ignore missing/unreadable candidates
+        }
+    }
+    return null;
+}
+export async function writeDevToolsActivePort(userDataDir, port) {
+    const contents = `${port}\n/devtools/browser`;
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            await mkdir(path.dirname(candidate), { recursive: true });
+            await writeFile(candidate, contents, "utf8");
+        }
+        catch {
+            // best effort
+        }
+    }
+}
+export async function readChromePid(userDataDir) {
+    const pidPath = path.join(userDataDir, CHROME_PID_FILENAME);
+    try {
+        const raw = (await readFile(pidPath, "utf8")).trim();
+        const pid = Number.parseInt(raw, 10);
+        if (!Number.isFinite(pid) || pid <= 0) {
+            return null;
+        }
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeChromePid(userDataDir, pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return;
+    const pidPath = path.join(userDataDir, CHROME_PID_FILENAME);
+    try {
+        await mkdir(path.dirname(pidPath), { recursive: true });
+        await writeFile(pidPath, `${Math.trunc(pid)}\n`, "utf8");
+    }
+    catch {
+        // best effort
+    }
+}
+export async function markChromeLaunchStarting(userDataDir) {
+    const markerPath = path.join(userDataDir, CHROME_STARTING_FILENAME);
+    await mkdir(path.dirname(markerPath), { recursive: true });
+    await writeFile(markerPath, "", "utf8");
+}
+export async function hasChromeLaunchStarting(userDataDir) {
+    try {
+        await stat(path.join(userDataDir, CHROME_STARTING_FILENAME));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function clearChromeLaunchStarting(userDataDir) {
+    await rm(path.join(userDataDir, CHROME_STARTING_FILENAME), { force: true }).catch(() => undefined);
+}
+export function isProcessAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM means "exists but no permission"; treat as alive.
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "EPERM") {
+            return true;
+        }
+        return false;
+    }
+}
+export async function createManagedChromeRunLease(userDataDir) {
+    const leaseId = randomUUID();
+    const leaseDir = path.join(userDataDir, ASK_PRO_RUN_LEASE_DIRNAME);
+    const leasePath = path.join(leaseDir, `${process.pid}-${leaseId}.lease`);
+    await mkdir(leaseDir, { recursive: true });
+    await writeFile(leasePath, "", { encoding: "utf8", flag: "wx" });
+    return { path: leasePath };
+}
+export async function releaseManagedChromeRunLeaseAndCountPeers(userDataDir, lease, logger) {
+    try {
+        await rm(lease.path, { force: true });
+    }
+    catch (error) {
+        logger?.(`Failed to release ask-pro browser run lease: ${String(error)}`);
+        return null;
+    }
+    const leaseDir = path.join(userDataDir, ASK_PRO_RUN_LEASE_DIRNAME);
+    let entries;
+    try {
+        entries = await readdir(leaseDir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return 0;
+        logger?.(`Failed to inspect ask-pro browser run leases: ${String(error)}`);
+        return null;
+    }
+    let peers = 0;
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".lease"))
+            continue;
+        const leasePath = path.join(leaseDir, entry.name);
+        const pid = Number(entry.name.match(/^(\d+)-/)?.[1]);
+        if (!Number.isInteger(pid) || pid <= 0 || !isProcessAlive(pid)) {
+            try {
+                await rm(leasePath, { force: true });
+            }
+            catch (error) {
+                logger?.(`Failed to remove stale ask-pro browser run lease: ${String(error)}`);
+                return null;
+            }
+            continue;
+        }
+        peers += 1;
+    }
+    return peers;
+}
+function parseProfileRunLock(payload) {
+    if (!payload)
+        return null;
+    try {
+        const parsed = JSON.parse(payload);
+        if (!Number.isFinite(parsed.pid) || parsed.pid <= 0)
+            return null;
+        if (!parsed.lockId || typeof parsed.lockId !== "string")
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export async function isBrowserProfileInUse(userDataDir, options = {}) {
+    const lockPath = path.join(userDataDir, ASK_PRO_PROFILE_LOCK_FILENAME);
+    let lockPayload;
+    try {
+        lockPayload = await readFile(lockPath, "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);
+    }
+    if (lock && lock.lockId !== options.ignoreLockId && isProcessAlive(lock.pid))
+        return true;
+    const pid = await readChromePid(userDataDir);
+    const port = await readDevToolsPort(userDataDir);
+    const [owner, devTools] = await Promise.all([
+        isChromeUsingUserDataDir(userDataDir),
+        port ? verifyDevToolsReachable({ port, attempts: 1 }) : null,
+    ]);
+    if (owner === true || (pid && isProcessAlive(pid) && devTools?.ok))
+        return true;
+    return owner === null;
+}
+export async function acquireProfileRunLock(userDataDir, options) {
+    const timeoutMs = options.timeoutMs;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return null;
+    }
+    const pollMs = typeof options.pollMs === "number" && Number.isFinite(options.pollMs) && options.pollMs > 0
+        ? options.pollMs
+        : 1000;
+    const lockPath = path.join(userDataDir, ASK_PRO_PROFILE_LOCK_FILENAME);
+    const lockId = randomUUID();
+    const startedAt = Date.now();
+    let warned = false;
+    for (;;) {
+        try {
+            const payload = {
+                pid: process.pid,
+                lockId,
+                createdAt: new Date().toISOString(),
+                sessionId: options.sessionId,
+            };
+            if (options.requireExistingProfile) {
+                await stat(userDataDir);
+            }
+            else {
+                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 {
+                path: lockPath,
+                lockId,
+                release: async () => releaseProfileRunLock(lockPath, lockId, options.logger),
+            };
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "EEXIST") {
+                throw error;
+            }
+            let existing = parseProfileRunLock(await readFile(lockPath, "utf8").catch(() => null));
+            if (!existing) {
+                // Likely partial write / corruption; re-read once, then delete (user preference: delete unreadable lockfiles).
+                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;
+            }
+            if (!warned) {
+                const waited = Math.round(timeoutMs / 1000);
+                options.logger?.(`ask-pro profile lock held by pid ${existing.pid}; waiting up to ${waited}s.`);
+                warned = true;
+            }
+            const elapsed = Date.now() - startedAt;
+            if (elapsed >= timeoutMs) {
+                throw new Error(`ask-pro profile lock still held by pid ${existing.pid} after ${Math.round(elapsed / 1000)}s`);
+            }
+            await delay(Math.min(pollMs, timeoutMs - elapsed));
+        }
+    }
+}
+export async function releaseProfileRunLock(lockPath, lockId, logger) {
+    try {
+        const existing = parseProfileRunLock(await readFile(lockPath, "utf8").catch(() => null));
+        if (!existing || existing.lockId !== lockId) {
+            return;
+        }
+        await rm(lockPath, { force: true });
+        logger?.(`Released ask-pro profile lock ${lockPath}`);
+    }
+    catch {
+        // best effort
+    }
+}
+export async function verifyDevToolsReachable({ port, host = "127.0.0.1", attempts = 3, timeoutMs = 3000, }) {
+    const versionUrl = `http://${host}:${port}/json/version`;
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), timeoutMs);
+            const response = await fetch(versionUrl, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            return { ok: true };
+        }
+        catch (error) {
+            if (attempt < attempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, 500 * (attempt + 1)));
+                continue;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return { ok: false, error: message };
+        }
+    }
+    return { ok: false, error: "unreachable" };
+}
+export async function shouldCleanupManualLoginProfileState(userDataDir, logger, options = {}) {
+    if (!options.connectionClosedUnexpectedly) {
+        return true;
+    }
+    const port = await readDevToolsPort(userDataDir);
+    if (!port) {
+        return true;
+    }
+    const probe = await (options.probe ?? verifyDevToolsReachable)({ port, host: options.host });
+    if (probe.ok) {
+        logger?.(`DevTools port ${port} still reachable; preserving manual-login profile state`);
+        return false;
+    }
+    logger?.(`DevTools port ${port} unreachable (${probe.error}); clearing stale profile state`);
+    return true;
+}
+export async function cleanupStaleProfileState(userDataDir, logger, options = {}) {
+    for (const candidate of getDevToolsActivePortPaths(userDataDir)) {
+        try {
+            await rm(candidate, { force: true });
+            logger?.(`Removed stale DevToolsActivePort: ${candidate}`);
+        }
+        catch {
+            // ignore cleanup errors
+        }
+    }
+    const lockRemovalMode = options.lockRemovalMode ?? "never";
+    if (lockRemovalMode === "never") {
+        return;
+    }
+    const pid = await readChromePid(userDataDir);
+    if (!pid) {
+        return;
+    }
+    if (isProcessAlive(pid)) {
+        logger?.(`Chrome pid ${pid} still alive; skipping profile lock cleanup`);
+        return;
+    }
+    // Extra safety: if Chrome is running with this profile (but with a different PID, e.g. user relaunched
+    // without remote debugging), never delete lock files.
+    if ((await isChromeUsingUserDataDir(userDataDir)) === true) {
+        logger?.("Detected running Chrome using this profile; skipping profile lock cleanup");
+        return;
+    }
+    const lockFiles = [
+        path.join(userDataDir, "lockfile"),
+        path.join(userDataDir, "SingletonLock"),
+        path.join(userDataDir, "SingletonSocket"),
+        path.join(userDataDir, "SingletonCookie"),
+    ];
+    for (const lock of lockFiles) {
+        await rm(lock, { force: true }).catch(() => undefined);
+    }
+    logger?.("Cleaned up stale Chrome profile locks");
+}
+async function isChromeUsingUserDataDir(userDataDir) {
+    if (process.platform === "win32") {
+        try {
+            const { stdout } = await execFileAsync("powershell.exe", [
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                "$ErrorActionPreference = 'Stop'; $match = Get-CimInstance Win32_Process | Where-Object { $_.Name -match '^(chrome|chromium|msedge)\\.exe$' -and $_.CommandLine -and $_.CommandLine.Contains($env:ASK_PRO_PROFILE_SCAN_PATH) -and $_.CommandLine.Contains('--user-data-dir') } | Select-Object -First 1; if ($match) { 'match' } else { 'scan-ok' }",
+            ], {
+                env: { ...process.env, ASK_PRO_PROFILE_SCAN_PATH: userDataDir },
+                maxBuffer: 1024 * 1024,
+                windowsHide: true,
+            });
+            const result = String(stdout).trim();
+            return result === "match" ? true : result === "scan-ok" ? false : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        const { stdout } = await execFileAsync("ps", ["-ax", "-o", "command="], {
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        const lines = String(stdout ?? "").split("\n");
+        const needle = userDataDir;
+        for (const line of lines) {
+            if (!line)
+                continue;
+            const lower = line.toLowerCase();
+            if (!lower.includes("chrome") && !lower.includes("chromium"))
+                continue;
+            if (line.includes(needle) && lower.includes("user-data-dir")) {
+                return true;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return false;
+}