opendevbrowser 0.0.12 → 0.0.16

package/extension/dist/services/NativePortManager.js

@@ -0,0 +1,182 @@
+const DEFAULT_HOST = "com.opendevbrowser.native";
+export class NativePortManager {
+    port = null;
+    status = "disconnected";
+    lastError = null;
+    lastPongAt = null;
+    queue = [];
+    pendingPing = null;
+    handlers;
+    hostName;
+    connectPromise = null;
+    constructor(handlers = {}, hostName = DEFAULT_HOST) {
+        this.handlers = handlers;
+        this.hostName = hostName;
+    }
+    isConnected() {
+        return this.status === "connected";
+    }
+    getHealth() {
+        return {
+            status: this.status,
+            error: this.lastError?.code,
+            detail: this.lastError?.message,
+            lastPongAt: this.lastPongAt ?? undefined
+        };
+    }
+    async connect() {
+        if (this.connectPromise) {
+            return await this.connectPromise;
+        }
+        const run = (async () => {
+            this.disconnect();
+            let port;
+            try {
+                port = chrome.runtime.connectNative(this.hostName);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.setError(classifyNativeError(message), message);
+                return false;
+            }
+            this.port = port;
+            this.status = "connected";
+            this.lastError = null;
+            port.onMessage.addListener((payload) => this.handleMessage(payload));
+            port.onDisconnect.addListener(() => this.handleDisconnect());
+            this.flushQueue();
+            return true;
+        })();
+        this.connectPromise = run;
+        try {
+            return await run;
+        }
+        finally {
+            if (this.connectPromise === run) {
+                this.connectPromise = null;
+            }
+        }
+    }
+    disconnect() {
+        if (this.port) {
+            try {
+                this.port.disconnect();
+            }
+            catch {
+                // Ignore disconnect errors.
+            }
+        }
+        this.port = null;
+        this.status = "disconnected";
+        this.clearPendingPing();
+    }
+    send(payload) {
+        if (this.port && this.status === "connected") {
+            this.port.postMessage(payload);
+            return;
+        }
+        this.queue.push(payload);
+    }
+    async ping(timeoutMs = 5000) {
+        if (!this.port || this.status !== "connected") {
+            throw new Error("Native port not connected");
+        }
+        const id = crypto.randomUUID();
+        this.clearPendingPing();
+        return await new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.setError("host_timeout", "Native host ping timed out");
+                reject(new Error("Native host ping timed out"));
+            }, timeoutMs);
+            this.pendingPing = { id, resolve, reject, timeoutId };
+            this.port?.postMessage({ type: "ping", id });
+        });
+    }
+    handleMessage(payload) {
+        if (!payload || typeof payload !== "object") {
+            return;
+        }
+        const record = payload;
+        if (record.type === "pong" && typeof record.id === "string") {
+            if (this.pendingPing && this.pendingPing.id === record.id) {
+                clearTimeout(this.pendingPing.timeoutId);
+                const resolve = this.pendingPing.resolve;
+                this.pendingPing = null;
+                this.lastPongAt = Date.now();
+                resolve();
+            }
+            return;
+        }
+        if (record.type === "error" && typeof record.code === "string" && typeof record.message === "string") {
+            const code = mapNativeErrorCode(record.code);
+            this.setError(code, record.message);
+            return;
+        }
+        this.handlers.onMessage?.(payload);
+    }
+    handleDisconnect() {
+        const lastError = chrome.runtime.lastError;
+        const message = lastError?.message ?? "Native host disconnected";
+        this.setError(classifyNativeError(message), message);
+        if (this.pendingPing) {
+            clearTimeout(this.pendingPing.timeoutId);
+            const reject = this.pendingPing.reject;
+            this.pendingPing = null;
+            reject(new Error(message));
+        }
+        this.port = null;
+        this.handlers.onDisconnect?.(this.lastError ?? undefined);
+    }
+    flushQueue() {
+        if (!this.port || this.status !== "connected")
+            return;
+        const queued = [...this.queue];
+        this.queue = [];
+        for (const payload of queued) {
+            this.port.postMessage(payload);
+        }
+    }
+    clearPendingPing() {
+        if (!this.pendingPing)
+            return;
+        clearTimeout(this.pendingPing.timeoutId);
+        this.pendingPing = null;
+    }
+    setError(code, message) {
+        this.status = code === "host_disconnect" ? "disconnected" : "error";
+        this.lastError = { code, message };
+    }
+}
+const classifyNativeError = (message) => {
+    const lowered = message.toLowerCase();
+    if (lowered.includes("not found")) {
+        return "host_not_installed";
+    }
+    if (lowered.includes("forbidden")) {
+        return "host_forbidden";
+    }
+    if (lowered.includes("exited") || lowered.includes("exit code")) {
+        return "host_disconnect";
+    }
+    if (lowered.includes("disconnect") || lowered.includes("disconnected") || lowered.includes("terminated")) {
+        return "host_disconnect";
+    }
+    return "unknown";
+};
+const mapNativeErrorCode = (code) => {
+    if (code === "host_message_too_large")
+        return "host_message_too_large";
+    if (code === "host_timeout")
+        return "host_timeout";
+    if (code === "host_forbidden")
+        return "host_forbidden";
+    if (code === "host_not_installed")
+        return "host_not_installed";
+    if (code === "host_disconnect")
+        return "host_disconnect";
+    return "unknown";
+};
+export const __test__ = {
+    classifyNativeError,
+    mapNativeErrorCode
+};

