@silbercue/chrome 0.2.0

package/build/cdp/cdp-client.js

@@ -0,0 +1,146 @@
+export class CdpClient {
+    transport;
+    _nextId = 1;
+    _pending = new Map();
+    _listeners = new Map();
+    _onceListeners = new Map();
+    _timeoutMs;
+    _closed = false;
+    _onCloseCallback = null;
+    constructor(transport, options) {
+        this.transport = transport;
+        this._timeoutMs = options?.timeoutMs ?? 30_000;
+        this.transport.onMessage((raw) => this._dispatch(raw));
+        this.transport.onError((err) => {
+            this._rejectAll(new Error(`Transport error: ${err.message}`));
+        });
+        this.transport.onClose(() => {
+            this._closed = true;
+            this._rejectAll(new Error("Transport closed unexpectedly"));
+            this._onCloseCallback?.();
+        });
+    }
+    send(method, params, sessionId) {
+        if (this._closed) {
+            return Promise.reject(new Error("CdpClient is closed"));
+        }
+        if (!this.transport.connected) {
+            return Promise.reject(new Error("Transport is not connected"));
+        }
+        const id = this._nextId++;
+        const message = { id, method };
+        if (params !== undefined)
+            message.params = params;
+        if (sessionId !== undefined)
+            message.sessionId = sessionId;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this._pending.delete(id);
+                reject(new Error(`CDP call "${method}" timed out after ${this._timeoutMs}ms`));
+            }, this._timeoutMs);
+            this._pending.set(id, {
+                resolve: resolve,
+                reject,
+                timer,
+            });
+            // send() returning false means backpressure, not failure —
+            // data is still queued. Actual errors come via onError/onClose.
+            this.transport.send(JSON.stringify(message));
+        });
+    }
+    on(method, callback, sessionId) {
+        let set = this._listeners.get(method);
+        if (!set) {
+            set = new Set();
+            this._listeners.set(method, set);
+        }
+        set.add({ callback, sessionId });
+    }
+    once(method, callback, sessionId) {
+        let set = this._onceListeners.get(method);
+        if (!set) {
+            set = new Set();
+            this._onceListeners.set(method, set);
+        }
+        set.add({ callback, sessionId });
+    }
+    off(method, callback) {
+        for (const map of [this._listeners, this._onceListeners]) {
+            const set = map.get(method);
+            if (set) {
+                for (const entry of set) {
+                    if (entry.callback === callback) {
+                        set.delete(entry);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    onClose(callback) {
+        this._onCloseCallback = callback;
+    }
+    async close() {
+        this._closed = true;
+        this._rejectAll(new Error("CdpClient closed"));
+        await this.transport.close();
+    }
+    _dispatch(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if ("id" in msg && typeof msg.id === "number") {
+            // Response
+            const pending = this._pending.get(msg.id);
+            if (!pending)
+                return;
+            this._pending.delete(msg.id);
+            clearTimeout(pending.timer);
+            if (msg.error) {
+                const cdpErr = msg.error;
+                pending.reject(new Error(`CDP error ${cdpErr.code}: ${cdpErr.message}`));
+            }
+            else {
+                pending.resolve(msg.result);
+            }
+        }
+        else if ("method" in msg && typeof msg.method === "string") {
+            // Event
+            const eventMethod = msg.method;
+            const params = msg.params;
+            const sessionId = msg.sessionId;
+            const listeners = this._listeners.get(eventMethod);
+            if (listeners) {
+                for (const entry of listeners) {
+                    if (entry.sessionId === undefined || entry.sessionId === sessionId) {
+                        entry.callback(params, sessionId);
+                    }
+                }
+            }
+            const onceListeners = this._onceListeners.get(eventMethod);
+            if (onceListeners) {
+                const toRemove = [];
+                for (const entry of onceListeners) {
+                    if (entry.sessionId === undefined || entry.sessionId === sessionId) {
+                        entry.callback(params, sessionId);
+                        toRemove.push(entry);
+                    }
+                }
+                for (const entry of toRemove) {
+                    onceListeners.delete(entry);
+                }
+            }
+        }
+    }
+    _rejectAll(error) {
+        for (const [id, pending] of this._pending) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+            this._pending.delete(id);
+        }
+    }
+}

package/build/cdp/chrome-launcher.d.ts

@@ -0,0 +1,85 @@
+import { type ChildProcess } from "node:child_process";
+import { CdpClient } from "./cdp-client.js";
+import type { CdpTransport } from "../transport/transport.js";
+import { PipeTransport } from "../transport/pipe-transport.js";
+import type { ConnectionStatus, TransportType } from "../types.js";
+export interface ChromeConnectionOptions {
+    /** Port for WebSocket discovery (default: 9222) */
+    port?: number;
+    /** Auto-launch Chrome if no running instance found (default: true) */
+    autoLaunch?: boolean;
+    /** Launch Chrome in headless mode (default: false — browser is visible by default) */
+    headless?: boolean;
+    /** Pfad zu einem echten Chrome-Profil (user-data-dir). Opt-in: nur gesetzt = aktiv. */
+    profilePath?: string;
+}
+export interface LaunchOptions {
+    headless?: boolean;
+    /** Wenn gesetzt: Chrome nutzt dieses Verzeichnis als user-data-dir statt eines Temp-Verzeichnisses */
+    profilePath?: string;
+}
+interface LaunchResult {
+    cdpClient: CdpClient;
+    transport: PipeTransport;
+    process: ChildProcess;
+    transportType: "pipe";
+}
+/**
+ * Resolve the autoLaunch setting from environment variables.
+ * Pure function — no side effects, fully testable.
+ *
+ * - SILBERCUE_CHROME_AUTO_LAUNCH=true  → always auto-launch
+ * - SILBERCUE_CHROME_AUTO_LAUNCH=false → never auto-launch
+ * - unset → default: auto-launch (zero-config UX for new users)
+ *
+ * The `_headless` parameter is kept for backwards-compat with call-sites,
+ * but no longer influences the default — auto-launch is the standard path.
+ */
+export declare function resolveAutoLaunch(env: Record<string, string | undefined>, _headless: boolean): boolean;
+export declare function findChromePath(): string | null;
+export declare function launchChrome(options?: LaunchOptions): Promise<LaunchResult>;
+export declare class ChromeConnection {
+    readonly transportType: TransportType;
+    status: ConnectionStatus;
+    private _exitHandler;
+    private _closed;
+    private _cdpClient;
+    private _transport;
+    private _childProcess;
+    private _tmpDir;
+    private _reconnecting;
+    private _onReconnect;
+    private readonly _headless;
+    private readonly _port;
+    private readonly _profilePath;
+    constructor(cdpClient: CdpClient, transport: CdpTransport, transportType: TransportType, childProcess: ChildProcess | undefined, tmpDir: string | undefined, _launcher?: ChromeLauncher, port?: number, headless?: boolean, profilePath?: string);
+    get cdpClient(): CdpClient;
+    get transport(): CdpTransport;
+    get childProcess(): ChildProcess | undefined;
+    get headless(): boolean;
+    /** Register a callback to be invoked after successful reconnect for re-wiring */
+    onReconnect(callback: (connection: ChromeConnection) => Promise<void>): void;
+    /**
+     * Attempt to reconnect to Chrome with exponential backoff.
+     * BUG-004 fix: No race window (_reconnecting stays true during entire loop),
+     * failed transports are cleaned up, and onReconnect errors don't short-circuit.
+     * Returns true if reconnect succeeded, false otherwise.
+     */
+    reconnect(): Promise<boolean>;
+    close(): Promise<void>;
+    /** Register onClose callback on a CdpClient to trigger reconnect on unexpected disconnect.
+     *  BUG-004 fix: fired-flag prevents handler accumulation across reconnect attempts. */
+    private _setupOnClose;
+    /** Setup child process exit handler and global exit cleanup */
+    private _setupChildProcessHandlers;
+}
+export declare class ChromeLauncher {
+    private readonly _port;
+    private readonly _autoLaunch;
+    private readonly _headless;
+    private readonly _profilePath;
+    constructor(options?: ChromeConnectionOptions);
+    connect(): Promise<ChromeConnection>;
+    private _connectViaWebSocket;
+}
+export {};