teleportation-cli 1.1.5 → 1.2.1

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

@@ -31,7 +31,7 @@ async function loadVersionInfo() {
 
 /**
  * Register a session with the relay API if not already registered
- * @param {string} session_id - Session ID
+ * @param {string} session_id - Session ID (also Claude session ID)
  * @param {string} cwd - Current working directory
  * @param {object} config - Config object with relayApiUrl and relayApiKey
  * @returns {Promise<boolean|object>} - True if registered successfully, or error object if orphan
@@ -66,7 +66,7 @@ export async function ensureSessionRegistered(session_id, cwd, config) {
   }
 
   // Extract enhanced session metadata
-  let metadata = { cwd };
+  let metadata = { cwd, claude_session_id: session_id };
   try {
     // Try to load metadata extraction module
     const possiblePaths = [
@@ -88,6 +88,7 @@ export async function ensureSessionRegistered(session_id, cwd, config) {
     if (metadataModule && metadataModule.extractSessionMetadata && cwd) {
       const extracted = await metadataModule.extractSessionMetadata(cwd);
       extracted.session_id = session_id;
+      extracted.claude_session_id = session_id; // Include Claude session ID for autonomous task resumption
       metadata = extracted;
     }
   } catch (e) {
@@ -108,6 +109,36 @@ export async function ensureSessionRegistered(session_id, cwd, config) {
     // Version info not available - old installation
   }
 
+  // Mark cloud sessions (set by cloud provider bootstrap scripts)
+  if (env.TELEPORTATION_IS_CLOUD === 'true') {
+    metadata.is_cloud = true;
+  }
+
+  // PRD-0002: Create session file BEFORE relay registration
+  // This prevents race condition where registration succeeds but hook crashes before creating file
+  // If registration fails, we cleanup the session file
+  const sessionFile = join(tmpdir(), `teleportation-session-${session_id}.json`);
+  const claudePid = process.ppid || process.pid; // Use parent (Claude CLI), fallback to current process
+  let sessionFileCreated = false;
+
+  try {
+    await writeFile(sessionFile, JSON.stringify({
+      session_id,
+      claude_pid: claudePid,
+      cwd: cwd || process.cwd(),
+      registered_at: Date.now(),
+      meta: metadata
+    }), { mode: 0o600 });
+    sessionFileCreated = true;
+    
+    if (env.DEBUG) {
+      console.error(`[SessionRegister] Session file created (Claude PID: ${claudePid})`);
+    }
+  } catch (e) {
+    console.error('[SessionRegister] CRITICAL: Failed to create session file:', e.message);
+    // Continue with registration anyway - daemon won't track but session will exist
+  }
+
   try {
     if (env.DEBUG) {
       console.error(`[SessionRegister] Calling ${RELAY_API_URL}/api/sessions/register`);
@@ -132,124 +163,77 @@ export async function ensureSessionRegistered(session_id, cwd, config) {
         // Ignore marker write failures - registration still succeeded
       }
 
-      // Start heartbeat if not already running
+      // Write to shared session log for daemon discovery
       try {
-        const heartbeatInterval = config.session?.heartbeat?.interval || 120000;
-        const startDelay = config.session?.heartbeat?.startDelay || 5000;
-        const maxFailures = config.session?.heartbeat?.maxFailures || 3;
-
-        // Heartbeats are mandatory for session liveness tracking
-        if (RELAY_API_URL && RELAY_API_KEY) {
-          const { spawn } = await import('child_process');
-          const heartbeatPath = join(__dirname, 'heartbeat.mjs');
+        const { appendFile, mkdir } = await import('fs/promises');
+        const sessionLogPath = join(dirname(registrationMarker), 'session-events.log');
 
-          // Check if heartbeat is already running for this session
-          const { tmpdir } = await import('os');
-          const { readFile, unlink } = await import('fs/promises');
-          const pidFile = join(tmpdir(), `teleportation-heartbeat-${session_id}.pid`);
+        // Ensure directory exists
+        await mkdir(dirname(sessionLogPath), { recursive: true, mode: 0o700 }).catch(() => {});
 
-          let shouldStartHeartbeat = true;
-          try {
-            const pidContent = await readFile(pidFile, 'utf8');
-            // Parse PID file (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;
-            if (pid && !isNaN(pid)) {
-              // Check if the process is actually running
-              try {
-                process.kill(pid, 0); // Signal 0 checks existence without killing
-                // Process is running - don't start another heartbeat
-                shouldStartHeartbeat = false;
-                if (env.DEBUG) {
-                  console.error(`[SessionRegister] Heartbeat already running (PID: ${pid})`);
-                }
-              } catch (killError) {
-                if (killError.code === 'ESRCH') {
-                  // Process is dead - clean up stale PID file
-                  try {
-                    await unlink(pidFile);
-                    if (env.DEBUG) {
-                      console.error(`[SessionRegister] Cleaned up stale heartbeat PID file (PID: ${pid})`);
-                    }
-                  } catch (unlinkError) {
-                    if (env.DEBUG) {
-                      console.error(`[SessionRegister] Failed to unlink stale PID file: ${unlinkError.message}`);
-                    }
-                  }
-                  // Will start new heartbeat
-                } else {
-                  // Permission error - assume process exists, don't start duplicate
-                  shouldStartHeartbeat = false;
-                  if (env.DEBUG) {
-                    console.error(`[SessionRegister] Cannot check heartbeat (permission denied), assuming running (PID: ${pid})`);
-                  }
-                }
-              }
-            }
-          } catch (e) {
-            // PID file doesn't exist, start heartbeat
-          }
+        const logEvent = {
+          type: 'register',
+          session_id: session_id,
+          claude_session_id: session_id,
+          pid: process.pid,
+          cwd: cwd || process.cwd(),
+          meta: metadata,
+          timestamp: Date.now()
+        };
 
-          if (shouldStartHeartbeat) {
-            // Kill any orphan heartbeat processes for this session before starting a new one
-            // This handles race conditions where multiple processes pass the check simultaneously
-            try {
-              const { execSync } = await import('child_process');
-              // Use pkill with -f flag to match full command line (session_id argument)
-              // Returns 1 if no processes matched, so we ignore the exit code
-              execSync(`pkill -f "heartbeat.mjs ${session_id}" 2>/dev/null || true`, { stdio: 'ignore' });
-              if (env.DEBUG) {
-                console.error(`[SessionRegister] Cleaned up any orphan heartbeats for ${session_id}`);
-              }
-              // Small delay to let orphan processes terminate
-              await new Promise(r => setTimeout(r, 100));
-            } catch (pkillError) {
-              // Ignore pkill errors - process might not exist
-              if (env.DEBUG) {
-                console.error(`[SessionRegister] pkill cleanup failed: ${pkillError.message}`);
-              }
-            }
+        await appendFile(sessionLogPath, JSON.stringify(logEvent) + '\n', 'utf8');
+      } catch (e) {
+        // Log all failures - session recovery depends on this
+        console.error('[SessionRegister] WARN: Failed to write session log:', e.message);
 
-            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);
+        // Critical errors should be visible
+        if (e.code === 'EACCES' || e.code === 'ENOSPC') {
+          console.error(`[SessionRegister] CRITICAL: ${e.code} - Session recovery may fail after daemon restart`);
         }
       }
 
+      // Session file already created above (before registration)
+      // This ensures daemon can start tracking immediately
       return true;
     } else if (response.status === 403) {
       const data = await response.json().catch(() => ({}));
       if (data.error === 'orphan_api_key') {
+        // Cleanup session file on orphan key error
+        if (sessionFileCreated) {
+          try {
+            const { unlink } = await import('fs/promises');
+            await unlink(sessionFile);
+            if (env.DEBUG) {
+              console.error('[SessionRegister] Cleaned up session file (orphan API key)');
+            }
+          } catch {}
+        }
         return { success: false, error: 'orphan_api_key', message: data.message };
       }
     }
+    
+    // Registration failed - cleanup session file to prevent orphan
+    if (sessionFileCreated) {
+      try {
+        const { unlink } = await import('fs/promises');
+        await unlink(sessionFile);
+        if (env.DEBUG) {
+          console.error('[SessionRegister] Cleaned up session file (registration failed)');
+        }
+      } catch {}
+    }
   } catch (e) {
-    // Registration failed - this is okay, we'll try again next time
+    // Registration failed - cleanup session file
+    if (sessionFileCreated) {
+      try {
+        const { unlink } = await import('fs/promises');
+        await unlink(sessionFile);
+        if (env.DEBUG) {
+          console.error('[SessionRegister] Cleaned up session file (exception)');
+        }
+      } catch {}
+    }
+    
     if (env.DEBUG) {
       console.error('[SessionRegister] Failed to register session:', e.message);
     }
@@ -296,6 +280,7 @@ export async function updateSessionMetadata(session_id, cwd, config) {
     if (metadataModule && metadataModule.extractSessionMetadata && cwd) {
       const extracted = await metadataModule.extractSessionMetadata(cwd);
       extracted.session_id = session_id;
+      extracted.claude_session_id = session_id; // Critical: preserve claude_session_id for task resumption
       metadata = extracted;
     }
   } catch (e) {

package/.claude/hooks/session_end.mjs

@@ -40,6 +40,10 @@ const readStdin = () => new Promise((resolve, reject) => {
   const DAEMON_PORT = config.daemonPort || env.TELEPORTATION_DAEMON_PORT || '3050';
   const DAEMON_ENABLED = config.daemonEnabled !== false && env.TELEPORTATION_DAEMON_ENABLED !== 'false';
 
+  // Detect message source
+  const isAutonomousTask = env.TELEPORTATION_TASK_MODE === 'true' || !!env.TELEPORTATION_PARENT_SESSION_ID;
+  const source = isAutonomousTask ? 'autonomous_task' : 'cli_interactive';
+
   const updateSessionDaemonState = async (updates) => {
     if (!session_id || !RELAY_API_URL || !RELAY_API_KEY) return;
     try {
@@ -54,55 +58,38 @@ const readStdin = () => new Promise((resolve, reject) => {
     } catch {}
   };
 
-  // Kill heartbeat background process if running
+  // NOTE: Heartbeat processes are no longer spawned per-session.
+  // The daemon handles heartbeats inline (PRD-0025 migration).
+
   if (session_id) {
+    // Write unregister event to shared session log
     try {
-      const pidFile = join(tmpdir(), `teleportation-heartbeat-${session_id}.pid`);
-      const pidContent = await readFile(pidFile, 'utf8');
+      const { appendFile, mkdir } = await import('fs/promises');
+      const { homedir } = await import('os');
+      const { dirname } = await import('path');
+      const sessionLogPath = join(homedir(), '.teleportation', 'session-events.log');
 
-      // 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) };
-      }
+      // Ensure directory exists
+      await mkdir(dirname(sessionLogPath), { recursive: true, mode: 0o700 }).catch(() => {});
 
-      const pid = pidData.pid;
+      const logEvent = {
+        type: 'unregister',
+        session_id: session_id,
+        claude_session_id: session_id,
+        pid: process.pid,
+        cwd: process.cwd(),
+        timestamp: Date.now()
+      };
 
-      // 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);
-            }
-          }
-        }
-      }
+      await appendFile(sessionLogPath, JSON.stringify(logEvent) + '\n', 'utf8');
+    } catch (e) {
+      // Log all failures - session recovery depends on this
+      console.error('[SessionEnd] WARN: Failed to write session log:', e.message);
 
-      // Delete PID file
-      try {
-        await unlink(pidFile);
-      } catch (unlinkError) {
-        // Ignore errors - file might not exist
+      // Critical errors should be visible
+      if (e.code === 'EACCES' || e.code === 'ENOSPC') {
+        console.error(`[SessionEnd] CRITICAL: ${e.code} - Session recovery may fail after daemon restart`);
       }
-    } catch (error) {
-      // Ignore errors reading PID file - heartbeat might not have been started
     }
 
     // Delete registration marker file
@@ -113,6 +100,17 @@ const readStdin = () => new Promise((resolve, reject) => {
       // Ignore errors - marker might not exist
     }
 
+    // Delete daemon session file (prevents /tmp accumulation)
+    try {
+      const daemonSessionFile = join(tmpdir(), `teleportation-session-${session_id}.json`);
+      await unlink(daemonSessionFile);
+      if (env.DEBUG) {
+        console.error(`[SessionEnd] Deleted daemon session file: ${daemonSessionFile}`);
+      }
+    } catch (e) {
+      // Ignore errors - file might not exist
+    }
+
     // Clean up model tracking files
     try {
       const lastModelFile = join(tmpdir(), `teleportation-last-model-${session_id}.txt`);
@@ -215,6 +213,7 @@ const readStdin = () => new Promise((resolve, reject) => {
           body: JSON.stringify({
             session_id,
             type: 'session_end',
+            source,
             data: {
               reason: 'normal_exit',
               timestamp: Date.now()

package/.claude/hooks/session_start.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env bun
 
 import { stdin, exit, env } from 'node:process';
-import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { homedir } from 'os';
 import { existsSync, statSync, writeFileSync, mkdirSync } from 'fs';
+import { agentStart, agentStatus } from '@derivativelabs/agent-process';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -166,14 +166,22 @@ function updateSessionMarker(sessionId) {
   // Auto-start daemon if enabled
   if (DAEMON_ENABLED && session_id && RELAY_API_URL && RELAY_API_KEY) {
     try {
-      // Check if daemon is already running
+      // Check if daemon is already running using agent-runtime
       const daemonUrl = `http://127.0.0.1:${DAEMON_PORT}`;
       let daemonRunning = false;
 
       try {
-        const healthResponse = await fetchWithTimeout(`${daemonUrl}/health`, {}, 1000);
-        daemonRunning = healthResponse.ok;
-      } catch {}
+        const status = await agentStatus('teleportation-daemon');
+        daemonRunning = status.state === 'online' || status.running === true;
+        if (env.DEBUG && daemonRunning) {
+          console.error(`[SessionStart] Daemon already running (PID: ${status.pid})`);
+        }
+      } catch (statusError) {
+        // Agent not installed or not running - need to start it
+        if (env.DEBUG) {
+          console.error(`[SessionStart] Daemon status check: ${statusError.message}`);
+        }
+      }
 
       // Start daemon if not running
       if (!daemonRunning) {
@@ -209,63 +217,40 @@ function updateSessionMarker(sessionId) {
           return exit(0);
         }
 
-        // Retry daemon start with exponential backoff
-        let retries = 3;
-        let daemonStarted = false;
-
-        while (retries > 0 && !daemonStarted) {
-          try {
-            // Spawn daemon process
-            spawn(process.execPath, [daemonScript], {
-              detached: true,
-              stdio: 'ignore',
-              env: {
-                ...process.env,
-                TELEPORTATION_DAEMON: 'true',
-                RELAY_API_URL,
-                RELAY_API_KEY,
-                TELEPORTATION_DAEMON_PORT: DAEMON_PORT
-              }
-            }).unref();
+        // Start daemon using agent-runtime
+        // This handles retries, health checks, and platform-native service installation
+        try {
+          const handle = await agentStart({
+            name: 'teleportation-daemon',
+            script: daemonScript,
+            port: parseInt(DAEMON_PORT),
+            interpreter: process.execPath, // Use bun
+            env: {
+              ...process.env,
+              TELEPORTATION_DAEMON: 'true',
+              RELAY_API_URL,
+              RELAY_API_KEY,
+              TELEPORTATION_DAEMON_PORT: DAEMON_PORT,
+              // Disable idle timeout - daemon should stay running indefinitely
+              DAEMON_IDLE_TIMEOUT_MS: process.env.DAEMON_IDLE_TIMEOUT_MS || '0'
+            },
+            restart: true,         // Auto-restart on crash
+            maxRestarts: 10,
+            restartBackoff: 1000,
+            maxMemory: '500M',
+          });
 
-            // Wait for daemon to start with increasing delays
-            const waitTime = 500 * (4 - retries); // 500ms, 1000ms, 1500ms
-            await new Promise(r => setTimeout(r, waitTime));
-
-            // Verify daemon is actually running
-            try {
-              const healthCheck = await fetchWithTimeout(`${daemonUrl}/health`, {}, 2000);
-              if (healthCheck.ok) {
-                daemonStarted = true;
-                if (env.DEBUG) {
-                  console.error('[SessionStart] Daemon started successfully');
-                }
-                break;
-              }
-            } catch (healthError) {
-              if (env.DEBUG) {
-                console.error(`[SessionStart] Health check failed: ${healthError.message}`);
-              }
-            }
-
-            retries--;
-            if (retries === 0 && !daemonStarted) {
-              if (env.DEBUG) {
-                console.error('[SessionStart] Failed to start daemon after 3 attempts');
-              }
-              // Set flag to disable daemon for this session
-              process.env.TELEPORTATION_DAEMON_DISABLED = 'true';
-            }
-          } catch (spawnError) {
-            retries--;
-            if (env.DEBUG) {
-              console.error(`[SessionStart] Daemon spawn error (${3 - retries}/3):`, spawnError.message);
-            }
-            if (retries > 0) {
-              // Exponential backoff between retries
-              await new Promise(r => setTimeout(r, 1000 * (4 - retries)));
-            }
+          if (env.DEBUG) {
+            console.error(`[SessionStart] Daemon started successfully (PID: ${handle.pid}, Platform: ${handle.platform})`);
+          }
+        } catch (startError) {
+          console.error(`\n⚠️  Teleportation daemon failed to start: ${startError.message}`);
+          console.error('   Sessions may appear INACTIVE. Run: teleportation doctor\n');
+          if (env.DEBUG) {
+            console.error(`[SessionStart] Stack: ${startError.stack}`);
           }
+          // Set flag to disable daemon for this session
+          process.env.TELEPORTATION_DAEMON_DISABLED = 'true';
         }
       }