@skillful-agents/agent-computer 0.0.4 → 0.0.6

package/dist-cjs/src/cdp/connection.js

@@ -0,0 +1,285 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDPConnection = void 0;
+const http = __importStar(require("http"));
+const crypto = __importStar(require("crypto"));
+class CDPConnection {
+    socket = null;
+    nextId = 1;
+    pending = new Map();
+    eventHandlers = new Map();
+    buffer = Buffer.alloc(0);
+    _url = '';
+    commandTimeout;
+    constructor(options = {}) {
+        this.commandTimeout = options.timeout ?? 10000;
+    }
+    get url() { return this._url; }
+    get connected() { return this.socket !== null && !this.socket.destroyed; }
+    async connect(wsUrl) {
+        this._url = wsUrl;
+        const url = new URL(wsUrl);
+        const key = crypto.randomBytes(16).toString('base64');
+        return new Promise((resolve, reject) => {
+            const req = http.get({
+                hostname: url.hostname,
+                port: url.port || 80,
+                path: url.pathname + url.search,
+                headers: {
+                    'Connection': 'Upgrade',
+                    'Upgrade': 'websocket',
+                    'Sec-WebSocket-Key': key,
+                    'Sec-WebSocket-Version': '13',
+                },
+            });
+            const timeout = setTimeout(() => {
+                req.destroy();
+                reject(new Error('WebSocket connection timed out'));
+            }, 5000);
+            req.on('upgrade', (_res, socket, head) => {
+                clearTimeout(timeout);
+                this.socket = socket;
+                this.buffer = Buffer.alloc(0);
+                if (head.length > 0) {
+                    this.buffer = Buffer.concat([this.buffer, head]);
+                }
+                this.setupSocketHandlers();
+                resolve();
+            });
+            req.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`WebSocket connection failed: ${err.message}`));
+            });
+            req.on('response', (res) => {
+                clearTimeout(timeout);
+                reject(new Error(`WebSocket upgrade failed with status ${res.statusCode}`));
+            });
+        });
+    }
+    async send(method, params) {
+        if (!this.socket || this.socket.destroyed) {
+            throw new Error('CDP connection not open');
+        }
+        const id = this.nextId++;
+        const message = JSON.stringify({ id, method, params: params ?? {} });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`CDP command "${method}" timed out after ${this.commandTimeout}ms`));
+            }, this.commandTimeout);
+            this.pending.set(id, { resolve, reject, timer });
+            this.writeFrame(message);
+        });
+    }
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(handler);
+    }
+    off(event, handler) {
+        this.eventHandlers.get(event)?.delete(handler);
+    }
+    async close() {
+        if (!this.socket || this.socket.destroyed)
+            return;
+        // Send close frame
+        const frame = Buffer.alloc(6);
+        frame[0] = 0x88; // FIN + close opcode
+        frame[1] = 0x80; // Mask bit set, 0 payload length
+        crypto.randomBytes(4).copy(frame, 2); // Masking key
+        this.socket.write(frame);
+        // Reject pending
+        for (const [id, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(new Error('Connection closed'));
+            this.pending.delete(id);
+        }
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.socket?.destroy();
+                this.socket = null;
+                resolve();
+            }, 1000);
+            this.socket.once('close', () => {
+                clearTimeout(timer);
+                this.socket = null;
+                resolve();
+            });
+            this.socket.end();
+        });
+    }
+    setupSocketHandlers() {
+        if (!this.socket)
+            return;
+        this.socket.on('data', (chunk) => {
+            this.buffer = Buffer.concat([this.buffer, chunk]);
+            this.processFrames();
+        });
+        this.socket.on('close', () => {
+            for (const [id, p] of this.pending) {
+                clearTimeout(p.timer);
+                p.reject(new Error('Connection closed'));
+            }
+            this.pending.clear();
+            this.socket = null;
+        });
+        this.socket.on('error', () => {
+            // Handled by close event
+        });
+    }
+    processFrames() {
+        while (this.buffer.length >= 2) {
+            const firstByte = this.buffer[0];
+            const secondByte = this.buffer[1];
+            const opcode = firstByte & 0x0f;
+            const masked = (secondByte & 0x80) !== 0;
+            let payloadLength = secondByte & 0x7f;
+            let offset = 2;
+            if (payloadLength === 126) {
+                if (this.buffer.length < 4)
+                    return; // Need more data
+                payloadLength = this.buffer.readUInt16BE(2);
+                offset = 4;
+            }
+            else if (payloadLength === 127) {
+                if (this.buffer.length < 10)
+                    return;
+                // For simplicity, read as 32-bit (CDP messages won't exceed 4GB)
+                payloadLength = this.buffer.readUInt32BE(6);
+                offset = 10;
+            }
+            if (masked)
+                offset += 4; // Skip masking key (server shouldn't mask, but handle it)
+            if (this.buffer.length < offset + payloadLength)
+                return; // Need more data
+            let payload = this.buffer.subarray(offset, offset + payloadLength);
+            if (masked) {
+                const maskKey = this.buffer.subarray(offset - 4, offset);
+                payload = Buffer.from(payload); // Copy so we can mutate
+                for (let i = 0; i < payload.length; i++) {
+                    payload[i] ^= maskKey[i % 4];
+                }
+            }
+            this.buffer = this.buffer.subarray(offset + payloadLength);
+            if (opcode === 0x1) {
+                // Text frame
+                this.handleMessage(payload.toString('utf-8'));
+            }
+            else if (opcode === 0x8) {
+                // Close frame
+                this.socket?.end();
+            }
+            else if (opcode === 0x9) {
+                // Ping — respond with pong
+                this.writePong(payload);
+            }
+            // Ignore other opcodes (pong, binary, continuation)
+        }
+    }
+    handleMessage(text) {
+        try {
+            const msg = JSON.parse(text);
+            if (msg.id !== undefined && this.pending.has(msg.id)) {
+                const p = this.pending.get(msg.id);
+                this.pending.delete(msg.id);
+                clearTimeout(p.timer);
+                if (msg.error) {
+                    p.reject(new Error(`CDP error: ${msg.error.message}`));
+                }
+                else {
+                    p.resolve(msg.result);
+                }
+            }
+            else if (msg.method) {
+                // Event
+                const handlers = this.eventHandlers.get(msg.method);
+                if (handlers) {
+                    for (const handler of handlers) {
+                        handler(msg.params);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore malformed messages
+        }
+    }
+    writeFrame(text) {
+        if (!this.socket || this.socket.destroyed)
+            return;
+        const payload = Buffer.from(text, 'utf-8');
+        const maskKey = crypto.randomBytes(4);
+        let header;
+        if (payload.length < 126) {
+            header = Buffer.alloc(2);
+            header[0] = 0x81; // FIN + text opcode
+            header[1] = 0x80 | payload.length; // Masked
+        }
+        else if (payload.length < 65536) {
+            header = Buffer.alloc(4);
+            header[0] = 0x81;
+            header[1] = 0x80 | 126;
+            header.writeUInt16BE(payload.length, 2);
+        }
+        else {
+            header = Buffer.alloc(10);
+            header[0] = 0x81;
+            header[1] = 0x80 | 127;
+            header.writeBigUInt64BE(BigInt(payload.length), 2);
+        }
+        // Mask the payload
+        const masked = Buffer.alloc(payload.length);
+        for (let i = 0; i < payload.length; i++) {
+            masked[i] = payload[i] ^ maskKey[i % 4];
+        }
+        this.socket.write(Buffer.concat([header, maskKey, masked]));
+    }
+    writePong(payload) {
+        if (!this.socket || this.socket.destroyed)
+            return;
+        const maskKey = crypto.randomBytes(4);
+        const header = Buffer.alloc(2);
+        header[0] = 0x8a; // FIN + pong opcode
+        header[1] = 0x80 | payload.length;
+        const masked = Buffer.alloc(payload.length);
+        for (let i = 0; i < payload.length; i++) {
+            masked[i] = payload[i] ^ maskKey[i % 4];
+        }
+        this.socket.write(Buffer.concat([header, maskKey, masked]));
+    }
+}
+exports.CDPConnection = CDPConnection;

package/dist-cjs/src/cdp/diff.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeChanged = computeChanged;
+exports.computeDiff = computeDiff;
+/** Quick check if anything changed between two element arrays */
+function computeChanged(prev, curr) {
+    if (prev.length !== curr.length)
+        return true;
+    for (let i = 0; i < prev.length; i++) {
+        const p = prev[i];
+        const c = curr[i];
+        if (p.ref !== c.ref || p.role !== c.role || p.label !== c.label ||
+            p.value !== c.value || p.enabled !== c.enabled || p.focused !== c.focused) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Detailed diff between two element arrays */
+function computeDiff(prev, curr) {
+    const prevMap = new Map(prev.map(e => [e.ref, e]));
+    const currMap = new Map(curr.map(e => [e.ref, e]));
+    const added = [];
+    const removed = [];
+    const modified = [];
+    // Find added and modified
+    for (const [ref, el] of currMap) {
+        const prevEl = prevMap.get(ref);
+        if (!prevEl) {
+            added.push(el);
+        }
+        else {
+            const changes = {};
+            if (prevEl.label !== el.label)
+                changes.label = { from: prevEl.label, to: el.label };
+            if (prevEl.value !== el.value)
+                changes.value = { from: prevEl.value, to: el.value };
+            if (prevEl.enabled !== el.enabled)
+                changes.enabled = { from: prevEl.enabled, to: el.enabled };
+            if (prevEl.focused !== el.focused)
+                changes.focused = { from: prevEl.focused, to: el.focused };
+            if (Object.keys(changes).length > 0) {
+                modified.push({ ref, changes });
+            }
+        }
+    }
+    // Find removed
+    for (const [ref, el] of prevMap) {
+        if (!currMap.has(ref)) {
+            removed.push(el);
+        }
+    }
+    const changed = added.length > 0 || removed.length > 0 || modified.length > 0;
+    return { changed, added, removed, modified };
+}

package/dist-cjs/src/cdp/discovery.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverTargets = discoverTargets;
+exports.findPageTarget = findPageTarget;
+exports.waitForCDP = waitForCDP;
+const http = __importStar(require("http"));
+/** GET http://localhost:{port}/json/list — returns all CDP targets */
+async function discoverTargets(port) {
+    return new Promise((resolve, reject) => {
+        const req = http.get(`http://127.0.0.1:${port}/json/list`, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk.toString(); });
+            res.on('end', () => {
+                try {
+                    const targets = JSON.parse(data);
+                    resolve(targets);
+                }
+                catch (err) {
+                    reject(new Error(`Failed to parse CDP targets: ${err}`));
+                }
+            });
+        });
+        req.on('error', (err) => {
+            reject(new Error(`Failed to discover CDP targets on port ${port}: ${err.message}`));
+        });
+        req.setTimeout(5000, () => {
+            req.destroy();
+            reject(new Error(`CDP discovery timed out on port ${port}`));
+        });
+    });
+}
+/** Filter targets for type === 'page' and return first match */
+async function findPageTarget(port) {
+    const targets = await discoverTargets(port);
+    const page = targets.find(t => t.type === 'page');
+    if (!page) {
+        throw new Error(`No page target found on port ${port}. Found: ${targets.map(t => t.type).join(', ')}`);
+    }
+    return page;
+}
+/** Poll until a page target appears, with timeout */
+async function waitForCDP(port, timeout = 10000) {
+    const start = Date.now();
+    let lastError;
+    while (Date.now() - start < timeout) {
+        try {
+            return await findPageTarget(port);
+        }
+        catch (err) {
+            lastError = err;
+            await sleep(200);
+        }
+    }
+    throw new Error(`CDP not available on port ${port} after ${timeout}ms: ${lastError?.message}`);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist-cjs/src/cdp/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFreePort = exports.computeDiff = exports.computeChanged = exports.resolveAllBounds = exports.toScreenCoords = exports.getBounds = exports.INTERACTIVE_ROLES = exports.mapCDPRole = exports.CDPClient = exports.CDPInteractions = exports.CDPAXTree = exports.waitForCDP = exports.findPageTarget = exports.discoverTargets = exports.CDPConnection = void 0;
+var connection_js_1 = require("./connection.js");
+Object.defineProperty(exports, "CDPConnection", { enumerable: true, get: function () { return connection_js_1.CDPConnection; } });
+var discovery_js_1 = require("./discovery.js");
+Object.defineProperty(exports, "discoverTargets", { enumerable: true, get: function () { return discovery_js_1.discoverTargets; } });
+Object.defineProperty(exports, "findPageTarget", { enumerable: true, get: function () { return discovery_js_1.findPageTarget; } });
+Object.defineProperty(exports, "waitForCDP", { enumerable: true, get: function () { return discovery_js_1.waitForCDP; } });
+var ax_tree_js_1 = require("./ax-tree.js");
+Object.defineProperty(exports, "CDPAXTree", { enumerable: true, get: function () { return ax_tree_js_1.CDPAXTree; } });
+var interactions_js_1 = require("./interactions.js");
+Object.defineProperty(exports, "CDPInteractions", { enumerable: true, get: function () { return interactions_js_1.CDPInteractions; } });
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "CDPClient", { enumerable: true, get: function () { return client_js_1.CDPClient; } });
+var role_map_js_1 = require("./role-map.js");
+Object.defineProperty(exports, "mapCDPRole", { enumerable: true, get: function () { return role_map_js_1.mapCDPRole; } });
+Object.defineProperty(exports, "INTERACTIVE_ROLES", { enumerable: true, get: function () { return role_map_js_1.INTERACTIVE_ROLES; } });
+var bounds_js_1 = require("./bounds.js");
+Object.defineProperty(exports, "getBounds", { enumerable: true, get: function () { return bounds_js_1.getBounds; } });
+Object.defineProperty(exports, "toScreenCoords", { enumerable: true, get: function () { return bounds_js_1.toScreenCoords; } });
+Object.defineProperty(exports, "resolveAllBounds", { enumerable: true, get: function () { return bounds_js_1.resolveAllBounds; } });
+var diff_js_1 = require("./diff.js");
+Object.defineProperty(exports, "computeChanged", { enumerable: true, get: function () { return diff_js_1.computeChanged; } });
+Object.defineProperty(exports, "computeDiff", { enumerable: true, get: function () { return diff_js_1.computeDiff; } });
+var port_manager_js_1 = require("./port-manager.js");
+Object.defineProperty(exports, "findFreePort", { enumerable: true, get: function () { return port_manager_js_1.findFreePort; } });