@bewa/cdp-cli 0.1.0

package/lib/ws.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const { createConnection } = require('node:net');
+const { randomBytes } = require('node:crypto');
+
+/**
+ * Minimal WebSocket client for CDP. No dependencies.
+ * Only supports text frames (sufficient for CDP JSON protocol).
+ */
+class MinimalWebSocket {
+  constructor(url) {
+    this._url = new URL(url);
+    this._socket = null;
+    this._onMessage = null;
+    this._buffer = Buffer.alloc(0);
+    this._connected = false;
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      const port = this._url.port || 80;
+      const host = this._url.hostname;
+      const path = this._url.pathname + this._url.search;
+
+      this._socket = createConnection({ host, port }, () => {
+        const key = randomBytes(16).toString('base64');
+        const req = [
+          `GET ${path} HTTP/1.1`,
+          `Host: ${host}:${port}`,
+          `Upgrade: websocket`,
+          `Connection: Upgrade`,
+          `Sec-WebSocket-Key: ${key}`,
+          `Sec-WebSocket-Version: 13`,
+          ``,
+          ``,
+        ].join('\r\n');
+        this._socket.write(req);
+      });
+
+      this._socket.on('error', reject);
+
+      let handshakeDone = false;
+      this._socket.on('data', chunk => {
+        this._buffer = Buffer.concat([this._buffer, chunk]);
+
+        if (!handshakeDone) {
+          const idx = this._buffer.indexOf('\r\n\r\n');
+          if (idx === -1) return;
+          const header = this._buffer.subarray(0, idx).toString();
+          if (!header.includes('101')) {
+            reject(new Error('WebSocket handshake failed: ' + header.split('\r\n')[0]));
+            return;
+          }
+          this._buffer = this._buffer.subarray(idx + 4);
+          handshakeDone = true;
+          this._connected = true;
+          resolve();
+        }
+
+        this._processFrames();
+      });
+
+      this._socket.on('close', () => { this._connected = false; });
+    });
+  }
+
+  _processFrames() {
+    while (this._buffer.length >= 2) {
+      const secondByte = this._buffer[1];
+      const masked = (secondByte & 0x80) !== 0;
+      let payloadLen = secondByte & 0x7f;
+      let offset = 2;
+
+      if (payloadLen === 126) {
+        if (this._buffer.length < 4) return;
+        payloadLen = this._buffer.readUInt16BE(2);
+        offset = 4;
+      } else if (payloadLen === 127) {
+        if (this._buffer.length < 10) return;
+        payloadLen = Number(this._buffer.readBigUInt64BE(2));
+        offset = 10;
+      }
+
+      if (masked) offset += 4; // skip mask key (server shouldn't mask, but handle it)
+      if (this._buffer.length < offset + payloadLen) return;
+
+      const opcode = this._buffer[0] & 0x0f;
+      let payload = this._buffer.subarray(offset, offset + payloadLen);
+
+      if (masked) {
+        const maskKey = this._buffer.subarray(offset - 4, offset);
+        payload = Buffer.from(payload);
+        for (let i = 0; i < payload.length; i++) {
+          payload[i] ^= maskKey[i % 4];
+        }
+      }
+
+      this._buffer = this._buffer.subarray(offset + payloadLen);
+
+      if (opcode === 0x01 && this._onMessage) {
+        // Text frame
+        this._onMessage(payload.toString('utf-8'));
+      } else if (opcode === 0x08) {
+        // Close frame
+        this.close();
+        return;
+      } else if (opcode === 0x09) {
+        // Ping — respond with pong
+        this._sendFrame(0x0a, payload);
+      }
+    }
+  }
+
+  send(data) {
+    const payload = Buffer.from(data, 'utf-8');
+    this._sendFrame(0x01, payload, true);
+  }
+
+  _sendFrame(opcode, payload, mask = false) {
+    if (!this._socket || !this._connected) return;
+
+    const len = payload.length;
+    let header;
+
+    if (len < 126) {
+      header = Buffer.alloc(2);
+      header[0] = 0x80 | opcode; // FIN + opcode
+      header[1] = (mask ? 0x80 : 0) | len;
+    } else if (len < 65536) {
+      header = Buffer.alloc(4);
+      header[0] = 0x80 | opcode;
+      header[1] = (mask ? 0x80 : 0) | 126;
+      header.writeUInt16BE(len, 2);
+    } else {
+      header = Buffer.alloc(10);
+      header[0] = 0x80 | opcode;
+      header[1] = (mask ? 0x80 : 0) | 127;
+      header.writeBigUInt64BE(BigInt(len), 2);
+    }
+
+    if (mask) {
+      const maskKey = randomBytes(4);
+      const masked = Buffer.from(payload);
+      for (let i = 0; i < masked.length; i++) {
+        masked[i] ^= maskKey[i % 4];
+      }
+      this._socket.write(Buffer.concat([header, maskKey, masked]));
+    } else {
+      this._socket.write(Buffer.concat([header, payload]));
+    }
+  }
+
+  onMessage(fn) {
+    this._onMessage = fn;
+  }
+
+  close() {
+    if (this._socket) {
+      try { this._sendFrame(0x08, Buffer.alloc(0), true); } catch {}
+      this._socket.destroy();
+      this._connected = false;
+    }
+  }
+}
+
+module.exports = { MinimalWebSocket };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@bewa/cdp-cli",
+  "version": "0.1.0",
+  "description": "Browser DevTools bridge for AI coding assistants",
+  "license": "Apache-2.0",
+  "bin": {
+    "cdp-cli": "./bin/cdp-cli.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "AGENT.md"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "test:watch": "node --test --watch test/*.test.js",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "chrome",
+    "devtools",
+    "cdp",
+    "debugging",
+    "ai",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bewa/cdp-cli.git"
+  }
+}