@monoes/monobrowse 2.24.1 → 2.24.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monobrowse",
-  "version": "2.24.1",
+  "version": "2.24.3",
   "description": "Native browser automation via Chrome DevTools Protocol — the engine powering monomind browse",
   "type": "module",
   "bin": {
@@ -37,13 +37,6 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "scripts": {
-    "build": "tsc && node ../../../scripts/build-fs.mjs copy-into dist/src/browser/dashboard src/browser/dashboard/ui.html",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "prebuild": "node ../../../scripts/build-fs.mjs clean dist tsconfig.tsbuildinfo",
-    "prepublishOnly": "npm run build"
-  },
   "keywords": [
     "browser-automation",
     "cdp",
@@ -70,5 +63,11 @@
   "devDependencies": {
     "typescript": "^7.0.2",
     "vitest": "^4.1.4"
+  },
+  "scripts": {
+    "build": "tsc && node ../../../scripts/build-fs.mjs copy-into dist/src/browser/dashboard src/browser/dashboard/ui.html",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "prebuild": "node ../../../scripts/build-fs.mjs clean dist tsconfig.tsbuildinfo"
   }
-}
+}

package/src/__tests__/open-url-navigate-error.test.ts

@@ -54,3 +54,36 @@ describe('openUrl navigation-failure detection', () => {
     expect(calls).toHaveLength(0);
   });
 });
