@monoes/monobrowse 1.0.5 → 1.0.7

package/src/browser/tabs.ts

@@ -24,11 +24,16 @@ export async function activateTab(client: CdpClient, oldSessionId: string, targe
   return result.sessionId;
 }
 
+export interface FrameSwitchResult {
+  url: string | null;
+  sessionId: string | null;
+}
+
 export async function switchToFrame(
   client: CdpClient,
   sessionId: string,
   frameSelector: string
-): Promise<string | null> {
+): Promise<FrameSwitchResult> {
   const { result } = await client.send<{ result: { result: { value: string | null } } }>(
     'Runtime.evaluate',
     {
@@ -50,7 +55,7 @@ export async function switchToFrame(
   const match = frameTree.childFrames?.find(
     (cf) => cf.frame.url === frameSrc || cf.frame.id === frameSelector
   );
-  if (!match) return frameSrc;
+  if (!match) return { url: frameSrc, sessionId: null };
 
   const targets = await client.send<{ targetInfos: Array<{ targetId: string; type: string; url: string }> }>(
     'Target.getTargets', {}
@@ -59,8 +64,11 @@ export async function switchToFrame(
     (t) => t.type === 'iframe' && t.url === match.frame.url
   );
   if (oopif) {
-    await client.send('Target.attachToTarget', { targetId: oopif.targetId, flatten: true });
+    const attached = await client.send<{ sessionId: string }>(
+      'Target.attachToTarget', { targetId: oopif.targetId, flatten: true }
+    );
+    return { url: frameSrc, sessionId: attached.sessionId };
   }
 
-  return frameSrc;
+  return { url: frameSrc, sessionId: null };
 }

package/src/browser/types.ts

@@ -9,6 +9,10 @@ export interface BrowserConfig {
   executablePath?: string;
   userDataDir?: string;
   args?: string[];
+  /** Milliseconds to wait for the launched Chrome to open its CDP port
+   *  before giving up. Default 10000 — raise this for environments where
+   *  process spawn is consistently slower (e.g. constrained CI runners). */
+  launchTimeoutMs?: number;
 }
 
 export interface SessionState {

package/src/cli/commands.ts

@@ -16,11 +16,52 @@ let _sessionId = '';
 let _targetId = '';
 let _port = DEFAULT_PORT;
 let _refs: Map<string, ElementRef> = new Map();
+// Saved parent sessionId when inside an iframe — restored by `frame main`.
+let _parentSessionId = '';
 
 async function getBrowser() {
   return import('../index.js');
 }
 
+// Best-effort cleanup on Ctrl-C / kill so a launched Chrome doesn't linger as
+// an orphan process when a command is interrupted mid-flight (e.g. during a
+// long-running wait/eval that CdpClient.send()'s own timeout hasn't tripped
+// yet).
+//
+// This module is imported for EVERY `monomind` CLI invocation (commands/
+// index.ts statically imports browse.ts, which imports this file) — not just
+// browse commands — so the handler is only *registered* once a browser
+// session is actually launched here (see ensureSignalCleanupHandlers(),
+// called from the `open` action below), not at module load. Registering
+// unconditionally at import time would call process.exit() on Ctrl-C for
+// every unrelated monomind command (e.g. a long-running `org run` daemon),
+// pre-empting whatever other SIGINT/SIGTERM handling that process needs.
+const SIGNAL_EXIT_CODES: Record<'SIGINT' | 'SIGTERM', number> = { SIGINT: 130, SIGTERM: 143 };
+let _signalHandlersRegistered = false;
+function ensureSignalCleanupHandlers(): void {
+  if (_signalHandlersRegistered) return;
+  _signalHandlersRegistered = true;
+  for (const sig of ['SIGINT', 'SIGTERM'] as const) {
+    process.on(sig, () => {
+      void (async () => {
+        try {
+          const browser = await getBrowser();
+          if (_client) {
+            await browser.closeBrowser(_client, _port);
+          } else {
+            const pid = browser.getLaunchedPid(_port);
+            if (pid !== undefined) {
+              try { process.kill(pid, 'SIGKILL'); } catch { /* already exited */ }
+            }
+          }
+        } catch {
+          // best-effort — never block process exit on cleanup failure
+        }
+      })().finally(() => process.exit(SIGNAL_EXIT_CODES[sig]));
+    });
+  }
+}
+
 // Each CLI invocation is a fresh process, so this module's `_port` variable
 // is always freshly initialized to DEFAULT_PORT — a `--port 9333` passed to
 // an earlier `open` command has no effect on this process's own default.
@@ -62,6 +103,7 @@ async function ensureConnected(port: number, targetId?: string) {
     _client = conn.client;
     _sessionId = conn.sessionId;
     _targetId = conn.target.id;
+    _parentSessionId = '';
     _refs = new Map();
     await hydrateRefsFromCache(browser, _targetId, conn.target.url);
   }
@@ -157,6 +199,7 @@ async function switchToHeaded(url: string, port: number): Promise<void> {
     _client.close();
     _client = null;
     _sessionId = '';
+    _parentSessionId = '';
     _targetId = '';
   }
 
@@ -203,6 +246,7 @@ async function switchToHeaded(url: string, port: number): Promise<void> {
   _client.close();
   _client = null;
   _sessionId = '';
+  _parentSessionId = '';
   _targetId = '';
 
   // Relaunch headless and restore session
@@ -277,14 +321,40 @@ const openCommand: Command = {
       prevClient.close();
       _client = null;
       _sessionId = '';
+      _parentSessionId = '';
       _targetId = '';
       _refs = new Map();
     }
 
     _port = await browser.launchBrowser({ port, headless: !forceHeaded });
     // Persist the active port so subsequent CLI invocations (each a fresh
-    // process) default to attaching here instead of hardcoded 9222.
-    await browser.saveActivePort(_port);
+    // process) default to attaching here instead of hardcoded 9222. Also
+    // persist the launched PID/userDataDir so a later process's closeBrowser
+    // can still kill this Chrome even though launchedPids (browser.ts) is
+    // per-process and empty there.
+    //
+    // launchBrowser() can either LAUNCH a fresh Chrome or ATTACH to one
+    // already listening on the requested port (see its own "attach if
+    // already Chrome" comment) — it returns only a port number, with no
+    // signal telling this caller which happened. getLaunchedPid(_port) is
+    // undefined on the attach path (this process never spawned anything).
+    // Bug fixed here: unconditionally saving {pid: undefined, ...} on
+    // attach used to CLOBBER a real PID a previous `open` had already
+    // persisted for this exact port, destroying the only way a later
+    // process's closeBrowser() PID-kill fallback could ever find it.
+    const freshPid = browser.getLaunchedPid(_port);
+    const freshUserDataDir = browser.getLaunchedUserDataDir(_port);
+    if (freshPid !== undefined) {
+      await browser.saveActivePort(_port, { pid: freshPid, userDataDir: freshUserDataDir });
+    } else {
+      // Attach path: preserve whatever PID/userDataDir was already on file
+      // for this port (most likely from the process that originally
+      // launched it) instead of overwriting with undefined.
+      const existing = await browser.loadActivePortInfo();
+      const preserved = existing && existing.port === _port ? existing : undefined;
+      await browser.saveActivePort(_port, { pid: preserved?.pid, userDataDir: preserved?.userDataDir });
+    }
+    ensureSignalCleanupHandlers();
     const conn = await browser.connectToTarget(_port);
     _client = conn.client;
     _sessionId = conn.sessionId;
@@ -777,7 +847,8 @@ const getCommand: Command = {
         const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
         const ref = _refs.get(refKey);
         if (!ref) throw new Error(`Ref @${refKey} not found`);
-        value = await browser.getElementBox(client, sessionId, ref);
+        const center = await browser.getElementBox(client, sessionId, ref);
+        value = deriveBoxOutput(center);
         break;
       }
       case 'styles': {
@@ -1274,6 +1345,7 @@ const closeCommand: Command = {
       client.close();
       _client = null;
       _sessionId = '';
+      _parentSessionId = '';
       _targetId = '';
       _refs = new Map();
       // Session is gone — forget the persisted port and stale refs so later
@@ -1591,8 +1663,11 @@ const tapCommand: Command = {
       const ref = await browser.resolveRef(client, sessionId, _refs, key);
       const box = await browser.getElementBox(client, sessionId, ref);
       if (!box) throw new Error(`Cannot get bounds for @${key}`);
-      x = Math.round(box.x + box.width / 2);
-      y = Math.round(box.y + box.height / 2);
+      // box.x/box.y from getElementBox() ARE already the center point (see
+      // its own doc comment) — adding width/2 here double-offset the tap
+      // target away from the element (issue #15).
+      x = Math.round(box.x);
+      y = Math.round(box.y);
     } else {
       const posJson = await browser.evaluateJs(client, sessionId,
         `(function(){var el=document.querySelector(${JSON.stringify(arg)});if(!el)return null;var r=el.getBoundingClientRect();return JSON.stringify({x:r.left+r.width/2,y:r.top+r.height/2});})()`) as string | null;
@@ -1915,10 +1990,23 @@ const frameCommand: Command = {
     if (!target) throw new Error('Usage: monomind browse frame <selector>|main');
 
     if (target === 'main') {
+      if (_parentSessionId) {
+        // Detach from the OOPIF session (best-effort — it may already be gone)
+        await client.send('Target.detachFromTarget', { sessionId: _sessionId }).catch(() => {});
+        _sessionId = _parentSessionId;
+        _parentSessionId = '';
+      }
       output.printSuccess('Switched to main frame');
     } else {
-      const frameSrc = await browser.switchToFrame(client, sessionId, target);
-      output.printSuccess(`Switched to frame: ${frameSrc ?? target}`);
+      const frameResult = await browser.switchToFrame(client, sessionId, target);
+      if (frameResult.sessionId) {
+        // Save the parent session so `frame main` can restore it
+        _parentSessionId = _sessionId;
+        _sessionId = frameResult.sessionId;
+        // Enable CDP domains on the iframe's session so subsequent commands work
+        await browser.enableSessionDomains(client, _sessionId);
+      }
+      output.printSuccess(`Switched to frame: ${frameResult.url ?? target}`);
     }
     return { success: true };
   },
@@ -1970,6 +2058,7 @@ const tabCommand: Command = {
           client.close();
           _client = null;
           _sessionId = '';
+          _parentSessionId = '';
           _targetId = '';
           _refs = new Map();
         } else {
@@ -2497,8 +2586,30 @@ function tokenizeBatchCommand(input: string): string[] {
  * only its own known --flags are consumed from the front; everything after
  * them is taken verbatim as one argument, untouched by tokenization.
  *
+/**
+ * `get box`'s output shape: browser.getElementBox() returns the element's
+ * CENTER point under x/y (correct for internal click-target callers), but
+ * `get box` is a bounding-box accessor where x/y conventionally means the
+ * top-left origin — a caller computing its own center as `box.x + width/2`
+ * would otherwise double-offset away from the element (issue #15). Expose
+ * both conventions, explicitly labeled, so neither is ambiguous.
+ *
  * Exported for direct unit testing — not part of the CLI's public API.
  */
+export function deriveBoxOutput(
+  center: { x: number; y: number; width: number; height: number } | null
+): { x: number; y: number; width: number; height: number; centerX: number; centerY: number } | null {
+  if (!center) return null;
+  return {
+    x: center.x - center.width / 2,
+    y: center.y - center.height / 2,
+    width: center.width,
+    height: center.height,
+    centerX: center.x,
+    centerY: center.y,
+  };
+}
+
 export function parseBatchCommandLine(cmdStr: string): { subName: string; subArgs: string[]; flags: Record<string, unknown> } {
   const trimmed = cmdStr.trim();
   const evalMatch = trimmed.match(/^eval\b\s*/);
@@ -2700,6 +2811,7 @@ const connectCommand: Command = {
       prevClient.close();
       _client = null;
       _sessionId = '';
+      _parentSessionId = '';
       _targetId = '';
       _refs = new Map();
     }