@elizaos/capacitor-gateway 1.0.0

package/dist/esm/web.js

@@ -0,0 +1,419 @@
+import { WebPlugin } from "@capacitor/core";
+/**
+ * Generate a UUID v4
+ */
+function generateUUID() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    if (typeof crypto !== "undefined" &&
+        typeof crypto.getRandomValues === "function") {
+        const bytes = new Uint8Array(16);
+        crypto.getRandomValues(bytes);
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    }
+    throw new Error("No secure random source available for UUID generation");
+}
+const isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getString = (value) => typeof value === "string" ? value : undefined;
+const getNumber = (value) => typeof value === "number" ? value : undefined;
+const getBoolean = (value) => typeof value === "boolean" ? value : undefined;
+const toStringArray = (value) => Array.isArray(value)
+    ? value.filter((item) => typeof item === "string")
+    : [];
+const parseGatewayError = (value) => {
+    if (!value || !isJsonObject(value))
+        return undefined;
+    const code = getString(value.code);
+    const message = getString(value.message);
+    if (!code || !message)
+        return undefined;
+    return {
+        code,
+        message,
+        details: value.details,
+    };
+};
+/**
+ * Web implementation of the Gateway Plugin
+ *
+ * Uses browser WebSocket API for connectivity.
+ * Note: Web platform cannot perform Bonjour/mDNS discovery.
+ */
+export class GatewayWeb extends WebPlugin {
+    constructor() {
+        super(...arguments);
+        this.ws = null;
+        this.pending = new Map();
+        this.options = null;
+        this.sessionId = null;
+        this.protocol = null;
+        this.role = null;
+        this.scopes = [];
+        this.methods = [];
+        this.events = [];
+        this.lastSeq = null;
+        this.reconnectTimer = null;
+        this.backoffMs = 800;
+        this.closed = false;
+        this.connectResolve = null;
+        this.connectReject = null;
+    }
+    /**
+     * Start gateway discovery (not supported on web)
+     *
+     * On web platforms, Bonjour/mDNS discovery is not available.
+     * Returns an empty list of gateways.
+     */
+    async startDiscovery() {
+        return {
+            gateways: [],
+            status: "Discovery not supported on web platform",
+        };
+    }
+    /**
+     * Stop gateway discovery (no-op on web)
+     */
+    async stopDiscovery() {
+        // No-op on web
+    }
+    /**
+     * Get discovered gateways (always empty on web)
+     */
+    async getDiscoveredGateways() {
+        return {
+            gateways: [],
+            status: "Discovery not supported on web platform",
+        };
+    }
+    /**
+     * Connect to a Gateway server
+     */
+    async connect(options) {
+        // Close existing connection if any
+        if (this.ws) {
+            this.closed = true;
+            this.ws.close();
+            this.ws = null;
+        }
+        this.options = options;
+        this.closed = false;
+        this.backoffMs = 800;
+        return new Promise((resolve, reject) => {
+            this.connectResolve = resolve;
+            this.connectReject = reject;
+            this.establishConnection();
+        });
+    }
+    /**
+     * Establish WebSocket connection
+     */
+    establishConnection() {
+        if (this.closed || !this.options) {
+            return;
+        }
+        this.notifyStateChange("connecting");
+        this.ws = new WebSocket(this.options.url);
+        this.ws.addEventListener("open", () => {
+            this.sendConnectFrame();
+        });
+        this.ws.addEventListener("message", (event) => {
+            this.handleMessage(String(event.data));
+        });
+        this.ws.addEventListener("close", (event) => {
+            const reason = event.reason || "Connection closed";
+            this.handleClose(event.code, reason);
+        });
+        this.ws.addEventListener("error", (event) => {
+            console.warn("[Gateway] WebSocket error:", event);
+        });
+    }
+    /**
+     * Send the connect frame to authenticate
+     */
+    sendConnectFrame() {
+        if (!this.ws || !this.options || this.ws.readyState !== WebSocket.OPEN) {
+            return;
+        }
+        const auth = {};
+        if (this.options.token) {
+            auth.token = this.options.token;
+        }
+        if (this.options.password) {
+            auth.password = this.options.password;
+        }
+        const params = {
+            minProtocol: 3,
+            maxProtocol: 3,
+            client: {
+                id: this.options.clientName || "eliza-capacitor",
+                version: this.options.clientVersion || "1.0.0",
+                platform: this.getPlatform(),
+                mode: "ui",
+            },
+            role: this.options.role || "operator",
+            scopes: this.options.scopes || ["operator.admin"],
+            caps: [],
+            auth,
+        };
+        const frame = {
+            type: "req",
+            id: generateUUID(),
+            method: "connect",
+            params,
+        };
+        this.ws.send(JSON.stringify(frame));
+        // Set up timeout for connect response
+        const timeout = setTimeout(() => {
+            if (this.connectReject) {
+                this.connectReject(new Error("Connection timeout"));
+                this.connectReject = null;
+                this.connectResolve = null;
+            }
+        }, 30000);
+        this.pending.set(frame.id, {
+            resolve: (result) => {
+                clearTimeout(timeout);
+                if (result.ok && result.payload && isJsonObject(result.payload)) {
+                    this.handleHelloOk(result.payload);
+                }
+                else {
+                    if (this.connectReject) {
+                        this.connectReject(new Error(result.error?.message || "Connection failed"));
+                    }
+                }
+                this.connectReject = null;
+                this.connectResolve = null;
+            },
+            reject: (error) => {
+                clearTimeout(timeout);
+                if (this.connectReject) {
+                    this.connectReject(error);
+                }
+                this.connectReject = null;
+                this.connectResolve = null;
+            },
+            timeout,
+        });
+    }
+    /**
+     * Handle successful hello response
+     */
+    handleHelloOk(hello) {
+        const protocol = getNumber(hello.protocol);
+        const auth = isJsonObject(hello.auth) ? hello.auth : null;
+        const features = isJsonObject(hello.features) ? hello.features : null;
+        this.sessionId = generateUUID();
+        this.protocol = protocol ?? null;
+        this.role = getString(auth?.role) || this.options?.role || "operator";
+        this.scopes = toStringArray(auth?.scopes);
+        this.methods = toStringArray(features?.methods);
+        this.events = toStringArray(features?.events);
+        this.backoffMs = 800;
+        this.notifyStateChange("connected");
+        if (this.connectResolve) {
+            this.connectResolve({
+                connected: true,
+                sessionId: this.sessionId,
+                protocol: this.protocol ?? undefined,
+                methods: this.methods,
+                events: this.events,
+                role: this.role,
+                scopes: this.scopes,
+            });
+        }
+    }
+    /**
+     * Handle incoming WebSocket message
+     */
+    handleMessage(raw) {
+        let parsedValue;
+        try {
+            parsedValue = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (!isJsonObject(parsedValue)) {
+            return;
+        }
+        const frameType = getString(parsedValue.type);
+        if (!frameType) {
+            return;
+        }
+        // Handle response frames
+        if (frameType === "res") {
+            const id = getString(parsedValue.id);
+            if (!id)
+                return;
+            const pending = this.pending.get(id);
+            if (pending) {
+                this.pending.delete(id);
+                clearTimeout(pending.timeout);
+                pending.resolve({
+                    ok: getBoolean(parsedValue.ok) ?? false,
+                    payload: parsedValue.payload,
+                    error: parseGatewayError(parsedValue.error),
+                });
+            }
+            return;
+        }
+        // Handle event frames
+        if (frameType === "event") {
+            const event = getString(parsedValue.event);
+            if (!event)
+                return;
+            const payload = parsedValue.payload;
+            const seq = getNumber(parsedValue.seq);
+            // Check for sequence gap
+            if (seq !== undefined &&
+                this.lastSeq !== null &&
+                seq > this.lastSeq + 1) {
+                console.warn(`[Gateway] Event sequence gap: expected ${this.lastSeq + 1}, got ${seq}`);
+            }
+            if (seq !== undefined) {
+                this.lastSeq = seq;
+            }
+            // Emit the event
+            this.notifyListeners("gatewayEvent", {
+                event,
+                payload,
+                seq,
+            });
+            return;
+        }
+    }
+    /**
+     * Handle WebSocket close
+     */
+    handleClose(code, reason) {
+        this.ws = null;
+        // Reject all pending requests
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error(`Connection closed: ${reason}`));
+            this.pending.delete(id);
+        }
+        if (this.closed) {
+            this.notifyStateChange("disconnected", reason);
+            return;
+        }
+        // Attempt reconnection
+        this.notifyStateChange("reconnecting", reason);
+        this.notifyListeners("error", {
+            message: `Connection lost: ${reason}`,
+            code: String(code),
+            willRetry: true,
+        });
+        this.scheduleReconnect();
+    }
+    /**
+     * Schedule a reconnection attempt
+     */
+    scheduleReconnect() {
+        if (this.closed || this.reconnectTimer) {
+            return;
+        }
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.backoffMs = Math.min(this.backoffMs * 1.7, 15000);
+            this.establishConnection();
+        }, this.backoffMs);
+    }
+    /**
+     * Notify state change listeners
+     */
+    notifyStateChange(state, reason) {
+        this.notifyListeners("stateChange", {
+            state,
+            reason,
+        });
+    }
+    /**
+     * Get platform identifier
+     */
+    getPlatform() {
+        if (typeof navigator !== "undefined") {
+            return navigator.platform || "web";
+        }
+        return "web";
+    }
+    /**
+     * Disconnect from the Gateway
+     */
+    async disconnect() {
+        this.closed = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close(1000, "Client disconnect");
+            this.ws = null;
+        }
+        this.sessionId = null;
+        this.protocol = null;
+        this.notifyStateChange("disconnected", "Client disconnect");
+    }
+    /**
+     * Check if connected
+     */
+    async isConnected() {
+        return {
+            connected: this.ws !== null && this.ws.readyState === WebSocket.OPEN,
+        };
+    }
+    /**
+     * Send an RPC request
+     */
+    async send(options) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            return {
+                ok: false,
+                error: {
+                    code: "NOT_CONNECTED",
+                    message: "Not connected to gateway",
+                },
+            };
+        }
+        const id = generateUUID();
+        const frame = {
+            type: "req",
+            id,
+            method: options.method,
+            params: options.params || {},
+        };
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                resolve({
+                    ok: false,
+                    error: {
+                        code: "TIMEOUT",
+                        message: "Request timed out",
+                    },
+                });
+            }, 60000); // 60 second timeout
+            this.pending.set(id, {
+                resolve,
+                reject,
+                timeout,
+            });
+            this.ws?.send(JSON.stringify(frame));
+        });
+    }
+    /**
+     * Get connection info
+     */
+    async getConnectionInfo() {
+        return {
+            url: this.options?.url || null,
+            sessionId: this.sessionId,
+            protocol: this.protocol,
+            role: this.role,
+        };
+    }
+}