apex-auditor 0.3.0 → 0.3.3

package/dist/cdp-client.js

@@ -0,0 +1,264 @@
+import WebSocket from "ws";
+function isWebSocketMessageEvent(event) {
+    if (!event || typeof event !== "object") {
+        return false;
+    }
+    return "data" in event;
+}
+function createWebSocket(url) {
+    const ws = new WebSocket(url);
+    const handlers = new Map();
+    const mapType = (type) => {
+        return type;
+    };
+    const ensureMap = (type) => {
+        const existing = handlers.get(type);
+        if (existing) {
+            return existing;
+        }
+        const created = new Map();
+        handlers.set(type, created);
+        return created;
+    };
+    return {
+        addEventListener: (type, listener) => {
+            const t = mapType(type);
+            const byListener = ensureMap(t);
+            if (byListener.has(listener)) {
+                return;
+            }
+            const wrapped = (...args) => {
+                if (t === "message") {
+                    const data = args[0];
+                    const text = typeof data === "string" ? data : Buffer.isBuffer(data) ? data.toString("utf8") : "";
+                    listener({ data: text });
+                    return;
+                }
+                listener(undefined);
+            };
+            byListener.set(listener, wrapped);
+            ws.on(t, wrapped);
+        },
+        removeEventListener: (type, listener) => {
+            const t = mapType(type);
+            const byListener = handlers.get(t);
+            if (!byListener) {
+                return;
+            }
+            const wrapped = byListener.get(listener);
+            if (!wrapped) {
+                return;
+            }
+            byListener.delete(listener);
+            ws.off(t, wrapped);
+        },
+        send: (data) => {
+            ws.send(data);
+        },
+        close: () => {
+            ws.close();
+        },
+    };
+}
+export class CdpClient {
+    url;
+    socket;
+    nextId;
+    pending;
+    listeners;
+    /**
+     * @param url - WebSocket URL for the Chrome DevTools Protocol endpoint.
+     */
+    constructor(url) {
+        this.url = url;
+        this.socket = undefined;
+        this.nextId = 1;
+        this.pending = new Map();
+        this.listeners = new Map();
+    }
+    /**
+     * Connect to the CDP websocket.
+     */
+    async connect() {
+        if (this.socket) {
+            return;
+        }
+        const socket = createWebSocket(this.url);
+        this.socket = socket;
+        await new Promise((resolve, reject) => {
+            const onOpen = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = () => {
+                cleanup();
+                reject(new Error("CDP WebSocket connection failed"));
+            };
+            const cleanup = () => {
+                socket.removeEventListener("open", onOpen);
+                socket.removeEventListener("error", onError);
+            };
+            socket.addEventListener("open", onOpen);
+            socket.addEventListener("error", onError);
+        });
+        socket.addEventListener("message", (event) => {
+            if (!isWebSocketMessageEvent(event)) {
+                return;
+            }
+            this.handleMessage(typeof event.data === "string" ? event.data : "");
+        });
+        socket.addEventListener("close", () => {
+            this.handleClose();
+        });
+    }
+    /**
+     * Close the CDP websocket.
+     */
+    close() {
+        if (!this.socket) {
+            return;
+        }
+        this.socket.close();
+        this.socket = undefined;
+        this.handleClose();
+    }
+    /**
+     * Subscribe to a CDP event.
+     *
+     * @param method - CDP event name, e.g. "Page.loadEventFired".
+     * @param listener - Event handler.
+     */
+    on(method, listener) {
+        const set = this.listeners.get(method) ?? new Set();
+        const entry = { listener: (params) => listener(params) };
+        set.add(entry);
+        this.listeners.set(method, set);
+        return () => {
+            const current = this.listeners.get(method);
+            current?.delete(entry);
+        };
+    }
+    /**
+     * Subscribe to a CDP event, optionally filtering by sessionId.
+     *
+     * @param method - CDP event name.
+     * @param sessionId - Optional sessionId to filter events.
+     * @param listener - Event handler.
+     */
+    onEvent(method, sessionId, listener) {
+        const set = this.listeners.get(method) ?? new Set();
+        const entry = { sessionId, listener: (params, eventSessionId) => {
+                if (sessionId !== undefined && eventSessionId !== sessionId) {
+                    return;
+                }
+                listener(params);
+            } };
+        set.add(entry);
+        this.listeners.set(method, set);
+        return () => {
+            const current = this.listeners.get(method);
+            current?.delete(entry);
+        };
+    }
+    /**
+     * Send a CDP command and await its result.
+     *
+     * @param method - CDP method name.
+     * @param params - CDP params object.
+     * @param sessionId - Optional sessionId when using Target.attachToTarget with flatten.
+     */
+    async send(method, params = {}, sessionId) {
+        const socket = this.socket;
+        if (!socket) {
+            throw new Error("CDP client is not connected");
+        }
+        const id = this.nextId;
+        this.nextId += 1;
+        const message = sessionId ? { id, method, params, sessionId } : { id, method, params };
+        const payload = JSON.stringify(message);
+        const result = await new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            socket.send(payload);
+        });
+        return result;
+    }
+    /**
+     * Wait for a CDP event once.
+     *
+     * @param method - CDP event name.
+     * @param timeoutMs - Timeout in milliseconds.
+     */
+    waitForEvent(method, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                off();
+                reject(new Error(`Timed out waiting for CDP event: ${method}`));
+            }, timeoutMs);
+            const off = this.on(method, (params) => {
+                clearTimeout(timer);
+                off();
+                resolve(params);
+            });
+        });
+    }
+    /**
+     * Wait for a CDP event once for a specific session.
+     *
+     * @param method - CDP event name.
+     * @param sessionId - Target sessionId.
+     * @param timeoutMs - Timeout in milliseconds.
+     */
+    waitForEventForSession(method, sessionId, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                off();
+                reject(new Error(`Timed out waiting for CDP event: ${method}`));
+            }, timeoutMs);
+            const off = this.onEvent(method, sessionId, (params) => {
+                clearTimeout(timer);
+                off();
+                resolve(params);
+            });
+        });
+    }
+    handleClose() {
+        for (const entry of this.pending.values()) {
+            entry.reject(new Error("CDP connection closed"));
+        }
+        this.pending.clear();
+    }
+    handleMessage(raw) {
+        if (raw.length === 0) {
+            return;
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return;
+        }
+        const record = parsed;
+        if (typeof record.id === "number") {
+            const pending = this.pending.get(record.id);
+            if (!pending) {
+                return;
+            }
+            this.pending.delete(record.id);
+            if (record.error && typeof record.error === "object") {
+                const message = record.error.message;
+                pending.reject(new Error(message || "CDP error"));
+                return;
+            }
+            pending.resolve(record.result);
+            return;
+        }
+        if (typeof record.method === "string") {
+            const listeners = this.listeners.get(record.method);
+            if (!listeners) {
+                return;
+            }
+            const sessionId = typeof record.sessionId === "string" ? record.sessionId : undefined;
+            for (const listener of listeners) {
+                listener.listener(record.params, sessionId);
+            }
+        }
+    }
+}