termify-agent 1.0.28 → 1.0.29

package/hooks/termify-codex-notify.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+/**
+ * Termify Sync for Codex CLI (notify hook)
+ *
+ * Syncs Codex conversations to Termify chat.
+ * Codex passes JSON as argv[1] on "agent-turn-complete" events.
+ *
+ * Payload: { type, thread-id, turn-id, cwd, input-messages, last-assistant-message }
+ *
+ * Token: ~/.termify/config.json
+ * Session: /tmp/termify-session-codex-{thread-id}.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Skip sync when running inside a Termify-managed chat terminal
+if (process.env.TERMIFY_CONVERSATION_ID) {
+  process.exit(0);
+}
+
+(async () => {
+  let payload;
+  try {
+    payload = JSON.parse(process.argv[2] || '{}');
+  } catch {
+    process.exit(0);
+    return;
+  }
+
+  if (payload.type !== 'agent-turn-complete') {
+    process.exit(0);
+    return;
+  }
+
+  const threadId = payload['thread-id'];
+  const lastMessage = payload['last-assistant-message'];
+  const inputMessages = payload['input-messages'];
+
+  if (!threadId || !lastMessage) {
+    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}`,
+  };
+
+  // Session file keyed by thread-id
+  const sessionFile = path.join('/tmp', `termify-session-codex-${threadId}.json`);
+
+  let session = null;
+  try {
+    session = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
+  } catch {}
+
+  try {
+    let conversationId = session?.conversationId;
+
+    if (!conversationId) {
+      // Extract user prompt for conversation title
+      let userPrompt = '';
+      if (typeof inputMessages === 'string') {
+        userPrompt = inputMessages;
+      } else if (Array.isArray(inputMessages) && inputMessages.length > 0) {
+        const first = inputMessages[0];
+        userPrompt = typeof first === 'string' ? first : (first?.content || first?.text || '');
+      }
+      userPrompt = userPrompt.trim();
+
+      const firstLine = (userPrompt || 'Codex session').split('\n')[0].trim();
+      const title = firstLine.length > 80 ? firstLine.substring(0, 77) + '...' : firstLine;
+
+      // Create conversation
+      const res = await fetch(`${apiUrl}/api/chat/conversations`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ title, provider: 'codex' }),
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!res.ok) {
+        process.exit(0);
+        return;
+      }
+      const json = await res.json();
+      conversationId = json.data?.id;
+
+      // Add user message
+      if (userPrompt) {
+        await fetch(`${apiUrl}/api/chat/conversations/${conversationId}/messages`, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({ role: 'user', content: userPrompt }),
+          signal: AbortSignal.timeout(5000),
+        });
+      }
+
+      // Save session
+      fs.writeFileSync(sessionFile, JSON.stringify({
+        conversationId,
+        threadId,
+        provider: 'codex',
+        updatedAt: new Date().toISOString(),
+      }));
+    } else {
+      // Existing conversation — check if there are new user messages to sync
+      // input-messages contains the latest user prompt that triggered this turn
+      let userPrompt = '';
+      if (typeof inputMessages === 'string') {
+        userPrompt = inputMessages;
+      } else if (Array.isArray(inputMessages) && inputMessages.length > 0) {
+        const last = inputMessages[inputMessages.length - 1];
+        userPrompt = typeof last === 'string' ? last : (last?.content || last?.text || '');
+      }
+      userPrompt = userPrompt.trim();
+
+      if (userPrompt && userPrompt !== session.lastUserPrompt) {
+        await fetch(`${apiUrl}/api/chat/conversations/${conversationId}/messages`, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify({ role: 'user', content: userPrompt }),
+          signal: AbortSignal.timeout(5000),
+        });
+      }
+
+      // Update session with last prompt to avoid duplicates
+      session.lastUserPrompt = userPrompt;
+      session.updatedAt = new Date().toISOString();
+      fs.writeFileSync(sessionFile, JSON.stringify(session));
+    }
+
+    // Add assistant response
+    await fetch(`${apiUrl}/api/chat/conversations/${conversationId}/messages`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ role: 'assistant', content: lastMessage.trim() }),
+      signal: AbortSignal.timeout(5000),
+    });
+  } catch {
+    // Silently fail
+  }
+
+  process.exit(0);
+})();

package/hooks/termify-needs-input-hook.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * Termify Needs-Input Hook (PreToolUse - ExitPlanMode, EnterPlanMode, etc.)
+ *
+ * When Claude Code invokes tools that pause for user input in the terminal
+ * (plan approval, plan mode entry, etc.), this hook signals Termify to:
+ * 1. Pause execution watchdogs (prevents 90s idle timeout)
+ * 2. Set conversation status to needs_input
+ * 3. Send notification to the user
+ *
+ * Token: ~/.termify/config.json
+ * Session: /tmp/termify-session-{hash}.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const TOOL_REASONS = {
+  ExitPlanMode: 'Claude has a plan ready for your approval',
+  EnterPlanMode: 'Claude wants to enter plan mode',
+};
+
+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 toolName = hookData?.tool_name;
+
+  if (!transcriptPath || !toolName) {
+    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) {
+    process.exit(0);
+    return;
+  }
+
+  // Auth: use session token or config
+  let authToken = session.token;
+  let apiUrl = session.apiUrl;
+
+  if (!authToken || !apiUrl) {
+    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 reason = TOOL_REASONS[toolName] || `Waiting for input (${toolName})`;
+
+  try {
+    await fetch(
+      `${apiUrl}/api/chat/conversations/${session.conversationId}/needs-input`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${authToken}`,
+        },
+        body: JSON.stringify({ reason }),
+        signal: AbortSignal.timeout(3000),
+      }
+    );
+  } catch {
+    // Silently fail — don't block Claude Code
+  }
+
+  process.exit(0);
+});

package/hooks/termify-question-hook.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * Termify Question Hook (PreToolUse - AskUserQuestion)
+ *
+ * When Claude Code invokes AskUserQuestion, this hook:
+ * 1. Sends the question as a stream event to Termify
+ * 2. Registers the pending question on the server
+ * 3. Long-polls for the user's answer from Termify UI
+ * 4. If answered, pre-fills the response via updatedInput
+ *
+ * Token: ~/.termify/config.json
+ * Session: /tmp/termify-session-{hash}.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+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 toolInput = hookData?.tool_input;
+
+  if (!transcriptPath || !toolInput?.questions) {
+    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;
+  }
+
+  // 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}`,
+  };
+
+  const questionId = crypto.randomUUID();
+
+  try {
+    // 1. Send question event to Termify stream
+    await fetch(
+      `${apiUrl}/api/chat/conversations/${session.conversationId}/messages/${session.assistantMessageId}/events`,
+      {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          events: [{ type: 'question', questionId, questions: toolInput.questions }],
+        }),
+        signal: AbortSignal.timeout(3000),
+      }
+    );
+
+    // 2. Register pending question on server
+    await fetch(
+      `${apiUrl}/api/chat/conversations/${session.conversationId}/question`,
+      {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+          questionId,
+          questions: toolInput.questions,
+          messageId: session.assistantMessageId,
+        }),
+        signal: AbortSignal.timeout(3000),
+      }
+    );
+
+    // 3. Signal needs-input: pause execution watchdog + set status + notify
+    const firstQuestion = toolInput.questions[0]?.question || 'Waiting for your answer';
+    await fetch(
+      `${apiUrl}/api/chat/conversations/${session.conversationId}/needs-input`,
+      {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ reason: firstQuestion }),
+        signal: AbortSignal.timeout(3000),
+      }
+    );
+
+    // 4. Long-poll for the user's answer (timeout 120s)
+    const response = await fetch(
+      `${apiUrl}/api/chat/conversations/${session.conversationId}/question/${questionId}/response`,
+      {
+        headers,
+        signal: AbortSignal.timeout(120000),
+      }
+    );
+
+    if (response.ok) {
+      const data = await response.json();
+      if (data.answer) {
+        // 4. Pre-fill the answer in the tool input
+        console.log(JSON.stringify({
+          hookSpecificOutput: {
+            permissionDecision: 'allow',
+            updatedInput: { ...toolInput, answers: data.answer },
+          },
+        }));
+        process.exit(0);
+        return;
+      }
+    }
+  } catch {
+    // Timeout or error: fall through to terminal
+  }
+
+  // Fallback: let the question modal appear in the terminal
+  process.exit(0);
+});

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