ask-pro 0.2.80 → 0.2.93

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,17 @@ The calling agent still owns the work. Use Pro for judgment, architecture, risk
 
 ## Running ask-pro
 
+On a display-less Linux host, install Xvfb (`sudo apt install xvfb`); ask-pro
+manages a private display for headed Chrome during login and queries. 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,30 @@
+// The browser relays human input only. Never persist input or frames.
+// Keep the short-lived access key in the URL fragment so reload preserves access.
+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);
+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,278 @@
+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") ?? "");
+                // Reload cancels the image request. Release its pending CDP capture so
+                // it cannot hold the shared request queue and freeze the new viewer.
+                const cancel = () => {
+                    if (!res.writableEnded) {
+                        if (client === c) {
+                            client = undefined;
+                            targetId = undefined;
+                        }
+                        void c.close().catch(() => undefined);
+                    }
+                };
+                if (res.destroyed) {
+                    cancel();
+                    return;
+                }
+                res.once("close", cancel);
+                let frame;
+                try {
+                    frame = await c.Page.captureScreenshot({ format: "jpeg", quality: 70 });
+                }
+                finally {
+                    res.removeListener("close", cancel);
+                }
+                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 }), 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

@@ -12,6 +12,8 @@ import { clearChromeLaunchStarting, clearIdleBrowserProfileCaches, cleanupStaleP
 import { delay } from "./utils.js";
 import { formatElapsed } from "./format.js";
 import { withTimeout } from "./reattachHelpers.js";
+import { isHeadlessLinux } from "./config.js";
+import { spawnChromeWithVirtualDisplay } from "./linuxChrome.js";
 const execFileAsync = promisify(execFile);
 const CPU_THROTTLING_OVERRIDE_FLAGS = new Set([
     "--disable-backgrounding-occluded-windows",
@@ -747,7 +749,9 @@ export function spawnWindowsProcessOutsideJob(command, args, options) {
 }
 const spawnManagedChrome = ((command, args, options) => process.platform === "win32"
     ? spawnWindowsProcessOutsideJob(command, args, options)
-    : spawn(command, args, options));
+    : isHeadlessLinux() && !args.some((arg) => arg.startsWith("--headless"))
+        ? spawnChromeWithVirtualDisplay(command, args, options)
+        : spawn(command, args, options));
 async function launchManagedChrome({ chromeFlags, chromePath, userDataDir, host, requestedPort, }) {
     const launcher = new Launcher({
         chromePath: chromePath ?? undefined,

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 ?? false,
         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

@@ -3,7 +3,7 @@ import path from "node:path";
 import os from "node:os";
 import net from "node:net";
 import CDP from "chrome-remote-interface";
-import { DEFAULT_BROWSER_CONFIG, resolveBrowserConfig } from "./config.js";
+import { DEFAULT_BROWSER_CONFIG, resolveBrowserConfig, isHeadlessLinux } from "./config.js";
 import { launchChrome, registerTerminationHooks, hideChromeWindow, connectToRemoteChrome, connectWithNewTab, closeTab, closeRemoteChromeTarget, closeChromeGracefully, listRemoteChromeTargets, maybeReuseRunningChrome, releaseChromeProcessHandle, restoreChromeWindowByPid, shouldLaunchChromeMinimized, } from "./chromeLifecycle.js";
 import { syncCookies } from "./cookies.js";
 import { navigateToChatGPT, navigateToPromptReadyWithFallback, ensureNotBlocked, ensureLoggedIn, ensurePromptReady, installJavaScriptDialogAutoDismissal, ensureModelSelection, clearPromptComposer, waitForAssistantResponse, captureAssistantMarkdown, clearComposerAttachments, uploadAttachmentFile, waitForAttachmentCompletion, waitForUserTurnAttachments, readAssistantSnapshot, } from "./pageActions.js";
@@ -1346,7 +1346,7 @@ export async function runBrowserMode(options) {
                 ? "ChatGPT login required; leaving browser open so you can sign in."
                 : "Cloudflare challenge detected; leaving browser open so you can complete the check.");
             logger(`Reuse this browser profile with: ${reuseProfileHint}`);
-            if (isLoginRequired && manualLogin) {
+            if (isLoginRequired && manualLogin && !isHeadlessLinux()) {
                 const recoveryRuntime = client?.Runtime;
                 if (!recoveryRuntime) {
                     throw normalizedError;

package/dist/src/browser/linuxChrome.js

@@ -0,0 +1,82 @@
+import { spawn, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { randomBytes } from "node:crypto";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+// A separate supervisor outlives the controller when a browser is kept for resume.
+// Its PID represents the managed browser lifetime, including its private display.
+export function spawnChromeWithVirtualDisplay(command, args, options) {
+    const check = spawnSync("Xvfb", ["-help"], { stdio: "ignore" });
+    if (check.error)
+        throw Error("Xvfb is required on Linux without a display. Run: sudo apt install xvfb");
+    return spawn(process.execPath, [fileURLToPath(import.meta.url), "--supervise", command, ...args], options);
+}
+async function supervise() {
+    const directory = await mkdtemp(path.join(os.tmpdir(), "ask-pro-display-"));
+    const authority = path.join(directory, "Xauthority");
+    const cookie = randomBytes(16);
+    const writeAuthority = async (number) => {
+        const fields = [
+            Buffer.alloc(0),
+            Buffer.from(number),
+            Buffer.from("MIT-MAGIC-COOKIE-1"),
+            cookie,
+        ];
+        const records = fields.map((field) => {
+            const length = Buffer.alloc(2);
+            length.writeUInt16BE(field.length);
+            return Buffer.concat([length, field]);
+        });
+        await writeFile(authority, Buffer.concat([Buffer.from([255, 255]), ...records]), {
+            mode: 0o600,
+        });
+    };
+    await writeAuthority("");
+    const display = spawn("Xvfb", ["-displayfd", "3", "-screen", "0", "1280x800x24", "-nolisten", "tcp", "-auth", authority], {
+        stdio: ["ignore", "ignore", "inherit", "pipe"],
+    });
+    let chrome;
+    const stop = () => {
+        if (chrome)
+            chrome.kill("SIGTERM");
+        else
+            display.kill();
+    };
+    process.on("SIGTERM", stop);
+    process.on("SIGINT", stop);
+    let timer;
+    try {
+        const number = await new Promise((resolve, reject) => {
+            timer = setTimeout(() => reject(Error("Xvfb did not start within 10 seconds")), 10_000);
+            let output = "";
+            display.once("error", reject);
+            display.once("exit", () => reject(Error("Xvfb exited before Chrome started")));
+            display.stdio[3].on("data", (chunk) => {
+                output += String(chunk);
+                if (/^\d+\n$/.test(output))
+                    resolve(output.trim());
+            });
+        }).finally(() => clearTimeout(timer));
+        await writeAuthority(number);
+        chrome = spawn(process.argv[3], process.argv.slice(4), {
+            env: { ...process.env, DISPLAY: `:${number}`, XAUTHORITY: authority },
+            stdio: "inherit",
+        });
+        display.once("exit", () => chrome?.kill("SIGTERM"));
+        process.exitCode = await new Promise((resolve, reject) => {
+            chrome.once("error", reject);
+            chrome.once("exit", (code) => resolve(code ?? 1));
+        });
+    }
+    finally {
+        display.kill();
+        await rm(directory, { recursive: true, force: true });
+    }
+}
+if (process.argv[2] === "--supervise") {
+    await supervise().catch((error) => {
+        console.error(error.message);
+        process.exitCode = 1;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ask-pro",
-  "version": "0.2.80",
+  "version": "0.2.93",
   "description": "Browser-backed ChatGPT Pro escalation for hard engineering questions.",
   "keywords": [
     "agents",
@@ -29,6 +29,7 @@
     "dist/src/browser/attachRunning.js",
     "dist/src/browser/chatgptModelCatalog.js",
     "dist/src/browser/chromeLifecycle.js",
+    "dist/src/browser/linuxChrome.js",
     "dist/src/browser/config.js",
     "dist/src/browser/constants.js",
     "dist/src/browser/cookies.js",