@mefistofelix/cdp.js 0.1.2 → 0.2.0

package/cdp_ext/cdp_ext.js

@@ -0,0 +1,263 @@
+const config = chrome.runtime.getManifest().cdp ?? {}
+const sessions = {}
+const attached = {}
+const attaching = {}
+let socket
+let disconnecting
+let discovering = false
+let auto_attach = {}
+
+function send(message) {
+  if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(message))
+}
+
+function target_info(tab) {
+  return {
+    targetId: String(tab.id),
+    type: 'page',
+    title: tab.title ?? '',
+    url: tab.url ?? tab.pendingUrl ?? '',
+    attached: !!attached[tab.id],
+    incognito: tab.incognito,
+  }
+}
+
+function detached(source) {
+  if (!attached[source.tabId]) return
+  delete attached[source.tabId]
+  for (const [id, session] of Object.entries(sessions)) {
+    if (session.tabId === source.tabId) delete sessions[id]
+  }
+  send({
+    method: 'Target.detachedFromTarget',
+    params: {
+      sessionId: String(source.tabId),
+      targetId: String(source.tabId),
+    },
+  })
+}
+
+async function attach_tab(tabId) {
+  const source = { tabId }
+  await chrome.debugger.attach(source, '1.3')
+  if (socket.readyState !== WebSocket.OPEN) {
+    await chrome.debugger.detach(source)
+    throw new Error('Reverse connection closed during attachment')
+  }
+  const sessionId = String(tabId)
+  sessions[sessionId] = source
+  attached[tabId] = true
+  await chrome.debugger.sendCommand(source, 'Target.setAutoAttach', auto_attach)
+  send({
+    method: 'Target.attachedToTarget',
+    params: {
+      sessionId,
+      targetInfo: target_info(await chrome.tabs.get(tabId)),
+      waitingForDebugger: false,
+    },
+  })
+  return { sessionId }
+}
+
+const methods = {
+  'Browser.getVersion'() {
+    return {
+      protocolVersion: '1.3',
+      product: navigator.userAgent.match(/Chrome\/[^ ]+/)?.[0] ?? 'Chrome',
+      userAgent: navigator.userAgent,
+      revision: '',
+      jsVersion: '',
+    }
+  },
+  async 'Target.getTargets'() {
+    return { targetInfos: (await chrome.tabs.query({})).map(target_info) }
+  },
+  async 'Target.getTargetInfo'(params) {
+    return { targetInfo: target_info(await chrome.tabs.get(Number(params.targetId))) }
+  },
+  async 'Target.setDiscoverTargets'(params) {
+    discovering = params.discover
+    if (discovering) {
+      for (const tab of await chrome.tabs.query({})) {
+        send({
+          method: 'Target.targetCreated',
+          params: { targetInfo: target_info(tab) },
+        })
+      }
+    }
+  },
+  'Target.setAutoAttach'(params) {
+    if (params.waitForDebuggerOnStart) throw new Error('Pausing new browser tabs is unavailable through chrome.debugger')
+    auto_attach = params
+  },
+  async 'Target.createTarget'(params) {
+    if (Object.keys(params).some(key => !['url', 'background', 'incognito'].includes(key))) {
+      throw new Error('Reverse Target.createTarget supports only url, background and incognito')
+    }
+    const options = {
+      url: params.url ?? 'about:blank',
+      active: params.background !== true,
+    }
+    let tab
+    if (params.incognito) {
+      if (!await chrome.extension.isAllowedIncognitoAccess()) {
+        throw new Error('Enable Allow in incognito for cdp_ext in chrome://extensions')
+      }
+      const window = (await chrome.windows.getAll()).find(window => window.incognito)
+      if (window) tab = await chrome.tabs.create({
+        ...options,
+        windowId: window.id,
+      })
+      else tab = (await chrome.windows.create({
+        incognito: true,
+        url: options.url,
+        focused: options.active,
+      })).tabs[0]
+    } else tab = await chrome.tabs.create(options)
+    return { targetId: String(tab.id) }
+  },
+  async 'Target.attachToTarget'(params) {
+    const tabId = Number(params.targetId)
+    if (attaching[tabId]) return attaching[tabId]
+    if (attached[tabId]) return { sessionId: String(tabId) }
+    return attaching[tabId] = attach_tab(tabId).finally(() => delete attaching[tabId])
+  },
+  async 'Target.detachFromTarget'(params) {
+    const source = sessions[params.sessionId]
+    if (!source) throw new Error('Unknown debugger session')
+    if (source.sessionId) {
+      await chrome.debugger.sendCommand({ tabId: source.tabId }, 'Target.detachFromTarget', { sessionId: source.sessionId })
+    } else {
+      await chrome.debugger.detach(source)
+      detached(source)
+    }
+  },
+  async 'Target.closeTarget'(params) {
+    await chrome.tabs.remove(Number(params.targetId))
+    return { success: true }
+  },
+  async 'Target.activateTarget'(params) {
+    const tab = await chrome.tabs.update(Number(params.targetId), { active: true })
+    await chrome.windows.update(tab.windowId, { focused: true })
+  },
+}
+
+chrome.debugger.onEvent.addListener((source, method, params) => {
+  if (!attached[source.tabId]) return
+  if (method === 'Target.attachedToTarget' || method === 'Target.detachedFromTarget') {
+    if (method === 'Target.attachedToTarget') sessions[params.sessionId] = {
+      tabId: source.tabId,
+      sessionId: params.sessionId,
+    }
+    else delete sessions[params.sessionId]
+  }
+  send({
+    method,
+    params,
+    sessionId: source.sessionId ?? String(source.tabId),
+  })
+})
+chrome.debugger.onDetach.addListener(detached)
+chrome.tabs.onCreated.addListener(tab => {
+  if (discovering) send({
+    method: 'Target.targetCreated',
+    params: { targetInfo: target_info(tab) },
+  })
+})
+chrome.tabs.onUpdated.addListener((id, changes, tab) => {
+  if (discovering) send({
+    method: 'Target.targetInfoChanged',
+    params: { targetInfo: target_info(tab) },
+  })
+})
+chrome.tabs.onRemoved.addListener(id => {
+  if (discovering) send({
+    method: 'Target.targetDestroyed',
+    params: { targetId: String(id) },
+  })
+})
+
+for (const [name, options] of Object.entries({
+  onBeforeRequest: [],
+  onBeforeSendHeaders: ['requestHeaders'],
+  onSendHeaders: ['requestHeaders'],
+  onHeadersReceived: ['responseHeaders'],
+  onAuthRequired: ['responseHeaders'],
+  onResponseStarted: ['responseHeaders'],
+  onBeforeRedirect: ['responseHeaders'],
+  onCompleted: ['responseHeaders'],
+  onErrorOccurred: [],
+})) {
+  chrome.webRequest[name].addListener(params => send({
+    method: 'chrome.webRequest.' + name,
+    params,
+    sessionId: params.tabId >= 0 ? String(params.tabId) : undefined,
+  }), { urls: ['<all_urls>'] }, options)
+}
+
+function connect() {
+  if (disconnecting) return
+  if (socket?.readyState === WebSocket.CONNECTING) return
+  if (socket?.readyState === WebSocket.OPEN) return socket.send('')
+  const connection = socket = new WebSocket(config.websocket_url ?? 'ws://127.0.0.1:9223')
+  connection.onopen = () => connection.send(JSON.stringify({ browser: chrome.runtime.id }))
+  connection.onmessage = async event => {
+    if (!event.data) return
+    const request = JSON.parse(event.data)
+    const { method, params = {}, sessionId, id } = request
+    let response
+    try {
+      let result
+      if (method.startsWith('chrome.')) {
+        const names = method.split('.').slice(1)
+        const name = names.pop()
+        const object = names.reduce((object, name) => object[name], chrome)
+        const args = params.args ?? []
+        if (method === 'chrome.scripting.executeScript' && typeof args[0]?.func === 'string') {
+          const injection = args[0]
+          injection.args = [injection.func, ...(injection.args ?? [])]
+          injection.func = (source, ...args) => (0, eval)('(' + source + ')')(...args)
+        }
+        result = params.callback
+          ? await new Promise((resolve, reject) => object[name](...args, value => {
+            const error = chrome.runtime.lastError
+            if (error) reject(new Error(error.message))
+            else resolve(value)
+          }))
+          : await object[name](...args)
+      } else {
+        if (sessionId == null && !methods[method]) throw new Error('Unsupported reverse browser command: ' + method)
+        result = sessionId != null
+          ? await chrome.debugger.sendCommand(sessions[sessionId], method, params)
+          : await methods[method](params)
+      }
+      response = {
+        id,
+        result: result === undefined ? {} : result,
+      }
+    } catch (error) {
+      response = {
+        id,
+        error: {
+          code: -32000,
+          message: error.message,
+        },
+      }
+    }
+    if (id != null && connection.readyState === WebSocket.OPEN) connection.send(JSON.stringify(response))
+  }
+  connection.onclose = () => {
+    discovering = false
+    disconnecting = Promise.all(Object.keys(attached).map(id => {
+      const source = { tabId: Number(id) }
+      detached(source)
+      return chrome.debugger.detach(source).catch(() => {})
+    })).finally(() => disconnecting = null)
+  }
+}
+
+chrome.runtime.onStartup.addListener(connect)
+chrome.alarms.onAlarm.addListener(connect)
+chrome.alarms.create('cdp-reconnect', { periodInMinutes: 0.5 })
+setInterval(connect, config.reconnect_ms ?? 5000)
+connect()

