teleportation-cli 1.4.0 → 1.4.2

package/lib/daemon/task-executor-v2.js

@@ -18,6 +18,7 @@ import { ingestTranscriptToTimeline } from './transcript-ingestion.js';
 const CLAUDE_CLI = process.env.CLAUDE_CLI_PATH || 'claude';
 const DEFAULT_TIMEOUT_MS = 600000; // 10 minutes per turn
 const MAX_TURNS = 100;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 // Track running processes for stop functionality (only active processes)
 const runningProcesses = new Map();
@@ -96,21 +97,48 @@ export async function executeTaskTurn(options) {
   }
 
   // 6. Determine prompt
-  const prompt = getNextPrompt(state, task);
+  let prompt = getNextPrompt(state, task);
   if (!prompt) {
     return { success: false, error: 'No prompt available' };
   }
 
   // 7. Determine which session to resume
-  // First turn: start fresh (don't resume parent — it's actively in use)
-  // Subsequent turns: resume child session from previous turn
-  const resumeSessionId = state.claude_session_id || null;
+  // Turn 1: resume parent session so Claude has full conversation context
+  // Turn 2+: resume child session from previous turn for continuity
+  // Safety: relay guarantees parent session is idle when this task was created (mobile Send
+  // flow only fires when the user is waiting for a response). Claude Code branches on --resume
+  // so the parent transcript is never mutated — only the child session ID is written back.
+  const validParentSessionId = UUID_PATTERN.test(task.parent_claude_session_id || '')
+    ? task.parent_claude_session_id
+    : null;
+  const resumeSessionId = state.claude_session_id  // child session from previous turns
+    || validParentSessionId                        // parent session for turn 1 context
+    || null;                                       // fallback: fresh session (tests / legacy tasks without relay validation)
 
   console.log(`[task-v2] Executing turn ${state.turn_count + 1} for task ${task_id.slice(0, 20)}...`);
