ask-pro 0.2.78 → 0.2.87

package/README.md

@@ -27,8 +27,8 @@ Both installs run the same bundled launcher. The `ask-pro` npm package
 (`npm i -g ask-pro`) still works too. All three share the same state.
 
 You need Node.js 24+, npm, Chrome, and a ChatGPT account with Pro access. The
-browser runtime is developed and tested on Windows; other operating systems
-need validation.
+browser runtime supports Windows and Linux. Linux without `DISPLAY` or
+`WAYLAND_DISPLAY` uses headless Chrome. See [Linux setup and remote sign-in](docs/linux.md).
 
 **Upgrading from an earlier version:** nothing to do. On its first run,
 ask-pro moves your signed-in browser profiles from `~/.codex/state/ask-pro` to

package/SKILL.md

@@ -11,6 +11,15 @@ The calling agent still owns the work. Use Pro for judgment, architecture, risk
 
 ## Running ask-pro
 
+On a headless Linux host, set `CHROME_PATH` if Chrome is not discovered, and
+`ASK_PRO_LOGIN_HOST` to the host's private Tailscale IP. Before the first query,
+run `ask-pro --login` and give the human its `login_url`. Keep that command alive
+while they sign in from their desktop or phone. The link expires after 15 minutes
+or Done. Never drive the login page or capture its frames during real sign-in.
+After the human confirms the ChatGPT composer is visible, resume the saved
+session or start the requested query. A later `needs_auth` result includes a
+`login` command for the same profile. See [Linux setup](docs/linux.md).
+
 This skill folder contains ask-pro itself; nothing else needs installing. In
 the commands below, `ask-pro` stands for:
 

package/dist/bin/ask-pro-cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import "dotenv/config";
+import { runRemoteLogin } from "../src/ask-pro/remoteLogin.js";
 import { AssistantStoppedError } from "../src/browser/errors.js";
 import { AssistantQuestionsError } from "../src/browser/actions/questions.js";
 import { readAskProQuestions } from "../src/ask-pro/questions.js";
@@ -8,7 +9,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { Command, Option } from "commander";
 import { createAskProSession, getAskProSessionPaths, pruneExpiredAskProSessions, readAskProAnswer, readAskProStatus, updateAskProResumeCommand, updateAskProStatus, } from "../src/ask-pro/session.js";
-import { AskProNeedsAuthError, isSuspiciousPreambleAnswer, resumeAskProBrowserSession, runAskProBrowserSession, } from "../src/ask-pro/browserRunner.js";
+import { AskProNeedsAuthError, resolveAskProLoginProfile, isSuspiciousPreambleAnswer, resumeAskProBrowserSession, runAskProBrowserSession, } from "../src/ask-pro/browserRunner.js";
 import { renderToonRecord } from "../src/ask-pro/toon.js";
 import { askProAgentIdForLegacyBrowserProfileDir, askProAgentIdForManagedBrowserProfileDir, defaultAskProBrowserProfileDir, isLegacyAskProManagedBrowserProfileDir, } from "../src/browser/profilePaths.js";
 import { migrateLegacyAskProProfiles } from "../src/browser/profileMigration.js";
@@ -20,6 +21,20 @@ program
     .version(getCliVersion())
     .argument("[question...]", "question to send to ChatGPT Pro")
     .option("--dry-run", "prepare the session and context bundle without opening the browser")
+    .addOption(new Option("--login [session-id]", "open a private remote sign-in link for headless Chrome").conflicts([
+    "dryRun",
+    "files",
+    "promptFile",
+    "answers",
+    "artifacts",
+    "github",
+    "responseZip",
+    "resume",
+    "status",
+    "harvest",
+    "copy",
+    "temporary",
+]))
     .option("--files <pattern>", "include files or globs in the context bundle", collectFiles, [])
     .option("--prompt-file <path>", "read the question from a UTF-8 file; use - for stdin")
     .option("--artifacts", "ask Pro for ask-pro-response.zip plus markdown fallback")
