@clawchatsai/connector 0.0.61 → 0.0.63

package/dist/webrtc-peer.js

@@ -70,6 +70,21 @@ export class WebRTCPeerManager extends EventEmitter {
     }
     async handleOffer(offer) {
         const { connectionId, sdp, candidates } = offer;
+        // ICE restart: existing PC — renegotiate on it, DataChannel stays open.
+        const existingPc = this.peerConnections.get(connectionId);
+        if (existingPc) {
+            console.log(`[WebRTCPeerManager] ICE restart for connection ${connectionId}`);
+            await existingPc.setRemoteDescription(new RTCSessionDescription({ sdp, type: 'offer' }));
+            for (const rawCandidate of candidates) {
+                try {
+                    await existingPc.addIceCandidate(new RTCIceCandidate(rawCandidate));
+                }
+                catch { /* ignore */ }
+            }
+            const answer = await existingPc.createAnswer();
+            await existingPc.setLocalDescription(answer);
+            return { connectionId, sdp: answer.sdp, candidates: [] };
+        }
         console.log(`[WebRTCPeerManager] Handling ICE offer for connection ${connectionId}`);
         const iceServers = this.pendingIceServers.get(connectionId) ?? [
             { urls: 'stun:stun.l.google.com:19302' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawchatsai/connector",
-  "version": "0.0.61",
+  "version": "0.0.63",
   "type": "module",
   "description": "ClawChats OpenClaw plugin — P2P tunnel + local API bridge",
   "main": "dist/index.js",

package/server.js

@@ -11,6 +11,7 @@ import { execSync } from 'node:child_process';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { createRequire } from 'node:module';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { WebSocket as WS, WebSocketServer } from 'ws';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -22,6 +23,9 @@ const __dirname = path.dirname(__filename);
 // auto-rebuild in-place before proceeding. Falls back to a clear error message
 // if the user is missing build tools.
 const _require = createRequire(import.meta.url);
+
+// Per-request workspace DB — isolates concurrent clients on different workspaces.
+const _requestDbStore = new AsyncLocalStorage();
 let Database;
 {
   const _nativeErr = (e) =>
@@ -331,7 +335,7 @@ function getDb(workspaceName) {
 }
 
 function getActiveDb() {
-  return getDb(getWorkspaces().active);
+  return _requestDbStore.getStore() || getDb(getWorkspaces().active);
 }
 
 const _globalDbCache = new Map(); // keyed by resolved dbPath
@@ -2172,6 +2176,12 @@ async function handleTranscribe(req, res) {
 }
 
 async function handleRequest(req, res) {
+  const _wsName = req.headers?.['x-workspace'];
+  const _requestDb = _wsName ? getDb(_wsName) : getActiveDb();
+  return _requestDbStore.run(_requestDb, () => _handleRequestImpl(req, res));
+}
+
+async function _handleRequestImpl(req, res) {
   // Parse URL and query string
   const [urlPath, queryString] = (req.url || '/').split('?');
   const query = {};
@@ -3207,6 +3217,61 @@ function extractContent(message) {
   return '';
 }
 
+// ─── Sentinel filtering helpers ───────────────────────────────────────────────
+// Mirrors logic from OpenClaw's tokens-C27XM9Ox.js so we can filter NO_REPLY /
+// HEARTBEAT_OK tokens before they reach the browser — including partial leaks
+// during streaming (e.g. "NO_" appearing mid-stream before the full token is
+// assembled). See GitHub issue #96.
+
+// Returns true if text is exactly the sentinel (with optional surrounding whitespace).
+function isSilentReplyExact(text, token = 'NO_REPLY') {
+  if (!text) return false;
+  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^\\s*${escaped}\\s*$`).test(text);
+}
+
+// Returns true if text could be the beginning of the sentinel token —
+// i.e. it is a strict uppercase-only prefix of the token.
+// Example: "NO" and "NO_" and "NO_REPLY" all return true for token="NO_REPLY".
+function isSilentReplyPrefix(text, token = 'NO_REPLY') {
+  if (!text) return false;
+  const trimmed = text.trimStart();
+  if (!trimmed) return false;
+  if (trimmed !== trimmed.toUpperCase()) return false;   // must be ALL CAPS
+  const normalized = trimmed.toUpperCase();
+  if (normalized.length < 2) return false;
+  if (/[^A-Z_]/.test(normalized)) return false;          // only letters + underscore
+  const tokenUpper = token.toUpperCase();
+  if (!tokenUpper.startsWith(normalized)) return false;  // must be a prefix
+  if (normalized.includes('_')) return true;             // past the first word — unambiguous
+  // Single word without underscore: only allow "NO" for NO_REPLY (avoids false-positives
+  // on other short all-caps words like "HI", "OK", etc.)
+  return tokenUpper === 'NO_REPLY' && normalized === 'NO';
+}
+
+// Strip a trailing sentinel token from mixed-content text (e.g. "answer NO_REPLY" → "answer").
+function stripTrailingSentinel(text, token = 'NO_REPLY') {
+  if (!text) return text;
+  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return text.replace(new RegExp(`(?:^|\\s+|\\*+)${escaped}\\s*$`), '').trim();
+}
+
+// Strip internal <final> / </final> tags that occasionally leak from the model.
+function stripFinalTags(text) {
+  if (!text) return text;
+  return text.replace(/<\s*\/?\s*final\s*>/gi, '');
+}
+
+// Apply all content sanitization steps before saving to DB.
+function sanitizeAssistantContent(text) {
+  if (!text) return text;
+  let out = stripFinalTags(text);
+  out = out.replace(/^(?:[ \t]*\r?\n)+/, ''); // strip leading blank lines
+  if (out.includes('NO_REPLY'))    out = stripTrailingSentinel(out, 'NO_REPLY');
+  if (out.includes('HEARTBEAT_OK')) out = stripTrailingSentinel(out, 'HEARTBEAT_OK');
+  return out;
+}
+
 // ─── Shared activity log helpers ─────────────────────────────────────────────
 // Pure functions extracted from GatewayClient / _GatewayClient so both classes
 // share a single implementation. Pass the workspace-scoped DB getter and a
@@ -3398,7 +3463,7 @@ export function createApp(config = {}) {
   }
 
   function _getActiveDb() {
-    return _getDb(_getWorkspaces().active);
+    return _requestDbStore.getStore() || _getDb(_getWorkspaces().active);
   }
 
   function _closeDb(workspaceName) {
@@ -4028,25 +4093,51 @@ export function createApp(config = {}) {
         return;
       }
       if (msg.type === 'res' && msg.payload?.type === 'hello-ok') { console.log('Gateway handshake complete'); this.connected = true; this.broadcastGatewayStatus(true); }
-      this.broadcastToBrowsers(data);
-      if (msg.type === 'event' && msg.event === 'chat' && msg.payload) this.handleChatEvent(msg.payload);
+      // Chat events are routed through handleChatEvent which decides when/if to
+      // broadcast (sentinel hold, flush ordering, suppression). All other events
+      // broadcast unconditionally.
+      if (msg.type === 'event' && msg.event === 'chat' && msg.payload) {
+        this.handleChatEvent(msg.payload, data);
+      } else {
+        this.broadcastToBrowsers(data);
+      }
       if (msg.type === 'event' && msg.event === 'agent' && msg.payload) this.handleAgentEvent(msg.payload);
     }
 
-    handleChatEvent(params) {
+    handleChatEvent(params, rawData) {
       const { sessionKey, state, message, seq } = params;
+
       if (state === 'delta') {
         const parsed = parseSessionKey(sessionKey);
         if (parsed) {
-          const existing = this.streamState.get(sessionKey) || { buffer: '', threadId: parsed.threadId, state: 'streaming' };
+          const existing = this.streamState.get(sessionKey) || { buffer: '', threadId: parsed.threadId, state: 'streaming', held: [] };
           existing.buffer += extractContent(message);
+
+          // If the accumulated buffer looks like a NO_REPLY or HEARTBEAT_OK prefix,
+          // hold this raw delta — don't forward to browsers yet.
+          if (isSilentReplyPrefix(existing.buffer, 'NO_REPLY') || isSilentReplyPrefix(existing.buffer, 'HEARTBEAT_OK')) {
+            existing.held = existing.held || [];
+            existing.held.push(rawData);
+            this.streamState.set(sessionKey, existing);
+            return; // suppressed — wait for more chunks
+          }
+
+          // Buffer diverged from any sentinel — flush held deltas first, then current.
+          if (existing.held?.length > 0) {
+            for (const h of existing.held) this.broadcastToBrowsers(h);
+            existing.held = [];
+          }
           this.streamState.set(sessionKey, existing);
         }
+        this.broadcastToBrowsers(rawData);
         return;
       }
+
+      // Capture stream entry before deletion so we can flush held deltas if needed.
+      const streamEntry = this.streamState.get(sessionKey);
       if (state === 'final' || state === 'aborted' || state === 'error') this.streamState.delete(sessionKey);
 
-      // Intercept title generation responses (final, error, or aborted)
+      // Title generation sessions: pass through without sentinel filtering.
       if (sessionKey && sessionKey.includes('__clawchats_title_')) {
         if (state === 'final') {
           const content = extractContent(message);
@@ -4061,7 +4152,33 @@ export function createApp(config = {}) {
         }
       }
 
-      if (state === 'final') this.saveAssistantMessage(sessionKey, message, seq);
+      if (state === 'final') {
+        const rawContent = extractContent(message);
+
+        // Exact NO_REPLY or HEARTBEAT_OK — suppress entirely. Discard any held deltas,
+        // don't broadcast the final event, don't save to DB.
+        if (isSilentReplyExact(rawContent, 'NO_REPLY') || isSilentReplyExact(rawContent, 'HEARTBEAT_OK')) {
+          return;
+        }
+
+        // If we held deltas (buffer was a sentinel prefix), flush them before the final
+        // so the browser has a response element ready for finalization.
+        if (streamEntry?.held?.length > 0) {
+          for (const h of streamEntry.held) this.broadcastToBrowsers(h);
+        }
+
+        // Broadcast the final event, then persist.
+        this.broadcastToBrowsers(rawData);
+        this.saveAssistantMessage(sessionKey, message, seq);
+        return;
+      }
+
+      if (state === 'aborted' || state === 'error') {
+        // Discard any held deltas silently — if stream was aborted while holding a
+        // NO_REPLY prefix, there's nothing to show. Broadcast the terminal event normally.
+        this.broadcastToBrowsers(rawData);
+      }
+
       if (state === 'error') this.saveErrorMarker(sessionKey, message);
     }
 
@@ -4073,7 +4190,7 @@ export function createApp(config = {}) {
       const db = _getDb(parsed.workspace);
       const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
       if (!thread) { console.log(`Ignoring response for deleted thread: ${parsed.threadId}`); return; }
-      let content = extractContent(message);
+      let content = sanitizeAssistantContent(extractContent(message));
       if (!content || !content.trim()) { console.log(`Skipping empty assistant response for thread ${parsed.threadId}`); return; }
 
       // Attach media captured by the after_tool_call hook (MEDIA: lines from exec stdout).
@@ -4336,7 +4453,11 @@ export function createApp(config = {}) {
         ws.send(JSON.stringify({ type: 'clawchats', event: 'gateway-status', connected: this.connected }));
         const streams = [];
         for (const [sessionKey, state] of this.streamState.entries()) {
-          if (state.state === 'streaming') streams.push({ sessionKey, threadId: state.threadId, buffer: state.buffer });
+          // Skip sessions in sentinel-hold state — their buffer contains a NO_REPLY/HEARTBEAT_OK
+          // prefix that should not be forwarded to reconnecting browsers.
+          if (state.state === 'streaming' && !(state.held?.length > 0)) {
+            streams.push({ sessionKey, threadId: state.threadId, buffer: state.buffer });
+          }
         }
         if (streams.length > 0) ws.send(JSON.stringify({ type: 'clawchats', event: 'stream-sync', streams }));
       }
@@ -4369,6 +4490,12 @@ export function createApp(config = {}) {
 
   // ── handleRequest (scoped to factory state) ────────────────────────────────
   async function _handleRequest(req, res) {
+    const _wsName = req.headers?.['x-workspace'];
+    const _requestDb = _wsName ? _getDb(_wsName) : _getActiveDb();
+    return _requestDbStore.run(_requestDb, () => _handleRequestImplFactory(req, res));
+  }
+
+  async function _handleRequestImplFactory(req, res) {
     const [urlPath, queryString] = (req.url || '/').split('?');
     const query = {};
     if (queryString) {