package/extension/dist/services/RelayClient.js

@@ -1,39 +1,157 @@
+import { logError } from "../logging.js";
 export class RelayClient {
     url;
     handlers;
     socket = null;
+    pendingHandshakeAckResolve = null;
+    pendingHandshakeAckReject = null;
+    pendingHandshakeAckTimeoutId = null;
+    lastHandshakeAck = null;
+    connectPromise = null;
+    pendingHealthChecks = new Map();
+    pendingPings = new Map();
     constructor(url, handlers) {
         this.url = url;
         this.handlers = handlers;
     }
     async connect(handshake) {
-        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-            return;
+        if (this.connectPromise) {
+            return await this.connectPromise;
         }
-        this.socket = new WebSocket(this.url);
-        await new Promise((resolve, reject) => {
-            if (!this.socket) {
-                reject(new Error("Relay socket not created"));
-                return;
+        const run = (async () => {
+            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                if (this.lastHandshakeAck) {
+                    return this.lastHandshakeAck;
+                }
+            }
+            else {
+                this.socket = new WebSocket(this.url);
+                await new Promise((resolve, reject) => {
+                    if (!this.socket) {
+                        reject(new Error("Relay socket not created"));
+                        return;
+                    }
+                    this.socket.addEventListener("open", () => resolve(), { once: true });
+                    this.socket.addEventListener("error", () => reject(new Error("Relay socket error")), {
+                        once: true
+                    });
+                });
+                this.socket.addEventListener("message", (event) => {
+                    const message = parseJson(event.data);
+                    if (!message || typeof message !== "object")
+                        return;
+                    const record = message;
+                    if (record.type === "handshakeAck") {
+                        if (!isValidHandshakeAck(record)) {
+                            if (this.pendingHandshakeAckReject) {
+                                const reject = this.pendingHandshakeAckReject;
+                                this.clearHandshakeAckWait();
+                                if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                                    this.socket.close(1002, "Invalid handshake acknowledgment");
+                                }
+                                reject(new Error("Relay handshake acknowledgement invalid"));
+                            }
+                            return;
+                        }
+                        const ack = record;
+                        this.lastHandshakeAck = ack;
+                        if (this.pendingHandshakeAckResolve) {
+                            const resolve = this.pendingHandshakeAckResolve;
+                            this.clearHandshakeAckWait();
+                            resolve(ack);
+                        }
+                        return;
+                    }
+                    if (record.type === "healthCheckResult") {
+                        if (!isValidHealthResponse(record)) {
+                            return;
+                        }
+                        const pending = this.pendingHealthChecks.get(record.id);
+                        if (pending) {
+                            clearTimeout(pending.timeoutId);
+                            this.pendingHealthChecks.delete(record.id);
+                            pending.resolve(record.payload);
+                        }
+                        return;
+                    }
+                    if (record.type === "pong") {
+                        if (!isValidPong(record)) {
+                            return;
+                        }
+                        const pending = this.pendingPings.get(record.id);
+                        if (pending) {
+                            clearTimeout(pending.timeoutId);
+                            this.pendingPings.delete(record.id);
+                            pending.resolve(record.payload);
+                        }
+                        return;
+                    }
+                    if (record.method === "forwardCDPCommand") {
+                        this.handlers.onCommand(record);
+                        return;
+                    }
+                    if (record.type === "annotationCommand") {
+                        this.handlers.onAnnotationCommand?.(record);
+                        return;
+                    }
+                    if (isOpsEnvelope(record)) {
+                        this.handlers.onOpsMessage?.(record);
+                        return;
+                    }
+                });
+                this.socket.addEventListener("close", (event) => {
+                    if (this.pendingHandshakeAckReject) {
+                        const reject = this.pendingHandshakeAckReject;
+                        this.clearHandshakeAckWait();
+                        reject(new Error("Relay socket closed before handshake acknowledgment"));
+                    }
+                    this.lastHandshakeAck = null;
+                    for (const pending of this.pendingHealthChecks.values()) {
+                        clearTimeout(pending.timeoutId);
+                        pending.reject(new Error("Relay socket closed"));
+                    }
+                    this.pendingHealthChecks.clear();
+                    for (const pending of this.pendingPings.values()) {
+                        clearTimeout(pending.timeoutId);
+                        pending.reject(new Error("Relay socket closed"));
+                    }
+                    this.pendingPings.clear();
+                    this.handlers.onClose({ code: event.code, reason: event.reason });
+                });
             }
-            this.socket.addEventListener("open", () => resolve(), { once: true });
-            this.socket.addEventListener("error", () => reject(new Error("Relay socket error")), {
-                once: true
+            const ackPromise = new Promise((resolve, reject) => {
+                this.clearHandshakeAckWait();
+                this.pendingHandshakeAckResolve = resolve;
+                this.pendingHandshakeAckReject = reject;
+                this.pendingHandshakeAckTimeoutId = setTimeout(() => {
+                    this.clearHandshakeAckWait();
+                    if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                        this.socket.close(1000, "Handshake ack timeout");
+                    }
+                    reject(new Error("Relay handshake not acknowledged"));
+                }, 2000);
             });
-        });
-        this.socket.addEventListener("message", (event) => {
-            const message = parseJson(event.data);
-            if (!message || typeof message !== "object")
-                return;
-            const record = message;
-            if (record.method === "forwardCDPCommand") {
-                this.handlers.onCommand(record);
+            try {
+                this.send(handshake);
             }
-        });
-        this.socket.addEventListener("close", () => {
-            this.handlers.onClose();
-        });
-        this.send(handshake);
+            catch (error) {
+                this.clearHandshakeAckWait();
+                if (this.socket && this.socket.readyState === WebSocket.OPEN) {
+                    this.socket.close(1000, "Handshake send failed");
+                }
+                throw error;
+            }
+            return await ackPromise;
+        })();
+        this.connectPromise = run;
+        try {
+            return await run;
+        }
+        finally {
+            if (this.connectPromise === run) {
+                this.connectPromise = null;
+            }
+        }
     }
     disconnect() {
         if (!this.socket)
@@ -42,6 +160,8 @@ export class RelayClient {
             this.socket.close(1000, "Relay disconnect");
         }
         this.socket = null;
+        this.lastHandshakeAck = null;
+        this.clearHandshakeAckWait();
     }
     sendResponse(response) {
         this.send(response);
@@ -52,14 +172,60 @@ export class RelayClient {
     sendHandshake(handshake) {
         this.send(handshake);
     }
+    sendAnnotationResponse(response) {
+        this.send(response);
+    }
+    sendAnnotationEvent(event) {
+        this.send(event);
+    }
+    sendOpsMessage(message) {
+        this.send(message);
+    }
+    async sendHealthCheck(timeoutMs = 1500) {
+        return await this.sendPing(timeoutMs);
+    }
+    async sendPing(timeoutMs = 1500) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error("Relay socket not connected");
+        }
+        const id = crypto.randomUUID();
+        const request = { type: "ping", id };
+        return await new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.pendingPings.delete(id);
+                reject(new Error("Relay ping timed out"));
+            }, timeoutMs);
+            this.pendingPings.set(id, { resolve, reject, timeoutId });
+            try {
+                this.send(request);
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                this.pendingPings.delete(id);
+                reject(error instanceof Error ? error : new Error("Relay ping failed"));
+            }
+        });
+    }
     isConnected() {
         return Boolean(this.socket && this.socket.readyState === WebSocket.OPEN);
     }
