termify-agent 1.0.27 → 1.0.29

package/hooks/termify-response.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * Termify Response Sync Hook (Stop / AfterAgent)
+ *
+ * Syncs the assistant's last response to the Termify conversation
+ * 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.
+ *
+ * Token: ~/.termify/config.json
+ * Session: /tmp/termify-session-{hash}.json
+ */
+
+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) {
+  try {
+    const data = fs.readFileSync(transcriptPath, 'utf-8');
+    const lines = data.trim().split('\n');
+
+    const thinkings = [];
+    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);
+            }
+          }
+        }
+      } catch {}
+    }
+
+    return thinkings;
+  } catch {
+    return [];
+  }
+}
+
+// Skip sync when running inside a Termify-managed chat terminal
+if (process.env.TERMIFY_CONVERSATION_ID) {
+  process.exit(0);
+}
+
+let input = '';
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', async () => {
+  let hookData;
+  try {
+    hookData = JSON.parse(input);
+  } catch {
+    process.exit(0);
+    return;
+  }
+
+  // Prevent infinite loops
+  if (hookData?.stop_hook_active) {
+    process.exit(0);
+    return;
+  }
+
+  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) {
+    process.exit(0);
+    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`);
+
+  let session;
+  try {
+    session = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
+  } catch {
+    process.exit(0);
+    return;
+  }
+
+  if (!session.conversationId) {
+    process.exit(0);
+    return;
+  }
+
+  // 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 {
+    process.exit(0);
+    return;
+  }
+
+  if (!config.token) {
+    process.exit(0);
+    return;
+  }
+
+  const apiUrl = config.apiUrl || 'http://localhost:3001';
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${config.token}`,
+  };
+
+  // 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
+      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),
+        }),
+      ]);
+    }
+  } 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(() => {});
+  }
+
+  process.exit(0);
+});

