@clawchatsai/connector 0.0.1

package/dist/gateway-bridge.d.ts

@@ -0,0 +1,53 @@
+/**
+ * GatewayBridge — persistent WebSocket connection to the local OpenClaw gateway.
+ *
+ * Responsibilities:
+ * 1. Connect to the local gateway using token-only auth (loopback connections
+ *    with valid token skip device identity entirely).
+ * 2. Broadcast incoming gateway events to all connected DataChannel clients
+ *    via the 'gateway-event' EventEmitter event.
+ * 3. Reconnect with exponential backoff on disconnect.
+ */
+import { EventEmitter } from 'node:events';
+export interface PluginConfig {
+    userId: string;
+    serverUrl: string;
+    apiKey: string;
+    gatewayToken?: string;
+    devicePrivateKey?: string;
+    schemaVersion: number;
+    installedAt: string;
+}
+export interface BridgeConfig {
+    gatewayToken: string;
+}
+export declare class GatewayBridge extends EventEmitter {
+    private readonly gatewayUrl;
+    private readonly config;
+    private ws;
+    private _isConnected;
+    private destroyed;
+    private reconnectTimer;
+    private backoffMs;
+    constructor(gatewayUrl: string, config: BridgeConfig);
+    /**
+     * Initiate the connection. Resolves once the WebSocket has been opened
+     * (not necessarily after the gateway handshake completes — listen for
+     * the 'connected' event for that).
+     */
+    connect(): Promise<void>;
+    /**
+     * Forward a message to the gateway (transparent proxy).
+     */
+    send(data: string): void;
+    /**
+     * Permanently close the connection and cancel any pending reconnect.
+     */
+    disconnect(): void;
+    get isConnected(): boolean;
+    private _openSocket;
+    private _handleMessage;
+    private _sendConnect;
+    private _scheduleReconnect;
+    private _cancelReconnect;
+}

package/dist/gateway-bridge.js

