@clawchatsai/connector 0.0.46 → 0.0.48

package/dist/index.d.ts

@@ -47,6 +47,15 @@ interface PluginApi {
             text: string;
         };
     }) => void;
+    registerHook: (events: string | string[], handler: (event: Record<string, unknown>, ctx: Record<string, unknown>) => void | Promise<void>, opts: {
+        name: string;
+        description?: string;
+    }) => void;
+    registerTypedHook: (hookName: string, handler: (event: Record<string, unknown>, ctx: Record<string, unknown>) => void | Promise<void>, opts?: {
+        name?: string;
+        description?: string;
+        priority?: number;
+    }) => void;
     runtime: {
         requestRestart?: (reason: string) => void;
     };

package/dist/index.js

@@ -123,7 +123,7 @@ async function ensureNativeModules(ctx) {
         }
     }
 }
-async function startClawChats(ctx, api) {
+async function startClawChats(ctx, api, mediaStash) {
     _stopRequested = false;
     let config = loadConfig();
     if (!config) {
@@ -175,6 +175,7 @@ async function startClawChats(ctx, api) {
         gatewayUrl: 'ws://localhost:18789',
         authToken: '', // P2P: DataChannel is the auth boundary (signaling authenticates both sides)
         gatewayToken, // For WS auth to local OpenClaw gateway
+        mediaStash, // Shared Map populated by after_tool_call hook (captures MEDIA: paths from exec)
     });
     // 4. Connect createApp's gateway client (handles persistence + event relay)
     app.gatewayClient.connect();
@@ -958,10 +959,45 @@ const plugin = {
     name: 'ClawChats',
     description: 'Connects your gateway to ClawChats via WebRTC P2P',
     register(api) {
+        // Shared stash: after_tool_call hook populates this; saveAssistantMessage reads + clears it.
+        // Keyed by sessionKey → absolute paths extracted from MEDIA: lines in exec stdout.
+        const mediaStash = new Map();
+        // Capture MEDIA: paths from exec tool results before the gateway strips them from message text.
+        // Fires after every tool call; we filter to exec only and check for MEDIA: lines.
+        api.registerTypedHook('after_tool_call', (event, ctx) => {
+            // Diagnostic: log every tool call so we can confirm hook fires + see real tool names
+            console.log(`[clawchats] hook:after_tool_call toolName=${String(event.toolName)} sessionKey=${String(ctx.sessionKey)}`);
+            if (event.toolName !== 'exec')
+                return;
+            // result is { content: [{ type: 'text', text: '...' }] } — extract text defensively
+            const result = event.result;
+            let text = '';
+            if (typeof result?.text === 'string') {
+                text = result.text;
+            }
+            else if (Array.isArray(result?.content)) {
+                text = result.content
+                    .filter(c => c.type === 'text' && typeof c.text === 'string')
+                    .map(c => c.text)
+                    .join('\n');
+            }
+            else if (result != null) {
+                text = String(result);
+            }
+            const paths = [...text.matchAll(/^MEDIA:\s*(\S+)/gm)].map(m => m[1].trim());
+            if (paths.length === 0)
+                return;
+            const sessionKey = ctx.sessionKey;
+            if (!sessionKey)
+                return;
+            const existing = mediaStash.get(sessionKey) ?? [];
+            mediaStash.set(sessionKey, [...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
         api.registerService({
             id: 'connector-service',
-            start: (ctx) => startClawChats(ctx, api),
+            start: (ctx) => startClawChats(ctx, api, mediaStash),
             stop: (ctx) => stopClawChats(ctx),
         });
         // CLI commands

package/package.json

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

package/server.js

@@ -3969,7 +3969,6 @@ export function createApp(config = {}) {
       this._externalBroadcastTargets = [];
       this.streamState = new Map();
       this.activityLogs = new Map();
-      this._pendingMediaUrls = new Map(); // sessionKey → string[] of MEDIA: paths captured during streaming
       setInterval(() => {
         const cutoff = Date.now() - 10 * 60 * 1000;
         for (const [runId, log] of this.activityLogs) {
@@ -4062,46 +4061,21 @@ 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; }
-      const content = extractContent(message);
+      let content = extractContent(message);
       if (!content || !content.trim()) { console.log(`Skipping empty assistant response for thread ${parsed.threadId}`); return; }
-      const now = Date.now();
 
-      // Check if the final assembled message content contains MEDIA: lines
-      console.log('[ClawChats] saveAssistantMessage rawContent:', JSON.stringify(content.slice(0, 300)), 'rawMsgContent:', JSON.stringify(JSON.stringify(message?.content)?.slice(0, 300)));
-      console.log('[ClawChats] saveAssistantMessage msgKeys:', Object.keys(message||{}), 'msgMediaUrls:', JSON.stringify(message?.mediaUrls), 'msgMediaUrl:', message?.mediaUrl);
-
-      // Extract MEDIA: paths from the final complete message content (if gateway preserves them here)
-      let attachments = null;
-      const mediaMatches = [...content.matchAll(/^MEDIA:\s*(\S+)/gm)].map(m => m[1].trim()).filter(p => /\.\w{1,10}$/.test(p));
-      if (mediaMatches.length > 0) {
-        console.log('[ClawChats] MEDIA paths from final content:', JSON.stringify(mediaMatches));
-        attachments = mediaMatches.map(filePath => {
-          const name = path.basename(filePath);
-          const ext = (name.split('.').pop() || '').toLowerCase();
-          const type = ['jpg','jpeg','png','gif','webp','svg','bmp','ico'].includes(ext) ? 'image'
-            : ['mp3','wav','ogg','aac','m4a','flac','opus'].includes(ext) ? 'audio'
-            : ['mp4','webm','mov','avi','mkv'].includes(ext) ? 'video' : 'file';
-          return { path: filePath, name, type };
-        });
+      // Attach any images captured by the after_tool_call hook (MEDIA: lines from exec stdout).
+      // Always clear the stash entry regardless of whether we find paths, to prevent leaking across turns.
+      const _mediaStash = config.mediaStash;
+      const _pendingPaths = _mediaStash?.get(sessionKey) ?? [];
+      _mediaStash?.delete(sessionKey);
+      if (_pendingPaths.length > 0) {
+        const imageMarkdown = _pendingPaths.map(p => `![image](${p})`).join('\n');
+        content = content.trimEnd() + '\n\n' + imageMarkdown;
+        console.log(`[clawchats] media-attach: appended ${_pendingPaths.length} image(s) to message for ${sessionKey}`);
       }
 
-      // Fallback: use MEDIA: paths captured from delta stream
-      if (!attachments) {
-        const paths = this._pendingMediaUrls.get(sessionKey);
-        this._pendingMediaUrls.delete(sessionKey);
-        if (paths?.length) {
-          attachments = paths.map(filePath => {
-            const name = path.basename(filePath);
-            const ext = (name.split('.').pop() || '').toLowerCase();
-            const type = ['jpg','jpeg','png','gif','webp','svg','bmp','ico'].includes(ext) ? 'image'
-              : ['mp3','wav','ogg','aac','m4a','flac','opus'].includes(ext) ? 'audio'
-              : ['mp4','webm','mov','avi','mkv'].includes(ext) ? 'video' : 'file';
-            return { path: filePath, name, type };
-          });
-        }
-      } else {
-        this._pendingMediaUrls.delete(sessionKey); // clean up either way
-      }
+      const now = Date.now();
 
       // Check for pending activity message
       const pendingMsg = db.prepare(`
@@ -4122,15 +4096,13 @@ export function createApp(config = {}) {
           if (lastAssistantIdx >= 0) metadata.activityLog.splice(lastAssistantIdx, 1);
           metadata.activitySummary = this.generateActivitySummary(metadata.activityLog);
         }
-        if (attachments) metadata.attachments = attachments;
         db.prepare('UPDATE messages SET content = ?, metadata = ?, timestamp = ? WHERE id = ?')
           .run(content, JSON.stringify(metadata), now, pendingMsg.id);
         messageId = pendingMsg.id;
       } else {
         // No pending activity — normal INSERT (simple responses, no tools)
         messageId = seq != null ? `gw-${parsed.threadId}-${seq}` : `gw-${parsed.threadId}-${now}`;
-        const metaStr = attachments ? JSON.stringify({ attachments }) : null;
-        db.prepare(`INSERT INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, 'assistant', ?, 'sent', ?, ?, ?) ON CONFLICT(id) DO UPDATE SET content = excluded.content, metadata = COALESCE(excluded.metadata, metadata), timestamp = excluded.timestamp`).run(messageId, parsed.threadId, content, metaStr, now, now);
+        db.prepare(`INSERT INTO messages (id, thread_id, role, content, status, timestamp, created_at) VALUES (?, ?, 'assistant', ?, 'sent', ?, ?) ON CONFLICT(id) DO UPDATE SET content = excluded.content, timestamp = excluded.timestamp`).run(messageId, parsed.threadId, content, now, now);
       }
 
       try {
@@ -4172,8 +4144,6 @@ export function createApp(config = {}) {
       } catch (e) { console.error(`Failed to save error marker:`, e.message); }
     }
 
-    // _scanRecentWorkspaceFiles removed — MEDIA: paths captured from delta stream instead
-
     generateThreadTitle(db, threadId, workspace, skipHeuristic = false) {
       const thread = db.prepare('SELECT title FROM threads WHERE id = ?').get(threadId);
       if (!thread) return;
@@ -4224,25 +4194,7 @@ export function createApp(config = {}) {
       if (!this.activityLogs.has(runId)) this.activityLogs.set(runId, { sessionKey, steps: [], startTime: Date.now() });
       const log = this.activityLogs.get(runId);
       if (stream === 'assistant') {
-        // Check data.mediaUrls — gateway populates this via splitMediaFromOutput on each streaming event.
-        // Partial path events (e.g. ["/"]) fail the extension filter; complete-path events pass.
-        const incomingUrls = Array.isArray(data?.mediaUrls) ? data.mediaUrls : (data?.mediaUrl ? [data.mediaUrl] : []);
-        for (const p of incomingUrls) {
-          if (typeof p === 'string' && /\.\w{1,10}$/.test(p)) {
-            if (!log._seenMediaPaths) log._seenMediaPaths = new Set();
-            if (!log._seenMediaPaths.has(p)) {
-              log._seenMediaPaths.add(p);
-              if (!this._pendingMediaUrls.has(sessionKey)) this._pendingMediaUrls.set(sessionKey, []);
-              this._pendingMediaUrls.get(sessionKey).push(p);
-              console.log('[ClawChats] MEDIA path captured from mediaUrls:', p);
-            }
-          }
-        }
-        if (incomingUrls.length > 0) console.log('[ClawChats] mediaUrls on event:', JSON.stringify(incomingUrls));
         const text = data?.text || '';
-        const delta = data?.delta || '';
-        // Log if a MEDIA: directive appears in text or delta (must look like an actual path, not just the word)
-        if (/MEDIA:\s*[./~a-zA-Z]/.test(text.slice(-80)) || /MEDIA:\s*[./~a-zA-Z]/.test(delta)) console.log('[ClawChats] MEDIA in stream! text tail:', JSON.stringify(text.slice(-80)), 'delta:', JSON.stringify(delta));
         if (text) {
           let currentSegment = log._currentAssistantSegment;
           if (!currentSegment || currentSegment._sealed) {
@@ -4269,7 +4221,6 @@ export function createApp(config = {}) {
         if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) { log._currentAssistantSegment._sealed = true; }
         const step = { type: 'tool', timestamp: Date.now(), name: data?.name || 'unknown', phase: data?.phase || 'start', toolCallId: data?.toolCallId, meta: data?.meta, isError: data?.isError || false };
         if (data?.phase === 'result') {
-          if (data?.name === 'exec') console.log('[ClawChats] exec tool result meta:', JSON.stringify(data?.meta));
           const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId && (s.phase === 'start' || s.phase === 'running'));
           if (existing) { existing.phase = 'done'; existing.resultMeta = data?.meta; existing.isError = data?.isError || false; existing.durationMs = Date.now() - existing.timestamp; }
           else { step.phase = 'done'; log.steps.push(step); }
@@ -4282,7 +4233,6 @@ export function createApp(config = {}) {
       }
       if (stream === 'lifecycle') {
         if (data?.phase === 'end' || data?.phase === 'error') {
-          // MEDIA: paths already captured during delta streaming — nothing to do here
           if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) log._currentAssistantSegment._sealed = true;
           const lastAssistantIdx = log.steps.findLastIndex(s => s.type === 'assistant');
           if (lastAssistantIdx >= 0) log.steps.splice(lastAssistantIdx, 1);
@@ -4609,7 +4559,7 @@ export function createApp(config = {}) {
   }
 
   // ── Browser WebSocket setup (shared logic for standalone and plugin) ────────
-    function _setupBrowserWs(wssInstance) {
+  function _setupBrowserWs(wssInstance) {
     wssInstance.on('connection', (ws) => {
       console.log('Browser client connected');
       _gatewayClient.addBrowserClient(ws);
@@ -4619,7 +4569,6 @@ export function createApp(config = {}) {
       ws.on('message', (data) => {
         const msgStr = data.toString();
         _debugLogger.logFrame('BR→SRV', msgStr);
-        let forwardStr = msgStr;
         try {
           const msg = JSON.parse(msgStr);
           if (msg.type === 'req' && msg.method === 'connect') {
@@ -4639,9 +4588,8 @@ export function createApp(config = {}) {
             if (msg.action === 'debug-start') { const result = _debugLogger.start(msg.ts, ws); if (result.error === 'already-active') ws.send(JSON.stringify({ type: 'clawchats', event: 'debug-error', error: 'Recording already active in another tab', sessionId: result.sessionId })); else ws.send(JSON.stringify({ type: 'clawchats', event: 'debug-started', sessionId: result.sessionId })); return; }
             if (msg.action === 'debug-dump') { const { sessionId, files } = _debugLogger.saveDump(msg); ws.send(JSON.stringify({ type: 'clawchats', event: 'debug-saved', sessionId, files })); return; }
           }
-          // (no hint injection — mediaUrls are captured from agent events directly)
-        } catch { /* Not JSON or not a ClawChats message, forward as-is */ }
-        _gatewayClient.sendToGateway(forwardStr);
+        } catch { /* Not JSON or not a ClawChats message, forward to gateway */ }
+        _gatewayClient.sendToGateway(msgStr);
       });
 
       ws.on('close', () => { console.log('Browser client disconnected'); _debugLogger.handleClientDisconnect(ws); _gatewayClient.removeBrowserClient(ws); });
@@ -4697,7 +4645,7 @@ if (isDirectRun) {
     app.gatewayClient.connect();
 
     // Initialize global DB (custom emojis, etc.)
-    getGlobalDb(_DATA_DIR);
+    getGlobalDb(DATA_DIR);
   });
 
   // Graceful shutdown