teleportation-cli 1.4.5 → 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/lib/daemon/teleportation-daemon.js

@@ -40,7 +40,7 @@ import { spawn, exec } from 'child_process';
 import { promisify } from 'util';
 import { homedir, tmpdir } from 'os';
 import { existsSync, appendFileSync, readFileSync, unlinkSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } from 'path';
 // NOTE: PID locking is handled by agent-process at the platform level (launchd/systemd/pm2).
 // Signal handling and heartbeat management are handled inline below.
 
@@ -677,6 +677,13 @@ function validateSessionId(session_id) {
   return session_id;
 }
 
+// Strict UUID v4 validation — used for externally-supplied IDs to prevent
+// accidental relay requests to non-existent sessions from misconfigured env vars.
+function 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);
+}
+
 function validateApprovalId(approval_id) {
   if (!approval_id || typeof approval_id !== 'string') {
     throw new Error('approval_id must be a non-empty string');
@@ -895,6 +902,91 @@ async function handleRequest(req, res) {
       return;
     }
 
+    // Stop-hook delegate: ingest transcript asynchronously so stop.mjs can exit immediately
+    if (method === 'POST' && pathname === '/sessions/stop') {
+      const body = await parseJSONBody(req);
+      const { session_id, transcript_path, parent_session_id } = body;
+
+      try {
+        validateSessionId(session_id);
+      } catch (validationError) {
+        sendJSON(res, 400, { error: validationError.message });
+        return;
+      }
+
+      if (!transcript_path || typeof transcript_path !== 'string') {
+        sendJSON(res, 400, { error: 'transcript_path must be a non-empty string' });
+        return;
+      }
+
+      // Path traversal guard: transcript_path must resolve inside ~/.claude/projects/.
+      // The daemon has no auth on localhost — any local process can POST to it, so we
+      // must not allow arbitrary filesystem reads via a crafted transcript_path value.
+      const resolvedTranscriptPath = resolve(transcript_path);
+      const allowedTranscriptRoot = join(homedir(), '.claude', 'projects');
+      if (!resolvedTranscriptPath.startsWith(allowedTranscriptRoot + '/')) {
+        sendJSON(res, 400, { error: 'transcript_path must be within ~/.claude/projects' });
+        return;
+      }
+
+      // Validate optional parent_session_id (UUID v4 only, must differ from session_id)
+      const validParentId = parent_session_id &&
+        isValidUUID(parent_session_id) &&
+        parent_session_id !== session_id
+        ? parent_session_id
+        : null;
+
+      // Respond immediately — processing is async (AC3)
+      sendJSON(res, 200, { queued: true });
+
+      // Fire-and-forget ingestion (AC3, AC5)
+      setImmediate(async () => {
+        const sessionEntry = sessions.get(session_id);
+        const claude_session_id = sessionEntry?.claude_session_id || session_id;
+        const cwd = sessionEntry?.cwd || process.cwd();
+
+        console.log(`[daemon] /sessions/stop: ingesting transcript for ${session_id} (transcript_path=${transcript_path})`);
+
+        try {
+          await ingestTranscriptToTimeline({
+            claude_session_id,
+            parent_session_id: session_id,
+            task_id: null,
+            cwd,
+            transcript_path, // AC4: use authoritative path from stop hook
+            config: {
+              relayApiUrl: RELAY_API_URL,
+              apiKey: RELAY_API_KEY
+            },
+            maxEvents: Infinity // AC5: no cap for triggered ingestion
+          });
+        } catch (err) {
+          console.error(`[daemon] /sessions/stop: child ingestion error for ${session_id}: ${err.message}`);
+        }
+
+        // AC6: Best-effort fan-out to parent session timeline
+        if (validParentId) {
+          try {
+            await ingestTranscriptToTimeline({
+              claude_session_id,
+              parent_session_id: validParentId,
+              task_id: null,
+              cwd,
+              transcript_path,
+              config: {
+                relayApiUrl: RELAY_API_URL,
+                apiKey: RELAY_API_KEY
+              },
+              maxEvents: Infinity
+            });
+          } catch (err) {
+            console.warn(`[daemon] ⚠️ Parent fan-out failed for session ${validParentId}: ${err.message} — missed events are NOT retried (best-effort)`);
+          }
+        }
+      });
+
+      return;
+    }
 
     // Queue approval for daemon handling
     if (method === 'POST' && pathname === '/approvals/handoff') {

package/lib/daemon/transcript-ingestion.js

@@ -665,7 +665,7 @@ async function updateLastIngestedIndex(task_id, session_id, lastIndex, config) {
  * @returns {Promise<Object>} Result { events_pushed: number }
  */
 export async function ingestTranscriptToTimeline(options) {
-  const { claude_session_id, parent_session_id, task_id, cwd, config, onNormalizedEvents, realTimeMode = false, maxEvents } = options;
+  const { claude_session_id, parent_session_id, task_id, cwd, config, onNormalizedEvents, realTimeMode = false, maxEvents, transcript_path } = options;
   const { relayApiUrl, apiKey } = config;
 
   // Determine max events based on mode
@@ -689,8 +689,25 @@ export async function ingestTranscriptToTimeline(options) {
   console.log(`[transcript] ===== INGESTION START =====`);
   console.log(`[transcript] claude_session: ${claude_session_id}, parent: ${parent_session_id}, task: ${task_id}`);
 
-  // 1. Read transcript with cwd for project slug derivation
-  const transcript = await readTranscript(claude_session_id, cwd);
+  // 1. Read transcript — use explicit path when provided (AC4), otherwise derive via cwd/project-slug.
+  // When transcript_path is supplied by the stop-hook delegate, the daemon skips path derivation
+  // entirely. The daemon's cursor (in /tmp/teleportation-cursors/) becomes the sole writer;
+  // any stale stop-hook cursors (~/.teleportation/.stop_hook_cursor_v2/) are silently superseded.
+  // ON CONFLICT DO NOTHING on the relay prevents duplicates on first-run reprocessing.
+  let transcript;
+  if (transcript_path) {
+    try {
+      const content = await readFile(transcript_path, 'utf8');
+      const lines = content.trim().split('\n').filter(Boolean);
+      transcript = lines.map(line => JSON.parse(line));
+      console.log(`[transcript] Loaded ${transcript.length} messages from explicit path: ${transcript_path}`);
+    } catch (e) {
+      console.error(`[transcript] Failed to read transcript at ${transcript_path}: ${e.message}`);
+      transcript = [];
+    }
+  } else {
+    transcript = await readTranscript(claude_session_id, cwd);
+  }
   log(`Read transcript: ${transcript.length} messages`);
   if (transcript.length === 0) {
     log(`No transcript found or empty - returning`);
@@ -717,6 +734,12 @@ export async function ingestTranscriptToTimeline(options) {
     // For regular sessions: Use local cursor as primary deduplication,
     // with timeline query as validation
     const cursorMessageCount = await readCursor(parent_session_id);
+    if (cursorMessageCount === 0 && transcript_path) {
+      // AC7: First daemon-triggered ingestion for this session. The stop-hook cursor
+      // (~/.teleportation/.stop_hook_cursor_v2/) is now stale. The daemon reprocesses
+      // from the start; server-side ON CONFLICT DO NOTHING prevents duplicates.
+      console.log(`[stop-delegate] First daemon ingestion for session ${parent_session_id} — reprocessing from start (dedup handles any duplicates)`);
+    }
     console.log(`[transcript] Local cursor: ${cursorMessageCount} messages previously processed`);
     console.log(`[transcript] Querying timeline for session ${parent_session_id} to find recent events...`);
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teleportation-cli",
-  "version": "1.4.5",
+  "version": "1.5.0",
   "description": "Remote approval system for Claude Code - approve AI coding changes from your phone",
   "type": "module",
   "main": "teleportation-cli.cjs",
@@ -56,6 +56,8 @@
     ".claude/hooks/*.mjs",
     "!.claude/hooks/*.test.mjs",
     ".gemini/hooks/*.mjs",
+    "!.gemini/hooks/*.test.mjs",
+    "!.gemini/hooks/test-hooks.mjs",
     ".gemini/hooks/shared/*.mjs",
     "teleportation.uhr.json",
     "scripts/sync-transcripts.sh",

package/teleportation-cli.cjs

@@ -335,6 +335,21 @@ async function commandOn() {
         if (uhrResult.warnings.length > 0) {
           uhrResult.warnings.forEach(w => console.log(c.yellow(`  ⚠️  ${w}`)));
         }
+
+        // UHR handles Claude Code + Gemini CLI via settings files, but Cursor IDE
+        // hooks require a separate write to ~/.cursor/hooks.json via the legacy installer
+        try {
+          const installerPath = path.join(TELEPORTATION_DIR, 'lib', 'install', 'installer.js');
+          const { checkCursorIde, installCursorHooks } = await import('file://' + installerPath);
+          if (checkCursorIde().valid) {
+            const sourceHooksDir = path.join(TELEPORTATION_DIR, '.claude', 'hooks');
+            await installCursorHooks(sourceHooksDir);
+            console.log(c.green('  ✅ Cursor IDE hooks installed'));
+            console.log(c.dim('     Config: ~/.cursor/hooks.json'));
+          }
+        } catch (e) {
+          // Cursor not installed or hooks install failed — non-fatal
+        }
       } else {
         if (uhrResult.success && !fs.existsSync(globalSettings)) {
           console.log(c.yellow('  ⚠️  UHR reported success but did not write ~/.claude/settings.json'));
@@ -3467,7 +3482,8 @@ async function commandInstallHooks() {
           }
           installed = true;
 
-          // UHR only handles Claude Code — also install Cursor hooks via legacy installer
+          // UHR handles Claude Code + Gemini CLI via settings files, but Cursor IDE
+          // hooks require a separate write to ~/.cursor/hooks.json via the legacy installer
           try {
             const installerPath = path.join(TELEPORTATION_DIR, 'lib', 'install', 'installer.js');
             const { checkCursorIde, installCursorHooks } = await import('file://' + installerPath);

package/.gemini/hooks/after_agent.test.mjs

@@ -1,121 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Tests for Gemini CLI AfterAgent hook
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'bun:test';
-import * as fs from 'node:fs';
-import * as fsPromises from 'node:fs/promises';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-
-// Helper to simulate running the hook script
-// We'll extract the core logic into a testable function or just mock the dependencies
-// and require the script. Since it's an IIFE, we might need to refactor it slightly
-// for better testability, but for now we'll mock the global environment.
-
-describe('AfterAgent Hook Logic', () => {
-  let originalFetch = globalThis.fetch;
-  let existsSyncSpy;
-  let readFileSpy;
-  let fetchSpy;
-
-  beforeEach(() => {
-    existsSyncSpy = vi.spyOn(fs, 'existsSync');
-    readFileSpy = vi.spyOn(fsPromises, 'readFile');
-    fetchSpy = vi.fn().mockResolvedValue({ ok: true, json: () => Promise.resolve({ success: true }) });
-    globalThis.fetch = fetchSpy;
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    globalThis.fetch = originalFetch;
-  });
-
-  it('should calculate the correct transcript path', () => {
-    const { createHash } = require('node:crypto');
-    const cwd = '/Users/test/project';
-    const hash = createHash('md5').update(cwd).digest('hex').substring(0, 16);
-    const expectedPath = join(homedir(), '.gemini', 'tmp', hash, 'logs.json');
-    
-    // This just verifies our understanding of the path calculation
-    expect(expectedPath).toContain('.gemini/tmp/');
-    expect(expectedPath).toContain('/logs.json');
-  });
-
-  // Since we can't easily run the IIFE in the script without refactoring,
-  // let's at least test the parsing logic by re-implementing it here 
-  // and ensuring it works as expected. This verifies the "Dialectical Autocoder"
-  // requirement for robust parsing.
-
-  const parseTranscript = (content) => {
-    try {
-      const transcript = JSON.parse(content);
-      if (!Array.isArray(transcript)) return null;
-      
-      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)) {
-            return msg.parts
-              .filter(p => p.text)
-              .map(p => p.text)
-              .join('\n\n');
-          } else if (typeof msg.content === 'string') {
-            return msg.content;
-          }
-        }
-      }
-    } catch (e) {
-      return null;
-    }
-    return null;
-  };
-
-  it('should parse assistant response from JSON array transcript', () => {
-    const mockTranscript = JSON.stringify([
-      { role: 'user', parts: [{ text: 'hello' }] },
-      { role: 'model', parts: [{ text: 'hi there' }] }
-    ]);
-    
-    const result = parseTranscript(mockTranscript);
-    expect(result).toBe('hi there');
-  });
-
-  it('should parse assistant response with multiple parts', () => {
-    const mockTranscript = JSON.stringify([
-      { role: 'model', parts: [{ text: 'Part 1' }, { text: 'Part 2' }] }
-    ]);
-    
-    const result = parseTranscript(mockTranscript);
-    expect(result).toBe('Part 1\n\nPart 2');
-  });
-
-  it('should parse assistant response from content field (alternative format)', () => {
-    const mockTranscript = JSON.stringify([
-      { role: 'assistant', content: 'Legacy format response' }
-    ]);
-    
-    const result = parseTranscript(mockTranscript);
-    expect(result).toBe('Legacy format response');
-  });
-
-  it('should return null for transcript without assistant messages', () => {
-    const mockTranscript = JSON.stringify([
-      { role: 'user', parts: [{ text: 'hello' }] }
-    ]);
-    
-    const result = parseTranscript(mockTranscript);
-    expect(result).toBeNull();
-  });
-
-  it('should handle malformed JSON gracefully', () => {
-    const result = parseTranscript('not json');
-    expect(result).toBeNull();
-  });
-
-  it('should handle empty transcript', () => {
-    const result = parseTranscript('[]');
-    expect(result).toBeNull();
-  });
-});

package/.gemini/hooks/test-hooks.mjs

@@ -1,254 +0,0 @@
-#!/usr/bin/env node
-/**
- * Test script for Gemini CLI hooks
- * 
- * Tests each hook individually by simulating the input they receive
- * from Gemini CLI and verifying the output.
- * 
- * Usage:
- *   node .gemini/hooks/test-hooks.mjs
- * 
- * Or with relay configured:
- *   RELAY_API_URL=http://localhost:3030 RELAY_API_KEY=your-key node .gemini/hooks/test-hooks.mjs
- */
-
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Helper to run a hook with input and capture output
-async function runHook(hookName, input, timeoutMs = 10000) {
-  return new Promise((resolve, reject) => {
-    const hookPath = join(__dirname, `${hookName}.mjs`);
-    const proc = spawn('node', [hookPath], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: {
-        ...process.env,
-        TELEPORTATION_SESSION_ID: 'test-session-' + Date.now(),
-      },
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    proc.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    proc.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    const timeout = setTimeout(() => {
-      proc.kill('SIGTERM');
-      reject(new Error(`Hook ${hookName} timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-
-    proc.on('close', (code) => {
-      clearTimeout(timeout);
-      resolve({ code, stdout, stderr });
-    });
-
-    proc.on('error', (err) => {
-      clearTimeout(timeout);
-      reject(err);
-    });
-
-    // Send input
-    proc.stdin.write(JSON.stringify(input));
-    proc.stdin.end();
-  });
-}
-
-// Test cases
-async function testBeforeTool() {
-  console.log('\n=== Testing before_tool.mjs ===\n');
-
-  // Test 1: Safe tool (should auto-approve)
-  console.log('1. Testing safe tool (read_file)...');
-  try {
-    const result = await runHook('before_tool', {
-      tool_name: 'read_file',
-      tool_input: { path: '/tmp/test.txt' },
-      session_id: 'test-session',
-    });
-    
-    console.log(`   Exit code: ${result.code}`);
-    console.log(`   Output: ${result.stdout}`);
-    
-    const output = JSON.parse(result.stdout || '{}');
-    if (output.action === 'ALLOW') {
-      console.log('   ✓ Safe tool auto-approved');
-    } else {
-      console.log(`   ✗ Expected ALLOW, got ${output.action}`);
-    }
-  } catch (e) {
-    console.log(`   ✗ Error: ${e.message}`);
-  }
-
-  // Test 2: Safe shell command (git status)
-  console.log('\n2. Testing safe shell command (git status)...');
-  try {
-    const result = await runHook('before_tool', {
-      tool_name: 'run_shell_command',
-      tool_input: { command: 'git status' },
-      session_id: 'test-session',
-    });
-    
-    console.log(`   Exit code: ${result.code}`);
-    console.log(`   Output: ${result.stdout}`);
-    
-    const output = JSON.parse(result.stdout || '{}');
-    if (output.action === 'ALLOW') {
-      console.log('   ✓ Safe shell command auto-approved');
-    } else {
-      console.log(`   ✗ Expected ALLOW, got ${output.action}`);
-    }
-  } catch (e) {
-    console.log(`   ✗ Error: ${e.message}`);
-  }
-
-  // Test 3: Potentially dangerous tool (should ask or check relay)
-  console.log('\n3. Testing potentially dangerous tool (write_file)...');
-  try {
-    const result = await runHook('before_tool', {
-      tool_name: 'write_file',
-      tool_input: { path: '/tmp/test.txt', content: 'hello' },
-      session_id: 'test-session',
-    });
-    
-    console.log(`   Exit code: ${result.code}`);
-    console.log(`   Output: ${result.stdout}`);
-    
-    const output = JSON.parse(result.stdout || '{}');
-    console.log(`   Action: ${output.action}, Reason: ${output.reason}`);
-    // Without relay, should either ALLOW (no relay) or ASK_USER (user present)
-    if (output.action === 'ALLOW' || output.action === 'ASK_USER') {
-      console.log('   ✓ Handled correctly (no relay or user present)');
-    } else {
-      console.log(`   Note: Got ${output.action}`);
-    }
-  } catch (e) {
-    console.log(`   ✗ Error: ${e.message}`);
-  }
-}
-
-async function testAfterTool() {
-  console.log('\n=== Testing after_tool.mjs ===\n');
-
-  console.log('1. Testing tool result logging...');
-  try {
-    const result = await runHook('after_tool', {
-      tool_name: 'read_file',
-      tool_input: { path: '/tmp/test.txt' },
-      tool_output: 'file contents here',
-      success: true,
-      duration_ms: 50,
-      session_id: 'test-session',
-    });
-    
-    console.log(`   Exit code: ${result.code}`);
-    console.log(`   Output: ${result.stdout}`);
-    
-    if (result.code === 0) {
-      console.log('   ✓ After tool hook completed');
-    } else {
-      console.log(`   ✗ Hook failed with code ${result.code}`);
-    }
-  } catch (e) {
-    console.log(`   ✗ Error: ${e.message}`);
-  }
-}
-
-async function testSessionStart() {
-  console.log('\n=== Testing session_start.mjs ===\n');
-
-  console.log('1. Testing session registration...');
-  try {
-    const result = await runHook('session_start', {
-      session_id: 'gemini-test-' + Date.now(),
-      model: 'gemini-2.5-flash',
-      cwd: process.cwd(),
-    });
-    
-    console.log(`   Exit code: ${result.code}`);
-    console.log(`   Output: ${result.stdout}`);
-    
-    const output = JSON.parse(result.stdout || '{}');
-    if (output.session_id) {
-      console.log(`   ✓ Session registered: ${output.session_id}`);
-    } else {
-      console.log('   ✗ No session_id in output');
-    }
-  } catch (e) {
-    console.log(`   ✗ Error: ${e.message}`);
-  }
-}
-
-async function testSessionEnd() {
-  console.log('\n=== Testing session_end.mjs ===\n');
-
-  console.log('1. Testing session cleanup...');
-  try {
-    const result = await runHook('session_end', {
-      session_id: 'test-session',
-      reason: 'user_exit',
-      stats: {
-        total_tokens: 1000,
-        duration_ms: 60000,
-      },
-    });
-    
-    console.log(`   Exit code: ${result.code}`);
-    console.log(`   Output: ${result.stdout}`);
-    
-    if (result.code === 0) {
-      console.log('   ✓ Session end hook completed');
-    } else {
-      console.log(`   ✗ Hook failed with code ${result.code}`);
-    }
-  } catch (e) {
-    console.log(`   ✗ Error: ${e.message}`);
-  }
-}
-
-// Check hook log
-async function showHookLog() {
-  console.log('\n=== Hook Log ===\n');
-  try {
-    const { readFileSync } = await import('fs');
-    const log = readFileSync('/tmp/teleportation-gemini-hook.log', 'utf8');
-    const lines = log.split('\n').slice(-30); // Last 30 lines
-    console.log(lines.join('\n'));
-  } catch (e) {
-    console.log('No hook log found (this is normal for first run)');
-  }
-}
-
-// Main
-async function main() {
-  console.log('╔════════════════════════════════════════════════════════════╗');
-  console.log('║           Gemini CLI Hooks Test Suite                      ║');
-  console.log('╚════════════════════════════════════════════════════════════╝');
-  
-  console.log('\nEnvironment:');
-  console.log(`  RELAY_API_URL: ${process.env.RELAY_API_URL || '(not set)'}`);
-  console.log(`  RELAY_API_KEY: ${process.env.RELAY_API_KEY ? '***' : '(not set)'}`);
-  console.log(`  CWD: ${process.cwd()}`);
-
-  await testBeforeTool();
-  await testAfterTool();
-  await testSessionStart();
-  await testSessionEnd();
-  
-  await showHookLog();
-
-  console.log('\n╔════════════════════════════════════════════════════════════╗');
-  console.log('║                    Test Complete                           ║');
-  console.log('╚════════════════════════════════════════════════════════════╝\n');
-}
-
-main().catch(console.error);