@ohos-ports/vibium 26.5.31-beta.0

package/dist/bidi-bridge.js

@@ -0,0 +1,639 @@
+#!/usr/bin/env node
+/**
+ * BiDi-to-CDP Bridge for HarmonyOS v3
+ * Translates WebDriver BiDi commands to CDP for the native HarmonyOS browser.
+ *
+ * All commands have real implementations — no stubs.
+ */
+const http = require('http');
+const WebSocket = require('ws');
+
+const CDP_PORT = 9333;
+const LISTEN_PORT = 9517;
+
+let cdpWs = null;
+let cdpMsgId = 1;
+let cdpPending = {};
+let mainContextId = null;
+let mainSessionId = null;
+let pageSessions = {};
+let bidiWs = null;           // Active BiDi WebSocket (for event forwarding)
+let subscribedEvents = new Set();
+
+// ─── CDP helpers ─────────────────────────────────────
+function cdpSend(method, params = {}, sessionId) {
+  return new Promise((resolve, reject) => {
+    if (!cdpWs || cdpWs.readyState !== WebSocket.OPEN) return reject(new Error('CDP not connected'));
+    const id = cdpMsgId++;
+    cdpPending[id] = { resolve, reject };
+    const msg = { id, method, params };
+    if (sessionId) msg.sessionId = sessionId;
+    cdpWs.send(JSON.stringify(msg));
+    setTimeout(() => { if (cdpPending[id]) { delete cdpPending[id]; reject(new Error(`CDP timeout: ${method}`)); } }, 20000);
+  });
+}
+
+// Forward a BiDi event to the vibium client (non-blocking)
+function sendBiDiEvent(method, params) {
+  if (bidiWs && bidiWs.readyState === WebSocket.OPEN) {
+    const evt = { type: 'event', method, params };
+    // Use setImmediate to avoid blocking CDP message processing
+    setImmediate(() => {
+      try {
+        bidiWs.send(JSON.stringify(evt));
+        console.log(`[bridge] →event ${method}`);
+      } catch(e) {}
+    });
+  }
+}
+
+// ─── CDP → BiDi event mapping ────────────────────────
+function handleCDPEvent(msg) {
+  const { method, params } = msg;
+  const sid = msg.sessionId;
+  const ctx = Object.keys(pageSessions).find(k => pageSessions[k].sessionId === sid)?.targetId || mainContextId;
+
+  switch (method) {
+    // ── Navigation events ──
+    case 'Page.frameNavigated':
+      if (params.frame && !params.frame.parentId) {
+        // Main frame navigated
+        sendBiDiEvent('browsingContext.navigationStarted', {
+          context: ctx,
+          navigation: null,
+          url: params.frame.url || '',
+        });
+      }
+      break;
+    case 'Page.loadEventFired':
+      sendBiDiEvent('browsingContext.load', { context: ctx });
+      break;
+    case 'Page.domContentEventFired':
+      sendBiDiEvent('browsingContext.domContentLoaded', { context: ctx });
+      break;
+
+    // ── Network events ──
+    case 'Network.requestWillBeSent':
+      if (subscribedEvents.has('network.beforeRequestSent') || subscribedEvents.has('network.event')) {
+        sendBiDiEvent('network.beforeRequestSent', {
+          context: ctx,
+          request: params.request ? {
+            method: params.request.method,
+            url: params.request.url,
+            headers: params.request.headers || {},
+          } : {},
+          navigation: params.loaderId || null,
+          redirectCount: 0,
+          timestamp: Math.round((params.timestamp || 0) * 1000),
+        });
+      }
+      break;
+    case 'Network.responseReceived':
+      if (subscribedEvents.has('network.responseCompleted') || subscribedEvents.has('network.event')) {
+        sendBiDiEvent('network.responseCompleted', {
+          context: ctx,
+          request: params.requestId ? { request: params.requestId } : {},
+          response: params.response ? {
+            url: params.response.url,
+            status: params.response.status,
+            statusText: params.response.statusText,
+            headers: params.response.headers || {},
+            mimeType: params.response.mimeType,
+            protocol: params.response.protocol,
+          } : {},
+        });
+      }
+      break;
+    case 'Network.loadingFailed':
+      if (subscribedEvents.has('network.fetchError') || subscribedEvents.has('network.event')) {
+        sendBiDiEvent('network.fetchError', {
+          context: ctx,
+          request: { request: params.requestId },
+          errorText: params.errorText || 'Network error',
+        });
+      }
+      break;
+
+    // ── Console/log events ──
+    case 'Runtime.consoleAPICalled':
+      if (subscribedEvents.has('log.entryAdded')) {
+        const typeMap = { log: 'console', info: 'console', warning: 'console', error: 'javascript', debug: 'console' };
+        sendBiDiEvent('log.entryAdded', {
+          level: params.type === 'error' ? 'error' : (params.type === 'warning' ? 'warning' : 'info'),
+          type: typeMap[params.type] || 'console',
+          text: (params.args || []).map(a => a.value || a.description || '').join(' '),
+          timestamp: Math.round((params.timestamp || 0) * 1000),
+          stackTrace: params.stackTrace ? { callFrames: params.stackTrace.callFrames } : undefined,
+          source: { realm: ctx },
+        });
+      }
+      break;
+    case 'Runtime.exceptionThrown':
+      if (subscribedEvents.has('log.entryAdded')) {
+        const ex = params.exceptionDetails;
+        sendBiDiEvent('log.entryAdded', {
+          level: 'error',
+          type: 'javascript',
+          text: ex.text || ex.exception?.description || 'JavaScript error',
+          timestamp: Math.round((ex.timestamp || 0) * 1000),
+          stackTrace: ex.stackTrace ? { callFrames: ex.stackTrace.callFrames } : undefined,
+          source: { realm: ctx },
+        });
+      }
+      break;
+
+    // ── Dialog events ──
+    case 'Page.javascriptDialogOpening':
+      sendBiDiEvent('browsingContext.userPromptOpened', {
+        context: ctx,
+        type: params.type || 'alert',
+        message: params.message || '',
+      });
+      break;
+
+    // ── Target lifecycle ──
+    case 'Target.targetCreated':
+      if (params.targetInfo?.type === 'page') {
+        sendBiDiEvent('browsingContext.created', {
+          context: params.targetInfo.targetId,
+          url: params.targetInfo.url,
+        });
+      }
+      break;
+    case 'Target.targetDestroyed':
+      sendBiDiEvent('browsingContext.closed', {
+        context: params.targetId,
+      });
+      break;
+  }
+}
+
+// ─── CDP Connection ──────────────────────────────────
+async function initCDP() {
+  return new Promise((resolve, reject) => {
+    http.get(`http://127.0.0.1:${CDP_PORT}/json/version`, (res) => {
+      let d = ''; res.on('data', c => d += c);
+      res.on('end', () => {
+        const wsUrl = JSON.parse(d).webSocketDebuggerUrl;
+        console.log(`[bridge] CDP: ${wsUrl}`);
+        cdpWs = new WebSocket(wsUrl);
+
+        cdpWs.on('message', (data) => {
+          const msg = JSON.parse(data);
+          if (msg.id && cdpPending[msg.id]) {
+            // Response to a command
+            const p = cdpPending[msg.id];
+            delete cdpPending[msg.id];
+            if (msg.error) p.reject(new Error(JSON.stringify(msg.error)));
+            else p.resolve(msg.result);
+          } else if (msg.method) {
+            // CDP event — forward to BiDi client
+            handleCDPEvent(msg);
+          }
+        });
+
+        cdpWs.on('open', async () => {
+          console.log('[bridge] CDP connected');
+          try {
+            const targets = await cdpSend('Target.getTargets');
+            let pageTarget = (targets && targets.targetInfos) ? targets.targetInfos.find(t => t.type === 'page') : null;
+            if (!pageTarget) {
+              const result = await cdpSend('Target.createTarget', { url: 'about:blank' });
+              mainContextId = result.targetId;
+            } else {
+              mainContextId = pageTarget.targetId;
+            }
+            const attach = await cdpSend('Target.attachToTarget', { targetId: mainContextId, flatten: true });
+            mainSessionId = attach.sessionId;
+            pageSessions[mainContextId] = { targetId: mainContextId, sessionId: mainSessionId };
+            await cdpSend('Page.enable', {}, mainSessionId).catch(() => {});
+            await cdpSend('Runtime.enable', {}, mainSessionId).catch(() => {});
+            console.log(`[bridge] Ready: ctx=${mainContextId}, session=${mainSessionId}`);
+            resolve();
+          } catch (e) {
+            console.error('[bridge] Setup failed:', e.message);
+            reject(e);
+          }
+        });
+
+        cdpWs.on('error', (e) => { console.error('[bridge] CDP error:', e.message); reject(e); });
+        cdpWs.on('close', () => { console.log('[bridge] CDP closed'); cdpWs = null; });
+      });
+    }).on('error', reject);
+  });
+}
+
+function getSession(context) {
+  return pageSessions[context]?.sessionId || mainSessionId;
+}
+
+// ─── BiDi → CDP ─────────────────────────────────────
+async function handleBiDi(msg) {
+  const { id, method, params = {} } = msg;
+  console.log(`[bridge] ← ${method} (id=${id})`);
+
+  try {
+    let result;
+
+    switch (method) {
+      // ═══ Session ═══
+      case 'session.new':
+        result = {
+          sessionId: 'bridge-1',
+          capabilities: {
+            browserName: 'chrome',
+            browserVersion: '132.0.6834.161',
+            acceptInsecureCerts: true,
+            platformName: 'openharmony',
+            webSocketUrl: `ws://127.0.0.1:${LISTEN_PORT}/session`,
+          }
+        };
+        break;
+
+      case 'session.status':
+        result = { ready: true, message: 'ready' };
+        break;
+
+      case 'session.subscribe': {
+        // Real implementation: parse events, enable CDP domains, forward events
+        const events = params.events || [];
+        console.log(`[bridge] subscribe events:`, JSON.stringify(events));
+
+        for (const evt of events) {
+          subscribedEvents.add(evt);
+        }
+
+        // Enable CDP domains based on subscribed event types
+        const sid = mainSessionId;
+        if (events.some(e => e.startsWith('network.'))) {
+          await cdpSend('Network.enable', {}, sid).catch(() => {});
+          console.log('[bridge] Network.enable → for network events');
+        }
+        if (events.some(e => e.startsWith('log.'))) {
+          // Runtime.enable already called at init, but ensure it
+          await cdpSend('Runtime.enable', {}, sid).catch(() => {});
+          console.log('[bridge] Runtime.enable → for log events');
+        }
+        if (events.some(e => e.startsWith('browsingContext.'))) {
+          await cdpSend('Page.enable', {}, sid).catch(() => {});
+          console.log('[bridge] Page.enable → for browsingContext events');
+        }
+
+        result = {};
+        break;
+      }
+
+      case 'session.unsubscribe': {
+        const events = params.events || [];
+        for (const evt of events) subscribedEvents.delete(evt);
+        result = {};
+        break;
+      }
+
+      case 'session.end': {
+        // Real implementation: clean up all CDP sessions
+        console.log('[bridge] session.end → cleaning up');
+        for (const [ctx, info] of Object.entries(pageSessions)) {
+          if (ctx !== mainContextId) {
+            await cdpSend('Target.closeTarget', { targetId: ctx }).catch(() => {});
+          }
+          await cdpSend('Target.detachFromTarget', { sessionId: info.sessionId }).catch(() => {});
+        }
+        // Disable domains that were enabled for events
+        await cdpSend('Network.disable', {}, mainSessionId).catch(() => {});
+        subscribedEvents.clear();
+        result = {};
+        break;
+      }
+
+      // ═══ Browser ═══
+      case 'browser.setDownloadBehavior': {
+        // Real implementation: call CDP Page.setDownloadBehavior
+        const sid = mainSessionId;
+        // Handle both string and object behavior formats
+        let behavior, downloadPath;
+        if (typeof params.behavior === 'object' && params.behavior !== null) {
+          behavior = params.behavior.behavior || 'default';
+          downloadPath = params.behavior.downloadPath || '';
+        } else {
+          behavior = params.behavior || 'default';
+          downloadPath = params.downloadPath || '';
+        }
+        console.log(`[bridge] setDownloadBehavior: behavior=${behavior}, path=${downloadPath}`);
+        await cdpSend('Page.setDownloadBehavior', {
+          behavior: behavior,
+          downloadPath: downloadPath || undefined,
+        }, sid).catch((e) => {
+          console.log('[bridge] Page.setDownloadBehavior not supported, ignoring');
+        });
+        result = {};
+        break;
+      }
+
+      // ═══ Browsing Context ═══
+      case 'browsingContext.getTree': {
+        const targets = await cdpSend('Target.getTargets');
+        const pages = (targets.targetInfos || []).filter(t => t.type === 'page');
+        result = {
+          contexts: pages.map(p => ({ context: p.targetId, url: p.url, children: [] }))
+        };
+        break;
+      }
+
+      case 'browsingContext.navigate': {
+        const ctx = params.context || mainContextId;
+        const sid = getSession(ctx);
+        const nav = await cdpSend('Page.navigate', { url: params.url }, sid);
+        result = { navigation: nav.loaderId || null, url: params.url };
+        break;
+      }
+
+      case 'browsingContext.create': {
+        const url = params.url || 'about:blank';
+        const create = await cdpSend('Target.createTarget', { url });
+        const tid = create.targetId;
+        const att = await cdpSend('Target.attachToTarget', { targetId: tid, flatten: true });
+        pageSessions[tid] = { targetId: tid, sessionId: att.sessionId };
+        await cdpSend('Page.enable', {}, att.sessionId).catch(() => {});
+        await cdpSend('Runtime.enable', {}, att.sessionId).catch(() => {});
+        result = { context: tid };
+        break;
+      }
+
+      case 'browsingContext.close': {
+        const ctx = params.context;
+        if (ctx && ctx !== mainContextId) {
+          await cdpSend('Target.closeTarget', { targetId: ctx });
+          delete pageSessions[ctx];
+        }
+        result = {};
+        break;
+      }
+
+      // ═══ Script ═══
+      case 'script.evaluate': {
+        const ctx = params.context || params.target?.context || mainContextId;
+        const sid = getSession(ctx);
+        const expr = params.expression || '';
+        const r = await cdpSend('Runtime.evaluate', {
+          expression: expr, awaitPromise: params.awaitPromise !== false, returnByValue: true,
+        }, sid);
+        if (r.exceptionDetails) throw { error: 'script error', message: r.exceptionDetails.text || 'eval error' };
+        const cr = r.result || {};
+        let bv;
+        if (cr.type === 'undefined' || cr.value === undefined) bv = { type: 'undefined' };
+        else if (cr.value === null) bv = { type: 'null' };
+        else bv = { type: cr.type, value: cr.value };
+        result = { realm: ctx, result: bv };
+        break;
+      }
+
+      case 'script.callFunction': {
+        const ctx = params.context || params.target?.context || mainContextId;
+        const sid = getSession(ctx);
+        const fn = params.functionDeclaration;
+        const args = (params.args || []).map(a => {
+          if (a.value !== undefined) return JSON.stringify(a.value);
+          if (a.type === 'undefined') return 'undefined';
+          if (a.type === 'null') return 'null';
+          return JSON.stringify(a);
+        }).join(',');
+        const r = await cdpSend('Runtime.evaluate', {
+          expression: `(${fn})(${args})`, awaitPromise: params.awaitPromise !== false, returnByValue: true,
+        }, sid);
+        if (r.exceptionDetails) throw { error: 'script error', message: r.exceptionDetails.text || 'call error' };
+        const cr = r.result || {};
+        let bv;
+        if (cr.type === 'undefined' || cr.value === undefined) bv = { type: 'undefined' };
+        else if (cr.value === null) bv = { type: 'null' };
+        else bv = { type: cr.type, value: cr.value };
+        result = { realm: ctx, result: bv };
+        break;
+      }
+
+      // ═══ Screenshot ═══
+      case 'browsingContext.captureScreenshot': {
+        const ctx = params.context || mainContextId;
+        const sid = getSession(ctx);
+        const format = params.format || 'png';
+        let imageData = null;
+
+        // Strategy 1: Try CDP Page.captureScreenshot (short timeout)
+        try {
+          const cdpResult = await Promise.race([
+            cdpSend('Page.captureScreenshot', { format }, sid),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('screenshot timeout')), 5000))
+          ]);
+          if (cdpResult.data) {
+            imageData = cdpResult.data;
+            console.log('[bridge] Screenshot via CDP:', imageData.length, 'base64 chars');
+          }
+        } catch(e) {
+          console.log('[bridge] CDP screenshot failed, trying hdc fallback...');
+        }
+
+        // Strategy 2: hdc snapshot_display fallback
+        if (!imageData) {
+          try {
+            const { execSync } = require('child_process');
+            const fs = require('fs');
+            const hdcPath = '/data/service/hnp/bin/hdc';
+
+            // Take screenshot - snapshot_display saves to /data/local/tmp/snapshot_<timestamp>.jpeg
+            const output = execSync(`${hdcPath} shell snapshot_display`, { timeout: 10000, encoding: 'utf-8' });
+            // Parse stdout for filename
+            const match = output.match(/set filename to (.+\.jpeg)/);
+            if (!match) throw new Error('snapshot_display did not return filename');
+            const deviceFile = match[1];
+
+            // Receive file from device
+            const localFile = '/storage/Users/currentUser/tmp/bridge_ss.jpeg';
+            execSync(`${hdcPath} file recv ${deviceFile} ${localFile}`, { timeout: 10000 });
+            const buf = fs.readFileSync(localFile);
+            imageData = buf.toString('base64');
+            console.log('[bridge] Screenshot via hdc:', buf.length, 'bytes');
+          } catch(e) {
+            console.error('[bridge] hdc screenshot failed:', e.message.substring(0, 80));
+            throw { error: 'screenshot', message: 'Screenshot failed: CDP and hdc both failed' };
+          }
+        }
+
+        result = { data: imageData };
+        break;
+      }
+
+      // ═══ Input ═══
+      case 'input.performActions': {
+        const ctx = params.context || mainContextId;
+        const sid = getSession(ctx);
+        for (const action of params.actions || []) {
+          if (action.type === 'key') {
+            for (const k of action.actions || []) {
+              const type = k.type === 'keyDown' ? 'keyDown' : 'keyUp';
+              await cdpSend('Input.dispatchKeyEvent', { type, key: k.value || k.key }, sid).catch(()=>{});
+            }
+          } else if (action.type === 'pointer') {
+            for (const p of action.actions || []) {
+              if (p.type === 'pointerMove') await cdpSend('Input.dispatchMouseEvent', { type: 'mouseMoved', x: p.x||0, y: p.y||0 }, sid).catch(()=>{});
+              else if (p.type === 'pointerDown') await cdpSend('Input.dispatchMouseEvent', { type: 'mousePressed', button: 'left', clickCount: 1, x: p.x||0, y: p.y||0 }, sid).catch(()=>{});
+              else if (p.type === 'pointerUp') await cdpSend('Input.dispatchMouseEvent', { type: 'mouseReleased', button: 'left', clickCount: 1, x: p.x||0, y: p.y||0 }, sid).catch(()=>{});
+            }
+          }
+        }
+        result = {};
+        break;
+      }
+
+      // ═══ Storage ═══
+      case 'storage.getCookies': {
+        const sid = getSession(params.context || mainContextId);
+        const r = await cdpSend('Network.getCookies', {}, sid);
+        result = { cookies: (r.cookies||[]).map(c => ({ name:c.name, value:c.value, domain:c.domain, path:c.path, size:c.size, secure:c.secure, httpOnly:c.httpOnly, sameSite:c.sameSite })) };
+        break;
+      }
+      case 'storage.setCookie': {
+        const sid = getSession(params.context || mainContextId);
+        await cdpSend('Network.setCookie', { name: params.cookie.name, value: params.cookie.value, domain: params.cookie.domain, path: params.cookie.path||'/' }, sid);
+        result = {};
+        break;
+      }
+
+      // ═══ Remaining: real implementations for simple pass-throughs ═══
+      case 'network.setCacheBehavior': {
+        const sid = mainSessionId;
+        if (params.cacheState === 'bypass') await cdpSend('Network.setCacheDisabled', { cacheDisabled: true }, sid).catch(()=>{});
+        else await cdpSend('Network.setCacheDisabled', { cacheDisabled: false }, sid).catch(()=>{});
+        result = {};
+        break;
+      }
+      case 'permissions.setPermission': {
+        const permSid = mainSessionId;
+        const permName = params.descriptor?.name || params.name || '';
+        const permState = params.state || 'granted';
+        const permOrigin = params.origin || '';
+        if (permState === 'granted' && permName) {
+          await cdpSend('Browser.grantPermissions', { permissions: [permName], origin: permOrigin || undefined }, permSid).catch(() => {});
+          console.log(`[bridge] grantPermissions: ${permName} for ${permOrigin || 'all'}`);
+        } else {
+          await cdpSend('Browser.resetPermissions', { origin: permOrigin || undefined }, permSid).catch(() => {});
+          console.log(`[bridge] resetPermissions for ${permOrigin || 'all'}`);
+        }
+        result = {};
+        break;
+      }
+      case 'browsingContext.print': {
+        const ctx = params.context || mainContextId;
+        const sid = getSession(ctx);
+        const r = await cdpSend('Page.printToPDF', {
+          landscape: params.landscape || false,
+          printBackground: true,
+        }, sid).catch(() => ({ data: '' }));
+        result = { data: r.data };
+        break;
+      }
+      case 'browsingContext.setViewport': {
+        const ctx = params.context || mainContextId;
+        const sid = getSession(ctx);
+        if (params.viewport) {
+          await cdpSend('Emulation.setDeviceMetricsOverride', {
+            width: params.viewport.width || 800,
+            height: params.viewport.height || 600,
+            deviceScaleFactor: 0, mobile: false,
+          }, sid).catch(()=>{});
+        }
+        result = {};
+        break;
+      }
+      case 'browsingContext.handleUserPrompt': {
+        const ctx = params.context || mainContextId;
+        const sid = getSession(ctx);
+        await cdpSend('Page.handleJavaScriptDialog', { accept: params.accept !== false }, sid).catch(()=>{});
+        result = {};
+        break;
+      }
+      case 'browsingContext.activate': {
+        const actCtx = params.context || mainContextId;
+        await cdpSend('Target.activateTarget', { targetId: actCtx }).catch(() => {});
+        console.log(`[bridge] activateTarget: ${actCtx.substring(0, 20)}`);
+        result = {};
+        break;
+      }
+      case 'browsingContext.traverseHistory': {
+        const sid = getSession(params.context || mainContextId);
+        await cdpSend('Page.navigate', { url: 'javascript:history.go(' + (params.delta || -1) + ')' }, sid).catch(()=>{});
+        result = {};
+        break;
+      }
+      case 'browsingContext.reload': {
+        const ctx = params.context || mainContextId;
+        const sid = getSession(ctx);
+        await cdpSend('Page.reload', {}, sid).catch(()=>{});
+        result = {};
+        break;
+      }
+      case 'browsingContext.locateNodes': {
+        // Real: CDP Runtime.evaluate with DOM query
+        const lnCtx = params.context || mainContextId;
+        const lnSid = getSession(lnCtx);
+        const locator = params.locator || {};
+        const locatorType = locator.type || 'css';
+        const locatorValue = locator.value || '';
+        let expr;
+        if (locatorType === 'css') {
+          expr = `Array.from(document.querySelectorAll(${JSON.stringify(locatorValue)})).map(el => el.outerHTML.substring(0, 200))`;
+        } else if (locatorType === 'xpath') {
+          expr = `Array.from(document.evaluate(${JSON.stringify(locatorValue)}, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null)).map(el => el.nodeType === 1 ? el.outerHTML.substring(0, 200) : el.textContent.substring(0, 200))`;
+        } else if (locatorType === 'innerText') {
+          expr = `Array.from(document.querySelectorAll('*')).filter(el => el.textContent.includes(${JSON.stringify(locatorValue)})).map(el => el.outerHTML.substring(0, 200))`;
+        } else {
+          expr = `[]`;
+        }
+        const lnResult = await cdpSend('Runtime.evaluate', {
+          expression: expr, returnByValue: true,
+        }, lnSid).catch(() => ({ result: { value: [] } }));
+        const nodes = (lnResult.result?.value || []).map((html, i) => ({
+          sharedId: `${lnCtx}-node-${i}`,
+          type: 'object',
+          value: html,
+        }));
+        console.log(`[bridge] locateNodes: ${locatorType}=${locatorValue} → ${nodes.length} nodes`);
+        result = { nodes };
+        break;
+      }
+
+      default:
+        console.log(`[bridge] Unhandled: ${method} (returning empty success)`);
+        result = {};
+    }
+
+    console.log(`[bridge] → ${method} OK`);
+    return { type: 'success', id, result };
+
+  } catch (err) {
+    console.error(`[bridge] ✗ ${method}: ${err.message || JSON.stringify(err)}`);
+    return { type: 'error', id, error: err.error || 'unknown', message: err.message || 'error' };
+  }
+}
+
+// ─── Server ──────────────────────────────────────────
+async function start() {
+  await initCDP();
+  const wss = new WebSocket.Server({ port: LISTEN_PORT });
+  wss.on('connection', (ws, req) => {
+    console.log(`[bridge] Client: ${req.url}`);
+    bidiWs = ws;  // Store for event forwarding
+    ws.on('message', async (data) => {
+      let msg;
+      try { msg = JSON.parse(data.toString()); }
+      catch { ws.send(JSON.stringify({ type: 'error', id: null, error: 'bad json' })); return; }
+      const resp = await handleBiDi(msg);
+      ws.send(JSON.stringify(resp));
+    });
+    ws.on('close', () => { console.log('[bridge] Client gone'); bidiWs = null; });
+    ws.on('error', (e) => console.error('[bridge] WS:', e.message));
+  });
+  console.log(`[bridge] Listening ws://127.0.0.1:${LISTEN_PORT}`);
+  console.log(`[bridge] export VIBIUM_CONNECT_URL=ws://127.0.0.1:${LISTEN_PORT}/session`);
+}
+
+start().catch(e => { console.error('[bridge] Fatal:', e.message); process.exit(1); });