@monoes/monobrowse 1.0.6 → 1.0.8

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

@@ -0,0 +1,205 @@
+/**
+ * closeBrowser()'s cross-process PID-kill fallback (browser.ts) — previously
+ * had zero test coverage anywhere in this package (found in a review pass
+ * after commit c4847e22). Covers:
+ *   - using a persisted PID when the in-process launchedPids map is empty
+ *     (the always-true case for a fresh CLI invocation)
+ *   - rejecting a persisted PID that is too old to trust (staleness bound)
+ *   - a liveness check (process.kill(pid, 0)) gating the SIGKILL itself
+ *
+ * No real Chrome or child process is spawned: Browser.close is driven via a
+ * 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';
+
+let lastSocket: FakeWs | null = null;
+
+class FakeWs {
+  handlers = new Map<string, Array<(...a: unknown[]) => void>>();
+  constructor(public url: string) {
+    lastSocket = this;
+  }
+  on(event: string, fn: (...a: unknown[]) => void): void {
+    if (!this.handlers.has(event)) this.handlers.set(event, []);
+    this.handlers.get(event)!.push(fn);
+  }
+  emit(event: string, ...args: unknown[]): void {
+    for (const fn of [...(this.handlers.get(event) ?? [])]) fn(...args);
+  }
+  /** 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 {
+    this.emit('message', Buffer.from(JSON.stringify(msg)));
+  }
+}
+
+vi.mock('ws', () => ({ WebSocket: FakeWs }));
+
+let tempDir: string;
+let killSpy: ReturnType<typeof vi.spyOn>;
+
+beforeEach(async () => {
+  vi.useFakeTimers();
+  lastSocket = null;
+  tempDir = await mkdtemp(join(tmpdir(), 'monobrowse-close-test-'));
+  vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+  killSpy = vi.spyOn(process, 'kill').mockImplementation(() => true as never);
+});
+
+afterEach(async () => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+  await rm(tempDir, { recursive: true, force: true });
+});
+
+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');
+}
+
+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;
+}
+
+describe('#115 review follow-up: closeBrowser() cross-process PID-kill fallback', () => {
+  it('uses a fresh persisted PID (in-process map empty) and SIGKILLs it on an ungraceful close', async () => {
+    vi.resetModules();
+    const { closeBrowser, getLaunchedPid } = await import('../browser/browser.js');
+    const port = 9333;
+    await writePersistedPort(port, 54321, Date.now());
+    // Confirm the in-process map really is empty for this port (fresh module state).
+    expect(getLaunchedPid(port)).toBeUndefined();
+
+    const client = await connectedClient();
+    const closePromise = closeBrowser(client, port);
+    await vi.advanceTimersByTimeAsync(3000); // BROWSER_CLOSE_TIMEOUT_MS
+    await closePromise;
+
+    expect(killSpy).toHaveBeenCalledWith(54321, 0);
+    expect(killSpy).toHaveBeenCalledWith(54321, 'SIGKILL');
+  });
+
+  it('#124-review: does not trust a persisted PID older than the staleness bound', async () => {
+    vi.resetModules();
+    const { closeBrowser } = await import('../browser/browser.js');
+    const port = 9334;
+    const twoDaysAgo = Date.now() - 2 * 24 * 60 * 60 * 1000;
+    await writePersistedPort(port, 99999, twoDaysAgo);
+
+    const client = await connectedClient();
+    const closePromise = closeBrowser(client, port);
+    await vi.advanceTimersByTimeAsync(3000);
+    await closePromise;
+
+    expect(killSpy).not.toHaveBeenCalled();
+  });
+
+  it('#124-review: a persisted PID that is no longer alive is not force-killed (liveness check via kill(pid,0))', async () => {
+    vi.resetModules();
+    const { closeBrowser } = await import('../browser/browser.js');
+    const port = 9335;
+    await writePersistedPort(port, 11111, Date.now());
+    killSpy.mockImplementation((_pid: unknown, signal?: unknown) => {
+      if (signal === 0) throw Object.assign(new Error('ESRCH'), { code: 'ESRCH' });
+      return true as never;
+    });
+
+    const client = await connectedClient();
+    const closePromise = closeBrowser(client, port);
+    await vi.advanceTimersByTimeAsync(3000);
+    await closePromise;
+
+    expect(killSpy).toHaveBeenCalledWith(11111, 0);
+    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');
+    const client = await connectedClient();
+    const closePromise = closeBrowser(client, 9336);
+    await vi.advanceTimersByTimeAsync(3000);
+    await closePromise;
+
+    expect(killSpy).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,250 @@
+/**
+ * console-log.ts is pure in-process state: three CDP event listeners feeding
+ * 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 type { CdpClient } from '../browser/cdp.js';
+import {
+  setupConsoleCapture,
+  getConsoleMessages,
+  clearConsoleMessages,
+  getPageErrors,
+  clearPageErrors,
+  teardownConsoleCapture,
+} from '../browser/console-log.js';
+
+type Handler = (params: Record<string, unknown>, sessionId?: string) => void;
+
+class FakeClient {
+  listeners = new Map<string, Set<Handler>>();
+  offCalls = 0;
+
+  on(event: string, fn: Handler): () => void {
+    if (!this.listeners.has(event)) this.listeners.set(event, new Set());
+    this.listeners.get(event)!.add(fn);
+    return () => {
+      this.offCalls++;
+      this.listeners.get(event)!.delete(fn);
+    };
+  }
+
+  emit(event: string, params: Record<string, unknown>, sessionId?: string): void {
+    for (const fn of [...(this.listeners.get(event) ?? [])]) fn(params, sessionId);
+  }
+
+  get handlerCount(): number {
+    return [...this.listeners.values()].reduce((n, s) => n + s.size, 0);
+  }
+
+  asCdp(): CdpClient {
+    return this as unknown as CdpClient;
+  }
+}
+
+let client: FakeClient;
+
+beforeEach(() => {
+  client = new FakeClient();
+  // Wipe cross-test global state in the module's module-level Maps.
+  clearConsoleMessages();
+  clearPageErrors();
+});
+
+describe('setupConsoleCapture', () => {
+  it('registers exactly the three CDP listeners it needs', () => {
+    setupConsoleCapture(client.asCdp(), 'S1');
+    expect([...client.listeners.keys()].sort()).toEqual([
+      'Log.entryAdded',
+      'Runtime.consoleAPICalled',
+      'Runtime.exceptionThrown',
+    ]);
+    expect(client.handlerCount).toBe(3);
+  });
+
+  it('detaches the previous generation of listeners when re-run for the same session', () => {
+    setupConsoleCapture(client.asCdp(), 'S1');
+    setupConsoleCapture(client.asCdp(), 'S1');
+    // Three old handlers unsubscribed, three new ones live — not six live.
+    expect(client.offCalls).toBe(3);
+    expect(client.handlerCount).toBe(3);
+
+    // And a single emitted event must be recorded once, not twice.
+    client.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'hi' }] }, 'S1');
+    expect(getConsoleMessages('S1')).toHaveLength(1);
+  });
+
+  it('resets buffered messages for the session it re-attaches to', () => {
+    setupConsoleCapture(client.asCdp(), 'S1');
+    client.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'old' }] }, 'S1');
+    expect(getConsoleMessages('S1')).toHaveLength(1);
+
+    setupConsoleCapture(client.asCdp(), 'S1');
+    expect(getConsoleMessages('S1')).toEqual([]);
+  });
+});
+
+describe('Runtime.consoleAPICalled capture', () => {
+  beforeEach(() => setupConsoleCapture(client.asCdp(), 'S1'));
+
+  it('joins multiple args with a space, preferring description over value', () => {
+    client.emit(
+      'Runtime.consoleAPICalled',
+      { type: 'log', args: [{ value: 'count:' }, { value: 42 }, { description: 'Object {a: 1}' }] },
+      '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');
+    expect(getConsoleMessages('S1')[0]!.type).toBe('warn');
+  });
+
+  it('passes other CDP types through unchanged', () => {
+    client.emit('Runtime.consoleAPICalled', { type: 'error', args: [{ value: 'boom' }] }, 'S1');
+    expect(getConsoleMessages('S1')[0]!.type).toBe('error');
+  });
+
+  it('tolerates a missing args array', () => {
+    client.emit('Runtime.consoleAPICalled', { type: 'log' }, 'S1');
+    expect(getConsoleMessages('S1')[0]!.text).toBe('');
+  });
+
+  it('ignores events addressed to a different session', () => {
+    client.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'other' }] }, 'S2');
+    expect(getConsoleMessages('S1')).toEqual([]);
+  });
+});
+
+describe('Log.entryAdded capture', () => {
+  beforeEach(() => setupConsoleCapture(client.asCdp(), 'S1'));
+
+  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'
+    );
+    const [msg] = getConsoleMessages('S1');
+    expect(msg).toMatchObject({
+      type: 'warn',
+      text: 'deprecated API',
+      url: 'https://x.test/a.js',
+      lineNumber: 17,
+    });
+  });
+
+  it('defaults text to empty string when the entry omits it', () => {
+    client.emit('Log.entryAdded', { entry: { level: 'info' } }, 'S1');
+    expect(getConsoleMessages('S1')[0]).toMatchObject({ type: 'info', text: '' });
+  });
+});
+
+describe('Runtime.exceptionThrown capture', () => {
+  beforeEach(() => setupConsoleCapture(client.asCdp(), 'S1'));
+
+  it('prefers exception.description over the generic text field', () => {
+    client.emit(
+      'Runtime.exceptionThrown',
+      {
+        exceptionDetails: {
+          text: 'Uncaught',
+          exception: { description: 'TypeError: x is not a function' },
+          url: 'https://x.test/a.js',
+          lineNumber: 3,
+          columnNumber: 9,
+        },
+      },
+      'S1'
+    );
+    expect(getPageErrors('S1')[0]).toMatchObject({
+      text: 'TypeError: x is not a function',
+      url: 'https://x.test/a.js',
+      lineNumber: 3,
+      columnNumber: 9,
+    });
+  });
+
+  it('falls back to text, then to "Unknown error"', () => {
+    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)',
+      'Unknown error',
+    ]);
+  });
+
+  it('keeps page errors out of the console message buffer', () => {
+    client.emit('Runtime.exceptionThrown', { exceptionDetails: { text: 'nope' } }, 'S1');
+    expect(getConsoleMessages('S1')).toEqual([]);
+  });
+});
+
+describe('multi-session isolation and clearing', () => {
+  beforeEach(() => {
+    setupConsoleCapture(client.asCdp(), 'S1');
+    setupConsoleCapture(client.asCdp(), 'S2');
+    client.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'one' }] }, 'S1');
+    client.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'two' }] }, 'S2');
+    client.emit('Runtime.exceptionThrown', { exceptionDetails: { text: 'e1' } }, 'S1');
+    client.emit('Runtime.exceptionThrown', { exceptionDetails: { text: 'e2' } }, 'S2');
+  });
+
+  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']);
+  });
+
+  it('returns a copy, so mutating the result does not corrupt the buffer', () => {
+    const snapshot = getConsoleMessages('S1');
+    snapshot.push({ type: 'log', text: 'injected', timestamp: 0 });
+    expect(getConsoleMessages('S1')).toHaveLength(1);
+  });
+
+  it('clears only the named session', () => {
+    clearConsoleMessages('S1');
+    clearPageErrors('S1');
+    expect(getConsoleMessages('S1')).toEqual([]);
+    expect(getPageErrors('S1')).toEqual([]);
+    expect(getConsoleMessages('S2')).toHaveLength(1);
+    expect(getPageErrors('S2')).toHaveLength(1);
+  });
+
+  it('clears every session when called with no id', () => {
+    clearConsoleMessages();
+    clearPageErrors();
+    expect(getConsoleMessages()).toEqual([]);
+    expect(getPageErrors()).toEqual([]);
+  });
+
+  it('a cleared session keeps capturing new events', () => {
+    clearConsoleMessages('S1');
+    client.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'again' }] }, 'S1');
+    expect(getConsoleMessages('S1').map((m) => m.text)).toEqual(['again']);
+  });
+});
+
+describe('teardownConsoleCapture', () => {
+  it('unsubscribes the listeners and drops both buffers for that session only', () => {
+    setupConsoleCapture(client.asCdp(), 'S1');
+    setupConsoleCapture(client.asCdp(), 'S2');
+    client.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'two' }] }, 'S2');
+
+    teardownConsoleCapture('S1');
+
+    expect(client.offCalls).toBe(3);
+    client.emit('Runtime.consoleAPICalled', { type: 'log', args: [{ value: 'late' }] }, 'S1');
+    expect(getConsoleMessages('S1')).toEqual([]);
+    expect(getConsoleMessages('S2')).toHaveLength(1);
+  });
+
+  it('is a no-op for an unknown session', () => {
+    expect(() => teardownConsoleCapture('never-registered')).not.toThrow();
+  });
+});