+    getLastHandshakeAck() {
+        return this.lastHandshakeAck;
+    }
     send(payload) {
-        if (!this.socket || this.socket.readyState !== WebSocket.OPEN)
-            return;
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error("Relay socket not connected");
+        }
         this.socket.send(JSON.stringify(payload));
     }
+    clearHandshakeAckWait() {
+        if (this.pendingHandshakeAckTimeoutId !== null) {
+            clearTimeout(this.pendingHandshakeAckTimeoutId);
+        }
+        this.pendingHandshakeAckTimeoutId = null;
+        this.pendingHandshakeAckResolve = null;
+        this.pendingHandshakeAckReject = null;
+    }
 }
 const parseJson = (data) => {
     if (typeof data !== "string")
@@ -67,7 +233,42 @@ const parseJson = (data) => {
     try {
         return JSON.parse(data);
     }
-    catch {
+    catch (error) {
+        logError("relay.parse_json", error, { code: "relay_parse_failed" });
         return null;
     }
 };
+const isValidHandshakeAck = (value) => {
+    if (value.type !== "handshakeAck")
+        return false;
+    const payload = value.payload;
+    if (!payload || typeof payload !== "object")
+        return false;
+    const record = payload;
+    return typeof record.instanceId === "string" && typeof record.relayPort === "number";
+};
+const isValidHealthResponse = (value) => {
+    if (value.type !== "healthCheckResult")
+        return false;
+    if (typeof value.id !== "string")
+        return false;
+    const payload = value.payload;
+    if (!payload || typeof payload !== "object")
+        return false;
+    const record = payload;
+    return typeof record.reason === "string";
+};
+const isValidPong = (value) => {
+    if (value.type !== "pong")
+        return false;
+    if (typeof value.id !== "string")
+        return false;
+    const payload = value.payload;
+    if (!payload || typeof payload !== "object")
+        return false;
+    const record = payload;
+    return typeof record.reason === "string";
+};
+const isOpsEnvelope = (value) => {
+    return typeof value.type === "string" && value.type.startsWith("ops_");
+};

package/extension/dist/services/TabManager.js

@@ -1,4 +1,74 @@
 export class TabManager {
+    async createTab(url, active = true) {
+        return await new Promise((resolve, reject) => {
+            chrome.tabs.create({ url, active }, (tab) => {
+                const lastError = chrome.runtime.lastError;
+                if (lastError) {
+                    reject(new Error(lastError.message));
+                    return;
+                }
+                if (!tab) {
+                    reject(new Error("Tab creation failed"));
+                    return;
+                }
+                resolve(tab);
+            });
+        });
+    }
+    async waitForTabComplete(tabId, timeoutMs = 10000) {
+        const existing = await this.getTab(tabId);
+        if (existing?.status === "complete") {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const timeoutId = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                chrome.tabs.onUpdated.removeListener(listener);
+                reject(new Error("Tab load timeout"));
+            }, timeoutMs);
+            const listener = (updatedId, changeInfo) => {
+                if (updatedId !== tabId) {
+                    return;
+                }
+                if (changeInfo.status === "complete") {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timeoutId);
+                    chrome.tabs.onUpdated.removeListener(listener);
+                    resolve();
+                }
+            };
+            chrome.tabs.onUpdated.addListener(listener);
+        });
+    }
+    async closeTab(tabId) {
+        await new Promise((resolve, reject) => {
+            chrome.tabs.remove(tabId, () => {
+                const lastError = chrome.runtime.lastError;
+                if (lastError) {
+                    reject(new Error(lastError.message));
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    async activateTab(tabId) {
+        return await new Promise((resolve, reject) => {
+            chrome.tabs.update(tabId, { active: true }, (tab) => {
+                const lastError = chrome.runtime.lastError;
+                if (lastError) {
+                    reject(new Error(lastError.message));
+                    return;
+                }
+                resolve(tab ?? null);
+            });
+        });
+    }
     async getTab(tabId) {
         try {
             return await chrome.tabs.get(tabId);
@@ -15,4 +85,15 @@ export class TabManager {
         const tab = await this.getActiveTab();
         return tab?.id ?? null;
     }
+    async getFirstHttpTabId() {
+        const tabs = await chrome.tabs.query({});
+        const match = tabs.find((tab) => {
+            if (typeof tab.id !== "number")
+                return false;
+            if (!tab.url)
+                return false;
+            return tab.url.startsWith("http://") || tab.url.startsWith("https://");
+        });
+        return match?.id ?? null;
+    }
 }