package/cdp_ext/manifest.json

@@ -0,0 +1,76 @@
+{
+  "manifest_version": 3,
+  "name": "CDP reverse connection",
+  "version": "0.2.0",
+  "minimum_chrome_version": "125",
+  "permissions": [
+    "accessibilityFeatures.read",
+    "accessibilityFeatures.modify",
+    "alarms",
+    "bookmarks",
+    "browsingData",
+    "clipboardRead",
+    "clipboardWrite",
+    "contentSettings",
+    "contextMenus",
+    "cookies",
+    "debugger",
+    "declarativeContent",
+    "declarativeNetRequest",
+    "declarativeNetRequestFeedback",
+    "desktopCapture",
+    "downloads",
+    "downloads.open",
+    "downloads.ui",
+    "favicon",
+    "fontSettings",
+    "gcm",
+    "geolocation",
+    "history",
+    "identity",
+    "identity.email",
+    "idle",
+    "management",
+    "nativeMessaging",
+    "notifications",
+    "offscreen",
+    "pageCapture",
+    "power",
+    "privacy",
+    "proxy",
+    "readingList",
+    "scripting",
+    "search",
+    "sessions",
+    "sidePanel",
+    "storage",
+    "system.cpu",
+    "system.display",
+    "system.memory",
+    "system.storage",
+    "tabCapture",
+    "tabGroups",
+    "tabs",
+    "topSites",
+    "tts",
+    "ttsEngine",
+    "unlimitedStorage",
+    "userScripts",
+    "webAuthenticationProxy",
+    "webNavigation",
+    "webRequest",
+    "webRequestAuthProvider"
+  ],
+  "host_permissions": [
+    "<all_urls>"
+  ],
+  "action": {},
+  "incognito": "spanning",
+  "background": {
+    "service_worker": "cdp_ext.js"
+  },
+  "cdp": {
+    "websocket_url": "ws://127.0.0.1:9223",
+    "reconnect_ms": 5000
+  }
+}

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@mefistofelix/cdp.js",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Low-level Chromium DevTools Protocol client for Node.js, with no runtime dependencies.",
   "type": "module",
   "exports": "./cdp.js",
   "files": [
-    "cdp.js"
+    "cdp.js",
+    "cdp_ext/manifest.json",
+    "cdp_ext/cdp_ext.js"
   ],
   "engines": {
     "node": ">=22.19.0"