teleportation-cli 1.0.0

package/.claude/hooks/session-register.mjs

@@ -0,0 +1,274 @@
+#!/usr/bin/env bun
+/**
+ * Session Registration Helper
+ * Registers a session with the relay API if not already registered.
+ * This is called lazily when an approval is created or a message is sent.
+ */
+
+import { env } from 'node:process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFile, writeFile } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Load version info from ~/.teleportation/version.json
+ * Returns null if file doesn't exist (old installation)
+ */
+async function loadVersionInfo() {
+  const versionFile = join(homedir(), '.teleportation', 'version.json');
+  try {
+    const content = await readFile(versionFile, 'utf8');
+    return JSON.parse(content);
+  } catch (e) {
+    // Version file doesn't exist - old installation
+    return null;
+  }
+}
+
+/**
+ * Register a session with the relay API if not already registered
+ * @param {string} session_id - Session ID
+ * @param {string} cwd - Current working directory
+ * @param {object} config - Config object with relayApiUrl and relayApiKey
+ * @returns {Promise<boolean>} - True if registered successfully
+ */
+export async function ensureSessionRegistered(session_id, cwd, config) {
+  const RELAY_API_URL = config.relayApiUrl || '';
+  const RELAY_API_KEY = config.relayApiKey || '';
+
+  if (!session_id || !RELAY_API_URL || !RELAY_API_KEY) {
+    if (env.DEBUG) {
+      console.error(`[SessionRegister] Early return: session_id=${!!session_id}, RELAY_API_URL=${!!RELAY_API_URL}, RELAY_API_KEY=${!!RELAY_API_KEY}`);
+    }
+    return false;
+  }
+
+  // Check if session is already registered (marker file exists)
+  // If so, skip API call - heartbeat keeps the session alive
+  const registrationMarker = join(tmpdir(), `teleportation-session-${session_id}.registered`);
+  try {
+    await readFile(registrationMarker);
+    // Marker exists - session already registered, skip API call
+    if (env.DEBUG) {
+      console.error(`[SessionRegister] Session ${session_id} already registered, skipping`);
+    }
+    return true;
+  } catch (e) {
+    // Marker doesn't exist - proceed with registration
+  }
+
+  if (env.DEBUG) {
+    console.error(`[SessionRegister] Registering session ${session_id}`);
+  }
+
+  // Extract enhanced session metadata
+  let metadata = { cwd };
+  try {
+    // Try to load metadata extraction module
+    const possiblePaths = [
+      join(__dirname, '..', '..', 'lib', 'session', 'metadata.js'),
+      join(process.env.HOME || process.env.USERPROFILE || '', '.teleportation', 'lib', 'session', 'metadata.js'),
+      './lib/session/metadata.js'
+    ];
+
+    let metadataModule = null;
+    for (const path of possiblePaths) {
+      try {
+        metadataModule = await import('file://' + path);
+        break;
+      } catch (e) {
+        // Try next path
+      }
+    }
+
+    if (metadataModule && metadataModule.extractSessionMetadata && cwd) {
+      const extracted = await metadataModule.extractSessionMetadata(cwd);
+      extracted.session_id = session_id;
+      metadata = extracted;
+    }
+  } catch (e) {
+    // If metadata extraction fails, fall back to basic metadata
+    if (env.DEBUG) {
+      console.error('[SessionRegister] Failed to extract metadata:', e.message);
+    }
+  }
+
+  // Add version info to metadata
+  try {
+    const versionInfo = await loadVersionInfo();
+    if (versionInfo) {
+      metadata.teleportation_version = versionInfo.version;
+      metadata.protocol_version = versionInfo.protocol_version;
+    }
+  } catch (e) {
+    // Version info not available - old installation
+  }
+
+  try {
+    if (env.DEBUG) {
+      console.error(`[SessionRegister] Calling ${RELAY_API_URL}/api/sessions/register`);
+    }
+    const response = await fetch(`${RELAY_API_URL}/api/sessions/register`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${RELAY_API_KEY}`
+      },
+      body: JSON.stringify({ session_id, meta: metadata })
+    });
+
+    if (response.ok || response.status === 200) {
+      // Create marker file so we don't re-register on every tool use
+      try {
+        await writeFile(registrationMarker, JSON.stringify({
+          session_id,
+          registered_at: Date.now()
+        }), { mode: 0o600 });
+      } catch (e) {
+        // Ignore marker write failures - registration still succeeded
+      }
+
+      // Start heartbeat if not already running
+      try {
+        const heartbeatEnabled = config.session?.heartbeat?.enabled !== false;
+        const heartbeatInterval = config.session?.heartbeat?.interval || 120000;
+        const startDelay = config.session?.heartbeat?.startDelay || 5000;
+        const maxFailures = config.session?.heartbeat?.maxFailures || 3;
+
+        if (heartbeatEnabled && RELAY_API_URL && RELAY_API_KEY) {
+          const { spawn } = await import('child_process');
+          const heartbeatPath = join(__dirname, 'heartbeat.mjs');
+
+          // Check if heartbeat is already running for this session
+          const { tmpdir } = await import('os');
+          const { readFile } = await import('fs/promises');
+          const pidFile = join(tmpdir(), `teleportation-heartbeat-${session_id}.pid`);
+          
+          let shouldStartHeartbeat = true;
+          try {
+            await readFile(pidFile);
+            // PID file exists, heartbeat might be running
+            shouldStartHeartbeat = false;
+          } catch (e) {
+            // PID file doesn't exist, start heartbeat
+          }
+
+          if (shouldStartHeartbeat) {
+            const heartbeat = spawn('node', [heartbeatPath, session_id], {
+              detached: true,
+              stdio: 'ignore',
+              env: {
+                ...process.env,
+                SESSION_ID: session_id,
+                RELAY_API_URL,
+                RELAY_API_KEY,
+                HEARTBEAT_INTERVAL: String(heartbeatInterval),
+                START_DELAY: String(startDelay),
+                MAX_FAILURES: String(maxFailures),
+                TELEPORTATION_DEBUG: process.env.TELEPORTATION_DEBUG || 'false'
+              }
+            });
+            heartbeat.unref();
+          }
+        }
+      } catch (error) {
+        // Don't fail registration if heartbeat spawn fails
+        if (env.DEBUG) {
+          console.error('[SessionRegister] Failed to spawn heartbeat:', error.message);
+        }
+      }
+
+      return true;
+    }
+  } catch (e) {
+    // Registration failed - this is okay, we'll try again next time
+    if (env.DEBUG) {
+      console.error('[SessionRegister] Failed to register session:', e.message);
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Update session metadata without triggering a registration event
+ * Use this for updating dynamic metadata like current_branch, last_file_edited, etc.
+ * @param {string} session_id - Session ID
+ * @param {string} cwd - Current working directory
+ * @param {object} config - Config object with relayApiUrl and relayApiKey
+ * @returns {Promise<boolean>} - True if updated successfully
+ */
+export async function updateSessionMetadata(session_id, cwd, config) {
+  const RELAY_API_URL = config.relayApiUrl || '';
+  const RELAY_API_KEY = config.relayApiKey || '';
+
+  if (!session_id || !RELAY_API_URL || !RELAY_API_KEY) {
+    return false;
+  }
+
+  // Extract current session metadata (without started_at - that's preserved server-side)
+  let metadata = { cwd };
+  try {
+    const possiblePaths = [
+      join(__dirname, '..', '..', 'lib', 'session', 'metadata.js'),
+      join(process.env.HOME || process.env.USERPROFILE || '', '.teleportation', 'lib', 'session', 'metadata.js'),
+      './lib/session/metadata.js'
+    ];
+
+    let metadataModule = null;
+    for (const path of possiblePaths) {
+      try {
+        metadataModule = await import('file://' + path);
+        break;
+      } catch (e) {
+        // Try next path
+      }
+    }
+
+    if (metadataModule && metadataModule.extractSessionMetadata && cwd) {
+      const extracted = await metadataModule.extractSessionMetadata(cwd);
+      extracted.session_id = session_id;
+      metadata = extracted;
+    }
+  } catch (e) {
+    // If metadata extraction fails, fall back to basic metadata
+    if (env.DEBUG) {
+      console.error('[SessionUpdate] Failed to extract metadata:', e.message);
+    }
+  }
+
+  try {
+    const response = await fetch(`${RELAY_API_URL}/api/sessions/${session_id}`, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${RELAY_API_KEY}`
+      },
+      body: JSON.stringify({ meta: metadata })
+    });
+
+    if (response.ok || response.status === 200) {
+      if (env.DEBUG) {
+        console.error(`[SessionUpdate] Session metadata updated: ${session_id}`);
+      }
+      return true;
+    } else if (response.status === 404) {
+      // Session doesn't exist - need to register first
+      if (env.DEBUG) {
+        console.error(`[SessionUpdate] Session not found, needs registration: ${session_id}`);
+      }
+      return false;
+    }
+  } catch (e) {
+    if (env.DEBUG) {
+      console.error('[SessionUpdate] Failed to update session:', e.message);
+    }
+  }
+
+  return false;
+}
+

