@monoes/monobrowse 1.0.8 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monobrowse",
-  "version": "1.0.8",
+  "version": "1.0.11",
   "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__/close-browser.test.ts

@@ -13,6 +13,7 @@
  */
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { mkdtemp, rm, mkdir, writeFile } from 'fs/promises';
+import { setTimeout as realDelay } from 'timers/promises';
 import { join } from 'path';
 import { tmpdir } from 'os';
 
@@ -52,6 +53,10 @@ let tempDir: string;
 let killSpy: ReturnType<typeof vi.spyOn>;
 
 beforeEach(async () => {
+  // Clean env vars that can interfere with timer behavior in test environment
+  delete process.env.MONOMIND_SDK_AGENT;
+  delete process.env.MONOMIND_HOOK_QUIET;
+
   vi.useFakeTimers();
   lastSocket = null;
   tempDir = await mkdtemp(join(tmpdir(), 'monobrowse-close-test-'));
@@ -71,6 +76,29 @@ async function writePersistedPort(port: number, pid: number, savedAt: number): P
   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) {
   vi.resetModules();
   const { CdpClient } = await import('../browser/cdp.js');
@@ -153,13 +181,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
@@ -176,16 +206,19 @@ 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.
     let settled = false;
     void closePromise.then(() => {
       settled = true;
     });
-    for (let i = 0; i < 200 && !settled; i++) await vi.advanceTimersByTimeAsync(100);
+
+    // 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);

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

@@ -0,0 +1,58 @@
+/**
+ * openUrl() (browser.ts) previously ignored Page.navigate's own response and
+ * always fell through to waitForNetworkIdle, so a protocol-level navigation
+ * failure (e.g. a refused connection) settled on the chrome-error://
+ * chromewebdata/ page and `browse open` reported success with exit 0. CDP's
+ * Page.navigate response carries errorText when navigation itself failed —
+ * this checks that response before doing anything else.
+ */
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { CdpClient } from '../browser/cdp.js';
+import { openUrl } from '../browser/browser.js';
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+/** Client stub that records calls and answers from a per-method table. */
+function stubClient(table: Record<string, unknown> = {}): {
+  client: CdpClient;
+  calls: Array<{ method: string; params: unknown }>;
+} {
+  const calls: Array<{ method: string; params: unknown }> = [];
+  const client = {
+    send: vi.fn(async (method: string, params: unknown) => {
+      calls.push({ method, params });
+      const entry = table[method];
+      if (entry instanceof Error) throw entry;
+      return entry ?? {};
+    }),
+    on: vi.fn(() => {
+      throw new Error('waitForNetworkIdle should not run once Page.navigate reports errorText');
+    }),
+  } as unknown as CdpClient;
+  return { client, calls };
+}
+
+describe('openUrl navigation-failure detection', () => {
+  it('throws when Page.navigate reports errorText, without waiting for network idle', async () => {
+    const { client, calls } = stubClient({
+      'Page.navigate': { frameId: 'f1', errorText: 'net::ERR_CONNECTION_REFUSED' },
+    });
+
+    await expect(openUrl(client, 'sess-1', 'http://127.0.0.1:1/')).rejects.toThrow(
+      /net::ERR_CONNECTION_REFUSED/,
+    );
+    expect(calls).toEqual([
+      { method: 'Page.navigate', params: { url: 'http://127.0.0.1:1/' } },
+    ]);
+  });
+
+  it('rejects the 2 MB URL guard before ever calling Page.navigate', async () => {
+    const { client, calls } = stubClient();
+    const hugeUrl = `http://x/${'a'.repeat(2_097_152)}`;
+
+    await expect(openUrl(client, 'sess-1', hugeUrl)).rejects.toThrow(/2 MB/);
+    expect(calls).toHaveLength(0);
+  });
+});

package/src/__tests__/snapshot.test.ts

@@ -276,11 +276,11 @@ describe('captureSnapshot — property extraction and rendering', () => {
 });
 
 describe('resolveRef', () => {
-  it('returns the ref when present', () => {
+  it('returns the ref when present', async () => {
     const refs = new Map<string, ElementRef>([
       ['e1', { ref: 'e1', role: 'button', name: 'Go', nodeId: 1 }],
     ]);
-    expect(resolveRef({} as CdpClient, 'S1', refs, 'e1')).resolves.toMatchObject({ ref: 'e1' });
+    await expect(resolveRef({} as CdpClient, 'S1', refs, 'e1')).resolves.toMatchObject({ ref: 'e1' });
   });
 
   it('throws a snapshot-first hint when the ref is unknown', async () => {

package/src/browser/browser.ts

@@ -387,7 +387,12 @@ async function waitForProcessExit(pid: number): Promise<boolean> {
 export async function openUrl(client: CdpClient, sessionId: string, url: string): Promise<void> {
   // Cap to 2 MB to prevent OOM in CDP message serializer (e.g. data: URI attacks)
   if (url.length > 2_097_152) throw new Error('URL exceeds 2 MB limit');
-  await client.send('Page.navigate', { url }, sessionId);
+  // Page.navigate reports a protocol-level failure (e.g. a refused connection)
+  // via errorText in its own response, before Chrome ever settles on the
+  // chrome-error://chromewebdata/ page — without this check a refused
+  // 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);
 }