@@ -0,0 +1,183 @@
+/**
+ * GatewayBridge — persistent WebSocket connection to the local OpenClaw gateway.
+ *
+ * Responsibilities:
+ * 1. Connect to the local gateway using token-only auth (loopback connections
+ *    with valid token skip device identity entirely).
+ * 2. Broadcast incoming gateway events to all connected DataChannel clients
+ *    via the 'gateway-event' EventEmitter event.
+ * 3. Reconnect with exponential backoff on disconnect.
+ */
+import { EventEmitter } from 'node:events';
+import { WebSocket } from 'ws';
+import { PLUGIN_VERSION } from './index.js';
+// Reconnect backoff constants (milliseconds)
+const BACKOFF_INITIAL_MS = 1_000;
+const BACKOFF_MAX_MS = 30_000;
+// Fixed client identity fields
+const CLIENT_ID = 'gateway-client';
+const CLIENT_MODE = 'backend';
+const ROLE = 'operator';
+const SCOPES = ['operator.read', 'operator.write', 'operator.admin'];
+export class GatewayBridge extends EventEmitter {
+    gatewayUrl;
+    config;
+    ws = null;
+    _isConnected = false;
+    destroyed = false;
+    // Reconnect state
+    reconnectTimer = null;
+    backoffMs = BACKOFF_INITIAL_MS;
+    constructor(gatewayUrl, config) {
+        super();
+        this.gatewayUrl = gatewayUrl;
+        this.config = config;
+    }
+    /**
+     * Initiate the connection. Resolves once the WebSocket has been opened
+     * (not necessarily after the gateway handshake completes — listen for
+     * the 'connected' event for that).
+     */
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this.destroyed) {
+                reject(new Error('GatewayBridge has been destroyed'));
+                return;
+            }
+            this._openSocket(resolve, reject);
+        });
+    }
+    /**
+     * Forward a message to the gateway (transparent proxy).
+     */
+    send(data) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            console.warn('[GatewayBridge] send() called but WebSocket is not open');
+            return;
+        }
+        this.ws.send(data);
+    }
+    /**
+     * Permanently close the connection and cancel any pending reconnect.
+     */
+    disconnect() {
+        this.destroyed = true;
+        this._cancelReconnect();
+        if (this.ws) {
+            this.ws.terminate();
+            this.ws = null;
+        }
+        this._isConnected = false;
+    }
+    get isConnected() {
+        return this._isConnected;
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    _openSocket(resolveConnect = null, rejectConnect = null) {
+        console.log(`[GatewayBridge] Connecting to ${this.gatewayUrl}`);
+        const ws = new WebSocket(this.gatewayUrl);
+        this.ws = ws;
+        let resolved = false;
+        ws.on('open', () => {
+            console.log('[GatewayBridge] WebSocket opened');
+            if (!resolved && resolveConnect) {
+                resolved = true;
+                resolveConnect();
+            }
+        });
+        ws.on('error', (err) => {
+            console.error('[GatewayBridge] WebSocket error:', err.message);
+            if (!resolved && rejectConnect) {
+                resolved = true;
+                rejectConnect(err);
+            }
+        });
+        ws.on('message', (raw) => {
+            this._handleMessage(typeof raw === 'string' ? raw : raw.toString('utf8'));
+        });
+        ws.on('close', (code, reason) => {
+            console.log(`[GatewayBridge] WebSocket closed (code=${code} reason=${reason.toString('utf8') || '(none)'})`);
+            this._isConnected = false;
+            this.ws = null;
+            this.emit('disconnected');
+            if (!this.destroyed) {
+                this._scheduleReconnect();
+            }
+        });
+    }
+    _handleMessage(raw) {
+        // Always broadcast the raw event to connected DataChannel clients first.
+        this.emit('gateway-event', raw);
+        // Parse for handshake handling.
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            // Non-JSON frame — forward as-is, ignore for handshake purposes.
+            return;
+        }
+        const type = msg['type'];
+        const event = msg['event'];
+        // connect.challenge → send token-only connect request (loopback skips nonce)
+        if (type === 'event' && event === 'connect.challenge') {
+            this._sendConnect();
+            return;
+        }
+        // hello-ok → handshake complete
+        if (type === 'res') {
+            const payload = msg['payload'];
+            if (payload?.['type'] === 'hello-ok') {
+                console.log('[GatewayBridge] Gateway handshake complete');
+                this._isConnected = true;
+                // Reset backoff on successful connection.
+                this.backoffMs = BACKOFF_INITIAL_MS;
+                this.emit('connected');
+            }
+        }
+    }
+    _sendConnect() {
+        this.send(JSON.stringify({
+            type: 'req',
+            id: 'gw-connect-1',
+            method: 'connect',
+            params: {
+                minProtocol: 3,
+                maxProtocol: 3,
+                client: {
+                    id: CLIENT_ID,
+                    version: PLUGIN_VERSION,
+                    platform: 'node',
+                    mode: CLIENT_MODE,
+                },
+                role: ROLE,
+                scopes: SCOPES,
+                auth: { token: this.config.gatewayToken },
+                caps: ['tool-events'],
+            },
+        }));
+    }
+    _scheduleReconnect() {
+        if (this.destroyed)
+            return;
+        if (this.reconnectTimer !== null)
+            return; // already scheduled
+        console.log(`[GatewayBridge] Reconnecting in ${this.backoffMs}ms`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            if (!this.destroyed) {
+                this._openSocket();
+            }
+        }, this.backoffMs);
+        // Exponential backoff: double each time, cap at BACKOFF_MAX_MS.
+        this.backoffMs = Math.min(this.backoffMs * 2, BACKOFF_MAX_MS);
+    }
+    _cancelReconnect() {
+        if (this.reconnectTimer !== null) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @shellchat/tunnel — OpenClaw plugin entry point
+ *
+ * Registers ShellChat as a gateway plugin, providing:
+ * - Local HTTP API bridge via createApp()
+ * - WebRTC DataChannel for browser connections
+ * - Signaling client for NAT traversal
+ * - Gateway bridge for local OpenClaw communication
+ *
+ * Spec: specs/multitenant-p2p.md sections 6.1-6.2
+ */
+export declare const PLUGIN_ID = "tunnel";
+export declare const PLUGIN_VERSION = "0.0.1";
+interface PluginServiceContext {
+    stateDir: string;
+    logger: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+    };
+    _forceUpdate?: boolean;
+}
+interface PluginCliContext {
+    program: {
+        command: (name: string) => {
+            description: (desc: string) => CliCommand;
+            command: (nameAndArgs: string) => CliCommand;
+        };
+    };
+}
+interface CliCommand {
+    description: (desc: string) => CliCommand;
+    action: (handler: (...args: unknown[]) => void | Promise<void>) => CliCommand;
+    command: (nameAndArgs: string) => CliCommand;
+}
+interface PluginApi {
+    registerService: (opts: {
+        id: string;
+        start: (ctx: PluginServiceContext) => Promise<void>;
+        stop: (ctx: PluginServiceContext) => Promise<void>;
+    }) => void;
+    registerCli: (handler: (ctx: PluginCliContext) => void) => void;
+    registerCommand: (opts: {
+        name: string;
+        description: string;
+        handler: () => {
+            text: string;
+        };
+    }) => void;
+    runtime: {
+        requestRestart?: (reason: string) => void;
+    };
+    config?: Record<string, unknown>;
+}
+interface OpenClawPluginDefinition {
+    id: string;
+    name: string;
+    description: string;
+    register: (api: PluginApi) => void;
+}
+declare const plugin: OpenClawPluginDefinition;
+export default plugin;