@bubstack/moe-glass 0.1.0

package/skills/browsing/lib/browser-bridge.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const { createCdpRouter } = require('./cdp-router');
+const { attachPageSession, buildPageSessionFromAttached } = require('./page-session');
+
+/**
+ * attachBrowserBridge({browser, host, port, rewriteWsUrl}) — consumer-facing
+ * bridge over the browser-session.
+ *
+ * Exposes:
+ *   targets.list()                 — synchronous snapshot of current targets
+ *   targets.onCreated(handler)     — register listener; returns unsub fn
+ *   targets.onDestroyed(handler)
+ *   targets.waitForNew(predicate, {timeoutMs})
+ *   createBrowserContext({proxyServer?}) -> {browserContextId, createPage, dispose}
+ *   attachPageSession(targetId)    — page session over the browser-WS via flatten mode
+ *
+ * host/port/rewriteWsUrl are needed by createBrowserContext.createPage to construct
+ * per-page WS URLs for callers that still want one (the bridge itself never uses
+ * them — page sessions ride the browser-WS).
+ */
+async function attachBrowserBridge({ browser, host, port, rewriteWsUrl, autoAttach = false, onPageSession = null }) {
+  // The cdp-router sits between browser-session and bridge consumers.
+  // Page-session-tagged messages dispatch to the right session; root-session
+  // events (Target.*, etc.) fire root listeners. Command responses without
+  // sessionId stay correlated by browser-session.js's pendingRequests
+  // (single source of truth for root-session correlation).
+  const router = createCdpRouter({ browser });
+
+  const targetMap = new Map();      // targetId -> targetInfo
+  const onCreatedFns = new Set();
+  const onDestroyedFns = new Set();
+
+  router.getRootListeners().add((msg) => {
+    if (msg.method === 'Target.targetCreated') {
+      const t = msg.params.targetInfo;
+      targetMap.set(t.targetId, t);
+      for (const fn of onCreatedFns) {
+        try { fn(t); } catch (e) { console.error('targets onCreated handler threw:', e); }
+      }
+    } else if (msg.method === 'Target.targetInfoChanged') {
+      const t = msg.params.targetInfo;
+      targetMap.set(t.targetId, t);
+    } else if (msg.method === 'Target.targetDestroyed') {
+      const t = targetMap.get(msg.params.targetId);
+      targetMap.delete(msg.params.targetId);
+      if (t) {
+        for (const fn of onDestroyedFns) {
+          try { fn(t); } catch (e) { console.error('targets onDestroyed handler threw:', e); }
+        }
+      }
+    }
+  });
+
+  // Handle auto-attached targets (popups, child frames, etc.) when autoAttach is on.
+  // Chrome emits this with an already-allocated sessionId — no Target.attachToTarget needed.
+  //
+  // Only act on targets that are paused (waitingForDebugger: true). Existing tabs
+  // that Chrome retrospectively reports via attachedToTarget (waitingForDebugger: false)
+  // are not paused and will be set up through the normal getPageSession/attachPageSession
+  // path. Installing a page session here for those targets would register the same
+  // sessionId twice in the cdp-router, causing duplicate-id protocol errors.
+  router.getRootListeners().add(async (msg) => {
+    if (msg.method !== 'Target.attachedToTarget') return;
+    const { sessionId, targetInfo, waitingForDebugger } = msg.params;
+
+    if (!waitingForDebugger) return;
+
+    const ps = buildPageSessionFromAttached({ browser, router, sessionId, targetId: targetInfo.targetId });
+
+    // Only run the onPageSession hook for page-type targets. Non-page targets
+    // (service_worker, background_page, etc.) don't support the Page CDP domain
+    // and would cause 'Page.enable' wasn't found errors in the hook.
+    if (onPageSession && targetInfo.type === 'page') {
+      try { await onPageSession(ps); }
+      catch (e) { console.error('onPageSession hook threw:', e); }
+    }
+
+    // Resume the paused target AFTER the hook so any shims (e.g. dialog) are
+    // installed before the page's scripts run.
+    try { await ps.send('Runtime.runIfWaitingForDebugger', {}); }
+    catch (e) { console.error('Runtime.runIfWaitingForDebugger failed:', e); }
+  });
+
+  // Subscribe — replays existing targets as targetCreated events.
+  await browser.send('Target.setDiscoverTargets', { discover: true });
+
+  if (autoAttach) {
+    await browser.send('Target.setAutoAttach', {
+      autoAttach: true,
+      waitForDebuggerOnStart: true,
+      flatten: true,
+    });
+  }
+
+  function list() { return Array.from(targetMap.values()); }
+  function onCreated(fn) { onCreatedFns.add(fn); return () => onCreatedFns.delete(fn); }
+  function onDestroyed(fn) { onDestroyedFns.add(fn); return () => onDestroyedFns.delete(fn); }
+
+  function waitForNew(predicate, { timeoutMs = 15000 } = {}) {
+    return new Promise((resolve, reject) => {
+      let unsub = null;
+      const timeout = setTimeout(() => {
+        if (unsub) unsub();
+        reject(new Error(`waitForNew: timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      unsub = onCreated((t) => {
+        let match;
+        try { match = predicate(t); }
+        catch (e) {
+          clearTimeout(timeout);
+          if (unsub) unsub();
+          reject(e);
+          return;
+        }
+        if (match) {
+          clearTimeout(timeout);
+          if (unsub) unsub();
+          resolve(t);
+        }
+      });
+    });
+  }
+
+  /**
+   * createBrowserContext({proxyServer?}) — creates a Chrome BrowserContext.
+   * Returns {browserContextId, createPage, dispose}.
+   *
+   * createPage(url) calls Target.createTarget({url, browserContextId}) and
+   * constructs a tab-shape-compatible page handle whose webSocketDebuggerUrl
+   * is run through rewriteWsUrl.
+   *
+   * dispose() is atomic — Chrome tears down cookies/storage/IDB/SW for the
+   * context in one call.
+   */
+  async function createBrowserContext(opts = {}) {
+    const params = {};
+    if (opts.proxyServer) params.proxyServer = opts.proxyServer;
+    const { browserContextId } = await browser.send('Target.createBrowserContext', params);
+    let disposed = false;
+
+    async function createPage(url = 'about:blank') {
+      if (disposed) throw new Error('BrowserContext disposed');
+      const { targetId } = await browser.send('Target.createTarget', { url, browserContextId });
+      const rawWsUrl = `ws://${host}:${port}/devtools/page/${targetId}`;
+      return {
+        id: targetId, targetId,
+        webSocketDebuggerUrl: rewriteWsUrl(rawWsUrl, host, port),
+        type: 'page', url, browserContextId,
+      };
+    }
+
+    async function dispose() {
+      if (disposed) return;
+      disposed = true;
+      try { await browser.send('Target.disposeBrowserContext', { browserContextId }); }
+      catch (e) { console.warn('BrowserContext.dispose() failed:', e && e.message); }
+    }
+
+    return { browserContextId, createPage, dispose };
+  }
+
+  async function attachPage(targetId) {
+    return attachPageSession({ browser, router }, targetId);
+  }
+
+  return {
+    targets: { list, onCreated, onDestroyed, waitForNew },
+    createBrowserContext,
+    attachPageSession: attachPage,
+    router,
+  };
+}
+
+module.exports = { attachBrowserBridge };

package/skills/browsing/lib/browser-session.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const { WebSocketClient: DefaultWebSocketClient } = require('./websocket-client');
+
+/**
+ * createBrowserSession({host, port, rewriteWsUrl, chromeHttp, WebSocketClient?}) -> bridge handle.
+ *
+ * Owns the one root WebSocket to /devtools/browser/<id>. Page-action commands ride
+ * per-page sessions (attached via Target.attachToTarget({flatten:true})) and envelope
+ * messages with a sessionId via sendRaw — the page session manages its own pendingRequests
+ * (in the cdp-router). browser-session correlates ROOT-session command responses only.
+ *
+ * Returned API:
+ *   send(method, params?, {timeoutMs?})  -> Promise<result>  // root command
+ *   onEvent(handler)                     -> unsub fn
+ *   close()                              -> Promise<void>
+ *   isConnected()                        -> boolean
+ *   sendRaw(json)                        -> void
+ */
+function createBrowserSession({ host, port, rewriteWsUrl, chromeHttp, WebSocketClient = DefaultWebSocketClient }) {
+  let ws = null;
+  const pendingRequests = new Map(); // id -> {resolve, reject, timeout}
+  let messageIdCounter = 1;
+  const eventListeners = new Set();
+  let connectPromise = null;
+  let closed = false;
+
+  async function ensureConnected() {
+    if (ws && ws.isConnected()) return;
+    if (connectPromise) { await connectPromise; return; }
+    connectPromise = (async () => {
+      try {
+        const versionInfo = await chromeHttp('/json/version');
+        if (!versionInfo || !versionInfo.webSocketDebuggerUrl) {
+          throw new Error('chromeHttp(/json/version) returned no webSocketDebuggerUrl');
+        }
+        const url = rewriteWsUrl(versionInfo.webSocketDebuggerUrl, host, port);
+        const next = new WebSocketClient(url);
+        next.on('message', (raw) => {
+          let data;
+          try { data = JSON.parse(raw); } catch (e) {
+            console.error('browser-session: bad JSON from CDP:', e);
+            return;
+          }
+          // Correlate ROOT-session command responses (id without sessionId). Page-session
+          // responses carry {id, result, sessionId} and fall through to event listeners
+          // for the cdp-router to dispatch.
+          if (data.id !== undefined && data.sessionId === undefined) {
+            const pending = pendingRequests.get(data.id);
+            if (pending) {
+              clearTimeout(pending.timeout);
+              pendingRequests.delete(data.id);
+              if (data.error) {
+                pending.reject(new Error(data.error.message || JSON.stringify(data.error)));
+              } else {
+                pending.resolve(data.result);
+              }
+              return;
+            }
+          }
+          for (const fn of eventListeners) {
+            try { fn(data); } catch (e) { console.error('browser-session listener threw:', e); }
+          }
+        });
+        next.on('close', () => {
+          for (const [, p] of pendingRequests) {
+            clearTimeout(p.timeout);
+            p.reject(new Error('Browser session WS closed'));
+          }
+          pendingRequests.clear();
+        });
+        await next.connect();
+        // Assign ws only after a successful connect so concurrent callers that hit the
+        // `ws && ws.isConnected()` early-return don't see a half-initialized socket.
+        ws = next;
+      } catch (e) {
+        // Allow retry after a transient failure (network blip, Chrome not yet ready, etc.).
+        // We do NOT null on success — leaving the resolved promise in place makes subsequent
+        // ensureConnected() awaits a no-op.
+        connectPromise = null;
+        throw e;
+      }
+    })();
+    await connectPromise;
+  }
+
+  async function send(method, params = {}, { timeoutMs = 10000 } = {}) {
+    if (closed) throw new Error('Browser session closed');
+    await ensureConnected();
+    if (closed) throw new Error('Browser session closed');
+    const id = messageIdCounter++;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        pendingRequests.delete(id);
+        reject(new Error(`Browser session timeout: ${method}`));
+      }, timeoutMs);
+      pendingRequests.set(id, { resolve, reject, timeout });
+      try {
+        ws.send(JSON.stringify({ id, method, params }));
+      } catch (e) {
+        clearTimeout(timeout);
+        pendingRequests.delete(id);
+        reject(e);
+      }
+    });
+  }
+
+  function onEvent(handler) {
+    eventListeners.add(handler);
+    return () => eventListeners.delete(handler);
+  }
+
+  async function close() {
+    closed = true;
+    if (ws) { ws.close(); ws = null; }
+    for (const [, p] of pendingRequests) {
+      clearTimeout(p.timeout);
+      p.reject(new Error('Browser session closed'));
+    }
+    pendingRequests.clear();
+    eventListeners.clear();
+  }
+
+  function isConnected() { return ws !== null && ws.isConnected(); }
+
+  function sendRaw(json) {
+    if (closed) throw new Error('Browser session closed');
+    if (!ws || !ws.isConnected()) {
+      throw new Error('Browser WS not connected (call send() first to lazy-open)');
+    }
+    ws.send(json);
+  }
+
+  return { send, onEvent, close, isConnected, sendRaw };
+}
+
+module.exports = { createBrowserSession };