termify-agent 1.0.39 → 1.0.41

package/hooks/termify-response.js

@@ -2,13 +2,10 @@
 /**
  * Termify Response Sync Hook (Stop / AfterAgent)
  *
- * Syncs the assistant's last response to the Termify conversation
+ * Syncs the assistant's last response to all Termify endpoints
  * when Claude Code / Gemini finishes its turn.
  *
- * Also sends remaining thinking blocks and final text as stream events
- * so the full reasoning process is visible in the Termify UI.
- *
- * Uses transcript_path hash to find the session file created by termify-sync.js.
+ * Supports multiple endpoints (local + prod) — sends to all in parallel.
  *
  * Token: ~/.termify/config.json
  * Session: /tmp/termify-session-{hash}.json
@@ -18,79 +15,101 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 
-/**
- * Fix Gemini CLI streaming bug where prompt_response contains the response
- * text duplicated (full_response + partial_repeat_from_midpoint).
- * Detects and removes the duplicated tail.
- */
 function deduplicateGeminiResponse(text) {
   if (!text || text.length < 200) return text;
-
   const len = text.length;
-
-  // Scan for a split point where the tail matches earlier content
   for (let splitAt = Math.floor(len * 0.35); splitAt <= Math.floor(len * 0.65); splitAt++) {
     const tail = text.slice(splitAt);
-
-    // The duplicated portion must be significant (>25% of total)
     if (tail.length < len * 0.25) continue;
-
-    // Use first 80 chars of tail as search needle
     const needleLen = Math.min(80, tail.length);
     const needle = tail.slice(0, needleLen);
-
-    // Search for this needle BEFORE the split point
     const idx = text.indexOf(needle);
     if (idx >= 0 && idx < splitAt) {
-      // Verify longer match (at least 100 chars must match)
       const matchLen = Math.min(tail.length, len - idx, 300);
       if (matchLen > 100 && tail.slice(0, matchLen) === text.slice(idx, idx + matchLen)) {
         return text.slice(0, splitAt).trimEnd();
       }
     }
   }
-
   return text;
 }
 
