@clawchatsai/connector 0.0.62 → 0.0.64

package/dist/index.js

@@ -125,8 +125,33 @@ async function ensureNativeModules(ctx) {
         }
     }
 }
+const CLAWCHATS_MD_CONTENT = `# ClawChats — Inline File Delivery
+
+To deliver a file inline in this chat, print a MEDIA: line to stdout during an exec call:
+
+    MEDIA:/absolute/path/to/file
+
+- Supported for images (png, jpg, gif, webp, svg, etc.) and other file types
+- Include it at the end of the same exec command that creates the file
+- Example: \`python3 generate.py --output /tmp/result.png && echo "MEDIA:/tmp/result.png"\`
+- Output each path once — duplicates are ignored automatically
+`;
 async function startClawChats(ctx, api, mediaStash) {
     _stopRequested = false;
+    // Bootstrap CLAWCHATS.md in the agent workspace so the agent always knows the MEDIA: protocol.
+    // Written once on plugin start; never overwrites an existing file (user may have customised it).
+    try {
+        const workspaceDir = path.join(ctx.stateDir, 'workspace');
+        const clawchatsDoc = path.join(workspaceDir, 'CLAWCHATS.md');
+        if (!fs.existsSync(clawchatsDoc)) {
+            fs.mkdirSync(workspaceDir, { recursive: true });
+            fs.writeFileSync(clawchatsDoc, CLAWCHATS_MD_CONTENT, { encoding: 'utf8' });
+            ctx.logger.info('[clawchats] wrote CLAWCHATS.md to workspace');
+        }
+    }
+    catch (e) {
+        ctx.logger.warn(`[clawchats] could not write CLAWCHATS.md: ${e.message}`);
+    }
     let config = loadConfig();
     if (!config) {
         ctx.logger.info('ClawChats not configured. Waiting for setup...');
@@ -356,8 +381,6 @@ async function stopClawChats(ctx) {
  * guard checks MediaPath/MediaPaths but not inline base64 attachments).
  * Injecting a minimal placeholder ensures the agent run proceeds.
  */
-// Track which ClawChats thread sessions have received the file-hint (once per session).
-const _hintedSessions = new Set();
 function normalizeGatewayPayload(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -379,15 +402,6 @@ function normalizeGatewayPayload(raw) {
                 parsed.params.message = '[Image]';
                 return JSON.stringify(parsed);
             }
-            // Hint injection: teach the agent to emit MEDIA:/path via exec after creating files.
-            // Injected once per ClawChats thread session (~15 tokens, invisible to user).
-            const sk = parsed.params.sessionKey || '';
-            if (sk.includes(':chat:') && !_hintedSessions.has(sk)) {
-                _hintedSessions.add(sk);
-                parsed.params.message += '\n[ClawChats: after creating or saving any file, run: exec echo "MEDIA:/absolute/path/to/file" — this delivers it inline to the chat]';
-                console.log(`[clawchats] hint-injected for session ${sk}`);
-                return JSON.stringify(parsed);
-            }
         }
     }
     catch {
@@ -1102,7 +1116,7 @@ const plugin = {
             if (!sessionKey)
                 return;
             const existing = mediaStash.get(sessionKey) ?? [];
-            mediaStash.set(sessionKey, [...existing, ...paths]);
+            mediaStash.set(sessionKey, [...new Set([...existing, ...paths])]);
             console.log(`[clawchats] media-capture: stashed ${paths.length} path(s) for ${sessionKey}:`, paths);
         }, { name: 'clawchats-media-capture', description: 'Captures MEDIA: paths from exec results for inline image rendering' });
         // Background service: signaling + gateway bridge + future WebRTC

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawchatsai/connector",
-  "version": "0.0.62",
+  "version": "0.0.64",
   "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) {