@monoes/monobrowse 1.0.7 → 1.0.9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@monoes/monobrowse",
-  "version": "1.0.7",
-  "description": "Native browser automation via Chrome DevTools Protocol \u2014 the engine powering monomind browse",
+  "version": "1.0.9",
+  "description": "Native browser automation via Chrome DevTools Protocol — the engine powering monomind browse",
   "type": "module",
   "bin": {
     "monobrowse": "./dist/src/cli.js"
@@ -33,13 +33,6 @@
   "engines": {
     "node": ">=18.0.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",
@@ -66,5 +59,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__/close-browser.test.ts

@@ -30,10 +30,15 @@ class FakeWs {
   emit(event: string, ...args: unknown[]): void {
     for (const fn of [...(this.handlers.get(event) ?? [])]) fn(...args);
   }
-  send(_data: string, cb?: (err?: Error) => void): void {
-    // Never call cb — simulates a hung Browser.close so closeBrowser's own
-    // BROWSER_CLOSE_TIMEOUT_MS race is what settles it (ungraceful path).
+  /** When true, send() acknowledges the CDP command by delivering a matching
+   *  empty result — the GRACEFUL path. Default false leaves it hanging so
+   *  closeBrowser's own BROWSER_CLOSE_TIMEOUT_MS race settles it (ungraceful). */
+  autoAck = false;
+  send(data: string, cb?: (err?: Error) => void): void {
     void cb;
+    if (!this.autoAck) return;
+    const { id } = JSON.parse(data) as { id: number };
+    queueMicrotask(() => this.deliver({ id, result: {} }));
   }
   close(): void {}
   deliver(msg: unknown): void {
@@ -47,6 +52,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-'));
@@ -66,11 +75,12 @@ 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');
 }
 
-async function connectedClient() {
+async function connectedClient(autoAck = false) {
   vi.resetModules();
   const { CdpClient } = await import('../browser/cdp.js');
   const client = new CdpClient();
   const p = client.connect('ws://127.0.0.1:9333/devtools/page/ABC');
+  lastSocket!.autoAck = autoAck;
   lastSocket!.emit('open');
   await p;
   return client;
@@ -128,6 +138,75 @@ describe('#115 review follow-up: closeBrowser() cross-process PID-kill fallback'
     expect(killSpy).not.toHaveBeenCalledWith(11111, 'SIGKILL');
   });
 
+  // The graceful path is what the monodesign detection driver actually takes,
+  // and it had no coverage: closeBrowser used to return on the Browser.close
+  // ack while Chrome was still exiting, holding its CDP port and its profile's
+  // singleton lock, with an unref'd 1s timer as the only force-kill (which
+  // never fired at all if the caller's process exited first).
+  it('graceful close waits for the process to actually exit, without killing it', async () => {
+    vi.resetModules();
+    const { closeBrowser } = await import('../browser/browser.js');
+    const port = 9337;
+    await writePersistedPort(port, 22222, Date.now());
+
+    let alive = true;
+    killSpy.mockImplementation((_pid: unknown, signal?: unknown) => {
+      if (signal === 0 && !alive) throw Object.assign(new Error('ESRCH'), { code: 'ESRCH' });
+      return true as never;
+    });
+
+    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);
+    expect(settled).toBe(false);
+
+    alive = false; // Chrome finishes exiting
+    await vi.advanceTimersByTimeAsync(200);
+    await closePromise;
+    expect(killSpy).not.toHaveBeenCalledWith(22222, 'SIGKILL');
+  });
+
+  it('graceful close force-kills a process that never exits', async () => {
+    vi.resetModules();
+    const { closeBrowser } = await import('../browser/browser.js');
+    const port = 9338;
+    await writePersistedPort(port, 33333, Date.now());
+
+    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);
+    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();
     const { closeBrowser } = await import('../browser/browser.js');

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/browser/browser.ts

@@ -14,6 +14,11 @@ const DEFAULT_PORT = 9222;
 const LAUNCH_TIMEOUT = 10_000;
 const POLL_INTERVAL = 200;
 const BROWSER_CLOSE_TIMEOUT_MS = 3000;
+// How long closeBrowser() waits for the process to actually disappear before
+// forcing it, and again after forcing. Bounded so a wedged Chrome cannot hang
+// a caller indefinitely.
+const PROCESS_EXIT_TIMEOUT_MS = 5000;
+const PROCESS_EXIT_POLL_MS = 50;
 // A cross-process persisted PID older than this is not trusted for the
 // SIGKILL fallback in closeBrowser() — see the call site for why.
 const PERSISTED_PID_MAX_AGE_MS = 24 * 60 * 60 * 1000;
@@ -79,7 +84,10 @@ async function isChromeIdentity(port: number): Promise<boolean> {
     const res = await fetch(`http://127.0.0.1:${port}/json/version`, { signal: AbortSignal.timeout(1000) });
     if (!res.ok) return false;
     const info = (await res.json()) as { Browser?: string };
-    return typeof info.Browser === 'string' && /chrom(e|ium)/i.test(info.Browser);
+    // Edge's Browser field is "Edg/<version>" with no "chrome"/"chromium"
+    // substring, even though it's Chromium-based and CDP-compatible —
+    // accept it alongside Chrome/Chromium rather than rejecting a valid target.
+    return typeof info.Browser === 'string' && /chrom(e|ium)|edg/i.test(info.Browser);
   } catch {
     return false;
   }
@@ -282,6 +290,15 @@ export async function connectToTarget(port: number, targetId?: string): Promise<
  * falls back to killing the tracked PID directly so a headed/interactive
  * browser window (e.g. one spawned for a login/CAPTCHA flow) never lingers
  * as a visible, authenticated, still-debuggable orphan process.
+ *
+ * On the graceful path this resolves only once the process is actually gone,
+ * or after force-killing it when it outlasts PROCESS_EXIT_TIMEOUT_MS. Chrome
+ * acknowledges `Browser.close` well before it exits, and this used to return
+ * on the ack with an unref'd 1s timer as the only force-kill — so it resolved
+ * while Chrome was still running and holding its port and its profile's
+ * singleton lock, and if the caller's process exited first the kill never
+ * happened at all. Callers reasonably read a resolved close() as "that
+ * browser is gone"; on the graceful path it now means that.
  */
 export async function closeBrowser(client: CdpClient, port: number): Promise<void> {
   let gracefullyClosed = false;
@@ -338,23 +355,44 @@ export async function closeBrowser(client: CdpClient, port: number): Promise<voi
     return;
   }
 
-  // Browser.close was acknowledged — give the process a moment to exit on
-  // its own, then verify and force-kill as a safety net in case it hung.
-  const t = setTimeout(() => {
+  // Browser.close was acknowledged — wait for the process to actually go away,
+  // then force-kill as a safety net in case it hung.
+  if (await waitForProcessExit(pid)) return;
+  try {
+    process.kill(pid, 'SIGKILL');
+  } catch {
+    /* raced us to exit — expected */
+  }
+}
+
+/** Poll until `pid` is gone or PROCESS_EXIT_TIMEOUT_MS elapses. Returns
+ *  whether it exited. `process.kill(pid, 0)` throws once the process is no
+ *  longer there, on Windows as well as POSIX. */
+async function waitForProcessExit(pid: number): Promise<boolean> {
+  const deadline = Date.now() + PROCESS_EXIT_TIMEOUT_MS;
+  for (;;) {
     try {
-      process.kill(pid, 0); // throws if the process is already gone
-      process.kill(pid, 'SIGKILL');
+      process.kill(pid, 0);
     } catch {
-      /* already exited — expected path */
+      return true;
     }
-  }, 1000);
-  t.unref?.();
+    if (Date.now() >= deadline) return false;
+    await new Promise((resolve) => {
+      const t = setTimeout(resolve, PROCESS_EXIT_POLL_MS);
+      t.unref?.();
+    });
+  }
 }
 
 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);
 }