package/.claude/hooks/session_end.mjs

@@ -0,0 +1,256 @@
+#!/usr/bin/env bun
+
+import { stdin, exit, env } from 'node:process';
+import { readFile, unlink } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+const readStdin = () => new Promise((resolve, reject) => {
+  let data='';
+  stdin.setEncoding('utf8');
+  stdin.on('data', c => data += c);
+  stdin.on('end', () => resolve(data));
+  stdin.on('error', reject);
+});
+
+(async () => {
+  let input = {};
+  try {
+    const raw = await readStdin();
+    input = JSON.parse(raw || '{}');
+  } catch {}
+
+  const { session_id } = input || {};
+
+  // Load config from encrypted credentials, legacy config file, or env vars
+  let config;
+  try {
+    const { loadConfig } = await import('./config-loader.mjs');
+    config = await loadConfig();
+  } catch (e) {
+    // Fallback to environment variables if config loader fails
+    config = {
+      relayApiUrl: env.RELAY_API_URL || '',
+      relayApiKey: env.RELAY_API_KEY || ''
+    };
+  }
+
+  const RELAY_API_URL = config.relayApiUrl || '';
+  const RELAY_API_KEY = config.relayApiKey || '';
+  const DAEMON_PORT = config.daemonPort || env.TELEPORTATION_DAEMON_PORT || '3050';
+  const DAEMON_ENABLED = config.daemonEnabled !== false && env.TELEPORTATION_DAEMON_ENABLED !== 'false';
+
+  const updateSessionDaemonState = async (updates) => {
+    if (!session_id || !RELAY_API_URL || !RELAY_API_KEY) return;
+    try {
+      await fetch(`${RELAY_API_URL}/api/sessions/${session_id}/daemon-state`, {
+        method: 'PATCH',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${RELAY_API_KEY}`
+        },
+        body: JSON.stringify(updates)
+      });
+    } catch {}
+  };
+
+  // Kill heartbeat background process if running
+  if (session_id) {
+    try {
+      const pidFile = join(tmpdir(), `teleportation-heartbeat-${session_id}.pid`);
+      const pidContent = await readFile(pidFile, 'utf8');
+
+      // Parse PID file (now JSON format with session_id validation)
+      let pidData;
+      try {
+        pidData = JSON.parse(pidContent);
+      } catch {
+        // Fallback for old format (plain PID number)
+        pidData = { pid: parseInt(pidContent.trim(), 10) };
+      }
+
+      const pid = pidData.pid;
+
+      // Validate session_id matches (prevents killing wrong process)
+      if (pid && !isNaN(pid)) {
+        if (pidData.session_id && pidData.session_id !== session_id) {
+          console.error(`[SessionEnd] PID file session_id mismatch: expected ${session_id}, got ${pidData.session_id}`);
+        } else {
+          try {
+            // Verify process exists before killing
+            process.kill(pid, 0); // Signal 0 checks existence without killing
+
+            // Process exists, safe to kill
+            process.kill(pid, 'SIGTERM');
+            console.log(`[SessionEnd] Killed heartbeat process (PID: ${pid})`);
+          } catch (killError) {
+            if (killError.code === 'ESRCH') {
+              // Process already dead, that's okay
+              console.log(`[SessionEnd] Heartbeat process already terminated (PID: ${pid})`);
+            } else {
+              // Permission error or other issue
+              console.error(`[SessionEnd] Failed to kill heartbeat:`, killError.message);
+            }
+          }
+        }
+      }
+
+      // Delete PID file
+      try {
+        await unlink(pidFile);
+      } catch (unlinkError) {
+        // Ignore errors - file might not exist
+      }
+    } catch (error) {
+      // Ignore errors reading PID file - heartbeat might not have been started
+    }
+
+    // Delete registration marker file
+    try {
+      const registrationMarker = join(tmpdir(), `teleportation-session-${session_id}.registered`);
+      await unlink(registrationMarker);
+    } catch (e) {
+      // Ignore errors - marker might not exist
+    }
+
+    // Clean up model tracking files
+    try {
+      const lastModelFile = join(tmpdir(), `teleportation-last-model-${session_id}.txt`);
+      await unlink(lastModelFile);
+    } catch (e) {
+      // Ignore errors - file may not exist
+    }
+
+    // Clean up model change marker file (if it exists)
+    try {
+      const modelChangeMarker = join(tmpdir(), `teleportation-model-changing-${session_id}.txt`);
+      await unlink(modelChangeMarker);
+    } catch (e) {
+      // Ignore errors - file may not exist
+    }
+  }
+
+  // Clean up session resources
+  if (session_id) {
+    try {
+      // Cache module loading to prevent memory leaks from repeated imports
+      if (!global.__teleportationCleanup) {
+        const { fileURLToPath } = await import('url');
+        const { dirname, join } = await import('path');
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        
+        // Try to load cleanup utility from multiple possible locations
+        const possiblePaths = [
+          join(__dirname, '..', '..', 'lib', 'session', 'cleanup.js'),
+          join(process.env.HOME || process.env.USERPROFILE || '', '.teleportation', 'lib', 'session', 'cleanup.js'),
+          './lib/session/cleanup.js'
+        ];
+        
+        for (const path of possiblePaths) {
+          try {
+            global.__teleportationCleanup = await import('file://' + path);
+            break;
+          } catch (e) {
+            // Try next path
+          }
+        }
+      }
+      
+      const cleanupModule = global.__teleportationCleanup;
+      // Use cleanup utility if available, otherwise fall back to direct mute cache clearing
+      if (cleanupModule && cleanupModule.cleanupSession) {
+        await cleanupModule.cleanupSession(session_id);
+      } else {
+        // Fallback: try to clear mute cache directly
+        if (!global.__teleportationMuteChecker) {
+          const { fileURLToPath } = await import('url');
+          const { dirname, join } = await import('path');
+          const __filename = fileURLToPath(import.meta.url);
+          const __dirname = dirname(__filename);
+          
+          const mutePaths = [
+            join(__dirname, '..', '..', 'lib', 'session', 'mute-checker.js'),
+            join(process.env.HOME || process.env.USERPROFILE || '', '.teleportation', 'lib', 'session', 'mute-checker.js'),
+            './lib/session/mute-checker.js'
+          ];
+          
+          for (const path of mutePaths) {
+            try {
+              global.__teleportationMuteChecker = await import('file://' + path);
+              break;
+            } catch (e) {
+              // Try next path
+            }
+          }
+        }
+        
+        const muteChecker = global.__teleportationMuteChecker;
+        if (muteChecker && muteChecker.clearMuteCache) {
+          muteChecker.clearMuteCache(session_id);
+        }
+      }
+    } catch (e) {
+      // Ignore errors in cleanup - session end should always succeed
+    }
+  }
+
+  if (session_id) {
+    await updateSessionDaemonState({
+      status: 'stopped',
+      started_reason: null,
+      is_away: false,
+      stopped_reason: 'session_end'
+    });
+  }
+
+  // Deregister session with daemon
+  if (DAEMON_ENABLED && session_id) {
+    try {
+      const daemonUrl = `http://127.0.0.1:${DAEMON_PORT}`;
+      
+      // Add timeout to prevent hanging if daemon is unresponsive
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 2000); // 2 second timeout
+      
+      try {
+        await fetch(`${daemonUrl}/sessions/deregister`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ session_id }),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (env.DEBUG) {
+          console.error(`[SessionEnd] Deregistered session from daemon: ${session_id}`);
+        }
+      } catch (fetchError) {
+        clearTimeout(timeoutId);
+        throw fetchError; // Re-throw to be caught by outer try-catch
+      }
+    } catch (e) {
+      // Ignore errors - daemon might not be running
+      if (env.DEBUG) {
+        console.error(`[SessionEnd] Failed to deregister from daemon:`, e.message);
+      }
+    }
+  }
+
+  // Deregister session with relay API
+  if (session_id && RELAY_API_URL && RELAY_API_KEY) {
+    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 })
+      });
+    } catch (e) {
+      // Ignore errors - session end should always succeed even if API is unavailable
+    }
+  }
+
+  return exit(0);
+})();