-  if (resumeSessionId) {
-    console.log(`[task-v2] Resuming child session: ${resumeSessionId}`);
+  if (state.claude_session_id) {
+    console.log(`[task-v2] Resuming child session: ${state.claude_session_id}`);
+  } else if (validParentSessionId) {
+    console.log(`[task-v2] Turn 1: resuming parent session for context: ${validParentSessionId}`);
   } else {
-    console.log(`[task-v2] Starting fresh session (first turn)`);
+    if (task.parent_claude_session_id && !validParentSessionId) {
+      console.warn(`[task-v2] parent_claude_session_id is not a valid UUID, starting fresh: ${task.parent_claude_session_id}`);
+    }
+    // Fresh session: inject caller context so Claude is never completely blind
+    const contextLines = [];
+    if (task.caller) contextLines.push(`Triggered by: ${task.caller}`);
+    if (task.cwd) contextLines.push(`Working directory: ${task.cwd}`);
+    if (task.project_name) contextLines.push(`Project: ${task.project_name}`);
+    if (task.branch) contextLines.push(`Branch: ${task.branch}`);
+    if (task.hostname) contextLines.push(`Host: ${task.hostname}`);
+
+    if (contextLines.length > 0) {
+      const preamble = `[Context]\n${contextLines.join('\n')}\n\n`;
+      prompt = preamble + prompt;
+      console.log(`[task-v2] Starting fresh session with context preamble (${contextLines.length} fields)`);
+    } else {
+      console.log(`[task-v2] Starting fresh session (no context metadata available)`);
+    }
   }
   console.log(`[task-v2] Prompt: ${prompt.slice(0, 100)}...`);
 
@@ -177,12 +205,13 @@ export async function executeTaskTurn(options) {
           },
           body: JSON.stringify({
             session_id,
-            type: 'assistant_response',
+            type: 'task_update',
             data: {
               task_id,
               source: 'cli_interactive',
               claude_session_id: result.session_id,
-              turn: state.turn_count + 1,
+              turn_number: state.turn_count + 1,
+              status: 'turn_complete',
               cost_usd: result.cost_usd,
               timestamp: Date.now(),
               message: extractAssistantText(result.output) || 'Turn completed',

package/lib/daemon/teleportation-daemon.js

@@ -39,10 +39,29 @@ import { fileURLToPath } from 'url';
 import { spawn, exec } from 'child_process';
 import { promisify } from 'util';
 import { homedir, tmpdir } from 'os';
-import { existsSync, appendFileSync } from 'fs';
-import { join } from 'path';
+import { existsSync, appendFileSync, readFileSync, unlinkSync } from 'fs';
+import { join, dirname } 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.
+
+// File-based session registry — imported lazily so daemon can start without it
+// fileURLToPath is imported from 'url' at line 38.
+// REGISTRY_UNAVAILABLE is a no-op sentinel returned on transient import failure.
+// Callers guard with `if (!registry.readAllSessionFiles) return` so null-deref is safe.
+// _registry stays null so the next scan cycle retries the import automatically.
+const REGISTRY_UNAVAILABLE = Object.freeze({ readAllSessionFiles: null, isClaudePidAlive: null });
+let _registry = null;
+async function getRegistry() {
+  if (_registry) return _registry;
+  try {
+    const registryPath = join(dirname(fileURLToPath(import.meta.url)), 'session-file-registry.js');
+    _registry = await import(registryPath);
+  } catch (e) {
+    console.warn('[daemon] session-file-registry not available (will retry next scan):', e.message);
+    return REGISTRY_UNAVAILABLE;
+  }
+  return _registry;
+}
 // The following were removed in PRD-0025 migration:
 //   - pid-manager.js (replaced by agent-process platform locking)
 //   - lifecycle.js (replaced by inline signal handlers)
@@ -87,6 +106,8 @@ const CLAUDE_CLI = process.env.CLAUDE_CLI_PATH || 'claude'; // Configurable Clau
 const ALLOW_ALL_COMMANDS = process.env.TELEPORTATION_DAEMON_ALLOW_ALL_COMMANDS === 'true';
 const HEARTBEAT_INTERVAL_MS = parseInt(process.env.DAEMON_HEARTBEAT_INTERVAL_MS || '30000', 10); // 30 sec default
 const HEARTBEAT_CHECK_INTERVAL_MS = parseInt(process.env.DAEMON_HEARTBEAT_CHECK_INTERVAL_MS || '60000', 10); // 1 min default
+// How long a PID must be dead before the daemon marks the session stopped (ms)
+const DEAD_PID_THRESHOLD_MS = parseInt(process.env.DAEMON_DEAD_PID_THRESHOLD_MS || '60000', 10); // 60s default
 
 // Message routing configuration
 // REQUIRE_COMMAND_WHITELIST: If true, use legacy shell execution with command whitelist
@@ -110,6 +131,29 @@ const ROUTER_MAX_ESCALATIONS = parseInt(process.env.TELEPORTATION_ROUTER_MAX_ESC
 // Debug logging configuration
 const DEBUG = process.env.TELEPORTATION_DEBUG === 'true';
 const LOG_DIR = process.env.TELEPORTATION_LOG_DIR || tmpdir();
+const SESSION_LOG_FILE = join(homedir(), '.teleportation', 'session-events.log');
+
+/**
+ * Append a register event to the session log so daemon restarts can recover
+ * full session metadata (hostname, branch, etc.) and re-register correctly
+ * after a Redis TTL expiry.
+ */
+function appendSessionRegisterLog(session) {
+  try {
+    const line = JSON.stringify({
+      type: 'register',
+      session_id: session.session_id,
+      claude_session_id: session.claude_session_id,
+      pid: session.pid || null,
+      cwd: session.cwd,
+      meta: session.meta,
+      timestamp: session.registered_at || Date.now()
+    }) + '\n';
+    appendFileSync(SESSION_LOG_FILE, line);
+  } catch (err) {
+    if (DEBUG) console.error(`[daemon] Failed to append session log: ${err.message}`);
+  }
+}
 
 /**
  * Cross-platform debug logging utility
@@ -243,6 +287,13 @@ const stoppedSessions = new Set();
 // Session activity tracking for cleanup
 const sessionActivity = new Map(); // sessionId -> lastActivityTimestamp
 
+// PID liveness tracking (Bug 2):
+// Caches the Claude PID per session to avoid re-reading the session file every poll cycle.
+// lastPidCheck throttles the PID check to at most once every PID_CHECK_INTERVAL_MS per session.
+const sessionPidCache = new Map();   // sessionId -> number (claude_pid)
+const lastPidCheck = new Map();      // sessionId -> number (timestamp of last check)
+const PID_CHECK_INTERVAL_MS = parseInt(process.env.DAEMON_PID_CHECK_INTERVAL_MS || '30000', 10); // 30s default
+
 // Transcript ingestion throttling: Prevents concurrent ingestion runs per session
 // Map<session_id, Promise> tracks in-progress ingestion promises
 // If ingestion takes >5 seconds, prevents stacking multiple concurrent calls
@@ -271,6 +322,8 @@ setInterval(() => {
       sessionActivity.delete(sessionId);
       heartbeatState.delete(sessionId);
       heartbeatFailureLogged.delete(sessionId);
+      sessionPidCache.delete(sessionId);
+      lastPidCheck.delete(sessionId);
       sessionCleanedCount++;
 
       if (process.env.DEBUG) {
@@ -788,7 +841,11 @@ async function handleRequest(req, res) {
         }
       }
 
-      sessions.set(session_id, {
+      // Clear stale PID cache so the new session's PID is read fresh from marker file
+      sessionPidCache.delete(session_id);
+      lastPidCheck.delete(session_id);
+
+      const sessionEntry = {
         session_id,
         claude_session_id: claude_session_id || session_id, // Fallback to session_id if not provided
         cwd: cwd || process.cwd(),
@@ -797,7 +854,10 @@ async function handleRequest(req, res) {
           daemon_pid: process.pid // Add daemon PID to metadata
         },
         registered_at: Date.now()
-      });
+      };
+      sessions.set(session_id, sessionEntry);
+      // Persist to log so daemon restarts can recover full meta for re-registration
+      appendSessionRegisterLog(sessionEntry);
 
       console.log(`[daemon] Session registered: ${session_id} (claude_id: ${claude_session_id || session_id}) (daemon_pid: ${process.pid}) (cwd: ${cwd || process.cwd()})`);
       
@@ -1528,6 +1588,100 @@ async function sendHeartbeat(session_id) {
   }
 }
 
+/**
+ * Check if a Claude PID is still alive.
+ * Uses signal 0 (no signal sent, just existence check).
+ * CROSS-REFERENCE: pid-liveness.test.js has an equivalent local implementation.
+ * If this logic changes, update the test copy to match.
+ * @param {number} pid - Process ID to check
+ * @returns {boolean} true if process exists, false otherwise
+ */
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    // EPERM means process exists but we lack permission to signal it (different user/container)
+    return e.code === 'EPERM';
+  }
+}
+
+/**
+ * Read Claude PID from session marker file.
+ * Caches the PID per session to avoid reading the file on every poll cycle.
+ * CROSS-REFERENCE: pid-liveness.test.js has an equivalent local implementation
+ * (without cache). If this file-reading logic changes, update the test copy to match.
+ * @param {string} session_id - Session ID
+ * @returns {number|null} Claude PID or null if unavailable
+ */
+function getSessionPid(session_id) {
+  // Check cache first
+  if (sessionPidCache.has(session_id)) {
+    return sessionPidCache.get(session_id);
+  }
+
+  // Read from marker file
+  const sessionFile = join(tmpdir(), `teleportation-session-${session_id}.json`);
+  try {
+    const content = readFileSync(sessionFile, 'utf8');
+    const data = JSON.parse(content);
+    const pid = data.claude_pid;
+    if (typeof pid === 'number' && pid > 0) {
+      sessionPidCache.set(session_id, pid);
+      return pid;
+    }
+  } catch {
+    // File doesn't exist or can't be read - return null (no PID available)
+  }
+  return null;
+}
+
+/**
+ * Clean up a dead session: remove from all tracking maps, deregister from relay,
+ * and delete marker file.
+ * @param {string} session_id - Session ID to clean up
+ * @param {number|null} pid - The dead PID (for logging)
+ */
+async function cleanupDeadSession(session_id, pid) {
+  logInfo(`[daemon] PID ${pid} for session ${session_id.slice(0, 8)}... is dead - cleaning up`);
+
+  // Remove from all tracking maps
+  sessions.delete(session_id);
+  sessionActivity.delete(session_id);
+  heartbeatState.delete(session_id);
+  heartbeatFailureLogged.delete(session_id);
+  sessionPidCache.delete(session_id);
+  lastPidCheck.delete(session_id);
+  ingestionInProgress.delete(session_id);
+  stoppedSessions.add(session_id); // Prevent re-activation from stale registration attempts
+
+  // Delete marker file
+  const sessionFile = join(tmpdir(), `teleportation-session-${session_id}.json`);
+  try {
+    unlinkSync(sessionFile);
+  } catch {
+    // File may already be deleted
+  }
+
+  // Deregister from relay (best-effort)
+  try {
+    await fetch(
+      `${RELAY_API_URL}/api/sessions/${encodeURIComponent(session_id)}/end`,
+      {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${RELAY_API_KEY}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ reason: 'pid_dead' }),
+        signal: AbortSignal.timeout(5000)
+      }
+    );
+  } catch {
+    // Best-effort - relay will eventually expire the session via heartbeat timeout
+  }
+}
+
 /**
  * Relay API Polling Loop
  * Polls relay API every 5 seconds for approved requests
@@ -1553,8 +1707,25 @@ async function pollRelayAPI() {
       // Debug: Log to file for visibility
       debugLog('daemon-poll-debug.log', `Polling session ${session_id}`);
 
-      // Update activity timestamp for cleanup tracking
-      sessionActivity.set(session_id, Date.now());
+      // PID liveness check (Bug 2):
+      // Instead of unconditionally refreshing sessionActivity, check if the Claude
+      // process is still alive. Only update activity if PID is confirmed alive.
+      // Throttled to at most once per PID_CHECK_INTERVAL_MS per session.
+      const pidCheckNow = Date.now();
+      const lastCheck = lastPidCheck.get(session_id) || 0;
+      if (pidCheckNow - lastCheck >= PID_CHECK_INTERVAL_MS) {
+        lastPidCheck.set(session_id, pidCheckNow);
+        const pid = getSessionPid(session_id);
+        if (pid !== null && !isPidAlive(pid)) {
+          // PID is dead - clean up and skip this session
+          await cleanupDeadSession(session_id, pid);
+          continue;
+        }
+        // PID is alive (or no PID file exists - backward compat: treat as alive)
+        sessionActivity.set(session_id, pidCheckNow);
+      }
+      // Between PID checks, do NOT refresh sessionActivity - let the cleanup
+      // sweep use the last confirmed-alive timestamp.
 
       // 0) Check for stop_requested flag (mobile stop button)
       // Uses daemon-state endpoint (lightweight) instead of full session fetch
@@ -2820,8 +2991,6 @@ async function cleanup() {
  * Enables daemon to recover sessions after restart
  */
 async function discoverSessionsFromLog() {
-  const SESSION_LOG_FILE = join(homedir(), '.teleportation', 'session-events.log');
-
   try {
     const { readFile } = await import('fs/promises');
     const content = await readFile(SESSION_LOG_FILE, 'utf8');
@@ -2906,8 +3075,6 @@ async function discoverSessionsFromLog() {
  * Keeps only active sessions to prevent unbounded growth
  */
 async function compactSessionLog(activeSessions) {
-  const SESSION_LOG_FILE = join(homedir(), '.teleportation', 'session-events.log');
-
   try {
     const { writeFile } = await import('fs/promises');
 
@@ -2948,22 +3115,39 @@ async function compactSessionLog(activeSessions) {
 async function main() {
   console.log('[daemon] Main function started.');
 
-  // Load credentials from encrypted file if not in environment
-  if (!RELAY_API_KEY) {
+  // Load credentials from encrypted file if not in environment, OR if the env var
+  // looks like a relay service key (raw hex, no 'tp_' prefix) rather than a user API key.
+  // This handles the case where Bun auto-loads relay/.env when the daemon cwd is /relay,
+  // injecting a hex service key that causes all heartbeats to fail with 404.
+  const envKeyIsServiceKey = RELAY_API_KEY && !RELAY_API_KEY.startsWith('tp_');
+  if (!RELAY_API_KEY || envKeyIsServiceKey) {
     try {
-      console.log('[daemon] RELAY_API_KEY not in environment, loading from credentials file...');
+      console.log(
+        envKeyIsServiceKey
+          ? '[daemon] RELAY_API_KEY looks like a service key (no tp_ prefix), loading user credentials from encrypted file...'
+          : '[daemon] RELAY_API_KEY not in environment, loading from credentials file...'
+      );
       const credManager = new CredentialManager();
       const creds = await credManager.load();
       if (creds && creds.apiKey) {
         RELAY_API_KEY = creds.apiKey;
-        RELAY_API_URL = creds.relayUrl || RELAY_API_URL;
+        RELAY_API_URL = creds.relayApiUrl || creds.relayUrl || RELAY_API_URL;
         console.log('[daemon] ✅ Loaded credentials from encrypted file');
+      } else if (envKeyIsServiceKey) {
+        console.warn('[daemon] ⚠️  No user credentials found — refusing to use service key for heartbeats');
+        RELAY_API_KEY = '';
       } else {
         console.warn('[daemon] ⚠️  No API key found in credentials file');
       }
     } catch (e) {
-      console.warn('[daemon] ⚠️  Failed to load credentials:', e.message);
-      console.warn('[daemon] Daemon will run but cannot authenticate with relay API');
+      if (envKeyIsServiceKey) {
+        console.warn('[daemon] ⚠️  Failed to load credentials and env key is a service key:', e.message);
+        console.warn('[daemon] Clearing service key — daemon will run without relay auth');
+        RELAY_API_KEY = '';
+      } else {
+        console.warn('[daemon] ⚠️  Failed to load credentials:', e.message);
+        console.warn('[daemon] Daemon will run but cannot authenticate with relay API');
+      }
     }
   } else {
     console.log('[daemon] Using RELAY_API_KEY from environment');
@@ -3082,6 +3266,85 @@ async function main() {
     }, HEARTBEAT_INTERVAL_MS);
     console.log(`[daemon] Session heartbeat interval started (${HEARTBEAT_INTERVAL_MS / 1000}s)`);
 
+    // PID-based session file scan: discover sessions written by session_start.mjs hooks
+    // and check liveness via OS process table rather than waiting for hooks to re-register.
+    const scanSessionFiles = async () => {
+      if (isShuttingDown) return;
+      const registry = await getRegistry();
+      if (!registry.readAllSessionFiles || !registry.isClaudePidAlive) return;
+
+      let records;
+      try { records = await registry.readAllSessionFiles(); } catch { return; }
+
+      for (const record of records) {
+        const { session_id, claude_pid, cwd, meta, acked, ended } = record;
+        if (!session_id || !claude_pid) continue;
+
+        // Fast path: session already ended
+        if (ended) {
+          if (sessions.has(session_id)) {
+            sessions.delete(session_id);
+            console.log(`[daemon] Session ${session_id.slice(0,8)} ended (file flag)`);
+          }
+          try { await registry.deleteSessionFile(session_id); } catch {}
+          continue;
+        }
+
+        const alive = await registry.isClaudePidAlive(claude_pid);
+
+        if (!sessions.has(session_id) && alive) {
+          // New session discovered via file — add to Map and ack
+          // claude_session_id is intentionally set to session_id here: session files
+          // don't store the Anthropic-assigned claude session ID (not available at
+          // hook time). The daemon only uses session_id for heartbeats/relay calls;
+          // claude_session_id is only needed for --resume, which goes through the HTTP
+          // registration path or agentic-executor, not file-based discovery.
+          sessions.set(session_id, { session_id, claude_session_id: session_id, cwd, meta: meta || {}, claude_pid });
+          try { await registry.ackSessionFile(session_id, process.pid); } catch {}
+          console.log(`[daemon] Discovered session ${session_id.slice(0,8)} (PID ${claude_pid}, project: ${meta?.project_name || 'unknown'})`);
+          // Send immediate heartbeat so relay shows it active right away
+          try {
+            await fetch(`${RELAY_API_URL}/api/sessions/${encodeURIComponent(session_id)}/heartbeat`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${RELAY_API_KEY}` },
+              body: JSON.stringify({ timestamp: Date.now() }),
+              signal: AbortSignal.timeout(5000)
+            });
+          } catch {}
+        } else if (sessions.has(session_id) && !alive) {
+          // Track when PID first went dead
+          const sessionData = sessions.get(session_id);
+          const now = Date.now();
+          if (!sessionData._pid_dead_since) {
+            sessionData._pid_dead_since = now;
+            console.log(`[daemon] Session ${session_id.slice(0,8)} PID ${claude_pid} no longer alive — starting ${DEAD_PID_THRESHOLD_MS / 1000}s grace period`);
+          } else if (now - sessionData._pid_dead_since >= DEAD_PID_THRESHOLD_MS) {
+            // Grace period expired — mark stopped
+            sessions.delete(session_id);
+            try { await registry.deleteSessionFile(session_id); } catch {}
+            console.log(`[daemon] Session ${session_id.slice(0,8)} marked stopped (PID dead > ${DEAD_PID_THRESHOLD_MS / 1000}s)`);
+            try {
+              await fetch(`${RELAY_API_URL}/api/sessions/${encodeURIComponent(session_id)}/daemon-state`, {
+                method: 'PATCH',
+                headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${RELAY_API_KEY}` },
+                body: JSON.stringify({ status: 'stopped', stopped_reason: 'pid_dead' }),
+                signal: AbortSignal.timeout(5000)
+              });
+            } catch {}
+          }
+        } else if (!sessions.has(session_id) && !alive) {
+          // Stale file for a dead PID we never tracked — clean up
+          try { await registry.deleteSessionFile(session_id); } catch {}
+        }
+      }
+    };
+
+    // Run scan on startup to recover sessions from a daemon restart
+    scanSessionFiles().catch(e => console.warn('[daemon] Initial session file scan failed:', e.message));
+    // Then scan on every heartbeat cycle
+    setInterval(scanSessionFiles, HEARTBEAT_INTERVAL_MS);
+    console.log(`[daemon] PID-based session file scan active (${HEARTBEAT_INTERVAL_MS / 1000}s interval)`);
+
     // Start polling loop
     console.log('[daemon] Starting relay API polling...');
     pollRelayAPI();
@@ -3152,7 +3415,14 @@ const __test = {
   // Stopped sessions test helpers
   _getStoppedSessions: () => stoppedSessions,
   _addStoppedSession: (session_id) => stoppedSessions.add(session_id),
-  _clearStoppedSessions: () => stoppedSessions.clear()
+  _clearStoppedSessions: () => stoppedSessions.clear(),
+  // PID liveness test helpers (Bug 2)
+  isPidAlive,
+  getSessionPid,
+  cleanupDeadSession,
+  _getSessionPidCache: () => sessionPidCache,
+  _getLastPidCheck: () => lastPidCheck,
+  _getSessionActivity: () => sessionActivity,
 };
 
 // Test helper to register a session