-/**
- * Extract ALL thinking blocks from the current assistant turn in the transcript.
- */
-function extractAllThinking(transcriptPath) {
+function extractTranscriptEvents(transcriptPath) {
+  const result = { thinkings: [], toolEvents: [] };
   try {
     const data = fs.readFileSync(transcriptPath, 'utf-8');
     const lines = data.trim().split('\n');
-
-    const thinkings = [];
+    const entries = [];
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
         const entry = JSON.parse(lines[i]);
-        // Stop at user message (end of current assistant turn)
         if (entry.type === 'user' && !entry.toolUseResult && !entry.sourceToolAssistantUUID) break;
-        if (entry.type === 'assistant' && entry.message) {
-          let msg;
-          try {
-            msg = typeof entry.message === 'string' ? JSON.parse(entry.message) : entry.message;
-          } catch {
-            // message might use Python-style single quotes, try eval-like parse
-            try {
-              msg = typeof entry.message === 'string' ? JSON.parse(entry.message.replace(/'/g, '"')) : entry.message;
-            } catch { continue; }
-          }
-          const content = msg?.content || [];
-          for (const block of content) {
-            if (block?.type === 'thinking' && block.thinking) {
-              thinkings.unshift(block.thinking);
+        entries.unshift(entry);
+      } catch {}
+    }
+    for (const entry of entries) {
+      if (entry.type !== 'assistant' || !entry.message) continue;
+      let msg;
+      try {
+        msg = typeof entry.message === 'string' ? JSON.parse(entry.message) : entry.message;
+      } catch {
+        try {
+          msg = typeof entry.message === 'string' ? JSON.parse(entry.message.replace(/'/g, '"')) : entry.message;
+        } catch { continue; }
+      }
+      const content = msg?.content;
+      if (!Array.isArray(content)) continue;
+      for (const block of content) {
+        if (block?.type === 'thinking' && block.thinking) {
+          result.thinkings.push(block.thinking);
+        }
+        if (block?.type === 'tool_use' && block.name) {
+          const toolEvent = { type: 'tool_use', tool: block.name };
+          if (block.input) {
+            const displayKeys = ['file_path', 'command', 'pattern', 'query', 'description', 'url', 'prompt', 'skill', 'subagent_type', 'old_string', 'notebook_path'];
+            const slim = {};
+            for (const k of displayKeys) {
+              if (block.input[k] != null) {
+                const v = String(block.input[k]);
+                slim[k] = v.length > 200 ? v.substring(0, 197) + '...' : v;
+              }
             }
+            if (Object.keys(slim).length > 0) toolEvent.args = slim;
+          }
+          result.toolEvents.push(toolEvent);
+          if (block.name === 'AskUserQuestion' && block.input?.questions) {
+            result.toolEvents.push({
+              type: 'question',
+              questionId: block.id || `q-${Date.now()}`,
+              questions: block.input.questions,
+            });
           }
         }
-      } catch {}
+      }
     }
+  } catch {}
+  return result;
+}
 
-    return thinkings;
-  } catch {
-    return [];
-  }
+/**
+ * Read endpoints from config. Supports both old and new format.
+ */
+function readEndpoints() {
+  try {
+    const configPath = path.join(process.env.HOME || '', '.termify', 'config.json');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    if (Array.isArray(config.endpoints) && config.endpoints.length > 0) {
+      return config.endpoints.map(ep => ({
+        name: ep.name || 'default',
+        apiUrl: ep.apiUrl,
+        token: ep.token,
+      })).filter(ep => ep.apiUrl && ep.token);
+    }
+    if (config.token) {
+      return [{ name: 'default', apiUrl: config.apiUrl || 'http://localhost:3001', token: config.token }];
+    }
+  } catch {}
+  return [];
 }
 
 // Skip sync when running inside a Termify-managed chat terminal
@@ -109,7 +128,6 @@ process.stdin.on('end', async () => {
     return;
   }
 
-  // Prevent infinite loops
   if (hookData?.stop_hook_active) {
     process.exit(0);
     return;
@@ -117,8 +135,6 @@ process.stdin.on('end', async () => {
 
   const transcriptPath = hookData?.transcript_path;
   const hookEvent = hookData?.hook_event_name || '';
-
-  // Claude Code: last_assistant_message, Gemini CLI: prompt_response
   let lastMessage = hookData?.last_assistant_message || hookData?.prompt_response;
 
   if (!transcriptPath || !lastMessage) {
@@ -126,15 +142,11 @@ process.stdin.on('end', async () => {
     return;
   }
 
-  // Trim leading whitespace from Gemini responses (they often start with spaces)
   lastMessage = lastMessage.trimStart();
-
-  // Fix Gemini CLI streaming duplication bug
   if (hookEvent === 'AfterAgent') {
     lastMessage = deduplicateGeminiResponse(lastMessage);
   }
 
-  // Find session file
   const sessionHash = crypto.createHash('md5').update(transcriptPath).digest('hex').substring(0, 12);
   const sessionFile = path.join('/tmp', `termify-session-${sessionHash}.json`);
 
@@ -146,99 +158,114 @@ process.stdin.on('end', async () => {
     return;
   }
 
-  if (!session.conversationId) {
-    process.exit(0);
-    return;
+  // Legacy single-endpoint session: convert to multi-endpoint format
+  if (session.conversationId && !session.endpoints) {
+    const endpoints = readEndpoints();
+    const defaultName = endpoints[0]?.name || 'default';
+    session.endpoints = {
+      [defaultName]: {
+        conversationId: session.conversationId,
+        assistantMessageId: session.assistantMessageId,
+      }
+    };
   }
 
-  // Read Termify config
-  let config;
-  try {
-    const configPath = path.join(process.env.HOME || '', '.termify', 'config.json');
-    config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-  } catch {
+  if (!session.endpoints || Object.keys(session.endpoints).length === 0) {
     process.exit(0);
     return;
   }
 
-  if (!config.token) {
+  const endpoints = readEndpoints();
+  if (endpoints.length === 0) {
     process.exit(0);
     return;
   }
 
-  const apiUrl = config.apiUrl || 'http://localhost:3001';
+  const { thinkings, toolEvents } = extractTranscriptEvents(transcriptPath);
+  const alreadySent = session.thinkingsSent || 0;
 
-  const headers = {
-    'Content-Type': 'application/json',
-    'Authorization': `Bearer ${config.token}`,
-  };
+  /**
+   * Sync response to a single endpoint.
+   */
+  async function syncResponseToEndpoint(ep) {
+    const epState = session.endpoints[ep.name];
+    if (!epState?.conversationId) return;
 
-  // CRITICAL PATH FIRST: complete message + set idle (atomic DB transaction).
-  // This must run before anything else so the conversation doesn't get stuck
-  // if Claude Code kills this hook process early.
-  try {
-    if (session.assistantMessageId) {
-      const completeRes = await fetch(
-        `${apiUrl}/api/chat/conversations/${session.conversationId}/messages/${session.assistantMessageId}/complete`,
-        {
-          method: 'POST',
-          headers,
-          body: JSON.stringify({ content: lastMessage }),
-          signal: AbortSignal.timeout(5000),
-        }
-      );
-      if (!completeRes.ok) throw new Error('complete failed');
-    } else {
-      // No streaming message — create a completed one + set idle in parallel
+    const { conversationId, assistantMessageId } = epState;
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${ep.token}`,
+    };
+
+    // CRITICAL: complete message + set idle
+    try {
+      if (assistantMessageId) {
+        const res = await fetch(
+          `${ep.apiUrl}/api/chat/conversations/${conversationId}/messages/${assistantMessageId}/complete`,
+          {
+            method: 'POST', headers,
+            body: JSON.stringify({ content: lastMessage }),
+            signal: AbortSignal.timeout(5000),
+          }
+        );
+        if (!res.ok) throw new Error('complete failed');
+      } else {
+        await Promise.allSettled([
+          fetch(`${ep.apiUrl}/api/chat/conversations/${conversationId}/messages`, {
+            method: 'POST', headers,
+            body: JSON.stringify({ role: 'assistant', content: lastMessage }),
+            signal: AbortSignal.timeout(5000),
+          }),
+          fetch(`${ep.apiUrl}/api/chat/conversations/${conversationId}`, {
+            method: 'PATCH', headers,
+            body: JSON.stringify({ status: 'idle' }),
+            signal: AbortSignal.timeout(3000),
+          }),
+        ]);
+      }
+    } catch {
+      // Fallback
       await Promise.allSettled([
-        fetch(`${apiUrl}/api/chat/conversations/${session.conversationId}/messages`, {
-          method: 'POST',
-          headers,
+        fetch(`${ep.apiUrl}/api/chat/conversations/${conversationId}/messages`, {
+          method: 'POST', headers,
           body: JSON.stringify({ role: 'assistant', content: lastMessage }),
           signal: AbortSignal.timeout(5000),
         }),
-        fetch(`${apiUrl}/api/chat/conversations/${session.conversationId}`, {
-          method: 'PATCH',
-          headers,
+        fetch(`${ep.apiUrl}/api/chat/conversations/${conversationId}`, {
+          method: 'PATCH', headers,
           body: JSON.stringify({ status: 'idle' }),
           signal: AbortSignal.timeout(3000),
         }),
       ]);
     }
-  } catch {
-    // /complete failed — fallback: create message + PATCH idle in parallel
-    await Promise.allSettled([
-      fetch(`${apiUrl}/api/chat/conversations/${session.conversationId}/messages`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({ role: 'assistant', content: lastMessage }),
-        signal: AbortSignal.timeout(5000),
-      }),
-      fetch(`${apiUrl}/api/chat/conversations/${session.conversationId}`, {
-        method: 'PATCH',
-        headers,
-        body: JSON.stringify({ status: 'idle' }),
-        signal: AbortSignal.timeout(3000),
-      }),
-    ]);
-  }
 
-  // NON-CRITICAL: Send stream events for real-time UI update.
-  // If this fails, the message is already completed in DB — no harm done.
-  if (session.assistantMessageId) {
-    const eventsUrl = `${apiUrl}/api/chat/conversations/${session.conversationId}/messages/${session.assistantMessageId}/events`;
-    fetch(eventsUrl, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({
-        events: [
-          { type: 'text', content: lastMessage },
-          { type: 'status', status: 'done' },
-        ],
-      }),
-      signal: AbortSignal.timeout(3000),
-    }).catch(() => {});
+    // NON-CRITICAL: stream events
+    if (assistantMessageId) {
+      const eventsUrl = `${ep.apiUrl}/api/chat/conversations/${conversationId}/messages/${assistantMessageId}/events`;
+      const events = [];
+      for (let i = alreadySent; i < thinkings.length; i++) {
+        events.push({ type: 'thinking', content: thinkings[i] });
+      }
+      for (const te of toolEvents) {
+        events.push(te);
+      }
+      events.push({ type: 'text', content: lastMessage });
+      events.push({ type: 'status', status: 'done' });
+
+      try {
+        await fetch(eventsUrl, {
+          method: 'POST', headers,
+          body: JSON.stringify({ events }),
+          signal: AbortSignal.timeout(5000),
+        });
+      } catch {}
+    }
   }
 
+  // Sync all endpoints in parallel
+  await Promise.allSettled(
+    endpoints.map(ep => syncResponseToEndpoint(ep))
+  );
+
   process.exit(0);
 });