@@ -58,6 +73,21 @@ program
 await program.parseAsync(process.argv);
 async function runAskPro(question, options) {
     const cwd = resolveProjectCwd(options);
+    if (options.login) {
+        if (question.trim())
+            throw new Error("Use --login without a question.");
+        const profile = typeof options.login === "string"
+            ? await resolveAskProLoginProfile(cwd, options.login)
+            : undefined;
+        await runRemoteLogin((url) => writeToon("ask_pro", {
+            state: "needs_auth",
+            action: "open_login_url",
+            login_url: url,
+            expires_minutes: 15,
+        }), profile);
+        writeToon("ask_pro", { state: "login_closed", action: "confirm_composer_then_resume" });
+        return;
+    }
     if (options.answers && question.trim())
         throw new Error("Use --answers with --resume, without a question argument.");
     await pruneExpiredAskProSessions({ cwd });
@@ -347,6 +377,11 @@ async function printAuthInstructions(sessionId, options, cwd, error) {
         ...fallbackPreflight,
         ...browserPreflight,
         action: "human_login_then_resume",
+        ...(process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY
+            ? {
+                login: `${buildLauncherCommand()} --cwd ${quoteCommandArg(cwd)} --login ${quoteCommandArg(sessionId)}`,
+            }
+            : {}),
         resume: resumeCommand,
     });
 }

package/dist/src/ask-pro/browserRunner.js

@@ -717,6 +717,10 @@ async function writeTerminalBrowserMetadata(cwd, sessionId, status, reason) {
         },
     });
 }