package/hooks/termify-sync.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+/**
+ * Termify Sync Hook (UserPromptSubmit / BeforeAgent)
+ *
+ * Syncs Claude Code & Gemini conversations to Termify chat.
+ * On each prompt: creates/reuses a conversation and adds the user message.
+ *
+ * Handles compressed context: Claude Code sometimes sends the full compressed
+ * transcript as "prompt". We extract just the user's actual message.
+ *
+ * Token: ~/.termify/config.json
+ * Session: /tmp/termify-session-{hash}.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Extract the actual user message from a prompt that might contain
+ * compressed transcript or system-reminder tags.
+ */
+/**
+ * Detect if the prompt is a compacted/compressed context rather than a real user message.
+ * Claude Code sends the full compressed transcript as prompt when context is compacted.
+ */
+function isCompactedContext(raw) {
+  if (!raw) return false;
+  // Compacted prompts are huge and contain summary markers
+  if (raw.length > 5000 && raw.includes('<system-reminder>')) return true;
+  // Starts with the transcript compaction header
+  if (raw.startsWith('This session is being continued from a previous conversation')) return true;
+  // Contains compaction-specific markers
+  if (raw.includes('conversation that ran out of context') && raw.includes('summary below')) return true;
+  return false;
+}
+
+function extractUserMessage(raw) {
+  if (!raw) return null;
+
+  // Skip compacted context entirely — not a real user message
+  if (isCompactedContext(raw)) return null;
+
+  // Clean prompt (no system markers, reasonable size) — use as-is
+  if (raw.length < 2000 && !raw.includes('<system-reminder>') && !raw.startsWith('===')) {
+    return raw.trim();
+  }
+
+  // Compressed context: extract the last user message after all system tags
+  // Pattern: ...system stuff...\n</system-reminder>\nactual user message
+  const parts = raw.split('</system-reminder>');
+  if (parts.length > 1) {
+    const lastPart = parts[parts.length - 1].trim();
+    // Must look like a real message, not continuation instructions
+    if (lastPart && lastPart.length > 0 && lastPart.length < 5000 && !isCompactedContext(lastPart)) {
+      return lastPart;
+    }
+  }
+
+  // Fallback: if starts with === Transcript, skip entirely
+  if (raw.startsWith('===')) {
+    return null;
+  }
+
+  // Last resort: take first 500 chars
+  return raw.substring(0, 500).trim() || null;
+}
+
+/**
+ * Detect which CLI is running from hook event name.
+ */
+function detectProvider(hookData) {
+  const event = hookData?.hook_event_name;
+  if (event === 'BeforeAgent') return 'gemini';
+  // Default to claude for Claude Code
+  return 'claude';
+}
+
+// Flag: running inside a Termify-managed chat terminal
+const isTermifyManaged = !!process.env.TERMIFY_CONVERSATION_ID;
+
+let input = '';
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', async () => {
+  let hookData;
+  try {
+    hookData = JSON.parse(input);
+  } catch {
+    process.exit(0);
+    return;
+  }
+
+  const transcriptPath = hookData?.transcript_path;
+  if (!transcriptPath) {
+    process.exit(0);
+    return;
+  }
+
+  // Session key from transcript_path
+  const sessionHash = crypto.createHash('md5').update(transcriptPath).digest('hex').substring(0, 12);
+  const sessionFile = path.join('/tmp', `termify-session-${sessionHash}.json`);
+
+  // ── Termify-managed: create session file from env vars (no API calls) ──
+  if (isTermifyManaged) {
+    fs.writeFileSync(sessionFile, JSON.stringify({
+      conversationId: process.env.TERMIFY_CONVERSATION_ID,
+      assistantMessageId: process.env.TERMIFY_MESSAGE_ID || null,
+      token: process.env.TERMIFY_TOKEN || null,
+      apiUrl: process.env.TERMIFY_API_URL || 'http://localhost:3001',
+      termifyManaged: true,
+      provider: 'claude',
+      thinkingsSent: 0,
+      updatedAt: new Date().toISOString(),
+    }));
+    process.exit(0);
+    return;
+  }
+
+  // ── External CLI: normal flow (create conversation, messages, etc.) ──
+
+  const rawPrompt = hookData?.prompt;
+  if (!rawPrompt) {
+    process.exit(0);
+    return;
+  }
+
+  const prompt = extractUserMessage(rawPrompt);
+  if (!prompt) {
+    // Compacted context or unparseable prompt — don't create messages.
+    // But update the session file to clear the old assistantMessageId
+    // so the Stop hook creates a fresh message for the next response.
+    if (session?.conversationId) {
+      fs.writeFileSync(sessionFile, JSON.stringify({
+        ...session,
+        assistantMessageId: null,
+        updatedAt: new Date().toISOString(),
+      }));
+    }
+    process.exit(0);
+    return;
+  }
+
+  // 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 {
+    process.exit(0);
+    return;
+  }
+
+  if (!config.token) {
+    process.exit(0);
+    return;
+  }
+
+  const apiUrl = config.apiUrl || 'http://localhost:3001';
+  const provider = detectProvider(hookData);
+
+  let session = null;
+  try {
+    session = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
+  } catch {}
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${config.token}`,
+  };
+
+  try {
+    let conversationId = session?.conversationId;
+
+    if (!conversationId) {
+      const firstLine = prompt.split('\n')[0].trim();
+      const title = firstLine.length > 80 ? firstLine.substring(0, 77) + '...' : firstLine;
+      const res = await fetch(`${apiUrl}/api/chat/conversations`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ title, provider }),
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!res.ok) {
+        process.exit(0);
+        return;
+      }
+      const json = await res.json();
+      conversationId = json.data?.id;
+    }
+
+    // Add user message (clean text only)
+    await fetch(`${apiUrl}/api/chat/conversations/${conversationId}/messages`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ role: 'user', content: prompt }),
+      signal: AbortSignal.timeout(5000),
+    });
+
+    // Create streaming assistant message placeholder
+    let assistantMessageId = null;
+    try {
+      const assistantRes = await fetch(`${apiUrl}/api/chat/conversations/${conversationId}/messages`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ role: 'assistant', content: '', status: 'streaming' }),
+        signal: AbortSignal.timeout(5000),
+      });
+      if (assistantRes.ok) {
+        const assistantJson = await assistantRes.json();
+        assistantMessageId = assistantJson.data?.id || null;
+      }
+    } catch {}
+
+    // Set conversation to working so frontend reconciliation doesn't show error
+    try {
+      await fetch(`${apiUrl}/api/chat/conversations/${conversationId}`, {
+        method: 'PATCH',
+        headers,
+        body: JSON.stringify({ status: 'working' }),
+        signal: AbortSignal.timeout(3000),
+      });
+    } catch {}
+
+    // Send initial thinking status event
+    if (assistantMessageId) {
+      try {
+        await fetch(`${apiUrl}/api/chat/conversations/${conversationId}/messages/${assistantMessageId}/events`, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({ events: [{ type: 'status', status: 'thinking' }] }),
+          signal: AbortSignal.timeout(3000),
+        });
+      } catch {}
+    }
+
+    fs.writeFileSync(sessionFile, JSON.stringify({
+      conversationId,
+      assistantMessageId,
+      transcriptPath,
+      provider,
+      thinkingsSent: 0,
+      updatedAt: new Date().toISOString(),
+    }));
+  } catch {}
+
+  process.exit(0);
+});

package/hooks/termify-tool-hook.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * Termify Tool Hook (PreToolUse / PostToolUse)
+ *
+ * Sends real-time events to Termify as Claude/Gemini works:
+ * - Thinking content as `text` events (italic markdown) → appears in message bubble
+ * - Tool calls as `tool_use` events → appears in ThinkingCollapsible
+ * - Tool results as `tool_result` events → appears in ThinkingCollapsible
+ *
+ * The `text` events replace each other (appendStreamEventReplacingText),
+ * so the message bubble always shows the latest accumulated thinking.
+ * When the Stop hook fires, the final response replaces the thinking.
+ *
+ * Token: ~/.termify/config.json
+ * Session: /tmp/termify-session-{hash}.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Read the transcript JSONL and extract ALL thinking blocks from the
+ * current assistant turn. Returns them in order.
+ */
+function extractAllThinkingFromTranscript(transcriptPath) {
+  try {
+    const data = fs.readFileSync(transcriptPath, 'utf-8');
+    const lines = data.trim().split('\n');
+
+    const thinkings = [];
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        // Stop at user message that isn't a tool result
+        if (entry.type === 'user' && !entry.toolUseResult && !entry.sourceToolAssistantUUID) break;
+        if (entry.type === 'assistant' && entry.message) {
+          const msg = entry.message;
+          const content = msg?.content || [];
+          for (const block of content) {
+            if (block?.type === 'thinking' && block.thinking) {
+              thinkings.unshift(block.thinking);
+            }
+          }
+        }
+      } catch {}
+    }
+
+    return thinkings;
+  } catch {
+    return [];
+  }
+}
+
+// Flag: Termify-managed terminal (hooks handle thinking, parser handles tools/text)
+const isTermifyManaged = !!process.env.TERMIFY_CONVERSATION_ID;
+
+let input = '';
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', async () => {
+  let hookData;
+  try {
+    hookData = JSON.parse(input);
+  } catch {
+    process.exit(0);
+    return;
+  }
+
+  const transcriptPath = hookData?.transcript_path;
+  const hookEvent = hookData?.hook_event_name;
+
+  if (!transcriptPath || !hookEvent) {
+    process.exit(0);
+    return;
+  }
+
+  // Find session file
+  const sessionHash = crypto.createHash('md5').update(transcriptPath).digest('hex').substring(0, 12);
+  const sessionFile = path.join('/tmp', `termify-session-${sessionHash}.json`);
+
+  let session;
+  try {
+    session = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
+  } catch {
+    process.exit(0);
+    return;
+  }
+
+  if (!session.conversationId || !session.assistantMessageId) {
+    process.exit(0);
+    return;
+  }
+
+  // Auth: for Termify-managed, use session token; otherwise use config
+  let authToken = session.token;
+  let apiUrl = session.apiUrl;
+
+  if (!authToken || !apiUrl) {
+    // Fallback: read from Termify config
+    try {
+      const configPath = path.join(process.env.HOME || '', '.termify', 'config.json');
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      authToken = authToken || config.token;
+      apiUrl = apiUrl || config.apiUrl || 'http://localhost:3001';
+    } catch {
+      process.exit(0);
+      return;
+    }
+  }
+
+  if (!authToken) {
+    process.exit(0);
+    return;
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${authToken}`,
+  };
+
+  const eventsUrl = `${apiUrl}/api/chat/conversations/${session.conversationId}/messages/${session.assistantMessageId}/events`;
+
+  try {
+    if (hookEvent === 'PreToolUse') {
+      const toolName = hookData?.tool_name || 'Unknown';
+      const toolInput = hookData?.tool_input || {};
+
+      // Detect AskUserQuestion / ExitPlanMode → signal needs_input to Termify
+      if (!session.termifyManaged && (toolName === 'AskUserQuestion' || toolName === 'ExitPlanMode')) {
+        const reason = toolName === 'AskUserQuestion'
+          ? (toolInput?.questions?.[0]?.question || 'Waiting for user input')
+          : 'Plan ready for approval';
+        fetch(`${apiUrl}/api/chat/conversations/${session.conversationId}/needs-input`, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({ reason }),
+          signal: AbortSignal.timeout(3000),
+        }).catch(() => {});
+      }
+
+      // Extract ALL thinking from transcript and build italic markdown
+      const allThinkings = extractAllThinkingFromTranscript(transcriptPath);
+
+      if (session.termifyManaged) {
+        // Termify-managed: parser handles everything (thinking + tools + text).
+        // No-op — events posted here would be overwritten by finalizeExecution anyway.
+      } else {
+        // External CLI: send thinking text + tool_use events
+        const events = [];
+        if (allThinkings.length > 0) {
+          const thinkingText = allThinkings
+            .map(t => t.length > 4000 ? t.substring(0, 4000) + '...' : t)
+            .join('\n\n');
+          events.push({ type: 'text', content: '*' + thinkingText + '*' });
+        }
+        events.push({ type: 'tool_use', tool: toolName, args: toolInput });
+
+        await fetch(eventsUrl, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({ events }),
+          signal: AbortSignal.timeout(3000),
+        });
+      }
+    } else if (hookEvent === 'PostToolUse') {
+      // For Termify-managed: skip tool_result (parser handles it)
+      if (session.termifyManaged) {
+        // Termify-managed: parser handles everything. No-op.
+      } else {
+        // External CLI: send tool_result
+        const toolResponse = hookData?.tool_response;
+        let output = '';
+        if (typeof toolResponse === 'string') {
+          output = toolResponse.substring(0, 500);
+        } else if (toolResponse != null) {
+          output = JSON.stringify(toolResponse).substring(0, 500);
+        }
+        await fetch(eventsUrl, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({
+            events: [{ type: 'tool_result', output }],
+          }),
+          signal: AbortSignal.timeout(3000),
+        });
+      }
+    }
+  } catch {
+    // Silently fail - don't block Claude Code
+  }
+
+  process.exit(0);
+});