@youdie006/prodex 0.34.0 → 0.35.0

package/dist/chatgpt-browser.js

@@ -2545,6 +2545,143 @@ export function resolveConversationToDelete(conversations, request) {
  * Remove one conversation. ChatGPT deletes a chat by hiding it, which is the
  * same call its own UI makes; the caller is responsible for confirming intent.
  */
+/**
+ * Processes that ARE the browser prodex launched, from `ps` output.
+ *
+ * prodex only ever asked whether the debug port answered, so a Chrome that
+ * stopped answering read as "not running". Measured on a real machine: such an
+ * instance sat for four days with two renderers pinned near 100% and the
+ * window server burning 75% CPU on its zombie window, and nothing reported it.
+ * The port cannot tell a dead browser from an absent one; the process list can.
+ */
+export function findLaunchedBrowserProcesses(psOutput, input) {
+    // `ps -Ao user,pid,command` leads with a user NAME, not a uid.
+    const pidOf = (line) => {
+        const match = /^\s*\S+\s+(\d+)\s/.exec(line);
+        return match ? Number(match[1]) : undefined;
+    };
+    // Mentioning the flag is not being the browser: a shell, an editor, or the
+    // very tool running this scan can carry it on its command line, and this list
+    // is what gets SIGTERM. Caught live - the probe matched its own node process.
+    const isBrowserCommand = (line) => {
+        const command = line.replace(/^\s*\S+\s+\d+\s+/, "");
+        // Only the executable counts, never the arguments: a process that merely
+        // quotes a Chrome path is not Chrome. Everything up to the first flag is
+        // the program, which keeps the spaces macOS puts in "Google Chrome".
+        const executable = command.split(/\s-{1,2}\w/)[0];
+        return /(^|[/\\])(google[ -]?chrome|chromium|chrome)( helper)?( \([^)]*\))?$/i.test(executable.trim());
+    };
+    const lines = psOutput.split(/\r?\n/).filter((line) => !/\bgrep\b/.test(line) && isBrowserCommand(line));
+    // Exactly this port: a plain substring test let port 9 match 9333.
+    const portFlag = new RegExp(`--remote-debugging-port=${input.port}(?!\\d)`);
+    const mains = lines.filter((line) => portFlag.test(line));
+    // The port is the instance's identity. A browser sharing the profile while
+    // listening on another port belongs to someone else, and treating it as ours
+    // made a check against an unused port report a healthy Chrome as wedged.
+    if (mains.length === 0)
+        return [];
+    const helpers = input.profileDir.length > 0 ? lines.filter((line) => line.includes(input.profileDir) && !mains.includes(line)) : [];
+    return [...mains, ...helpers].map(pidOf).filter((pid) => pid !== undefined);
+}
+/**
+ * A browser that is running but deaf is a different problem from one that is
+ * gone, and it needs a different instruction: relaunching on top of it stacks a
+ * second Chrome on the same profile rather than fixing anything.
+ */
+/**
+ * The wedged instance, if there is one: a browser prodex launched that is still
+ * running while its control port answers nothing.
+ */
+export function findWedgedBrowser(input = {}) {
+    const port = resolveCdpPort(input.port);
+    const profileDir = input.profileDir ?? defaultChatGptProfileDir();
+    // -A over every user's processes is deliberate: the browser may have been
+    // launched by another shell session than the one asking.
+    const listed = spawnSync("ps", ["-Ao", "user,pid,command"], { encoding: "utf8", timeout: 10_000 });
+    if (listed.status !== 0 || typeof listed.stdout !== "string")
+        return [];
+    return findLaunchedBrowserProcesses(listed.stdout, { port, profileDir });
+}
+const realSignals = {
+    kill: (pid, signal) => process.kill(pid, signal),
+    isAlive: (pid) => {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    sleep: (ms) => sleep(ms)
+};
+/**
+ * End a wedged instance. Callers must have confirmed intent before calling.
+ *
+ * Continue it first: a browser held in a stopped state cannot act on SIGTERM,
+ * so it keeps the profile lock and the replacement launch fails with "no
+ * reachable DevTools endpoint" - measured, on exactly that. Then ask politely,
+ * and only insist on what will not go.
+ */
+export async function endWedgedBrowser(pids, signals = realSignals) {
+    const send = (pid, signal) => {
+        try {
+            signals.kill(pid, signal);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    for (const pid of pids) {
+        send(pid, "SIGCONT");
+        send(pid, "SIGTERM");
+    }
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+        if (!pids.some((pid) => signals.isAlive(pid)))
+            break;
+        await signals.sleep(500);
+    }
+    for (const pid of pids.filter((pid) => signals.isAlive(pid)))
+        send(pid, "SIGKILL");
+    for (let attempt = 0; attempt < 6; attempt += 1) {
+        if (!pids.some((pid) => signals.isAlive(pid)))
+            break;
+        await signals.sleep(500);
+    }
+    const failed = pids.filter((pid) => signals.isAlive(pid));
+    return { ended: pids.filter((pid) => !failed.includes(pid)), failed };
+}
+/**
+ * What recovery should do when a send finds the browser unreachable.
+ *
+ * Launching is right when the browser is gone and wrong when it is merely deaf:
+ * a second Chrome on the same profile does not replace the wedged one, it joins
+ * it, and the wedged one keeps burning CPU while nobody is looking. That is the
+ * shape of the four-day incident this came from.
+ */
+export function browserRecoveryPlan(input) {
+    if (input.reachable)
+        return "reuse";
+    if (input.wedgedPids.length === 0)
+        return "launch";
+    // Reporting a wedged browser is not enough - nobody ran a check for four
+    // days. prodex started this browser and it has stopped answering its own
+    // control port, so clearing it is what a person would do anyway. It waits for
+    // several silent probes first: a browser mid-answer can miss a single poll,
+    // and ending that one would throw away a consult in flight.
+    if (input.confirmedSilent === true && input.autoClearDisabled !== true)
+        return "clear-and-launch";
+    return "reset-first";
+}
+export function wedgedBrowserBlocker(pids, port) {
+    return {
+        code: "browser_wedged",
+        message: `The dedicated ChatGPT browser is still running (pid ${pids.join(", ")}) but stopped answering on 127.0.0.1:${port}. A wedged Chrome keeps burning CPU and holding its window, so it will not recover on its own.`,
+        retryable: true,
+        next_step: "Clear it with `prodex pro browser reset --confirm` (it previews first), then run `prodex pro browser login`."
+    };
+}
 export function deleteConversationExpression(conversationId) {
     return `(async () => {
   let token = "";

package/dist/cli-help.js

@@ -274,6 +274,9 @@ export function printProBrowserHelp(stdout, sourceCli) {
     const chatDeleteUsage = sourceCli
         ? `${cli} pro browser chat-delete${sourceCliOption} [--title "exact title" | --id <id>] [--confirm-delete]  # previews unless --confirm-delete`
         : `prodex pro browser chat-delete [--source-cli /absolute/path/to/dist/cli.js] [--title "exact title" | --id <id>] [--confirm-delete]  # previews unless --confirm-delete`;
+    const resetUsage = sourceCli
+        ? `${cli} pro browser reset${sourceCliOption} [--port 9333] [--confirm]  # end a browser that runs but stopped answering; previews unless --confirm`
+        : "prodex pro browser reset [--source-cli /absolute/path/to/dist/cli.js] [--port 9333] [--confirm]  # end a browser that runs but stopped answering; previews unless --confirm";
     const recoverUsage = sourceCli
         ? `${cli} pro browser recover${sourceCliOption} [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--timeout-ms 60000]  # fetch a finished answer (deep research reports too) from a thread whose send timed out`
         : "prodex pro browser recover [--source-cli /absolute/path/to/dist/cli.js] [--cwd /absolute/path/to/repo] [--port 9333] --target-url <thread-url> [--timeout-ms 60000]  # fetch a finished answer (deep research reports too) from a thread whose send timed out";
@@ -288,6 +291,7 @@ Commands:
   ${projectDeleteUsage}
   ${chatsUsage}
   ${chatDeleteUsage}
+  ${resetUsage}
   ${askUsage}
   ${recoverUsage}
 

package/dist/cli-pro.js

@@ -2,7 +2,7 @@ import { existsSync, statSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { buildDryRunBundle } from "./bundle.js";
-import { DEFAULT_CDP_PORT, resolveCdpPort, resolveConversationToDelete, resolveProjectToDelete, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, listChatGptModelOptions, deleteChatGptConversation, deleteChatGptProject, listChatGptProjectsWithIds, listRecentChatGptConversations, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, openChatGptTab, parseProMode, parseReasoningEffort, defaultTimeoutForTools, ensureVirtualDisplay, minimizeChatGptWindow, readLastBrowserLoginLaunch, resolveVirtualDisplayPreference, resolveBrowserWindowMode, resolveHeadlessPreference, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt } from "./chatgpt-browser.js";
+import { DEFAULT_CDP_PORT, resolveCdpPort, resolveConversationToDelete, resolveProjectToDelete, chatGptVisibilityBlocker, defaultChatGptProfileDir, formatDurationMs, getChatGptBrowserStatus, listChatGptModelOptions, deleteChatGptConversation, endWedgedBrowser, browserRecoveryPlan, findWedgedBrowser, wedgedBrowserBlocker, deleteChatGptProject, listChatGptProjectsWithIds, listRecentChatGptConversations, listChatGptSidebarProjects, normalizeChatGptTargetUrl, openChatGptBrowser, openChatGptTab, parseProMode, parseReasoningEffort, defaultTimeoutForTools, ensureVirtualDisplay, minimizeChatGptWindow, readLastBrowserLoginLaunch, resolveVirtualDisplayPreference, resolveBrowserWindowMode, resolveHeadlessPreference, recordBrowserLoginLaunch, recoverChatGptAnswerFromThread, sendChatGptPrompt } from "./chatgpt-browser.js";
 import { ASK_PRO_BOOLEAN_FLAGS, ASK_PRO_PREVIEW_VALUE_FLAGS, ASK_PRO_VALUE_FLAGS, assertHelpRequestArgs, assertNoExtraArgs, assertOnlyOptions, findHelpFlagIndexBeforePromptDelimiter, formatCliCommand, hasAskProDryRunMode, hasAskProMode, hasAskProSendMode, isHelpSubcommand, parseAskProArgs, printHelpIfRequested, readFlag, readPortFlag, readPositionalsWithOptions, readNonNegativeIntegerFlag, readPositiveIntegerFlag, readRepeatedFlag, resolveCwdFlag, resolveOptionalFileFlag, unknownSubcommandError } from "./cli-args.js";
 import { printProBrowserHelp, printProHelp } from "./cli-help.js";
 import { listRawResultsForInspection, listTasksForInspection } from "./cli-ledger.js";
@@ -265,6 +265,18 @@ export async function runProCommand(rest, io, runCliFn) {
                     throw new Error(`A ChatGPT browser is already running on port ${port} on ${runningVirtual ? "a virtual display" : "your desktop"}, but ${wantsVirtualDisplay ? "a virtual display" : "your desktop"} was requested. Close it first (\`pkill -f "remote-debugging-port=${port}"\`), then rerun.`);
                 }
             }
+            // A wedged browser is unreachable, so without this login would launch a
+            // second Chrome onto the same profile and leave the first one burning
+            // CPU - the same mistake the unattended recovery path made. Checked
+            // here, after the arguments are validated, so a bad flag still reports
+            // as a bad flag.
+            if (!alreadyRunning) {
+                const wedgedPids = findWedgedBrowser({ port, ...(profileDir ? { profileDir } : {}) });
+                if (wedgedPids.length > 0) {
+                    const wedgedBlocker = wedgedBrowserBlocker(wedgedPids, port);
+                    throw new Error(`${wedgedBlocker.message} ${wedgedBlocker.next_step}`);
+                }
+            }
             const opened = alreadyRunning
                 ? { profileDir: profileDir ?? defaultChatGptProfileDir(), port }
                 : openChatGptBrowser({
@@ -537,6 +549,47 @@ export async function runProCommand(rest, io, runCliFn) {
             io.stderr(`recovered: answer saved to .bridge; re-print with \`prodex pro latest --cwd ${recoverCwd}\``);
             return 0;
         }
+        if (browserSubcommand === "reset") {
+            if (printProBrowserHelpIfRequested(browserArgs, "pro browser reset", io, {
+                valueFlags: ["--port", "--profile-dir", "--source-cli"],
+                booleanFlags: ["--confirm"]
+            })) {
+                return 0;
+            }
+            assertOnlyOptions(browserArgs, "pro browser reset", ["--port", "--profile-dir", "--source-cli"], ["--confirm"]);
+            const resetPort = readPortFlag(browserArgs, "--port");
+            const resetProfileDir = readFlag(browserArgs, "--profile-dir");
+            const reachable = (await getChatGptBrowserStatus({ ...(resetPort !== undefined ? { port: resetPort } : {}), timeoutMs: 2_000 }))
+                .reachable;
+            const pids = findWedgedBrowser({
+                ...(resetPort !== undefined ? { port: resetPort } : {}),
+                ...(resetProfileDir ? { profileDir: resetProfileDir } : {})
+            });
+            if (pids.length === 0) {
+                io.stdout("No browser launched by prodex is running; nothing to reset.");
+                return 0;
+            }
+            // A browser that still answers is doing its job - ending it would take
+            // an in-flight consult with it.
+            if (reachable) {
+                io.stdout(`The dedicated browser is running and answering (pid ${pids.join(", ")}). Nothing was ended.`);
+                io.stdout("Close it yourself if you meant to, or run this again once it stops responding.");
+                return 0;
+            }
+            if (!browserArgs.includes("--confirm")) {
+                io.stdout(`Would end the wedged browser: pid ${pids.join(", ")}.`);
+                io.stdout("It is not answering its control port, so nothing in flight is lost; the profile and login stay on disk.");
+                io.stdout("Nothing was ended. Re-run with --confirm to go ahead.");
+                return 0;
+            }
+            const outcome = await endWedgedBrowser(pids);
+            if (outcome.ended.length > 0)
+                io.stdout(`ended wedged browser: pid ${outcome.ended.join(", ")}`);
+            if (outcome.failed.length > 0)
+                io.stdout(`could not end: pid ${outcome.failed.join(", ")} (try again from the account that started it)`);
+            io.stdout("Run `prodex pro browser login` to start a fresh one; it reuses the same profile.");
+            return 0;
+        }
         if (browserSubcommand === "chats") {
             if (printProBrowserHelpIfRequested(browserArgs, "pro browser chats", io, { valueFlags: ["--port", "--timeout-ms", "--limit", "--source-cli"] }))
                 return 0;
@@ -639,6 +692,7 @@ export async function runProCommand(rest, io, runCliFn) {
             "project-delete",
             "chats",
             "chat-delete",
+            "reset",
             "recover"
         ]);
     }
@@ -1393,7 +1447,60 @@ export async function performBrowserConsultForMcp(cwd, input, onProgress) {
  * throws) when recovery does not reach readiness, so the original blocker
  * flow stays intact.
  */
+/**
+ * Is the control port really dead, or was that one unlucky poll?
+ *
+ * A browser writing a long answer can miss a probe. Ending that one would throw
+ * away a consult in flight, so silence has to hold across several tries before
+ * anything gets killed.
+ */
+async function confirmBrowserSilence(port, probes = 3, gapMs = 2_000) {
+    for (let attempt = 0; attempt < probes; attempt += 1) {
+        if (attempt > 0)
+            await sleep(gapMs);
+        const status = await getChatGptBrowserStatus({ ...(port !== undefined ? { port } : {}), timeoutMs: 2_000 });
+        if (status.reachable)
+            return false;
+    }
+    return true;
+}
+function autoClearDisabledByEnv(env = process.env) {
+    const raw = (env.PRODEX_NO_AUTO_CLEAR ?? "").trim().toLowerCase();
+    return raw === "1" || raw === "true" || raw === "yes";
+}
 export async function attemptBrowserAutoRecovery(stderr, options) {
+    // Launching is right when the browser is gone and wrong when it is only deaf:
+    // a second Chrome on the same profile joins the wedged one rather than
+    // replacing it, and the wedged one keeps burning CPU while nobody looks. This
+    // runs unattended for agents, so it is the path that let four days pass.
+    const wedged = findWedgedBrowser({ ...(options.port !== undefined ? { port: options.port } : {}) });
+    if (wedged.length > 0) {
+        // Confirm the silence before ending anything: one missed poll is a busy
+        // browser, several in a row is a dead one.
+        const confirmedSilent = await confirmBrowserSilence(options.port);
+        const plan = browserRecoveryPlan({
+            reachable: false,
+            wedgedPids: wedged,
+            confirmedSilent,
+            autoClearDisabled: autoClearDisabledByEnv()
+        });
+        if (plan === "reset-first") {
+            const blocker = wedgedBrowserBlocker(wedged, resolveCdpPort(options.port));
+            stderr(`recover: ${blocker.message}`);
+            stderr(`recover: ${blocker.next_step}`);
+            return false;
+        }
+        stderr(`recover: the browser stopped answering; ending it (pid ${wedged.join(", ")}) and starting a fresh one...`);
+        await endWedgedBrowser(wedged);
+        // Wait for the profile lock to actually clear rather than guessing at a
+        // delay: the replacement launch fails outright if the old process still
+        // holds it, which is how the first self-heal attempt ended.
+        for (let attempt = 0; attempt < 10; attempt += 1) {
+            if (findWedgedBrowser({ ...(options.port !== undefined ? { port: options.port } : {}) }).length === 0)
+                break;
+            await sleep(1_000);
+        }
+    }
     stderr("recover: browser is not running - launching the dedicated ChatGPT browser (Ctrl+C aborts)...");
     try {
         // Reuse the profile the user last logged in with; launching the default
@@ -1869,8 +1976,14 @@ export async function printProductCheck(store, io, args, configCwd = io.cwd) {
     if (browserStatus) {
         const visibilityBlocker = chatGptVisibilityBlocker(browserStatus.visibilityState, browserStatus.url);
         if (!browserStatus.reachable) {
-            io.stdout(`chatgpt: ${browserStatus.blocker?.code ?? "unreachable"} - ${browserStatus.blocker?.message ?? "browser is not reachable"}`);
-            const nextStep = productCheckBrowserNextStep(browserStatus.blocker?.next_step, sourceCli, browserCommandOptions);
+            // An unreachable port has two very different causes, and prodex used to
+            // report both as "not running": the browser really is gone, or it is still
+            // there and has stopped answering. The second keeps burning CPU until
+            // somebody notices, and nobody notices a message that says it is absent.
+            const wedged = findWedgedBrowser({ ...(browserCommandOptions.port !== undefined ? { port: browserCommandOptions.port } : {}) });
+            const blocker = wedged.length > 0 ? wedgedBrowserBlocker(wedged, browserCommandOptions.port ?? DEFAULT_CDP_PORT) : browserStatus.blocker;
+            io.stdout(`chatgpt: ${blocker?.code ?? "unreachable"} - ${blocker?.message ?? "browser is not reachable"}`);
+            const nextStep = productCheckBrowserNextStep(blocker?.next_step, sourceCli, browserCommandOptions);
             if (nextStep)
                 io.stdout(`next: ${nextStep}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdie006/prodex",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Local receipt bus for coordinating Codex execution with ChatGPT Pro/Projects consultation.",
   "author": "youdie006",
   "license": "MIT",