+
+describe('openUrl on a page with a persistent connection (#670)', () => {
+  it('resolves once the page has loaded even though the network never goes idle', async () => {
+    vi.useFakeTimers();
+    try {
+      const handlers = new Map<string, (p: Record<string, unknown>, sid?: string) => void>();
+      const client = {
+        send: vi.fn(async (method: string) => {
+          if (method === 'Page.navigate') return { frameId: 'f1' };
+          if (method === 'Runtime.evaluate') return { result: { value: true } };
+          return {};
+        }),
+        on: vi.fn((event: string, fn: (p: Record<string, unknown>, sid?: string) => void) => {
+          handlers.set(event, fn);
+          // An SSE/long-poll request that never finishes.
+          if (event === 'Network.requestWillBeSent') {
+            queueMicrotask(() => fn({ requestId: 'sse' }, 'sess-1'));
+          }
+          return () => handlers.delete(event);
+        }),
+      } as unknown as CdpClient;
+
+      const done = openUrl(client, 'sess-1', 'http://127.0.0.1:1/login').then(
+        () => 'ok',
+        (e: Error) => e.message,
+      );
+      await vi.advanceTimersByTimeAsync(31_000);
+      await expect(done).resolves.toBe('ok');
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

package/src/__tests__/profile-dir.test.ts

@@ -68,13 +68,15 @@ async function profile(name: string, opts: { young?: boolean } = {}): Promise<st
 }
 
 describe('#395 profileDirOwnerPid', () => {
-  it('reads the pid from exactly our two name patterns', () => {
+  it('reads the pid from exactly our name patterns', () => {
     expect(profileDirOwnerPid('monomind-browser-9222-1234-0a1b2c3d')).toBe(1234);
     expect(profileDirOwnerPid('monomind-browse-4321-0a1b2c3d')).toBe(4321);
+    expect(profileDirOwnerPid('monomind-browse-headed-4321-0a1b2c3d')).toBe(4321);
     for (const name of [
       'monomind-browse-4321-0A1B2C3D',
       'monomind-browse-4321-0a1b2c3d0',
       'monomind-browse-x-0a1b2c3d',
+      'monomind-browse-headed-x-0a1b2c3d',
       'monomind-browser-4321-0a1b2c3d',
       'xmonomind-browse-4321-0a1b2c3d',
       'org.chromium.Chromium.abc123',
@@ -89,12 +91,14 @@ describe('#395 sweepStaleProfileDirs', () => {
     const pid = await deadPid();
     const a = await profile(`monomind-browser-9222-${pid}-aaaaaaaa`);
     const b = await profile(`monomind-browse-${pid}-bbbbbbbb`);
+    const c = await profile(`monomind-browse-headed-${pid}-cccccccc`);
 
     const removed = await sweepStaleProfileDirs({ root });
 
-    expect(removed.sort()).toEqual([a, b].sort());
+    expect(removed.sort()).toEqual([a, b, c].sort());
     expect(existsSync(a)).toBe(false);
     expect(existsSync(b)).toBe(false);
+    expect(existsSync(c)).toBe(false);
   });
 
   it('keeps young dirs, dirs whose pid is alive, non-matching names, symlinks and files', async () => {

package/src/browser/browser-lifecycle.ts

@@ -48,32 +48,34 @@ const REAP_CONNECT_TIMEOUT_MS = 3000;
  * the process is gone, on both paths (#395). In a fresh process the dir and
  * its ownership come from the persisted session record.
  */
-export async function closeBrowser(client: CdpClient, port: number): Promise<void> {
+export async function closeBrowser(client: CdpClient | null, port: number): Promise<void> {
   let gracefullyClosed = false;
   let closeTimer: ReturnType<typeof setTimeout> | undefined;
-  try {
-    await Promise.race([
-      client.send('Browser.close', {}),
-      // Deliberately NOT unref'd, for the same reason waitForProcessExit()'s
-      // poll below is not. This timer is the only thing that settles the race
-      // when Chrome's socket dies without ever acknowledging the close, and
-      // closeBrowser() is actively awaited by callers. An unref'd timer does
-      // not hold the event loop open, so Node would consider the loop drained
-      // and exit — status 0, before the caller's verdict was ever printed.
-      // Cleared in the finally so a close that IS acknowledged does not pin
-      // the loop for the rest of BROWSER_CLOSE_TIMEOUT_MS.
-      new Promise<never>((_, reject) => {
-        closeTimer = setTimeout(
-          () => reject(new Error('Browser.close timed out')),
-          BROWSER_CLOSE_TIMEOUT_MS,
-        );
-      }),
-    ]);
-    gracefullyClosed = true;
-  } catch {
-    // fall through to PID-kill fallback below
-  } finally {
-    clearTimeout(closeTimer);
+  if (client) {
+    try {
+      await Promise.race([
+        client.send('Browser.close', {}),
+        // Deliberately NOT unref'd, for the same reason waitForProcessExit()'s
+        // poll below is not. This timer is the only thing that settles the race
+        // when Chrome's socket dies without ever acknowledging the close, and
+        // closeBrowser() is actively awaited by callers. An unref'd timer does
+        // not hold the event loop open, so Node would consider the loop drained
+        // and exit — status 0, before the caller's verdict was ever printed.
+        // Cleared in the finally so a close that IS acknowledged does not pin
+        // the loop for the rest of BROWSER_CLOSE_TIMEOUT_MS.
+        new Promise<never>((_, reject) => {
+          closeTimer = setTimeout(
+            () => reject(new Error('Browser.close timed out')),
+            BROWSER_CLOSE_TIMEOUT_MS,
+          );
+        }),
+      ]);
+      gracefullyClosed = true;
+    } catch {
+      // fall through to PID-kill fallback below
+    } finally {
+      clearTimeout(closeTimer);
+    }
   }
 
   let pid = launchedPids.get(port);

package/src/browser/browser-page.ts

@@ -58,7 +58,11 @@ export async function openUrl(client: CdpClient, sessionId: string, url: string)
   // connection previously reported success against that error page.
   const nav = await client.send<{ errorText?: string }>('Page.navigate', { url }, sessionId);
   if (nav.errorText) throw new Error(`Navigation to ${url} failed: ${nav.errorText}`);
-  await waitForNetworkIdle(client, sessionId, 500, 30_000);
+  await waitForLoad(client, sessionId, 'load', 30_000);
+  // Best-effort settle for SPAs that keep fetching after `load`. A page holding
+  // an SSE/long-poll connection (e.g. the monomind dashboard) never goes idle,
+  // so a timeout here is not a failure (#670).
+  await waitForNetworkIdle(client, sessionId, 500, 5_000).catch(() => undefined);
 }
 
 export async function waitForLoad(

package/src/browser/profile-dir.ts

@@ -25,8 +25,8 @@ import { basename, dirname, join } from 'node:path';
 
 /** `monomind-browser-<port>-<pid>-<uuid8>` (launchBrowser's default profile). */
 const LAUNCH_PROFILE_RE = /^monomind-browser-\d+-(\d+)-[0-9a-f]{8}$/;
-/** `monomind-browse-<pid>-<uuid8>` (a CLI browse session's profile). */
-const SESSION_PROFILE_RE = /^monomind-browse-(\d+)-[0-9a-f]{8}$/;
+/** `monomind-browse-<pid>-<uuid8>` or `monomind-browse-headed-<pid>-<uuid8>` (a CLI browse session's profile). */
+const SESSION_PROFILE_RE = /^monomind-browse(?:-headed)?-(\d+)-[0-9a-f]{8}$/;
 
 /** A directory younger than this is never swept: its launch may still be
  *  starting (Chrome has not yet put its pid anywhere we can see). */
@@ -63,8 +63,9 @@ export function launchProfileDirPath(port: number, id: string, root = tmpdir()):
 }
 
 /** Name for a new CLI session profile, directly under `root`. */
-export function sessionProfileDirPath(id: string, root = tmpdir()): string {
-  return join(root, `monomind-browse-${process.pid}-${id}`);
+export function sessionProfileDirPath(id: string, root = tmpdir(), headed = false): string {
+  const prefix = headed ? 'monomind-browse-headed' : 'monomind-browse';
+  return join(root, `${prefix}-${process.pid}-${id}`);
 }
 
 /** The pid encoded in a profile directory name we create, or null when

package/src/cli/attention-wall.ts

@@ -9,6 +9,7 @@
 import { randomUUID } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { sessionProfileDirPath } from '../browser/profile-dir.js';
 import type { CdpClient } from '../index.js';
 import { output } from './output.js';
 import { getBrowser, session } from './session.js';
@@ -110,10 +111,8 @@ export async function switchToHeaded(url: string, port: number): Promise<void> {
     headedPort = await browser.launchBrowser({
       port: 0,
       headless: false,
-      userDataDir: join(
-        tmpdir(),
-        `monomind-browse-headed-${process.pid}-${randomUUID().slice(0, 8)}`,
-      ),
+      userDataDir: sessionProfileDirPath(randomUUID().slice(0, 8), tmpdir(), true),
+      ownsUserDataDir: true,
     });
   } catch (err) {
     // Headed launch failed (no display, locked down env). Restore headless and rethrow.
@@ -127,51 +126,60 @@ export async function switchToHeaded(url: string, port: number): Promise<void> {
       `Cannot open headed browser: ${err instanceof Error ? err.message : String(err)}`,
     );
   }
-  const conn = await browser.connectToTarget(headedPort);
-  session.client = conn.client;
-  session.sessionId = conn.sessionId;
-  session.targetId = conn.target.id;
-  session.refs = new Map();
 
-  if (savedCookies.length) {
-    try {
-      await browser.setCookies(
-        session.client,
-        session.sessionId,
-        savedCookies as Parameters<typeof browser.setCookies>[2],
-      );
-    } catch {
-      /* ignore */
-    }
-  }
-  await browser.openUrl(session.client, session.sessionId, url);
+  let authCookies: unknown[] = [];
+  let authLocalStorage: Record<string, string> = {};
+  try {
+    const conn = await browser.connectToTarget(headedPort);
+    session.client = conn.client;
+    session.sessionId = conn.sessionId;
+    session.targetId = conn.target.id;
+    session.refs = new Map();
 
-  output.printInfo(
-    'Browser window opened. Complete the required action (login / CAPTCHA), then press Enter to continue in headless mode...',
-  );
-  await waitForEnter();
+    if (savedCookies.length) {
+      try {
+        await browser.setCookies(
+          session.client,
+          session.sessionId,
+          savedCookies as Parameters<typeof browser.setCookies>[2],
+        );
+      } catch {
+        /* ignore */
+      }
+    }
+    await browser.openUrl(session.client, session.sessionId, url);
 
-  // Capture post-auth cookies
-  const authCookies = await browser
-    .getCookies(session.client, session.sessionId)
-    .catch(() => [] as unknown[]);
-  const authLocalStorage = await browser
-    .getLocalStorage(session.client, session.sessionId)
-    .catch(() => ({}) as Record<string, string>);
+    output.printInfo(
+      'Browser window opened. Complete the required action (login / CAPTCHA), then press Enter to continue in headless mode...',
+    );
+    await waitForEnter();
 
-  // Close headed session — actually terminate the underlying Chrome process
-  // (Browser.close CDP command, PID-kill fallback), not just our CDP client
-  // connection, so the visible authenticated window doesn't linger forever.
-  browser.teardownRouteInterception(session.sessionId);
-  browser.stopRequestCapture(session.sessionId);
-  browser.teardownDialogHandling(session.sessionId);
-  browser.teardownConsoleCapture(session.sessionId);
-  await browser.closeBrowser(session.client, headedPort);
-  session.client.close();
-  session.client = null;
-  session.sessionId = '';
-  session.parentSessionId = '';
-  session.targetId = '';
+    // Capture post-auth cookies
+    authCookies = await browser
+      .getCookies(session.client, session.sessionId)
+      .catch(() => [] as unknown[]);
+    authLocalStorage = await browser
+      .getLocalStorage(session.client, session.sessionId)
+      .catch(() => ({}) as Record<string, string>);
+  } finally {
+    // Close headed session — actually terminate the underlying Chrome process
+    // (Browser.close CDP command, PID-kill fallback), not just our CDP client
+    // connection, so the visible authenticated window doesn't linger forever.
+    if (session.sessionId) {
+      browser.teardownRouteInterception(session.sessionId);
+      browser.stopRequestCapture(session.sessionId);
+      browser.teardownDialogHandling(session.sessionId);
+      browser.teardownConsoleCapture(session.sessionId);
+    }
+    await browser.closeBrowser(session.client, headedPort);
+    if (session.client) {
+      session.client.close();
+      session.client = null;
+    }
+    session.sessionId = '';
+    session.parentSessionId = '';
+    session.targetId = '';
+  }
 
   // Relaunch headless and restore session
   session.port = await browser.launchBrowser({ port, headless: true });