termify-agent 1.0.28 → 1.0.29

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);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termify-agent",
-  "version": "1.0.28",
+  "version": "1.0.29",
   "description": "Termify Agent CLI - Connect your local terminal to Termify",
   "type": "module",
   "main": "dist/index.js",