@monoes/monobrowse 1.0.9 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monobrowse",
-  "version": "1.0.9",
+  "version": "1.0.12",
   "description": "Native browser automation via Chrome DevTools Protocol — the engine powering monomind browse",
   "type": "module",
   "bin": {
@@ -31,7 +31,7 @@
     "src"
   ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.12.0"
   },
   "keywords": [
     "browser-automation",

package/src/__tests__/adapters.test.ts

@@ -2,7 +2,7 @@
  * Platform adapters are pure declarations plus two tiny page-probing methods.
  * A fake PageInterface (evaluate + url) is all that's needed — no browser.
  */
-import { describe, it, expect, vi } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { adapters, getAdapter, type PageInterface } from '../browser/adapters/index.js';
 
 const PLATFORMS = ['linkedin', 'instagram', 'x', 'gemini', 'google', 'microsoft'] as const;
@@ -32,7 +32,7 @@ describe('getAdapter', () => {
 
   it('throws for an unknown platform, listing the supported ones', () => {
     expect(() => getAdapter('myspace')).toThrow(
-      `Unknown platform: myspace. Supported: ${PLATFORMS.join(', ')}`
+      `Unknown platform: myspace. Supported: ${PLATFORMS.join(', ')}`,
     );
   });
 
@@ -72,12 +72,19 @@ describe('adapter invariants', () => {
 
 describe('isLoggedIn', () => {
   it('coerces the page probe to the boolean the caller expects', async () => {
-    await expect(getAdapter('linkedin').isLoggedIn(fakePage({ evaluate: true }))).resolves.toBe(true);
-    await expect(getAdapter('linkedin').isLoggedIn(fakePage({ evaluate: false }))).resolves.toBe(false);
+    await expect(getAdapter('linkedin').isLoggedIn(fakePage({ evaluate: true }))).resolves.toBe(
+      true,
+    );
+    await expect(getAdapter('linkedin').isLoggedIn(fakePage({ evaluate: false }))).resolves.toBe(
+      false,
+    );
   });
 
   it('google short-circuits to false on the sign-in page without probing the DOM', async () => {
-    const page = fakePage({ url: 'https://accounts.google.com/signin/v2/identifier', evaluate: true });
+    const page = fakePage({
+      url: 'https://accounts.google.com/signin/v2/identifier',
+      evaluate: true,
+    });
     await expect(getAdapter('google').isLoggedIn(page)).resolves.toBe(false);
     expect(page.evaluated).toEqual([]);
   });
@@ -109,9 +116,9 @@ describe('isLoggedIn', () => {
 describe('extractUsername', () => {
   it('returns whatever the page evaluation yields', async () => {
     for (const key of PLATFORMS) {
-      await expect(getAdapter(key).extractUsername(fakePage({ evaluate: 'someuser' }))).resolves.toBe(
-        'someuser'
-      );
+      await expect(
+        getAdapter(key).extractUsername(fakePage({ evaluate: 'someuser' })),
+      ).resolves.toBe('someuser');
     }
   });
 

package/src/__tests__/batch-eval-parsing.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import { parseBatchCommandLine } from '../cli/commands.js';
 
 describe('parseBatchCommandLine — eval expressions inside a batch command string', () => {
@@ -25,7 +25,9 @@ describe('parseBatchCommandLine — eval expressions inside a batch command stri
     const input = "eval [...document.querySelectorAll('li')].map(x => x.textContent.trim())";
     const { subName, subArgs } = parseBatchCommandLine(input);
     expect(subName).toBe('eval');
-    expect(subArgs).toEqual(["[...document.querySelectorAll('li')].map(x => x.textContent.trim())"]);
+    expect(subArgs).toEqual([
+      "[...document.querySelectorAll('li')].map(x => x.textContent.trim())",
+    ]);
   });
 
   it('still recognizes --json and --max-output flags placed before the expression', () => {

package/src/__tests__/box-model.test.ts

@@ -1,10 +1,10 @@
-import { describe, it, expect, vi } from 'vitest';
-import { deriveBoxOutput } from '../cli/commands.js';
+import { describe, expect, it, vi } from 'vitest';
 import { getElementBox } from '../browser/snapshot.js';
 import type { ElementRef } from '../browser/types.js';
+import { deriveBoxOutput } from '../cli/commands.js';
 
 describe('getElementBox (issue #15: center-vs-top-left contract)', () => {
-  it('averages the CDP content quad\'s four corners into a center point', async () => {
+  it("averages the CDP content quad's four corners into a center point", async () => {
     // Content quad order per CDP DOM.getBoxModel: [x1,y1 top-left, x2,y2
     // top-right, x3,y3 bottom-right, x4,y4 bottom-left]. A 372x37 box whose
     // top-left is (454, 513.5) — matching the issue's own reproduction data.
@@ -28,8 +28,12 @@ describe('deriveBoxOutput (issue #15: get box exposing both conventions)', () =>
     const center = { x: 640, y: 532, width: 372, height: 37 };
     const result = deriveBoxOutput(center);
     expect(result).toEqual({
-      x: 454, y: 513.5, width: 372, height: 37,
-      centerX: 640, centerY: 532,
+      x: 454,
+      y: 513.5,
+      width: 372,
+      height: 37,
+      centerX: 640,
+      centerY: 532,
     });
   });
 

package/src/__tests__/browser-launch.test.ts

@@ -8,9 +8,10 @@
  * Fixed port range (23470-23479) chosen to avoid colliding with real
  * services; each test binds/tears down its own listeners.
  */
-import { describe, it, expect, afterEach } from 'vitest';
-import { createServer as createTcpServer, type Server as TcpServer, type Socket } from 'net';
-import { createServer as createHttpServer, type Server as HttpServer } from 'http';
+
+import { createServer as createHttpServer, type Server as HttpServer } from 'node:http';
+import { createServer as createTcpServer, type Socket, type Server as TcpServer } from 'node:net';
+import { afterEach, describe, expect, it } from 'vitest';
 import { launchBrowser } from '../browser/browser.js';
 
 const BASE = 23470;
@@ -24,16 +25,21 @@ afterEach(async () => {
   // to close on their own, which can outlast the test. Destroy explicitly.
   for (const sock of sockets) sock.destroy();
   sockets = [];
-  await Promise.all(servers.map(s => new Promise<void>(resolve => s.close(() => resolve()))));
+  await Promise.all(servers.map((s) => new Promise<void>((resolve) => s.close(() => resolve()))));
   servers = [];
 }, 5000);
 
 /** Bind a bare TCP listener — accepts connections but speaks no HTTP/CDP. */
 function occupyNonChrome(port: number): Promise<void> {
   return new Promise((resolve, reject) => {
-    const s = createTcpServer(sock => { sockets.push(sock); /* accept and do nothing — no CDP response */ });
+    const s = createTcpServer((sock) => {
+      sockets.push(sock); /* accept and do nothing — no CDP response */
+    });
     s.once('error', reject);
-    s.listen(port, '127.0.0.1', () => { servers.push(s); resolve(); });
+    s.listen(port, '127.0.0.1', () => {
+      servers.push(s);
+      resolve();
+    });
   });
 }
 
@@ -45,12 +51,16 @@ function occupyChrome(port: number): Promise<void> {
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ Browser: 'Chrome/999.0.0.0' }));
       } else {
-        res.writeHead(404); res.end();
+        res.writeHead(404);
+        res.end();
       }
     });
-    s.on('connection', sock => sockets.push(sock));
+    s.on('connection', (sock) => sockets.push(sock));
     s.once('error', reject);
-    s.listen(port, '127.0.0.1', () => { servers.push(s); resolve(); });
+    s.listen(port, '127.0.0.1', () => {
+      servers.push(s);
+      resolve();
+    });
   });
 }
 
@@ -65,8 +75,9 @@ describe('launchBrowser — port scan/attach decisions', () => {
     const port = BASE + 1;
     await occupyNonChrome(port);
     await occupyChrome(port + 1); // would succeed if scanning happened — must not be reached
-    await expect(launchBrowser({ port, strictPort: true }))
-      .rejects.toThrow(/does not identify as Chrome/);
+    await expect(launchBrowser({ port, strictPort: true })).rejects.toThrow(
+      /does not identify as Chrome/,
+    );
   });
 
   it('strictPort: attaches on an occupied Chrome requested port (identical to non-strict)', async () => {
@@ -80,7 +91,7 @@ describe('launchBrowser — port scan/attach decisions', () => {
     // Occupy the full 10-port scan window with non-Chrome listeners.
     for (let i = 0; i < 10; i++) await occupyNonChrome(port + i);
     await expect(launchBrowser({ port })).rejects.toThrow(
-      new RegExp(`Ports ${port}-${port + 9} are all occupied`)
+      new RegExp(`Ports ${port}-${port + 9} are all occupied`),
     );
   }, 15000); // generous margin — 10 candidates, each a fast isTcpPortOpen check
 
@@ -92,11 +103,11 @@ describe('launchBrowser — port scan/attach decisions', () => {
     // skipped, so if every candidate is occupied the call still fails even
     // though one of them is an attachable Chrome.
     const port = BASE + 4;
-    await occupyNonChrome(port);       // requested port: occupied, not Chrome
-    await occupyChrome(port + 1);      // scanned candidate: IS Chrome — must be skipped, not attached
+    await occupyNonChrome(port); // requested port: occupied, not Chrome
+    await occupyChrome(port + 1); // scanned candidate: IS Chrome — must be skipped, not attached
     for (let i = 2; i < 10; i++) await occupyNonChrome(port + i); // remaining candidates: occupied
     await expect(launchBrowser({ port })).rejects.toThrow(
-      new RegExp(`Ports ${port}-${port + 9} are all occupied`)
+      new RegExp(`Ports ${port}-${port + 9} are all occupied`),
     );
   }, 15000); // generous margin — 10 candidates, each a fast isTcpPortOpen check
 });

package/src/__tests__/cdp-client.test.ts

@@ -5,7 +5,7 @@
  * `ws` module (so we can drive 'message'/'close'/'error' by hand), and
  * fetchTargets/fetchNewTarget run against a stubbed global fetch.
  */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 // --- fake `ws` -------------------------------------------------------------
 // Captures the most recently constructed socket so tests can drive its events.
@@ -140,7 +140,9 @@ describe('send', () => {
   it('refuses to exceed the 1000 in-flight command cap', async () => {
     const { client } = await connected();
     const inflight = Array.from({ length: 1000 }, () => client.send('A').catch(() => {}));
-    await expect(client.send('A')).rejects.toThrow('CDP command queue full (>1000 in-flight commands)');
+    await expect(client.send('A')).rejects.toThrow(
+      'CDP command queue full (>1000 in-flight commands)',
+    );
     client.close();
     await Promise.all(inflight);
   });
@@ -152,7 +154,9 @@ describe('send', () => {
     it('rejects a command with no response after the default 30s timeout', async () => {
       const { client } = await connected();
       const p = client.send('Runtime.evaluate');
-      const assertion = expect(p).rejects.toThrow('CDP command "Runtime.evaluate" timed out after 30000ms');
+      const assertion = expect(p).rejects.toThrow(
+        'CDP command "Runtime.evaluate" timed out after 30000ms',
+      );
       await vi.advanceTimersByTimeAsync(30_000);
       await assertion;
     });
@@ -171,7 +175,13 @@ describe('send', () => {
       await vi.advanceTimersByTimeAsync(60_000);
       // Still pending — no timeout fired.
       let settled = false;
-      void p.then(() => { settled = true; }).catch(() => { settled = true; });
+      void p
+        .then(() => {
+          settled = true;
+        })
+        .catch(() => {
+          settled = true;
+        });
       await Promise.resolve();
       expect(settled).toBe(false);
       ws.deliver({ id: 1, result: {} });
@@ -331,21 +341,27 @@ describe('fetchTargets / fetchNewTarget', () => {
     globalThis.fetch = realFetch;
   });
 
-  function stubFetch(impl: (url: string, init?: RequestInit) => Response): ReturnType<typeof vi.fn> {
+  function stubFetch(
+    impl: (url: string, init?: RequestInit) => Response,
+  ): ReturnType<typeof vi.fn> {
     const fn = vi.fn((url: string, init?: RequestInit) => Promise.resolve(impl(url, init)));
     globalThis.fetch = fn as unknown as typeof fetch;
     return fn;
   }
 
   it('fetchTargets hits /json/list on the given port', async () => {
-    const fn = stubFetch(() => new Response(JSON.stringify([{ id: 'T1', type: 'page' }]), { status: 200 }));
+    const fn = stubFetch(
+      () => new Response(JSON.stringify([{ id: 'T1', type: 'page' }]), { status: 200 }),
+    );
     await expect(fetchTargets(9333)).resolves.toEqual([{ id: 'T1', type: 'page' }]);
     expect(fn.mock.calls[0]![0]).toBe('http://127.0.0.1:9333/json/list');
   });
 
   it('fetchTargets throws on a non-OK response', async () => {
     stubFetch(() => new Response('nope', { status: 500, statusText: 'Internal Server Error' }));
-    await expect(fetchTargets(9222)).rejects.toThrow('Failed to fetch targets: Internal Server Error');
+    await expect(fetchTargets(9222)).rejects.toThrow(
+      'Failed to fetch targets: Internal Server Error',
+    );
   });
 
   it('fetchNewTarget uses PUT and percent-encodes the URL', async () => {
@@ -354,7 +370,7 @@ describe('fetchTargets / fetchNewTarget', () => {
     const [url, init] = fn.mock.calls[0] as [string, RequestInit];
     expect(init.method).toBe('PUT');
     expect(url).toBe(
-      'http://127.0.0.1:9222/json/new?' + encodeURIComponent('https://x.test/a?b=1&c=2')
+      `http://127.0.0.1:9222/json/new?${encodeURIComponent('https://x.test/a?b=1&c=2')}`,
     );
     // The query separators of the target URL must not leak into Chrome's own query.
     expect(url.split('?').length).toBe(2);
@@ -363,7 +379,7 @@ describe('fetchTargets / fetchNewTarget', () => {
   it('fetchNewTarget throws on a non-OK response', async () => {
     stubFetch(() => new Response('', { status: 405, statusText: 'Method Not Allowed' }));
     await expect(fetchNewTarget(9222, 'about:blank')).rejects.toThrow(
-      'Failed to create target: Method Not Allowed'
+      'Failed to create target: Method Not Allowed',
     );
   });
 

package/src/__tests__/close-browser.test.ts

@@ -11,10 +11,12 @@
  * fake `ws` socket (same pattern as cdp-client.test.ts), and process.kill is
  * spied on rather than actually signaling anything.
  */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { mkdtemp, rm, mkdir, writeFile } from 'fs/promises';
-import { join } from 'path';
-import { tmpdir } from 'os';
+
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as realDelay } from 'node:timers/promises';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 let lastSocket: FakeWs | null = null;
 
@@ -72,7 +74,34 @@ afterEach(async () => {
 async function writePersistedPort(port: number, pid: number, savedAt: number): Promise<void> {
   const dir = join(tempDir, '.monomind', 'monobrowse');
   await mkdir(dir, { recursive: true });
-  await writeFile(join(dir, 'active-port.json'), JSON.stringify({ port, pid, launched: true, savedAt }), 'utf-8');
+  await writeFile(
+    join(dir, 'active-port.json'),
+    JSON.stringify({ port, pid, launched: true, savedAt }),
+    'utf-8',
+  );
+}
+
+/**
+ * Block (in REAL time) until closeBrowser()'s process-exit poll has actually
+ * started, observed via the poll's own first liveness probe — `kill(pid, 0)`
+ * is the first thing waitForProcessExit() does.
+ *
+ * Needed because closeBrowser() awaits the persisted-port read (real
+ * filesystem I/O) BEFORE that poll starts, while `advanceTimersByTimeAsync`
+ * only moves a FAKE clock and does not wait for real I/O. Advancing a fixed
+ * number of times therefore raced the read: every advance can complete in
+ * microseconds of real time while the read is still in flight, so on a loaded
+ * host the budget ran out with the poll never started — and since nothing
+ * then drives the fake clock again, the test did not merely run slow, it
+ * deadlocked on an unsettled promise until the test timeout fired.
+ *
+ * Once this returns, the remaining work is pure fake timers, so a single
+ * bounded advance carries it deterministically.
+ */
+async function exitPollStarted(pid: number): Promise<void> {
+  while (!killSpy.mock.calls.some(([p, signal]) => p === pid && signal === 0)) {
+    await realDelay(0);
+  }
 }
 
 async function connectedClient(autoAck = false) {
@@ -157,13 +186,15 @@ describe('#115 review follow-up: closeBrowser() cross-process PID-kill fallback'
 
     const client = await connectedClient(true);
     const closePromise = closeBrowser(client, port);
-    // Still running a moment after the ack — close() must NOT have resolved.
-    await vi.advanceTimersByTimeAsync(200);
     let settled = false;
     void closePromise.then(() => {
       settled = true;
     });
-    await vi.advanceTimersByTimeAsync(0);
+
+    // Poll is running and the process is still alive — several poll ticks in,
+    // close() must NOT have resolved.
+    await exitPollStarted(22222);
+    await vi.advanceTimersByTimeAsync(200);
     expect(settled).toBe(false);
 
     alive = false; // Chrome finishes exiting
@@ -180,32 +211,24 @@ describe('#115 review follow-up: closeBrowser() cross-process PID-kill fallback'
 
     const client = await connectedClient(true);
     const closePromise = closeBrowser(client, port);
-    // The exit poll schedules one timer per tick, each from the previous
-    // tick's callback. How far a single advance carries through a chain like
-    // that is a fake-timer implementation detail that differs by Node version
-    // (runAllTimersAsync hung this test on Node 22 while passing on 26), so
-    // step the clock until the promise settles instead of assuming.
-    //
-    // Each `advanceTimersByTimeAsync` call has real (non-fake) overhead of
-    // its own — a previous fix here just raised the iteration count at a
-    // fixed 100ms step (100ms x 600 = enough fake-time headroom, but up to
-    // 600 real await round-trips), which still intermittently timed out on a
-    // slow/busy CI runner because that overhead is per CALL, not per fake-ms
-    // advanced. Stepping by a much larger 2000ms per call reaches the same
-    // (and greater) fake-time coverage in a fraction of the calls — the exit
-    // poll's PROCESS_EXIT_TIMEOUT_MS deadline (5000ms) is comfortably inside
-    // even a handful of iterations — without giving up the settle-and-stop
-    // loop that avoids the Node 22 hang a single unbounded advance hit.
     let settled = false;
     void closePromise.then(() => {
       settled = true;
     });
-    for (let i = 0; i < 60 && !settled; i++) await vi.advanceTimersByTimeAsync(2000);
+
+    // Wait for the poll to exist before driving it (see exitPollStarted) —
+    // every previous fix here guessed an advance budget instead, which is
+    // what made this test hang rather than merely run slow. From here on the
+    // poll is the only thing left and it is pure fake timers, so one advance
+    // past its PROCESS_EXIT_TIMEOUT_MS (5000ms) deadline settles it, with no
+    // dependence on how fast the host happens to be.
+    await exitPollStarted(33333);
+    await vi.advanceTimersByTimeAsync(6000);
     await closePromise;
 
     expect(settled).toBe(true);
     expect(killSpy).toHaveBeenCalledWith(33333, 'SIGKILL');
-  }, 20_000);
+  });
 
   it('no persisted port file at all — closeBrowser is a no-op, no kill attempted', async () => {
     vi.resetModules();

package/src/__tests__/console-log.test.ts

@@ -3,14 +3,14 @@
  * two per-session Maps. Nothing here touches a browser — we hand it a fake
  * client that just records handlers and lets us fire events by hand.
  */
-import { describe, it, expect, beforeEach } from 'vitest';
+import { beforeEach, describe, expect, it } from 'vitest';
 import type { CdpClient } from '../browser/cdp.js';
 import {
-  setupConsoleCapture,
-  getConsoleMessages,
   clearConsoleMessages,
-  getPageErrors,
   clearPageErrors,
+  getConsoleMessages,
+  getPageErrors,
+  setupConsoleCapture,
   teardownConsoleCapture,
 } from '../browser/console-log.js';
 
@@ -91,13 +91,17 @@ describe('Runtime.consoleAPICalled capture', () => {
     client.emit(
       'Runtime.consoleAPICalled',
       { type: 'log', args: [{ value: 'count:' }, { value: 42 }, { description: 'Object {a: 1}' }] },
-      'S1'
+      'S1',
     );
     expect(getConsoleMessages('S1')[0]!.text).toBe('count: 42 Object {a: 1}');
   });
 
   it('normalizes CDP\'s "warning" to the "warn" type used by ConsoleMessage', () => {
-    client.emit('Runtime.consoleAPICalled', { type: 'warning', args: [{ value: 'careful' }] }, 'S1');
+    client.emit(
+      'Runtime.consoleAPICalled',
+      { type: 'warning', args: [{ value: 'careful' }] },
+      'S1',
+    );
     expect(getConsoleMessages('S1')[0]!.type).toBe('warn');
   });
 
@@ -123,8 +127,15 @@ describe('Log.entryAdded capture', () => {
   it('records text, url and lineNumber and maps "warning" to "warn"', () => {
     client.emit(
       'Log.entryAdded',
-      { entry: { level: 'warning', text: 'deprecated API', url: 'https://x.test/a.js', lineNumber: 17 } },
-      'S1'
+      {
+        entry: {
+          level: 'warning',
+          text: 'deprecated API',
+          url: 'https://x.test/a.js',
+          lineNumber: 17,
+        },
+      },
+      'S1',
     );
     const [msg] = getConsoleMessages('S1');
     expect(msg).toMatchObject({
@@ -156,7 +167,7 @@ describe('Runtime.exceptionThrown capture', () => {
           columnNumber: 9,
         },
       },
-      'S1'
+      'S1',
     );
     expect(getPageErrors('S1')[0]).toMatchObject({
       text: 'TypeError: x is not a function',
@@ -167,7 +178,11 @@ describe('Runtime.exceptionThrown capture', () => {
   });
 
   it('falls back to text, then to "Unknown error"', () => {
-    client.emit('Runtime.exceptionThrown', { exceptionDetails: { text: 'Uncaught (in promise)' } }, 'S1');
+    client.emit(
+      'Runtime.exceptionThrown',
+      { exceptionDetails: { text: 'Uncaught (in promise)' } },
+      'S1',
+    );
     client.emit('Runtime.exceptionThrown', { exceptionDetails: {} }, 'S1');
     expect(getPageErrors('S1').map((e) => e.text)).toEqual([
       'Uncaught (in promise)',
@@ -191,14 +206,22 @@ describe('multi-session isolation and clearing', () => {
     client.emit('Runtime.exceptionThrown', { exceptionDetails: { text: 'e2' } }, 'S2');
   });
 
-  it('keeps each session\'s buffers separate', () => {
+  it("keeps each session's buffers separate", () => {
     expect(getConsoleMessages('S1').map((m) => m.text)).toEqual(['one']);
     expect(getConsoleMessages('S2').map((m) => m.text)).toEqual(['two']);
   });
 
   it('returns a flattened view across sessions when no session id is given', () => {
-    expect(getConsoleMessages().map((m) => m.text).sort()).toEqual(['one', 'two']);
-    expect(getPageErrors().map((e) => e.text).sort()).toEqual(['e1', 'e2']);
+    expect(
+      getConsoleMessages()
+        .map((m) => m.text)
+        .sort(),
+    ).toEqual(['one', 'two']);
+    expect(
+      getPageErrors()
+        .map((e) => e.text)
+        .sort(),
+    ).toEqual(['e1', 'e2']);
   });
 
   it('returns a copy, so mutating the result does not corrupt the buffer', () => {