teleportation-cli 1.0.0

package/.claude/hooks/config-loader.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+// Shared config loader for all hooks
+// Reads from encrypted credentials (~/.teleportation/credentials), then ~/.teleportation-config.json, then env vars
+
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { env } from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+// Get __dirname equivalent for ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export async function loadConfig() {
+  // Test override: allow forcing config to be loaded from environment variables only
+  // This is useful for unit tests that mock the relay API.
+  if (env.TELEPORTATION_CONFIG_FROM_ENV_ONLY === 'true') {
+    return {
+      relayApiUrl: env.RELAY_API_URL || '',
+      relayApiKey: env.RELAY_API_KEY || '',
+      userToken: env.DETACH_USER_TOKEN || '',
+      slackWebhookUrl: env.SLACK_WEBHOOK_URL || ''
+    };
+  }
+
+  // Priority 1: Try to load from encrypted credentials file
+  try {
+    // Try multiple possible paths for the credential manager
+    const possiblePaths = [
+      // If hook is still in project directory
+      join(process.cwd(), 'lib', 'auth', 'credentials.js'),
+      // If installed globally, try common locations
+      join(homedir(), '.teleportation', 'lib', 'auth', 'credentials.js'),
+      // Development path (if running from workspace)
+      join(homedir(), 'dev_env', 'teleporter', 'teleportation', 'lib', 'auth', 'credentials.js'),
+      // Try relative to hook location (if hooks are symlinked)
+      join(__dirname, '..', '..', 'lib', 'auth', 'credentials.js')
+    ];
+    
+    let CredentialManager = null;
+    for (const credentialsPath of possiblePaths) {
+      try {
+        const module = await import(credentialsPath);
+        CredentialManager = module.CredentialManager;
+        if (CredentialManager) break;
+      } catch (e) {
+        // Try next path
+        continue;
+      }
+    }
+    
+    if (CredentialManager) {
+      const manager = new CredentialManager();
+      const credentials = await manager.load();
+      
+      if (credentials) {
+        return {
+          relayApiUrl: credentials.relayApiUrl || credentials.relay_api_url || '',
+          relayApiKey: credentials.relayApiKey || credentials.apiKey || credentials.relay_api_key || '',
+          userToken: credentials.userToken || credentials.user_token || '',
+          slackWebhookUrl: credentials.slackWebhookUrl || credentials.slack_webhook_url || ''
+        };
+      }
+    }
+  } catch (e) {
+    // Credential manager not available or credentials don't exist, continue to fallback
+  }
+  
+  // Priority 2: Try to load from legacy config file
+  const configPath = join(homedir(), '.teleportation-config.json');
+  
+  try {
+    const content = await readFile(configPath, 'utf8');
+    const config = JSON.parse(content);
+    return {
+      relayApiUrl: config.relay_api_url || '',
+      relayApiKey: config.relay_api_key || '',
+      userToken: config.user_token || '',
+      slackWebhookUrl: config.slack_webhook_url || ''
+    };
+  } catch (e) {
+    // Config file doesn't exist, continue to fallback
+  }
+  
+  // Priority 3: Fall back to environment variables
+  return {
+    relayApiUrl: env.RELAY_API_URL || '',
+    relayApiKey: env.RELAY_API_KEY || '',
+    userToken: env.DETACH_USER_TOKEN || '',
+    slackWebhookUrl: env.SLACK_WEBHOOK_URL || ''
+  };
+}

package/.claude/hooks/heartbeat.mjs

