@clawchatsai/connector 0.0.21 → 0.0.23

package/dist/index.d.ts

@@ -10,7 +10,7 @@
  * Spec: specs/multitenant-p2p.md sections 6.1-6.2
  */
 export declare const PLUGIN_ID = "connector";
-export declare const PLUGIN_VERSION = "0.0.21";
+export declare const PLUGIN_VERSION = "0.0.23";
 interface PluginServiceContext {
     stateDir: string;
     logger: {

package/dist/index.js

@@ -22,7 +22,7 @@ import { generateSessionSecret } from './session-token.js';
 // Inline from shared/api-version.ts to avoid rootDir conflict
 const CURRENT_API_VERSION = 1;
 export const PLUGIN_ID = 'connector';
-export const PLUGIN_VERSION = '0.0.21';
+export const PLUGIN_VERSION = '0.0.23';
 /** Max DataChannel message size (~256KB, leave room for envelope) */
 const MAX_DC_MESSAGE_SIZE = 256 * 1024;
 /** Active DataChannel connections: connectionId → send function */

package/dist/shim.d.ts

@@ -56,11 +56,6 @@ declare class FakeRes extends Writable {
 }
 /**
  * Dispatch an RPC request through handleRequest and return the response.
- *
- * Safety nets:
- * 1. If handleRequest() throws, we return a 500 with the error message.
- * 2. If res.finished never resolves (handleRequest forgot to call res.end()),
- *    we time out after RPC_TIMEOUT_MS and return a 504.
  */
 export declare function dispatchRpc(rpc: RpcRequest, handleRequest: HandleRequestFn): Promise<RpcResponse>;
 export {};

package/dist/shim.js

@@ -137,51 +137,14 @@ function tryJsonParse(buf) {
         return buf.toString('base64');
     }
 }
-/** RPC dispatch timeout — if handleRequest doesn't call res.end() within
- *  this window, we return a 504 so the browser isn't left hanging. */
-const RPC_TIMEOUT_MS = 30_000;
 /**
  * Dispatch an RPC request through handleRequest and return the response.
- *
- * Safety nets:
- * 1. If handleRequest() throws, we return a 500 with the error message.
- * 2. If res.finished never resolves (handleRequest forgot to call res.end()),
- *    we time out after RPC_TIMEOUT_MS and return a 504.
  */
 export async function dispatchRpc(rpc, handleRequest) {
     const req = new FakeReq(rpc);
     const res = new FakeRes();
-    try {
-        await handleRequest(req, res);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const stack = err instanceof Error ? err.stack : undefined;
-        console.error(`[RPC] handleRequest threw for ${rpc.method} ${rpc.url}: ${message}`);
-        if (stack)
-            console.error(stack);
-        return {
-            id: rpc.id,
-            status: 500,
-            headers: {},
-            body: JSON.stringify({ error: 'Internal server error', detail: message }),
-        };
-    }
-    // Wait for res.finished, but give up after RPC_TIMEOUT_MS
-    const result = await Promise.race([
-        res.finished,
-        new Promise((_, reject) => setTimeout(() => reject(new Error('RPC_TIMEOUT')), RPC_TIMEOUT_MS)),
-    ]).catch((err) => {
-        console.error(`[RPC] Response never completed for ${rpc.method} ${rpc.url}: ${err.message}`);
-        return {
-            status: 504,
-            headers: {},
-            body: Buffer.from(JSON.stringify({
-                error: 'Gateway timeout',
-                detail: `Plugin did not respond within ${RPC_TIMEOUT_MS / 1000}s for ${rpc.method} ${rpc.url}`,
-            })),
-        };
-    });
+    await handleRequest(req, res);
+    const result = await res.finished;
     return {
         id: rpc.id,
         status: result.status,

package/dist/webrtc-peer.d.ts

@@ -1,127 +1,45 @@
 /**
  * WebRTCPeerManager — manages incoming WebRTC connections from browsers.
  *
- * Responsibilities:
- * 1. Store ICE server config received from the signaling server before an
- *    offer arrives (the signaling server sends ICE servers and offer separately).
- * 2. Handle an ice-offer from a browser: create an RTCPeerConnection, set the
- *    remote description, create an answer, and return it to the caller.
- * 3. Wrap werift's DataChannel in a DataChannelLike interface and emit a
- *    'datachannel' event when the channel opens.
- * 4. Clean up peer connections on explicit closeAll() or individual channel close.
+ * Uses node-datachannel (libdatachannel C++ bindings) for production-grade
+ * SCTP/DTLS/WebRTC. The W3C polyfill layer provides standard browser-like APIs.
  *
- * Spec: specs/multitenant-p2p.md sections 6.2–6.3 (plugin WebRTC peer endpoint)
- *
- * werift is a pure-JavaScript WebRTC implementation for Node.js with no
- * native bindings, satisfying the "no native deps" constraint in the spec.
- *
- * Key werift API notes (actual types, not W3C spec):
- *   - RTCDataChannel.onMessage is an rx.mini Event<[string | Buffer]> (.subscribe())
- *   - RTCDataChannel.onclose is a plain optional callback (() => void)
- *   - RTCPeerConnection.ondatachannel is a plain callback (RTCDataChannelEvent) => void
- *   - RTCPeerConnection.onDataChannel is an rx.mini Event<[RTCDataChannel]>
- *   - pc.addIceCandidate() accepts werift's RTCIceCandidate class
- *   - pc.close() returns Promise<void>
- *   - RTCSessionDescription constructor: (sdp: string, type: "offer" | "answer")
+ * Replaces werift (pure-JS WebRTC) which had unreliable SCTP message delivery
+ * under real network conditions (silent message drops on rapid sends).
  */
 import { EventEmitter } from 'node:events';
-/**
- * An ICE offer sent by a browser via the signaling server.
- * Mirrors the signaling protocol message (spec section 5.3).
- */
 export interface IceOffer {
     connectionId: string;
     sdp: string;
     candidates: unknown[];
 }
-/**
- * ICE server configuration delivered by the signaling server before the offer.
- * Contains STUN/TURN servers with optional credentials (Cloudflare TURN).
- */
 export interface IceServers {
     connectionId: string;
     iceServers: Array<{
-        urls: string;
+        urls: string | string[];
         username?: string;
         credential?: string;
     }>;
 }
-/**
- * Stable interface for a DataChannel, independent of werift internals.
- * Callers (index.ts) use this for message routing, not the raw werift object.
- */
 export interface DataChannelLike {
-    /** Send a UTF-8 string through the DataChannel. */
     send(data: string): void;
-    /** Close the DataChannel. */
     close(): void;
-    /** Register a handler for incoming string messages. */
     onMessage(handler: (data: string) => void): void;
-    /** Register a handler invoked when the channel closes. */
     onClosed(handler: () => void): void;
 }
 export declare class WebRTCPeerManager extends EventEmitter {
-    /**
-     * Pending ICE server configs keyed by connectionId.
-     * The signaling server delivers ICE servers before the offer arrives, so we
-     * buffer them here and consume them in handleOffer().
-     */
     private pendingIceServers;
-    /**
-     * Active RTCPeerConnection instances, keyed by connectionId.
-     * Used for cleanup in closeAll() and trickle-ICE in handleIceCandidate().
-     */
     private peerConnections;
-    /**
-     * Open DataChannel wrappers, keyed by connectionId.
-     * Used to compute activeCount and for bulk close in closeAll().
-     */
     private activeChannels;
     constructor();
-    /**
-     * Store ICE server configuration for a given connectionId.
-     * Called by index.ts when the signaling client emits 'ice-servers'.
-     * Must be called before handleOffer() for the same connectionId.
-     */
     setIceServers(data: IceServers): void;
-    /**
-     * Handle an incoming ICE offer from a browser (forwarded by the signaling server).
-     *
-     * Process:
-     * 1. Create RTCPeerConnection with buffered ICE servers (falls back to Google STUN).
-     * 2. Set the remote description from the offer SDP.
-     * 3. Add any trickle ICE candidates bundled in the offer payload.
-     * 4. Register ondatachannel before creating the answer.
-     * 5. Create answer, set as local description.
-     * 6. Return the answer for the signaling client to relay back to the browser.
-     *
-     * @returns The ICE answer payload to forward to the browser via signaling.
-     */
     handleOffer(offer: IceOffer): Promise<{
         connectionId: string;
         sdp: string;
         candidates: unknown[];
     }>;
-    /**
-     * Add a trickle ICE candidate for an existing peer connection.
-     * Called when the signaling server relays a late-arriving candidate from the browser.
-     */
     handleIceCandidate(connectionId: string, candidate: unknown): void;
-    /**
-     * Close all active peer connections and DataChannels.
-     * Called during plugin shutdown (stopClawChats).
-     */
     closeAll(): void;
-    /**
-     * The number of DataChannels that are currently open.
-     * Reported to the signaling server via connection-count messages so it can
-     * enforce per-user device limits (spec section 5.4).
-     */
     get activeCount(): number;
-    /**
-     * Called when the browser opens a DataChannel on the peer connection.
-     * Wraps the raw werift DataChannel, registers lifecycle handlers, and
-     * emits 'datachannel' so index.ts can wire up the message/gateway routing.
-     */
     private _handleDataChannel;
 }

package/dist/webrtc-peer.js

@@ -1,44 +1,34 @@
 /**
  * WebRTCPeerManager — manages incoming WebRTC connections from browsers.
  *
- * Responsibilities:
- * 1. Store ICE server config received from the signaling server before an
- *    offer arrives (the signaling server sends ICE servers and offer separately).
- * 2. Handle an ice-offer from a browser: create an RTCPeerConnection, set the
- *    remote description, create an answer, and return it to the caller.
- * 3. Wrap werift's DataChannel in a DataChannelLike interface and emit a
- *    'datachannel' event when the channel opens.
- * 4. Clean up peer connections on explicit closeAll() or individual channel close.
+ * Uses node-datachannel (libdatachannel C++ bindings) for production-grade
+ * SCTP/DTLS/WebRTC. The W3C polyfill layer provides standard browser-like APIs.
  *
- * Spec: specs/multitenant-p2p.md sections 6.2–6.3 (plugin WebRTC peer endpoint)
- *
- * werift is a pure-JavaScript WebRTC implementation for Node.js with no
- * native bindings, satisfying the "no native deps" constraint in the spec.
- *
- * Key werift API notes (actual types, not W3C spec):
- *   - RTCDataChannel.onMessage is an rx.mini Event<[string | Buffer]> (.subscribe())
- *   - RTCDataChannel.onclose is a plain optional callback (() => void)
- *   - RTCPeerConnection.ondatachannel is a plain callback (RTCDataChannelEvent) => void
- *   - RTCPeerConnection.onDataChannel is an rx.mini Event<[RTCDataChannel]>
- *   - pc.addIceCandidate() accepts werift's RTCIceCandidate class
- *   - pc.close() returns Promise<void>
- *   - RTCSessionDescription constructor: (sdp: string, type: "offer" | "answer")
+ * Replaces werift (pure-JS WebRTC) which had unreliable SCTP message delivery
+ * under real network conditions (silent message drops on rapid sends).
  */
 import { EventEmitter } from 'node:events';
-import { RTCIceCandidate, RTCPeerConnection, RTCSessionDescription, } from 'werift';
+import { RTCPeerConnection, RTCSessionDescription, RTCIceCandidate, } from 'node-datachannel/polyfill';
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
-/**
- * Wraps a werift RTCDataChannel in the DataChannelLike interface.
- *
- * Actual werift RTCDataChannel API used here:
- *   dc.onMessage  — rx.mini Event<[string | Buffer]>, use .subscribe()
- *   dc.onclose    — plain optional callback (() => void), assign directly
- *   dc.send(data) — sends string or Buffer
- *   dc.close()    — closes the channel
- */
 function wrapDataChannel(dc) {
+    const messageHandlers = [];
+    const closedHandlers = [];
+    // W3C-standard event handlers
+    dc.onmessage = (event) => {
+        const str = typeof event.data === 'string'
+            ? event.data
+            : Buffer.isBuffer(event.data)
+                ? event.data.toString('utf8')
+                : String(event.data);
+        for (const h of messageHandlers)
+            h(str);
+    };
+    dc.onclose = () => {
+        for (const h of closedHandlers)
+            h();
+    };
     return {
         send(data) {
             try {
@@ -53,19 +43,14 @@ function wrapDataChannel(dc) {
                 dc.close();
             }
             catch {
-                // Channel may already be closed — swallow the error.
+                // Channel may already be closed
             }
         },
         onMessage(handler) {
-            // onMessage is an rx.mini Event<[string | Buffer]>.
-            dc.onMessage.subscribe((data) => {
-                const str = Buffer.isBuffer(data) ? data.toString('utf8') : String(data);
-                handler(str);
-            });
+            messageHandlers.push(handler);
         },
         onClosed(handler) {
-            // onclose is a plain callback property on RTCDataChannel.
-            dc.onclose = handler;
+            closedHandlers.push(handler);
         },
     };
 }
@@ -73,61 +58,24 @@ function wrapDataChannel(dc) {
 // WebRTCPeerManager
 // ---------------------------------------------------------------------------
 export class WebRTCPeerManager extends EventEmitter {
-    /**
-     * Pending ICE server configs keyed by connectionId.
-     * The signaling server delivers ICE servers before the offer arrives, so we
-     * buffer them here and consume them in handleOffer().
-     */
     pendingIceServers = new Map();
-    /**
-     * Active RTCPeerConnection instances, keyed by connectionId.
-     * Used for cleanup in closeAll() and trickle-ICE in handleIceCandidate().
-     */
     peerConnections = new Map();
-    /**
-     * Open DataChannel wrappers, keyed by connectionId.
-     * Used to compute activeCount and for bulk close in closeAll().
-     */
     activeChannels = new Map();
     constructor() {
         super();
     }
-    // -------------------------------------------------------------------------
-    // Public API
-    // -------------------------------------------------------------------------
-    /**
-     * Store ICE server configuration for a given connectionId.
-     * Called by index.ts when the signaling client emits 'ice-servers'.
-     * Must be called before handleOffer() for the same connectionId.
-     */
     setIceServers(data) {
         console.log(`[WebRTCPeerManager] Storing ICE servers for connection ${data.connectionId}`);
         this.pendingIceServers.set(data.connectionId, data.iceServers);
     }
-    /**
-     * Handle an incoming ICE offer from a browser (forwarded by the signaling server).
-     *
-     * Process:
-     * 1. Create RTCPeerConnection with buffered ICE servers (falls back to Google STUN).
-     * 2. Set the remote description from the offer SDP.
-     * 3. Add any trickle ICE candidates bundled in the offer payload.
-     * 4. Register ondatachannel before creating the answer.
-     * 5. Create answer, set as local description.
-     * 6. Return the answer for the signaling client to relay back to the browser.
-     *
-     * @returns The ICE answer payload to forward to the browser via signaling.
-     */
     async handleOffer(offer) {
         const { connectionId, sdp, candidates } = offer;
         console.log(`[WebRTCPeerManager] Handling ICE offer for connection ${connectionId}`);
-        // Retrieve buffered ICE servers; fall back to Google's public STUN if none arrived.
         const iceServers = this.pendingIceServers.get(connectionId) ?? [
             { urls: 'stun:stun.l.google.com:19302' },
         ];
         this.pendingIceServers.delete(connectionId);
-        // Normalize iceServers: werift expects `urls` as a string, but Cloudflare
-        // (and the W3C spec) returns `urls` as an array.  Expand each array entry
-        // into individual objects so werift's String.includes() checks work.
+        // Normalize: ensure urls is always a string (not array) per entry
         const normalized = iceServers.flatMap((s) => {
             const urls = Array.isArray(s.urls) ? s.urls : [s.urls];
             return urls.map((url) => ({
@@ -136,66 +84,53 @@ export class WebRTCPeerManager extends EventEmitter {
                 ...(s.credential && { credential: s.credential }),
             }));
         });
-        // Create the peer connection with the resolved ICE servers.
         const pc = new RTCPeerConnection({ iceServers: normalized });
         this.peerConnections.set(connectionId, pc);
-        // Register ondatachannel before creating the answer so the browser's
-        // createDataChannel() call fires against an already-listening peer.
-        // werift's ondatachannel is a plain callback (CallbackWithValue<RTCDataChannelEvent>).
-        pc.ondatachannel = ({ channel }) => {
+        // W3C-standard ondatachannel
+        pc.ondatachannel = (event) => {
+            const channel = event.channel;
             this._handleDataChannel(channel, connectionId);
         };
-        // Trickle ICE candidates as they're discovered (STUN/TURN/host).
-        // werift gathers asynchronously after setLocalDescription — we must
-        // forward each candidate to the browser via signaling.
-        pc.onicecandidate = ({ candidate }) => {
-            if (candidate) {
-                this.emit('ice-candidate-local', { connectionId, candidate: candidate.toJSON() });
+        // Forward local ICE candidates to browser via signaling
+        pc.onicecandidate = (event) => {
+            if (event.candidate) {
+                this.emit('ice-candidate-local', {
+                    connectionId,
+                    candidate: event.candidate.toJSON ? event.candidate.toJSON() : event.candidate,
+                });
             }
         };
-        // Set the browser's offer as the remote description.
-        await pc.setRemoteDescription(new RTCSessionDescription(sdp, 'offer'));
-        // Add any trickle ICE candidates bundled in the offer payload.
+        // Set remote description (browser's offer)
+        await pc.setRemoteDescription(new RTCSessionDescription({ sdp, type: 'offer' }));
+        // Add bundled trickle ICE candidates
         for (const rawCandidate of candidates) {
             try {
-                // werift's addIceCandidate() expects its own RTCIceCandidate class.
-                const candidate = new RTCIceCandidate(rawCandidate);
-                await pc.addIceCandidate(candidate);
+                await pc.addIceCandidate(new RTCIceCandidate(rawCandidate));
             }
             catch (err) {
                 console.warn(`[WebRTCPeerManager] Failed to add ICE candidate for ${connectionId}:`, err);
             }
         }
-        // Create answer and commit it as the local description.
+        // Create and set local answer
         const answer = await pc.createAnswer();
         await pc.setLocalDescription(answer);
         console.log(`[WebRTCPeerManager] Answer created for connection ${connectionId}`);
-        // answer is werift's RTCSessionDescription — answer.sdp is the SDP string.
         return {
             connectionId,
             sdp: answer.sdp,
-            candidates: [], // werift gathers candidates into the SDP (non-trickle mode)
+            candidates: [],
         };
     }
-    /**
-     * Add a trickle ICE candidate for an existing peer connection.
-     * Called when the signaling server relays a late-arriving candidate from the browser.
-     */
     handleIceCandidate(connectionId, candidate) {
         const pc = this.peerConnections.get(connectionId);
         if (!pc) {
             console.warn(`[WebRTCPeerManager] handleIceCandidate: no peer connection for ${connectionId}`);
             return;
         }
-        const rtcCandidate = new RTCIceCandidate(candidate);
-        pc.addIceCandidate(rtcCandidate).catch((err) => {
+        pc.addIceCandidate(new RTCIceCandidate(candidate)).catch((err) => {
             console.warn(`[WebRTCPeerManager] Failed to add trickle ICE candidate for ${connectionId}:`, err);
         });
     }
-    /**
-     * Close all active peer connections and DataChannels.
-     * Called during plugin shutdown (stopClawChats).
-     */
     closeAll() {
         console.log(`[WebRTCPeerManager] Closing all connections (${this.peerConnections.size} peers, ${this.activeChannels.size} channels)`);
         for (const [, channel] of this.activeChannels) {
@@ -207,51 +142,33 @@ export class WebRTCPeerManager extends EventEmitter {
         this.activeChannels.clear();
         for (const [, pc] of this.peerConnections) {
             try {
-                // werift's pc.close() returns Promise<void>; fire-and-forget on shutdown.
-                void pc.close();
+                pc.close();
             }
             catch { /* already closed */ }
         }
         this.peerConnections.clear();
         this.pendingIceServers.clear();
     }
-    /**
-     * The number of DataChannels that are currently open.
-     * Reported to the signaling server via connection-count messages so it can
-     * enforce per-user device limits (spec section 5.4).
-     */
     get activeCount() {
         return this.activeChannels.size;
     }
-    // -------------------------------------------------------------------------
-    // Private helpers
-    // -------------------------------------------------------------------------
-    /**
-     * Called when the browser opens a DataChannel on the peer connection.
-     * Wraps the raw werift DataChannel, registers lifecycle handlers, and
-     * emits 'datachannel' so index.ts can wire up the message/gateway routing.
-     */
     _handleDataChannel(dc, connectionId) {
         console.log(`[WebRTCPeerManager] DataChannel opened for connection ${connectionId}`);
         const channel = wrapDataChannel(dc);
         this.activeChannels.set(connectionId, channel);
-        // Register the closed handler before emitting 'datachannel' so consumers
-        // can rely on onClosed firing for any channel they receive.
         channel.onClosed(() => {
             console.log(`[WebRTCPeerManager] DataChannel closed for connection ${connectionId}`);
             this.activeChannels.delete(connectionId);
-            // Clean up the peer connection — no DataChannel means the peer is done.
             const pc = this.peerConnections.get(connectionId);
             if (pc) {
                 try {
-                    void pc.close();
+                    pc.close();
                 }
                 catch { /* already closed */ }
                 this.peerConnections.delete(connectionId);
             }
             this.emit('datachannel-closed', connectionId);
         });
-        // Emit 'datachannel' so index.ts can call setupDataChannelHandler().
         this.emit('datachannel', channel, connectionId);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawchatsai/connector",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "type": "module",
   "description": "ClawChats OpenClaw plugin — P2P tunnel + local API bridge",
   "main": "dist/index.js",
@@ -26,7 +26,7 @@
   "dependencies": {
     "better-sqlite3": ">=9.0.0",
     "jose": "^5.10.0",
-    "werift": "^0.19.9",
+    "node-datachannel": "^0.32.1",
     "ws": "^8.0.0"
   },
   "openclaw": {