teleportation-cli 1.4.3 → 1.4.5

package/.gemini/hooks/session_end.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * Gemini CLI SessionEnd Hook
+ * 
+ * This hook executes when a Gemini CLI session ends.
+ * It mirrors the Claude Code session_end hook for Teleportation.
+ */
+
+import { stdin, stdout, exit, env } from 'node:process';
+import { appendFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { homedir, tmpdir } from 'node:os';
+import { loadConfig } from './shared/config.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Security: Session ID validation to prevent command injection
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+// 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:session_end] ${msg}\n`;
+  try {
+    appendFileSync(hookLogFile, logMsg);
+  } catch (e) {
+    // Silently ignore
+  }
+};
+
+(async () => {
+  log('=== SessionEnd 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, reason, stats } = input;
+    const teleportSessionId = env.TELEPORTATION_SESSION_ID || session_id || 'unknown';
+    
+    log(`Session: ${teleportSessionId}, Reason: ${reason}`);
+
+    // Load config from shared module
+    const config = await loadConfig(log);
+    const RELAY_API_URL = config.relayApiUrl;
+    const RELAY_API_KEY = config.relayApiKey;
+
+    // NOTE: Heartbeat processes are no longer spawned per-session.
+    // The daemon handles heartbeats inline (PRD-0025 migration).
+
+    // If no relay configured, just exit
+    if (!RELAY_API_URL || !RELAY_API_KEY) {
+      log('No relay configured, exiting');
+      return exit(0);
+    }
+
+    // Log session end to timeline
+    const timelineEvent = {
+      session_id: teleportSessionId,
+      type: 'session_ended',
+      data: {
+        reason: reason || 'normal_exit',
+        stats: stats || {},
+        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(`Session end logged to timeline`);
+    } catch (e) {
+      log(`Failed to log session end: ${e.message}`);
+    }
+
+    // Update session state
+    try {
+      await fetch(`${RELAY_API_URL}/api/sessions/${teleportSessionId}/daemon-state`, {
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${RELAY_API_KEY}`
+        },
+        body: JSON.stringify({
+          status: 'stopped',
+          is_away: false,
+          stopped_reason: 'session_end'
+        }),
+        signal: AbortSignal.timeout(2000)
+      });
+    } catch (e) {}
+
+    // Unregister from local daemon
+    const DAEMON_PORT = env.TELEPORTATION_DAEMON_PORT || '3050';
+    try {
+      await fetch(`http://localhost:${DAEMON_PORT}/sessions/deregister`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ session_id: teleportSessionId }),
+        signal: AbortSignal.timeout(2000),
+      });
+      log(`Session unregistered from daemon`);
+    } catch (e) {}
+
+    // Deregister session with relay API
+    try {
+      await fetch(`${RELAY_API_URL}/api/sessions/deregister`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${RELAY_API_KEY}`
+        },
+        body: JSON.stringify({ session_id: teleportSessionId })
+      });
+    } catch (e) {}
+
+    stdout.write('{}');
+    return exit(0);
+
+  } catch (e) {
+    log(`Hook error: ${e.message}`);
+    return exit(0);
+  }
+})();

package/.gemini/hooks/session_start.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * Gemini CLI SessionStart Hook
+ * 
+ * This hook executes when a Gemini CLI session starts.
+ * It mirrors the Claude Code session_start hook for Teleportation.
+ */
+
+import { stdin, stdout, exit, env } from 'node:process';
+import * as fs from 'node:fs';
+import { appendFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'node:crypto';
+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:session_start] ${msg}\n`;
+  try {
+    appendFileSync(hookLogFile, logMsg);
+  } catch (e) {
+    // Silently ignore
+  }
+};
+
+// Lazy-load metadata extraction
+let extractSessionMetadata = null;
+async function getSessionMetadata(cwd) {
+  if (!extractSessionMetadata) {
+    const possiblePaths = [
+      join(__dirname, '..', '..', 'lib', 'session', 'metadata.js'),
+      join(homedir(), '.teleportation', 'lib', 'session', 'metadata.js'),
+    ];
+
+    for (const path of possiblePaths) {
+      try {
+        const mod = await import('file://' + path);
+        extractSessionMetadata = mod.extractSessionMetadata;
+        break;
+      } catch (e) {
+        // Try next path
+      }
+    }
+  }
+
+  if (!extractSessionMetadata) return { cwd };
+
+  try {
+    return await extractSessionMetadata(cwd);
+  } catch (e) {
+    return { cwd };
+  }
+}
+
+/**
+ * Spawn the heartbeat background process
+ * NOTE: Heartbeat processes are no longer spawned per-session.
+ * The daemon handles heartbeats inline (PRD-0025 migration).
+ * This function is kept as a no-op for backward compatibility.
+ */
+function spawnHeartbeat(sessionId, config) {
+  // No-op: daemon handles heartbeats inline now
+  return;
+  }
+}
+
+(async () => {
+  log('=== SessionStart 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, cwd, owner_id } = input;
+    const workingDir = cwd || process.cwd();
+    
+    // Security: Use UUID instead of timestamp to prevent collisions
+    const teleportSessionId = env.TELEPORTATION_SESSION_ID || session_id || `gemini-${randomUUID().substring(0, 8)}`;
+    
+    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;
+
+    // If no relay configured, just log locally
+    if (!RELAY_API_URL || !RELAY_API_KEY) {
+      log('No relay configured, skipping session registration');
+      stdout.write(JSON.stringify({ session_id: teleportSessionId }));
+      return exit(0);
+    }
+
+    // Extract enhanced session metadata (Parity with Claude)
+    const meta = await getSessionMetadata(workingDir);
+    meta.session_id = teleportSessionId;
+    meta.gemini_session_id = session_id;
+    meta.current_model = model;
+
+    // Register session with relay
+    const sessionPayload = {
+      session_id: teleportSessionId,
+      meta: {
+        ...meta,
+        source: 'gemini-cli' // Ensure source is in meta for relay
+      },
+      owner_id: owner_id || null,
+      registered_at: Date.now(),
+    };
+
+    try {
+      await fetch(`${RELAY_API_URL}/api/sessions/register`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${RELAY_API_KEY}`,
+        },
+        body: JSON.stringify(sessionPayload),
+        signal: AbortSignal.timeout(10000),
+      });
+      log(`Session ${teleportSessionId} registered with relay`);
+      
+      // Start heartbeat process
+      spawnHeartbeat(teleportSessionId, config);
+    } catch (e) {
+      log(`Failed to register session: ${e.message}`);
+    }
+
+    // Also register with local daemon if running
+    const DAEMON_PORT = env.TELEPORTATION_DAEMON_PORT || '3050';
+    try {
+      await fetch(`http://localhost:${DAEMON_PORT}/sessions/register`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          session_id: teleportSessionId,
+          gemini_session_id: session_id,
+          cwd: workingDir,
+          meta: {
+            ...meta,
+            source: 'gemini-cli' // Pass source to daemon too
+          }
+        }),
+        signal: AbortSignal.timeout(2000),
+      });
+      log(`Session registered with local daemon`);
+    } catch (e) {
+      log(`Daemon not available: ${e.message}`);
+    }
+
+    // Output session ID for Gemini CLI to use
+    stdout.write(JSON.stringify({
+      session_id: teleportSessionId,
+      registered: true,
+    }));
+    return exit(0);
+
+  } catch (e) {
+    log(`Hook error: ${e.message}`);
+    stdout.write('{}');
+    return exit(0);
+  }
+})();

package/.gemini/hooks/shared/config.mjs

@@ -0,0 +1,67 @@
+/**
+ * Shared configuration loader for Gemini hooks
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { env } from 'node:process';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Load configuration for Gemini hooks
+ * Priority:
+ * 1. Environment variables
+ * 2. Claude's config-loader
+ * 3. Legacy config file (~/.teleportation-config.json)
+ */
+export async function loadConfig(log = () => {}) {
+  // Priority 1: Environment variables (Crucial for testing/overrides)
+  if (env.RELAY_API_URL && env.RELAY_API_KEY) {
+    return {
+      relayApiUrl: env.RELAY_API_URL,
+      relayApiKey: env.RELAY_API_KEY,
+      slackWebhookUrl: env.SLACK_WEBHOOK_URL || '',
+    };
+  }
+
+  // Priority 2: Claude's config-loader (Shared system config)
+  try {
+    // Shared module is in .gemini/hooks/shared/
+    // config-loader is in .claude/hooks/
+    const configLoaderPath = join(__dirname, '..', '..', '..', '.claude', 'hooks', 'config-loader.mjs');
+    if (existsSync(configLoaderPath)) {
+      const { loadConfig } = await import('file://' + configLoaderPath);
+      const config = await loadConfig();
+      if (config.relayApiUrl && config.relayApiKey) {
+        return config;
+      }
+    }
+  } catch (e) {
+    log(`Config loader failed: ${e.message}`);
+  }
+
+  // Priority 3: Legacy config file
+  const legacyConfigPath = join(homedir(), '.teleportation-config.json');
+  if (existsSync(legacyConfigPath)) {
+    try {
+      const config = JSON.parse(readFileSync(legacyConfigPath, 'utf8'));
+      return {
+        relayApiUrl: config.relay_api_url || '',
+        relayApiKey: config.relay_api_key || '',
+        slackWebhookUrl: config.slack_webhook_url || '',
+      };
+    } catch (e) {
+      log(`Legacy config failed: ${e.message}`);
+    }
+  }
+
+  return {
+    relayApiUrl: '',
+    relayApiKey: '',
+    slackWebhookUrl: '',
+  };
+}

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

@@ -0,0 +1,254 @@
+#!/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);