@@ -0,0 +1,331 @@
+#!/usr/bin/env bun
+/**
+ * Heartbeat Background Process
+ * Runs continuously while Claude Code session is active
+ * Sends periodic heartbeats to relay API to keep session alive
+ *
+ * This is NOT a hook - it's a background process spawned by session_start.mjs
+ * It runs detached and continues until killed by session_end.mjs
+ */
+
+import { env, exit, pid as processPid } from 'node:process';
+import { writeFile, unlink } from 'fs/promises';
+import { tmpdir, homedir } from 'os';
+import { join, dirname } from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+// Read configuration from environment variables (secure - not visible in process list)
+const SESSION_ID = process.argv[2] || env.SESSION_ID;
+const RELAY_API_URL = env.RELAY_API_URL;
+const RELAY_API_KEY = env.RELAY_API_KEY;
+const HEARTBEAT_INTERVAL = Math.max(100, Math.min(600000,
+  parseInt(env.HEARTBEAT_INTERVAL || '120000', 10)
+)); // Default 2 minutes, min 100ms (for testing), max 10min
+const START_DELAY = Math.max(100, Math.min(60000,
+  parseInt(env.START_DELAY || '5000', 10)
+)); // Default 5 seconds, min 100ms (for testing), max 1min
+const MAX_FAILURES = Math.max(1, Math.min(10,
+  parseInt(env.MAX_FAILURES || '3', 10)
+)); // Default 3, min 1, max 10
+const FETCH_TIMEOUT = Math.max(100, Math.min(30000,
+  parseInt(env.FETCH_TIMEOUT || '5000', 10)
+)); // Default 5s, min 100ms (for testing), max 30s
+const DEBUG = env.TELEPORTATION_DEBUG === 'true';
+
+// Get __dirname equivalent for ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+if (!SESSION_ID || !RELAY_API_URL || !RELAY_API_KEY) {
+  console.error('[Heartbeat] Missing required environment variables: SESSION_ID, RELAY_API_URL, RELAY_API_KEY');
+  exit(1);
+}
+
+const PID_FILE = join(tmpdir(), `teleportation-heartbeat-${SESSION_ID}.pid`);
+let intervalHandle = null;
+let heartbeatCount = 0;
+let failureCount = 0;
+let lastDaemonCheck = 0;
+// Make interval configurable via environment variable (default 60 seconds)
+const DAEMON_CHECK_INTERVAL = Math.max(10000, Math.min(300000,
+  parseInt(env.DAEMON_CHECK_INTERVAL || '60000', 10)
+)); // Default 60 seconds, min 10s, max 5min
+
+/**
+ * Check if daemon is running and start it if not
+ */
+async function ensureDaemonRunning() {
+  // Early return with throttle check BEFORE any async operations
+  // This prevents multiple concurrent executions of the expensive module import logic
+  const now = Date.now();
+  if (now - lastDaemonCheck < DAEMON_CHECK_INTERVAL) {
+    return;
+  }
+  // Set timestamp immediately after check to prevent race conditions
+  lastDaemonCheck = now;
+
+  try {
+    // Try to import lifecycle module from installed location
+    const possibleLocations = [
+      join(homedir(), '.teleportation', 'lib', 'daemon', 'lifecycle.js'),
+      join(__dirname, '..', '..', 'lib', 'daemon', 'lifecycle.js'),
+      env.TELEPORTATION_LIFECYCLE_PATH
+    ].filter(Boolean);
+
+    const { access } = await import('fs/promises');
+    let lifecyclePath = null;
+    for (const location of possibleLocations) {
+      try {
+        await access(location);
+        lifecyclePath = location;
+        break;
+      } catch {
+        // Try next location
+      }
+    }
+
+    if (!lifecyclePath) {
+      if (DEBUG) {
+        console.log('[Heartbeat] Lifecycle module not found, skipping daemon check');
+      }
+      return;
+    }
+
+    // Cache module imports to avoid re-importing on every check
+    // Use pathToFileURL for proper Windows path handling
+    const pidManagerPath = join(dirname(lifecyclePath), 'pid-manager.js');
+    
+    if (!lifecycleModule || !pidManagerModule) {
+      // Only import once, then cache
+      // Use pathToFileURL for cross-platform compatibility (especially Windows)
+      lifecycleModule = await import(pathToFileURL(lifecyclePath).href);
+      pidManagerModule = await import(pathToFileURL(pidManagerPath).href);
+    }
+
+    const lifecycle = lifecycleModule;
+    const { checkDaemonStatus } = pidManagerModule;
+
+    // Check daemon status
+    const status = await checkDaemonStatus();
+    if (!status.running && !daemonStartInProgress) {
+      // Set flag to prevent concurrent start attempts
+      daemonStartInProgress = true;
+      
+      if (DEBUG) {
+        console.log(`[Heartbeat] Daemon not running, attempting to start...`);
+      }
+
+      try {
+        await lifecycle.startDaemon({ silent: true });
+        if (DEBUG) {
+          console.log(`[Heartbeat] Daemon started successfully`);
+        }
+      } catch (error) {
+        // Don't fail heartbeat if daemon start fails - it might already be starting
+        if (DEBUG) {
+          console.log(`[Heartbeat] Daemon start attempt: ${error.message}`);
+        }
+      } finally {
+        // Always reset flag, even if start fails
+        daemonStartInProgress = false;
+      }
+    }
+  } catch (error) {
+    // Silently fail - daemon check shouldn't break heartbeat
+    if (DEBUG) {
+      console.log(`[Heartbeat] Error checking daemon: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Check for pending approvals and handle them
+ */
+async function checkAndHandlePendingApprovals() {
+  try {
+    // Fetch pending and allowed approvals for this session
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+
+    const [pendingResponse, allowedResponse] = await Promise.all([
+      fetch(`${RELAY_API_URL}/api/approvals?status=pending&session_id=${SESSION_ID}`, {
+        headers: {
+          'Authorization': `Bearer ${RELAY_API_KEY}`
+        },
+        signal: controller.signal
+      }),
+      fetch(`${RELAY_API_URL}/api/approvals?status=allowed&session_id=${SESSION_ID}`, {
+        headers: {
+          'Authorization': `Bearer ${RELAY_API_KEY}`
+        },
+        signal: controller.signal
+      })
+    ]);
+
+    clearTimeout(timeoutId);
+
+    if (!pendingResponse.ok && !allowedResponse.ok) {
+      return; // Skip if API calls fail
+    }
+
+    const pending = pendingResponse.ok ? await pendingResponse.json() : [];
+    const allowed = allowedResponse.ok ? await allowedResponse.json() : [];
+
+    // Find allowed approvals that haven't been acknowledged yet
+    const unacknowledged = allowed.filter(a => !a.acknowledgedAt);
+
+    if (unacknowledged.length > 0 && DEBUG) {
+      console.log(`[Heartbeat] Found ${unacknowledged.length} approved but unacknowledged approval(s)`);
+    }
+
+    // Acknowledge approved approvals (fire-and-forget, don't block heartbeat)
+    for (const approval of unacknowledged) {
+      try {
+        fetch(`${RELAY_API_URL}/api/approvals/${approval.id}/ack`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${RELAY_API_KEY}`
+          },
+          body: JSON.stringify({ processed: true })
+        }).catch(() => {}); // Ignore errors - acknowledgment is optional
+      } catch (e) {
+        // Ignore errors
+      }
+    }
+
+    // Log if there are pending approvals waiting for user decision
+    if (pending.length > 0 && DEBUG) {
+      console.log(`[Heartbeat] Session has ${pending.length} pending approval(s) waiting for user decision`);
+    }
+  } catch (error) {
+    // Silently fail - approval checking shouldn't break heartbeat
+    if (DEBUG) {
+      console.log(`[Heartbeat] Error checking approvals: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Send heartbeat to relay API
+ */
+async function sendHeartbeat() {
+  // Increment count before sending (so first heartbeat is #1, not #0)
+  heartbeatCount++;
+
+  try {
+    // Add timeout to prevent hanging on unreachable servers
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+
+    const response = await fetch(`${RELAY_API_URL}/api/sessions/${SESSION_ID}/heartbeat`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${RELAY_API_KEY}`
+      },
+      body: JSON.stringify({
+        timestamp: new Date().toISOString(),
+        pid: processPid,
+        count: heartbeatCount
+      }),
+      signal: controller.signal
+    });
+
+    clearTimeout(timeoutId); // Clear timeout if request succeeds
+
+    if (response.ok) {
+      failureCount = 0; // Reset failure count on success
+      
+      // Check daemon status and start if needed (asynchronously, don't block heartbeat)
+      ensureDaemonRunning().catch(() => {});
+      
+      // Check for pending approvals after successful heartbeat
+      // Do this asynchronously so it doesn't block the heartbeat
+      checkAndHandlePendingApprovals().catch(() => {});
+      
+      if (DEBUG) {
+        console.log(`[Heartbeat] Sent #${heartbeatCount} for session ${SESSION_ID}`);
+      }
+    } else {
+      heartbeatCount--; // Rollback count on failure
+      failureCount++;
+      console.error(`[Heartbeat] Failed (${response.status}): ${await response.text()}`);
+
+      if (failureCount >= MAX_FAILURES) {
+        console.error(`[Heartbeat] Max failures reached (${MAX_FAILURES}), stopping`);
+        await cleanup();
+      }
+    }
+  } catch (error) {
+    heartbeatCount--; // Rollback count on error
+    failureCount++;
+    console.error(`[Heartbeat] Error sending heartbeat:`, error.message);
+
+    if (failureCount >= MAX_FAILURES) {
+      console.error(`[Heartbeat] Max failures reached (${MAX_FAILURES}), stopping`);
+      await cleanup();
+    }
+  }
+}
+
+/**
+ * Cleanup and exit
+ */
+async function cleanup() {
+  console.log(`[Heartbeat] Cleaning up session ${SESSION_ID}`);
+
+  if (intervalHandle) {
+    clearInterval(intervalHandle);
+    intervalHandle = null;
+  }
+
+  // Remove PID file
+  try {
+    await unlink(PID_FILE);
+  } catch (error) {
+    // Ignore errors - file might not exist
+  }
+
+  exit(0);
+}
+
+/**
+ * Start heartbeat loop
+ */
+async function start() {
+  try {
+    // Write PID file with session_id for validation (prevents killing wrong process)
+    await writeFile(PID_FILE, JSON.stringify({
+      pid: processPid,
+      session_id: SESSION_ID,
+      started_at: Date.now()
+    }), { mode: 0o600 });
+
+    if (DEBUG) {
+      console.log(`[Heartbeat] Started for session ${SESSION_ID} (PID: ${processPid})`);
+      console.log(`[Heartbeat] Interval: ${HEARTBEAT_INTERVAL}ms, Start delay: ${START_DELAY}ms, Max failures: ${MAX_FAILURES}, Fetch timeout: ${FETCH_TIMEOUT}ms`);
+    }
+
+    // Wait for initial delay before first heartbeat
+    setTimeout(() => {
+      // Send first heartbeat immediately after delay
+      sendHeartbeat();
+
+      // Then set up interval for subsequent heartbeats
+      intervalHandle = setInterval(sendHeartbeat, HEARTBEAT_INTERVAL);
+    }, START_DELAY);
+
+    // Handle graceful shutdown
+    process.on('SIGTERM', cleanup);
+    process.on('SIGINT', cleanup);
+    process.on('SIGHUP', cleanup);
+
+  } catch (error) {
+    console.error(`[Heartbeat] Failed to start:`, error.message);
+    exit(1);
+  }
+}
+
+// Start the heartbeat process
+start();

package/.claude/hooks/notification.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+
+import { stdin, stdout, exit, env } from 'node:process';
+
+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 SLACK_WEBHOOK_URL = env.SLACK_WEBHOOK_URL || '';
+
+  try {
+    if (SLACK_WEBHOOK_URL) {
+      const text = `Notification: ${input?.message || input?.type || 'Claude Code'}`;
+      await fetch(SLACK_WEBHOOK_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text })
+      });
+    }
+  } catch {}
+
+  stdout.write(JSON.stringify({ suppressOutput: true }));
+  return exit(0);
+})();