+export async function resolveAskProLoginProfile(cwd, sessionId) {
+    const paths = getAskProSessionPaths(cwd, sessionId);
+    return resolveResumeBrowserProfile(await readBrowserMetadata(paths.browser));
+}
 async function resolveResumeBrowserProfile(metadata) {
     const agentProfile = resolveStoredAgentProfile(metadata.agentId);
     const profileDir = metadata.profileDir;

package/dist/src/ask-pro/loginPage.js

@@ -0,0 +1,29 @@
+// The browser relays human input only. Never persist input, frames, or the access key.
+export const loginPage = `<!doctype html>
+<html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>ask-pro sign in</title>
+<style>
+:root{font:16px/1.5 system-ui;color:#182421;background:#f5f7f6}body{margin:0}main{max-width:1280px;margin:auto;padding:20px}header{display:flex;gap:16px;align-items:center;flex-wrap:wrap;margin-bottom:16px}h1{font-size:22px;margin:0 auto 0 0}button,input,select{font:inherit;padding:10px;border:1px solid #62716b;border-radius:6px;background:white;color:inherit}button{cursor:pointer}button:hover{background:#e0ebe5}:focus-visible{outline:3px solid #197451;outline-offset:2px}#screen{display:block;width:100%;background:white;touch-action:manipulation}form{display:flex;gap:8px;flex-wrap:wrap;margin-top:16px}input{flex:1;min-width:150px}#status{min-height:24px;margin:8px 0;color:#344b41}button:disabled{opacity:.6;cursor:wait}
+</style><main><header><h1>Sign in to ChatGPT</h1><select id="tabs" aria-label="Browser tab"></select><button id="refresh">Refresh tabs</button><button id="done">Done</button></header>
+<p id="status" role="status">Connecting…</p><img id="screen" tabindex="0" alt="Remote browser. Click a field, then type, or use the text box below.">
+<form><input id="text" type="password" autocomplete="off" aria-label="Text for selected browser field" placeholder="Type into selected field"><button>Send text</button><button type="button" id="enter">Enter</button><button type="button" id="tab">Tab</button><button type="button" id="backspace">Backspace</button><button type="button" id="up">Scroll up</button><button type="button" id="down">Scroll down</button></form></main>
+<script>
+const token=location.hash.slice(1);history.replaceState(null,'',location.pathname);
+const screen=document.querySelector('#screen'),tabs=document.querySelector('#tabs'),status=document.querySelector('#status'),text=document.querySelector('#text');
+let stopped=false,frameUrl,inputQueue=Promise.resolve();
+async function api(route,body){const r=await fetch(route,{method:body===undefined?'GET':'POST',headers:{Authorization:'Bearer '+token,'Content-Type':'application/json'},body:body===undefined?undefined:JSON.stringify(body),cache:'no-store'});if(!r.ok)throw Error(r.status===401?'Link expired. Start ask-pro --login again.':'Connection failed. Retry or refresh tabs.');return r;}
+function report(e){status.textContent=e.message;}
+function input(body){const target=tabs.value;const request=inputQueue.then(()=>api('/input',{target,...body}));inputQueue=request.catch(report);return request;}
+async function refresh(){try{const list=await(await api('/tabs')).json();const previous=tabs.value;tabs.replaceChildren(...list.map(t=>new Option(t.name,t.id)));if(list.some(t=>t.id===previous))tabs.value=previous;status.textContent='Click the browser to sign in. Select Done when the ChatGPT composer is visible.';}catch(e){report(e);}}
+async function frame(){if(stopped)return;try{if(tabs.value){const r=await api('/frame?target='+encodeURIComponent(tabs.value));const url=URL.createObjectURL(await r.blob());screen.src=url;if(frameUrl)URL.revokeObjectURL(frameUrl);frameUrl=url;}}catch(e){report(e);}setTimeout(frame,350);}
+screen.onclick=e=>{const r=screen.getBoundingClientRect();input({kind:'click',x:(e.clientX-r.left)*screen.naturalWidth/r.width,y:(e.clientY-r.top)*screen.naturalHeight/r.height});screen.focus();};
+screen.onkeydown=e=>{if(e.ctrlKey||e.metaKey||e.altKey)return;if(e.key.length===1){e.preventDefault();input({kind:'text',text:e.key});}else if(['Enter','Tab','Backspace','Delete','ArrowLeft','ArrowRight','ArrowUp','ArrowDown','Escape','Home','End'].includes(e.key)){e.preventDefault();input({kind:'key',key:e.key});}};
+screen.onwheel=e=>{e.preventDefault();const r=screen.getBoundingClientRect();input({kind:'scroll',x:(e.clientX-r.left)*screen.naturalWidth/r.width,y:(e.clientY-r.top)*screen.naturalHeight/r.height,deltaY:e.deltaY});};
+document.querySelector('form').onsubmit=async e=>{e.preventDefault();const value=text.value;try{await input({kind:'text',text:value});if(text.value===value)text.value='';}catch(e){report(e);}};
+for(const key of ['Enter','Tab','Backspace'])document.querySelector('#'+key.toLowerCase()).onclick=()=>input({kind:'key',key});
+document.querySelector('#up').onclick=()=>input({kind:'scroll',x:100,y:100,deltaY:-400});
+document.querySelector('#down').onclick=()=>input({kind:'scroll',x:100,y:100,deltaY:400});
+document.querySelector('#refresh').onclick=refresh;
+document.querySelector('#done').onclick=async()=>{try{await api('/done',{});stopped=true;screen.removeAttribute('src');text.value='';status.textContent='Sign-in window closed. You can return to your agent.';}catch(e){report(e);}};
+refresh().then(frame);
+</script></html>`;

package/dist/src/ask-pro/remoteLogin.js

@@ -0,0 +1,254 @@
+import http from "node:http";
+import { randomBytes } from "node:crypto";
+import os from "node:os";
+import CDP from "chrome-remote-interface";
+import { resolveBrowserConfig } from "../browser/config.js";
+import { prepareAskProBrowserProfile } from "../browser/profileMigration.js";
+import { resolveAskProAgentId } from "../browser/profilePaths.js";
+import { acquireProfileRunLock, createManagedChromeRunLease, releaseManagedChromeRunLeaseAndCountPeers, writeChromePid, writeDevToolsActivePort, } from "../browser/profileState.js";
+import { launchChrome, maybeReuseRunningChrome, releaseChromeProcessHandle, } from "../browser/chromeLifecycle.js";
+import { loginPage } from "./loginPage.js";
+const keys = new Set([
+    "Enter",
+    "Tab",
+    "Backspace",
+    "Delete",
+    "ArrowLeft",
+    "ArrowRight",
+    "ArrowUp",
+    "ArrowDown",
+    "Escape",
+    "Home",
+    "End",
+]);
+/** Narrow human-operated relay: no cookies, DOM, evaluation, or arbitrary CDP endpoint. */
+export async function startLoginServer(options) {
+    const token = randomBytes(32).toString("hex");
+    let client;
+    let targetId;
+    let queue = Promise.resolve();
+    let finish;
+    const done = new Promise((resolve) => {
+        finish = resolve;
+    });
+    const targets = async () => (await CDP.List({ port: options.chromePort })).filter((t) => t.type === "page" && /^(https?:|about:blank)/.test(t.url));
+    async function connect(id) {
+        if (!(await targets()).some((t) => t.id === id))
+            throw Error("Unavailable tab");
+        if (targetId !== id || !client) {
+            await client?.close().catch(() => undefined);
+            client = await CDP({ port: options.chromePort, target: id });
+            targetId = id;
+            client.on("disconnect", () => {
+                if (targetId === id) {
+                    client = undefined;
+                    targetId = undefined;
+                }
+            });
+        }
+        return client;
+    }
+    const server = http.createServer((req, res) => {
+        res.setHeader("Cache-Control", "no-store");
+        res.setHeader("Referrer-Policy", "no-referrer");
+        res.setHeader("X-Frame-Options", "DENY");
+        res.setHeader("X-Content-Type-Options", "nosniff");
+        res.setHeader("Content-Security-Policy", "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src blob:; connect-src 'self'; frame-ancestors 'none'; form-action 'none'");
+        if (req.method === "GET" && req.url === "/") {
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.end(loginPage);
+            return;
+        }
+        if (req.headers.authorization !== "Bearer " + token) {
+            res.writeHead(401).end();
+            return;
+        }
+        // Reject cross-origin browser requests even when a caller has the link.
+        if (req.headers.origin && req.headers.origin !== "http://" + req.headers.host) {
+            res.writeHead(403).end();
+            return;
+        }
+        const route = new URL(req.url ?? "/", "http://localhost");
+        const run = async () => {
+            if (req.method === "GET" && route.pathname === "/tabs") {
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify((await targets()).map((t) => ({
+                    id: t.id,
+                    name: t.url === "about:blank" ? "Blank tab" : new URL(t.url).hostname,
+                }))));
+                return;
+            }
+            if (req.method === "GET" && route.pathname === "/frame") {
+                const c = await connect(route.searchParams.get("target") ?? "");
+                const frame = await c.Page.captureScreenshot({ format: "jpeg", quality: 70 });
+                res.setHeader("Content-Type", "image/jpeg");
+                res.end(Buffer.from(frame.data, "base64"));
+                return;
+            }
+            if (req.method !== "POST" || !["/input", "/done"].includes(route.pathname)) {
+                res.writeHead(404).end();
+                return;
+            }
+            let raw = "";
+            for await (const chunk of req) {
+                raw += chunk;
+                if (Buffer.byteLength(raw) > 16384) {
+                    res.writeHead(413).end();
+                    return;
+                }
+            }
+            if (route.pathname === "/done") {
+                res.end();
+                setImmediate(() => {
+                    void close();
+                });
+                return;
+            }
+            const body = JSON.parse(raw);
+            const c = await connect(typeof body.target === "string" ? body.target : "");
+            await c.Page.bringToFront();
+            const coordinate = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+            if (body.kind === "text" && typeof body.text === "string")
+                await c.Input.insertText({ text: body.text });
+            else if (body.kind === "key" && typeof body.key === "string" && keys.has(body.key)) {
+                const key = body.key;
+                const code = {
+                    Enter: 13,
+                    Tab: 9,
+                    Backspace: 8,
+                    Delete: 46,
+                    Escape: 27,
+                    ArrowLeft: 37,
+                    ArrowUp: 38,
+                    ArrowRight: 39,
+                    ArrowDown: 40,
+                    Home: 36,
+                    End: 35,
+                }[key];
+                await c.Input.dispatchKeyEvent({
+                    type: "keyDown",
+                    key,
+                    code: key,
+                    windowsVirtualKeyCode: code,
+                    ...(key === "Enter" ? { text: "\r" } : {}),
+                });
+                await c.Input.dispatchKeyEvent({
+                    type: "keyUp",
+                    key,
+                    code: key,
+                    windowsVirtualKeyCode: code,
+                });
+            }
+            else if ((body.kind === "click" || body.kind === "scroll") &&
+                coordinate(body.x) &&
+                coordinate(body.y)) {
+                const x = body.x, y = body.y;
+                if (body.kind === "click") {
+                    await c.Input.dispatchMouseEvent({
+                        type: "mousePressed",
+                        x,
+                        y,
+                        button: "left",
+                        clickCount: 1,
+                    });
+                    await c.Input.dispatchMouseEvent({
+                        type: "mouseReleased",
+                        x,
+                        y,
+                        button: "left",
+                        clickCount: 1,
+                    });
+                }
+                else if (typeof body.deltaY === "number" && Number.isFinite(body.deltaY))
+                    await c.Input.dispatchMouseEvent({
+                        type: "mouseWheel",
+                        x,
+                        y,
+                        deltaX: 0,
+                        deltaY: body.deltaY,
+                    });
+                else {
+                    res.writeHead(400).end();
+                    return;
+                }
+            }
+            else {
+                res.writeHead(400).end();
+                return;
+            }
+            res.end();
+        };
+        queue = queue.then(run).catch(() => {
+            if (!res.headersSent)
+                res.writeHead(400);
+            res.end();
+        });
+    });
+    let closed = false;
+    async function close() {
+        if (closed)
+            return;
+        closed = true;
+        clearTimeout(timer);
+        server.close();
+        server.closeAllConnections();
+        await client?.close().catch(() => undefined);
+        finish();
+    }
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(options.port ?? 0, options.host, resolve);
+    });
+    const timer = setTimeout(() => {
+        void close();
+    }, options.ttlMs ?? 15 * 60_000);
+    const address = server.address();
+    const hostname = options.host === "0.0.0.0" ? os.hostname() : options.host;
+    return { url: "http://" + hostname + ":" + address.port + "/#" + token, done, close };
+}
+export async function runRemoteLogin(onReady, savedProfile) {
+    const host = process.env.ASK_PRO_LOGIN_HOST?.trim();
+    if (!host)
+        throw Error("Set ASK_PRO_LOGIN_HOST to this machine’s private network IP (for example its Tailscale IP), then run --login.");
+    const profile = savedProfile ?? (await prepareAskProBrowserProfile(resolveAskProAgentId()));
+    const lock = await acquireProfileRunLock(profile, { timeoutMs: 1000 });
+    if (!lock)
+        throw Error("Browser busy. Wait for ask-pro runs to finish before --login.");
+    const lease = await createManagedChromeRunLease(profile);
+    let relay;
+    try {
+        // Count live automation leases while holding the launch lock; login never races a query.
+        const peers = await releaseManagedChromeRunLeaseAndCountPeers(profile, lease);
+        if (peers !== 0)
+            throw Error("Browser busy. Wait for ask-pro runs to finish before --login.");
+        const chrome = (await maybeReuseRunningChrome(profile, () => { })) ??
+            (await launchChrome(resolveBrowserConfig({ manualLogin: true, headless: true }), profile, () => { }, { ignoreLockId: lock.lockId }));
+        releaseChromeProcessHandle(chrome);
+        if (chrome.pid)
+            await writeChromePid(profile, chrome.pid);
+        await writeDevToolsActivePort(profile, chrome.port);
+        const pages = await CDP.List({ port: chrome.port });
+        if (!pages.some((t) => t.type === "page" && /^https:\/\/(chatgpt\.com|auth\.openai\.com)(\/|$)/.test(t.url))) {
+            await CDP.New({ port: chrome.port, url: "https://chatgpt.com/" });
+        }
+        relay = await startLoginServer({ chromePort: chrome.port, host });
+        const stop = () => {
+            void relay?.close();
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        try {
+            onReady(relay.url);
+            await relay.done;
+        }
+        finally {
+            process.removeListener("SIGINT", stop);
+            process.removeListener("SIGTERM", stop);
+        }
+    }
+    finally {
+        await relay?.close();
+        await releaseManagedChromeRunLeaseAndCountPeers(profile, lease);
+        await lock.release();
+    }
+}

package/dist/src/browser/chromeLifecycle.js

@@ -8,7 +8,7 @@ import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import CDP from "chrome-remote-interface";
 import { Launcher } from "chrome-launcher";
-import { clearChromeLaunchStarting, cleanupStaleProfileState, hasChromeLaunchStarting, markChromeLaunchStarting, readChromePid, readDevToolsPort, verifyDevToolsReachable, } from "./profileState.js";
+import { clearChromeLaunchStarting, clearIdleBrowserProfileCaches, cleanupStaleProfileState, hasChromeLaunchStarting, markChromeLaunchStarting, readChromePid, readDevToolsPort, verifyDevToolsReachable, } from "./profileState.js";
 import { delay } from "./utils.js";
 import { formatElapsed } from "./format.js";
 import { withTimeout } from "./reattachHelpers.js";
@@ -20,13 +20,14 @@ const CPU_THROTTLING_OVERRIDE_FLAGS = new Set([
     "--disable-ipc-flooding-protection",
 ]);
 const CHROME_STARTUP_HANDOFF_MS = 26_000;
-export async function launchChrome(config, userDataDir, logger) {
+export async function launchChrome(config, userDataDir, logger, options = {}) {
     const connectHost = resolveRemoteDebugHost();
     const debugBindAddress = connectHost && connectHost !== "127.0.0.1" ? "0.0.0.0" : connectHost;
     const debugPort = config.debugPort ?? parseDebugPortEnv();
     const chromeFlags = buildChromeLaunchFlags(buildChromeFlags(config.headless ?? false, debugBindAddress, config.acceptLanguage, {
         startMinimized: shouldLaunchChromeMinimized(config),
     }));
+    await clearIdleBrowserProfileCaches(userDataDir, options);
     await markChromeLaunchStarting(userDataDir);
     try {
         const launcher = await launchManagedChrome({
@@ -581,6 +582,7 @@ export function buildChromeFlags(headless, debugBindAddress, acceptLanguage = "e
     const primaryLanguage = acceptLanguage.split(",", 1)[0]?.trim() || "en-US";
     const flags = [
         "--disable-background-networking",
+        "--disk-cache-size=16777216",
         "--disable-breakpad",
         "--disable-client-side-phishing-detection",
         "--disable-default-apps",

package/dist/src/browser/config.js

@@ -2,6 +2,9 @@ import { CHATGPT_URL, DEFAULT_MODEL_STRATEGY, DEFAULT_MODEL_TARGET } from "./con
 import { normalizeBrowserModelStrategy } from "./modelStrategy.js";
 import { defaultAskProBrowserProfileDir } from "./profilePaths.js";
 import { normalizeChatgptUrl } from "./utils.js";
+export function isHeadlessLinux(platform = process.platform, env = process.env) {
+    return platform === "linux" && !env.DISPLAY && !env.WAYLAND_DISPLAY;
+}
 export const DEFAULT_BROWSER_CONFIG = {
     chromeProfile: null,
     chromePath: null,
@@ -76,14 +79,14 @@ export function resolveBrowserConfig(config) {
         cookieSyncWaitMs: config?.cookieSyncWaitMs ?? DEFAULT_BROWSER_CONFIG.cookieSyncWaitMs,
         inlineCookies: config?.inlineCookies ?? DEFAULT_BROWSER_CONFIG.inlineCookies,
         inlineCookiesSource: config?.inlineCookiesSource ?? DEFAULT_BROWSER_CONFIG.inlineCookiesSource,
-        headless: config?.headless ?? DEFAULT_BROWSER_CONFIG.headless,
+        headless: config?.headless ?? isHeadlessLinux(),
         keepBrowser: config?.keepBrowser ?? DEFAULT_BROWSER_CONFIG.keepBrowser,
         hideWindow: config?.hideWindow ?? DEFAULT_BROWSER_CONFIG.hideWindow,
         startMinimized: config?.startMinimized ?? DEFAULT_BROWSER_CONFIG.startMinimized,
         desiredModel,
         modelStrategy,
         chromeProfile: config?.chromeProfile ?? DEFAULT_BROWSER_CONFIG.chromeProfile,
-        chromePath: config?.chromePath ?? DEFAULT_BROWSER_CONFIG.chromePath,
+        chromePath: config?.chromePath ?? process.env.CHROME_PATH ?? DEFAULT_BROWSER_CONFIG.chromePath,
         chromeCookiePath: config?.chromeCookiePath ?? DEFAULT_BROWSER_CONFIG.chromeCookiePath,
         attachRunning: config?.attachRunning ?? DEFAULT_BROWSER_CONFIG.attachRunning,
         browserTabRef: config?.browserTabRef ?? DEFAULT_BROWSER_CONFIG.browserTabRef,

package/dist/src/browser/index.js

@@ -394,7 +394,7 @@ export async function runBrowserMode(options) {
                 (await launchChrome({
                     ...config,
                     remoteChrome: config.remoteChrome,
-                }, userDataDir, logger));
+                }, userDataDir, logger, { ignoreLockId: profileLock?.lockId }));
         // Persist profile state so future manual-login runs can reuse this Chrome.
         if (manualLogin && chrome.port) {
             await writeDevToolsActivePort(userDataDir, chrome.port);

package/dist/src/browser/profileState.js

@@ -182,6 +182,16 @@ export async function isBrowserProfileInUse(userDataDir, options = {}) {
     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([
@@ -192,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) {

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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ask-pro",
-  "version": "0.2.78",
+  "version": "0.2.87",
   "description": "Browser-backed ChatGPT Pro escalation for hard engineering questions.",
   "keywords": [
     "agents",