extension-develop 3.17.0 → 3.18.0

package/dist/bridge.mjs

@@ -0,0 +1,228 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import { WebSocket } from "ws";
+import { CONTROL_WS_PATH } from "./45.mjs";
+import * as __rspack_external_fs from "fs";
+import * as __rspack_external_path from "path";
+function readReadyContract(projectPath, browser = 'chrome') {
+    const readyPath = __rspack_external_path.resolve(projectPath, 'dist', 'extension-js', browser, 'ready.json');
+    try {
+        const c = JSON.parse(__rspack_external_fs.readFileSync(readyPath, 'utf-8'));
+        if ('number' != typeof c.controlPort || !c.instanceId) return null;
+        return {
+            controlPort: c.controlPort,
+            instanceId: String(c.instanceId),
+            runId: String(c.runId || ''),
+            logsPath: c.logsPath,
+            status: c.status
+        };
+    } catch  {
+        return null;
+    }
+}
+class BridgeConsumer {
+    opts;
+    socket = null;
+    backoff = 250;
+    maxBackoff = 5000;
+    closed = false;
+    timer = null;
+    constructor(options){
+        this.opts = options;
+    }
+    start() {
+        this.closed = false;
+        this.connect();
+    }
+    close() {
+        this.closed = true;
+        if (this.timer) clearTimeout(this.timer);
+        try {
+            this.socket?.close();
+        } catch  {}
+        this.socket = null;
+    }
+    url() {
+        const host = this.opts.host ?? '127.0.0.1';
+        const p = this.opts.path ?? CONTROL_WS_PATH;
+        return `ws://${host}:${this.opts.controlPort}${p}`;
+    }
+    connect() {
+        if (this.closed) return;
+        let socket;
+        try {
+            socket = new WebSocket(this.url());
+        } catch  {
+            this.scheduleReconnect();
+            return;
+        }
+        this.socket = socket;
+        socket.on('open', ()=>{
+            this.backoff = 250;
+            try {
+                socket.send(JSON.stringify({
+                    type: 'hello',
+                    v: 1,
+                    role: 'consumer',
+                    instanceId: this.opts.instanceId
+                }));
+            } catch  {}
+        });
+        socket.on('message', (data)=>{
+            let frame;
+            try {
+                frame = JSON.parse(data.toString());
+            } catch  {
+                return;
+            }
+            if ('ready' === frame.type) this.opts.onReady?.(frame);
+            else if ('log' === frame.type) this.opts.onLog?.(frame.event);
+            else if ('gap' === frame.type) this.opts.onGap?.(frame);
+        });
+        socket.on('close', ()=>{
+            this.socket = null;
+            this.opts.onClose?.();
+            if (this.opts.reconnect) this.scheduleReconnect();
+        });
+        socket.on('error', ()=>{
+            try {
+                socket.close();
+            } catch  {}
+        });
+    }
+    scheduleReconnect() {
+        if (this.closed || !this.opts.reconnect) return;
+        const delay = this.backoff;
+        this.backoff = Math.min(2 * this.backoff, this.maxBackoff);
+        this.timer = setTimeout(()=>this.connect(), delay);
+    }
+}
+const DEFAULT_CONNECT_TIMEOUT_MS = 10000;
+let cmdSeq = 0;
+class BridgeController {
+    opts;
+    socket = null;
+    ready = null;
+    connectPromise = null;
+    pending = new Map();
+    constructor(options){
+        this.opts = options;
+    }
+    get capabilities() {
+        return this.ready?.capabilities;
+    }
+    connect() {
+        if (this.connectPromise) return this.connectPromise;
+        const host = this.opts.host ?? '127.0.0.1';
+        const wsPath = this.opts.path ?? CONTROL_WS_PATH;
+        const url = `ws://${host}:${this.opts.controlPort}${wsPath}`;
+        this.connectPromise = new Promise((resolve, reject)=>{
+            let settled = false;
+            const connectTimer = setTimeout(()=>{
+                if (settled) return;
+                settled = true;
+                this.close();
+                reject(new Error(`control channel handshake timed out at ${url}`));
+            }, this.opts.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS);
+            let socket;
+            try {
+                socket = new WebSocket(url);
+            } catch (err) {
+                clearTimeout(connectTimer);
+                reject(err instanceof Error ? err : new Error(String(err)));
+                return;
+            }
+            this.socket = socket;
+            socket.on('open', ()=>{
+                socket.send(JSON.stringify({
+                    type: 'hello',
+                    v: 1,
+                    role: 'controller',
+                    instanceId: this.opts.instanceId,
+                    ...this.opts.token ? {
+                        token: this.opts.token
+                    } : {}
+                }));
+            });
+            socket.on('message', (data)=>{
+                let frame;
+                try {
+                    frame = JSON.parse(data.toString());
+                } catch  {
+                    return;
+                }
+                if ('ready' === frame.type) {
+                    this.ready = frame;
+                    if (!settled) {
+                        settled = true;
+                        clearTimeout(connectTimer);
+                        resolve(this.ready);
+                    }
+                    return;
+                }
+                if ('result' === frame.type) this.resolveResult(frame);
+            });
+            socket.on('close', (code, reasonBuf)=>{
+                const reason = reasonBuf?.toString() || '';
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(connectTimer);
+                    reject(new Error(`control channel refused the controller (code ${code}${reason ? `: ${reason}` : ''}). Is the session started with --allow-control?`));
+                }
+                this.failAllPending(new Error(`control channel closed (code ${code})`));
+                this.socket = null;
+            });
+            socket.on('error', ()=>{});
+        });
+        return this.connectPromise;
+    }
+    async command(input) {
+        await this.connect();
+        const socket = this.socket;
+        if (!socket || socket.readyState !== WebSocket.OPEN) throw new Error('control channel is not open');
+        const cmdId = `c-${Date.now()}-${++cmdSeq}`;
+        const timeoutMs = input.timeoutMs ?? 5000;
+        const backstopMs = Math.min(timeoutMs, 30000) + 2000;
+        return new Promise((resolve, reject)=>{
+            const timer = setTimeout(()=>{
+                this.pending.delete(cmdId);
+                reject(new Error(`command ${input.op} timed out after ${backstopMs}ms`));
+            }, backstopMs);
+            this.pending.set(cmdId, {
+                resolve,
+                reject,
+                timer
+            });
+            socket.send(JSON.stringify({
+                type: 'command',
+                cmdId,
+                op: input.op,
+                target: input.target,
+                args: input.args,
+                timeoutMs
+            }));
+        });
+    }
+    close() {
+        this.failAllPending(new Error('controller closed'));
+        try {
+            this.socket?.close();
+        } catch  {}
+        this.socket = null;
+    }
+    resolveResult(result) {
+        const p = this.pending.get(result.cmdId);
+        if (!p) return;
+        clearTimeout(p.timer);
+        this.pending.delete(result.cmdId);
+        p.resolve(result);
+    }
+    failAllPending(err) {
+        for (const [, p] of this.pending){
+            clearTimeout(p.timer);
+            p.reject(err);
+        }
+        this.pending.clear();
+    }
+}
+export { controlTokenPath, readControlToken } from "./45.mjs";
+export { BridgeConsumer, BridgeController, readReadyContract };