@monoes/monobrowse 1.0.7 → 1.0.8

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.8",
+  "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 {
@@ -66,11 +71,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 +134,64 @@ 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.
+    let settled = false;
+    void closePromise.then(() => {
+      settled = true;
+    });
+    for (let i = 0; i < 200 && !settled; i++) await vi.advanceTimersByTimeAsync(100);
+    await closePromise;
+
+    expect(settled).toBe(true);
+    expect(killSpy).toHaveBeenCalledWith(33333, 'SIGKILL');
+  });
+
   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/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,17 +355,33 @@ 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> {