teleportation-cli 1.4.4 → 1.5.0

package/.claude/hooks/stop.mjs

@@ -5,8 +5,8 @@
  * This hook fires when Claude Code finishes responding.
  *
  * Purpose:
- * 1. Check for pending messages from the mobile app (existing functionality)
- * 2. Extract Claude's last response from the transcript and log it to timeline
+ * 1. Delegate to daemon (lean path) — POST /sessions/stop with 1.5s timeout, exit immediately on 2xx.
+ * 2. Fallback (daemon unreachable): extract transcript events and batch-log to relay inline.
  */
 
 import { stdin, stdout, stderr, exit, env } from 'node:process';
@@ -128,6 +128,13 @@ const isValidSessionId = (id) => {
   return id && typeof id === 'string' && /^[a-zA-Z0-9-]+$/.test(id) && id.length >= 8;
 };
 
+// Strict UUID v4 validation — used for externally-supplied IDs like TELEPORTATION_PARENT_SESSION_ID
+// to prevent accidental relay requests to non-existent sessions from misconfigured env vars.
+const isValidUUID = (id) => {
+  return id && typeof id === 'string' &&
+    /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id);
+};
+
 /**
  * Truncation length constants - intentionally different for different message types
  *
@@ -1167,8 +1174,28 @@ const extractSystemMessages = async (transcriptPath, sessionId, log) => {
   const { session_id, transcript_path, stop_hook_active } = input || {};
   log(`Session: ${session_id}, Transcript: ${transcript_path}, stop_hook_active: ${stop_hook_active}`);
 
+  if (stop_hook_active) {
+    log('stop_hook_active=true — skipping all processing to prevent recursive hook calls');
+    return exit(0);
+  }
+
   const source = 'cli_interactive';
 
+  // When this session was spawned by a mobile Send (task executor), fan events to the parent timeline.
+  // Use strict UUID v4 validation — env var could be a typo, test value, or stale config.
+  const PARENT_SESSION_ID = env.TELEPORTATION_PARENT_SESSION_ID || '';
+  let parentSessionId = null;
+  if (PARENT_SESSION_ID) {
+    if (!isValidUUID(PARENT_SESSION_ID)) {
+      log(`WARN: TELEPORTATION_PARENT_SESSION_ID="${PARENT_SESSION_ID}" is not a valid UUID v4 — ignoring`);
+    } else if (PARENT_SESSION_ID === session_id) {
+      log(`WARN: TELEPORTATION_PARENT_SESSION_ID is the same as session_id — self-loop prevented`);
+    } else {
+      parentSessionId = PARENT_SESSION_ID;
+      log(`Parent session detected: ${parentSessionId} — will fan-out events to parent timeline`);
+    }
+  }
+
   const RELAY_API_URL = env.RELAY_API_URL || config.relayApiUrl || '';
   const RELAY_API_KEY = env.RELAY_API_KEY || config.relayApiKey || '';
 
@@ -1183,6 +1210,31 @@ const extractSystemMessages = async (transcriptPath, sessionId, log) => {
     return exit(0);
   }
 
+  // AC1/AC2: Lean path — delegate to daemon if reachable (1.5s timeout).
+  // On success (2xx), exit immediately. On any failure, fall through to inline logic.
+  const DAEMON_PORT = config.daemonPort || env.TELEPORTATION_DAEMON_PORT || '3050';
+  const daemonBody = { session_id, transcript_path };
+  if (parentSessionId) daemonBody.parent_session_id = parentSessionId;
+
+  try {
+    const daemonRes = await fetchWithTimeout(
+      `http://127.0.0.1:${DAEMON_PORT}/sessions/stop`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(daemonBody),
+      },
+      1500
+    );
+    if (daemonRes.ok) {
+      log(`[stop-delegate] Daemon accepted stop signal — exiting lean path`);
+      return exit(0);
+    }
+    log(`[stop-delegate] Daemon returned HTTP ${daemonRes.status} — falling back to inline logic`);
+  } catch (e) {
+    log(`[stop-delegate] Daemon unreachable (${e.message}) — falling back to inline logic`);
+  }
+
   if (!STOP_FULL_INGEST_ENABLED) {
     log('Stop full ingest disabled (TELEPORTATION_STOP_FULL_INGEST!=true) - running lightweight stop path');
   }
@@ -1213,8 +1265,6 @@ const extractSystemMessages = async (transcriptPath, sessionId, log) => {
       parseTranscriptToEvents(transcript_path, session_id, RELAY_API_URL, RELAY_API_KEY, log, transcript),
       extractFullTranscript(transcript_path, log, transcript)
     ]);
-  } else if (stop_hook_active) {
-    log('Skipping batch event log (stop_hook_active=true)');
   } else if (!STOP_FULL_INGEST_ENABLED) {
     log('Skipping batch event log (full ingest disabled)');
   } else if (skipHeavyUpload) {
@@ -1225,7 +1275,7 @@ const extractSystemMessages = async (transcriptPath, sessionId, log) => {
   cursor = parsedResult.cursor || null;
 
   // PARALLEL: Fire all HTTP calls together using Promise.allSettled
-  // This avoids sequential waiting for: batch events, transcript storage, pending messages
+  // This avoids sequential waiting for: batch events, transcript storage
   const httpTasks = [];
 
   // 1. Batch log events
@@ -1267,6 +1317,45 @@ const extractSystemMessages = async (transcriptPath, sessionId, log) => {
     }
   }
 
+  // 1b. Fan-out: send same events to parent session timeline so mobile-sent tasks
+  //     appear inline in the parent timeline (not only in the child session).
+  if (events.length > 0 && parentSessionId) {
+    const MAX_BATCH_SIZE = 1000;
+    const parentChunks = [];
+    for (let i = 0; i < events.length; i += MAX_BATCH_SIZE) {
+      parentChunks.push(events.slice(i, i + MAX_BATCH_SIZE));
+    }
+    log(`📤 Fanning out ${events.length} events to parent session ${parentSessionId} in ${parentChunks.length} batch(es)`);
+
+    for (let i = 0; i < parentChunks.length; i++) {
+      const chunk = parentChunks[i];
+      const batchIndex = i;
+      // Tag each event with child_session_id for provenance (non-breaking extra field)
+      const taggedChunk = chunk.map(evt => ({
+        ...evt,
+        data: { ...evt.data, child_session_id: session_id }
+      }));
+      httpTasks.push(
+        fetchJsonWithRetry(`${RELAY_API_URL}/api/sessions/${parentSessionId}/events/batch`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${RELAY_API_KEY}`
+          },
+          body: JSON.stringify({ events: taggedChunk })
+        }, log, 0, BATCH_FETCH_TIMEOUT_MS)
+          .then(response => {
+            log(`✅ Parent fan-out batch ${batchIndex + 1}/${parentChunks.length}: ${response.success || 0} success, ${response.failed || 0} failed`);
+            return { type: 'parent_fanout', success: response.success || 0, failed: response.failed || 0 };
+          })
+          .catch(e => {
+            log(`❌ Parent fan-out batch ${batchIndex + 1}/${parentChunks.length} failed: ${e.message}`);
+            return { type: 'parent_fanout', success: 0, failed: chunk.length };
+          })
+      );
+    }
+  }
+
   // 2. Store full transcript
   if (transcriptData && transcriptData.messages && transcriptData.messages.length > 0) {
     httpTasks.push(
@@ -1295,34 +1384,6 @@ const extractSystemMessages = async (transcriptPath, sessionId, log) => {
     );
   }
 
-  // 3. Check for pending messages from mobile app
-  httpTasks.push(
-    fetchWithTimeout(`${RELAY_API_URL}/api/messages/pending?session_id=${encodeURIComponent(session_id)}`, {
-      headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
-    })
-      .then(async res => {
-        if (res.ok) {
-          const msg = await res.json();
-          if (msg && msg.id && msg.text) {
-            log(`Found pending message: ${String(msg.text).slice(0, 50)}...`);
-            try {
-              await fetchWithTimeout(`${RELAY_API_URL}/api/messages/${msg.id}/ack`, {
-                method: 'POST',
-                headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
-              });
-            } catch {}
-            log(`Acknowledged pending message (mobile message injection not supported in stop hook)`);
-            return { type: 'messages', found: true };
-          }
-        }
-        return { type: 'messages', found: false };
-      })
-      .catch(e => {
-        log(`Error checking pending messages: ${e.message}`);
-        return { type: 'messages', found: false };
-      })
-  );
-
   // Wait for all HTTP calls to complete
   const results = await Promise.allSettled(httpTasks);
 
@@ -1356,6 +1417,26 @@ const extractSystemMessages = async (transcriptPath, sessionId, log) => {
     log(`⚠️ Transcript storage failed - timeline events were still logged separately`);
   }
 
+  // Log parent fan-out results. Fan-out is best-effort: failures do NOT block cursor advancement
+  // for the child session (cursor is only gated on primary batch success above). This means if
+  // the parent session has been garbage-collected or the relay rejects the fan-out, those events
+  // are permanently unrecoverable for the parent timeline. Acceptable tradeoff — the child
+  // session retains the authoritative record.
+  if (parentSessionId) {
+    const fanoutResults = results
+      .filter(r => r.status === 'fulfilled' && r.value?.type === 'parent_fanout')
+      .map(r => r.value);
+    if (fanoutResults.length > 0) {
+      const fanoutSuccess = fanoutResults.reduce((sum, r) => sum + r.success, 0);
+      const fanoutFailed = fanoutResults.reduce((sum, r) => sum + r.failed, 0);
+      if (fanoutFailed > 0) {
+        log(`⚠️ Parent fan-out: ${fanoutSuccess} success, ${fanoutFailed} failed — missed events are NOT retried (best-effort)`);
+      } else {
+        log(`✅ Parent fan-out: ${fanoutSuccess} events delivered to ${parentSessionId}`);
+      }
+    }
+  }
+
   log('Stop hook completed');
   return exit(0);
 })();

package/.gemini/hooks/after_agent.mjs

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+/**
+ * Gemini CLI AfterAgent Hook
+ *
+ * This hook fires when the Gemini agent completes its planning/execution loop.
+ * It mirrors the Claude Code stop hook for Teleportation.
+ */
+
+import { stdin, stdout, exit, env } from 'node:process';
+import { readFile } from 'node:fs/promises';
+import { appendFileSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadConfig } from './shared/config.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Security: Max input size to prevent memory exhaustion
+const MAX_INPUT_SIZE = 10 * 1024 * 1024; // 10MB
+
+// Read all stdin
+const readStdin = () => new Promise((resolve, reject) => {
+  let data = '';
+  stdin.setEncoding('utf8');
+  stdin.on('data', chunk => {
+    data += chunk;
+    if (data.length > MAX_INPUT_SIZE) {
+      reject(new Error('Input too large'));
+    }
+  });
+  stdin.on('end', () => resolve(data));
+  stdin.on('error', reject);
+});
+
+// Logging
+const hookLogFile = env.TELEPORTATION_HOOK_LOG || '/tmp/teleportation-gemini-hook.log';
+const log = (msg) => {
+  const timestamp = new Date().toISOString();
+  const logMsg = `[${timestamp}] [gemini:after_agent] ${msg}\n`;
+  try {
+    appendFileSync(hookLogFile, logMsg);
+  } catch (e) {
+    // Silently ignore
+  }
+};
+
+/**
+ * Generate MD5 hash of project slug for Gemini's directory naming.
+ */
+function hashSlug(slug) {
+  if (!slug) return createHash('md5').update('default').digest('hex').substring(0, 16);
+  return createHash('md5').update(slug).digest('hex').substring(0, 16);
+}
+
+/**
+ * Find and parse the Gemini transcript
+ */
+async function getTranscript(cwd, log) {
+  const hash = hashSlug(cwd);
+  const transcriptPath = join(homedir(), '.gemini', 'tmp', hash, 'logs.json');
+  
+  if (!existsSync(transcriptPath)) {
+    log(`Transcript not found at ${transcriptPath}`);
+    return null;
+  }
+
+  try {
+    const content = await readFile(transcriptPath, 'utf8');
+    return JSON.parse(content);
+  } catch (e) {
+    log(`Failed to parse transcript: ${e.message}`);
+    return null;
+  }
+}
+
+(async () => {
+  log('=== AfterAgent hook invoked ===');
+
+  try {
+    const raw = await readStdin();
+    let input;
+    try {
+      input = JSON.parse(raw || '{}');
+    } catch (e) {
+      log(`Invalid JSON input: ${e.message}`);
+      return exit(0);
+    }
+
+    const { session_id, model, response, cwd } = input;
+    const workingDir = cwd || process.cwd();
+    const teleportSessionId = env.TELEPORTATION_SESSION_ID || session_id || 'unknown';
+
+    log(`Session: ${teleportSessionId}, Model: ${model}, CWD: ${workingDir}`);
+
+    // Load config from shared module
+    const config = await loadConfig(log);
+    const RELAY_API_URL = config.relayApiUrl;
+    const RELAY_API_KEY = config.relayApiKey;
+
+    log(`Using Relay: ${RELAY_API_URL}`);
+
+    if (!RELAY_API_URL || !RELAY_API_KEY) {
+      log('No relay configured, skipping transcript ingestion');
+      return exit(0);
+    }
+
+    let assistantText = '';
+    
+    // 1. Try to use response from input if provided
+    if (response && response.content) {
+      log('Using response from hook input');
+      assistantText = typeof response.content === 'string' 
+        ? response.content 
+        : JSON.stringify(response.content);
+    } 
+    // 2. Otherwise, parse the transcript file
+    else {
+      log('Parsing transcript file from disk');
+      const transcript = await getTranscript(workingDir, log);
+      if (transcript && Array.isArray(transcript)) {
+        // Find last model message
+        for (let i = transcript.length - 1; i >= 0; i--) {
+          const msg = transcript[i];
+          if (msg.role === 'model' || msg.role === 'assistant') {
+            if (Array.isArray(msg.parts)) {
+              assistantText = msg.parts
+                .filter(p => p.text)
+                .map(p => p.text)
+                .join('\n\n');
+            } else if (typeof msg.content === 'string') {
+              assistantText = msg.content;
+            }
+            
+            if (assistantText) break;
+          }
+        }
+      }
+    }
+
+    if (!assistantText) {
+      log('No assistant message found to log');
+      return exit(0);
+    }
+
+    // Truncate if too long (parity with Claude)
+    const ASSISTANT_RESPONSE_MAX_LENGTH = 2000;
+    const preview = assistantText.length > ASSISTANT_RESPONSE_MAX_LENGTH 
+      ? assistantText.slice(0, ASSISTANT_RESPONSE_MAX_LENGTH) + '...' 
+      : assistantText;
+
+    // Log to timeline
+    const timelineEvent = {
+      session_id: teleportSessionId,
+      type: 'assistant_response',
+      data: {
+        message: preview,
+        model: model || null,
+        full_length: assistantText.length,
+        truncated: assistantText.length > ASSISTANT_RESPONSE_MAX_LENGTH,
+        timestamp: Date.now()
+      },
+      source: 'gemini-cli',
+      timestamp: Date.now()
+    };
+
+    try {
+      await fetch(`${RELAY_API_URL}/api/timeline`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${RELAY_API_KEY}`
+        },
+        body: JSON.stringify(timelineEvent),
+        signal: AbortSignal.timeout(5000)
+      });
+      log(`Logged assistant_response (${assistantText.length} chars)`);
+    } catch (e) {
+      log(`Failed to log timeline event: ${e.message}`);
+    }
+
+    return exit(0);
+
+  } catch (e) {
+    log(`Hook error: ${e.message}`);
+    return exit(0);
+  }
+})();

package/.gemini/hooks/after_tool.mjs

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * Gemini CLI AfterTool Hook
+ * 
+ * This hook executes AFTER any tool runs in Gemini CLI.
+ * It mirrors the Claude Code post_tool_use hook for Teleportation.
+ */
+
+import { stdin, stdout, exit, env } from 'node:process';
+import { appendFileSync } from 'node:fs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { loadConfig } from './shared/config.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Security: Max input size to prevent memory exhaustion
+const MAX_INPUT_SIZE = 10 * 1024 * 1024; // 10MB
+
+// Read all stdin
+const readStdin = () => new Promise((resolve, reject) => {
+  let data = '';
+  stdin.setEncoding('utf8');
+  stdin.on('data', chunk => {
+    data += chunk;
+    if (data.length > MAX_INPUT_SIZE) {
+      reject(new Error('Input too large'));
+    }
+  });
+  stdin.on('end', () => resolve(data));
+  stdin.on('error', reject);
+});
+
+// Logging
+const hookLogFile = env.TELEPORTATION_HOOK_LOG || '/tmp/teleportation-gemini-hook.log';
+const log = (msg) => {
+  const timestamp = new Date().toISOString();
+  const logMsg = `[${timestamp}] [gemini:after_tool] ${msg}\n`;
+  try {
+    appendFileSync(hookLogFile, logMsg);
+  } catch (e) {
+    // Silently ignore
+  }
+};
+
+// Fetch JSON helper
+const fetchJson = async (url, opts) => {
+  const res = await fetch(url, opts);
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+};
+
+(async () => {
+  log('=== AfterTool hook invoked ===');
+
+  try {
+    const raw = await readStdin();
+    let input;
+    try {
+      input = JSON.parse(raw || '{}');
+    } catch (e) {
+      log(`Invalid JSON input: ${e.message}`);
+      return exit(0);
+    }
+
+    const { tool_name, tool_input, tool_output, success, error, session_id, duration_ms } = input;
+    const teleportSessionId = env.TELEPORTATION_SESSION_ID || session_id || 'unknown';
+    log(`Tool: ${tool_name}, Success: ${success}, Duration: ${duration_ms}ms, TeleportSession: ${teleportSessionId}`);
+
+    // Load config from shared module
+    const config = await loadConfig(log);
+    const RELAY_API_URL = config.relayApiUrl;
+    const RELAY_API_KEY = config.relayApiKey;
+
+    log(`Using Relay: ${RELAY_API_URL}`);
+
+    // If no relay configured, just log locally
+    if (!RELAY_API_URL || !RELAY_API_KEY) {
+      log('No relay configured, skipping timeline event');
+      return exit(0);
+    }
+
+    // Log to timeline
+    const timelineEvent = {
+      session_id: teleportSessionId,
+      type: 'tool_executed',
+      data: {
+        tool_name,
+        tool_input: JSON.stringify(tool_input).slice(0, 1000),
+        tool_output: typeof tool_output === 'string' 
+          ? tool_output.slice(0, 5000) 
+          : JSON.stringify(tool_output).slice(0, 5000),
+        success,
+        error: error || null,
+        duration_ms,
+        timestamp: Date.now()
+      },
+      source: 'gemini-cli',
+      timestamp: Date.now(),
+    };
+
+    try {
+      await fetch(`${RELAY_API_URL}/api/timeline`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${RELAY_API_KEY}`,
+        },
+        body: JSON.stringify(timelineEvent),
+        signal: AbortSignal.timeout(5000),
+      });
+      log(`Timeline event logged for ${tool_name}`);
+    } catch (e) {
+      log(`Failed to log timeline event: ${e.message}`);
+    }
+
+    // Output empty response (hook completed successfully)
+    stdout.write('{}');
+    return exit(0);
+
+  } catch (e) {
+    log(`Hook error: ${e.message}`);
+    return exit(0);
+  }
+})();