teleportation-cli 1.0.0 → 1.0.2

package/.claude/hooks/heartbeat.mjs

@@ -46,11 +46,53 @@ let intervalHandle = null;
 let heartbeatCount = 0;
 let failureCount = 0;
 let lastDaemonCheck = 0;
+// Module cache for lifecycle and pid-manager (imported once, reused)
+let lifecycleModule = null;
+let pidManagerModule = null;
+// Flag to prevent concurrent daemon start attempts
+let daemonStartInProgress = false;
 // 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
 
+/**
+ * Update daemon state on relay
+ * @param {'running' | 'stopped'} status - Daemon status
+ * @param {string} reason - Reason for state change
+ */
+async function updateRelayDaemonState(status, reason) {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+
+    const response = 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({
+        status,
+        started_at: status === 'running' ? Date.now() : null,
+        started_reason: status === 'running' ? reason : null
+      }),
+      signal: controller.signal
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok && DEBUG) {
+      console.log(`[Heartbeat] Failed to update relay daemon state: ${response.status}`);
+    }
+  } catch (error) {
+    if (DEBUG) {
+      console.log(`[Heartbeat] Error updating relay daemon state: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
 /**
  * Check if daemon is running and start it if not
  */
@@ -67,8 +109,15 @@ async function ensureDaemonRunning() {
   try {
     // Try to import lifecycle module from installed location
     const possibleLocations = [
+      // npm global install location
+      '/usr/local/lib/node_modules/teleportation-cli/lib/daemon/lifecycle.js',
+      // User's npm global install (common on macOS with nvm/fnm)
+      join(homedir(), '.local', 'lib', 'node_modules', 'teleportation-cli', 'lib', 'daemon', 'lifecycle.js'),
+      // Legacy location
       join(homedir(), '.teleportation', 'lib', 'daemon', 'lifecycle.js'),
+      // Relative to hooks dir (development)
       join(__dirname, '..', '..', 'lib', 'daemon', 'lifecycle.js'),
+      // Environment override
       env.TELEPORTATION_LIFECYCLE_PATH
     ].filter(Boolean);
 
@@ -116,9 +165,11 @@ async function ensureDaemonRunning() {
       }
 
       try {
-        await lifecycle.startDaemon({ silent: true });
+        // Use startDaemonIfNeeded to both start the daemon AND update the relay
+        // This ensures the mobile UI knows the daemon is running
+        await lifecycle.startDaemonIfNeeded(SESSION_ID, 'heartbeat');
         if (DEBUG) {
-          console.log(`[Heartbeat] Daemon started successfully`);
+          console.log(`[Heartbeat] Daemon started and relay updated successfully`);
         }
       } catch (error) {
         // Don't fail heartbeat if daemon start fails - it might already be starting
@@ -129,6 +180,20 @@ async function ensureDaemonRunning() {
         // Always reset flag, even if start fails
         daemonStartInProgress = false;
       }
+    } else if (status.running) {
+      // Daemon is running - ensure relay knows about it
+      // This handles the case where daemon was started manually or by another session
+      try {
+        await updateRelayDaemonState('running', 'heartbeat');
+        if (DEBUG) {
+          console.log(`[Heartbeat] Synced daemon running state to relay`);
+        }
+      } catch (error) {
+        // Ignore errors - just a sync, not critical
+        if (DEBUG) {
+          console.log(`[Heartbeat] Failed to sync daemon state: ${error.message}`);
+        }
+      }
     }
   } catch (error) {
     // Silently fail - daemon check shouldn't break heartbeat

package/.claude/hooks/permission_request.mjs

@@ -132,7 +132,10 @@ const fetchJson = async (url, opts) => {
   const RELAY_API_URL = env.RELAY_API_URL || config.relayApiUrl || '';
   const RELAY_API_KEY = env.RELAY_API_KEY || config.relayApiKey || '';
   const POLLING_INTERVAL_MS = parseInt(env.APPROVAL_POLL_INTERVAL_MS || '2000', 10);
-  const APPROVAL_TIMEOUT_MS = parseInt(env.APPROVAL_TIMEOUT_MS || '300000', 10); // 5 min default
+  const FAST_APPROVAL_TIMEOUT_MS = parseInt(
+    env.FAST_APPROVAL_TIMEOUT_MS || env.FAST_POLL_TIMEOUT_MS || '55000',
+    10
+  );
 
   if (!RELAY_API_URL || !RELAY_API_KEY) {
     log('No relay config - letting Claude Code handle permission locally');
@@ -224,13 +227,10 @@ const fetchJson = async (url, opts) => {
 
   // Poll for remote approval decision
   log('Polling for remote approval decision...');
-  const AUTO_AWAY_TIMEOUT_MS = parseInt(env.AUTO_AWAY_TIMEOUT_MS || '300000', 10); // 5 min default
-  const startTime = Date.now();
-  let hasSetAutoAway = false;
   let consecutiveFailures = 0;
   const MAX_CONSECUTIVE_FAILURES = 5;
 
-  const deadline = Date.now() + APPROVAL_TIMEOUT_MS;
+  const deadline = Date.now() + FAST_APPROVAL_TIMEOUT_MS;
   while (Date.now() < deadline) {
     try {
       const status = await fetchJson(`${RELAY_API_URL}/api/approvals/${approvalId}`, {
@@ -240,6 +240,30 @@ const fetchJson = async (url, opts) => {
 
       if (status.status === 'allowed') {
         log('Remote approval: ALLOWED');
+        // Acknowledge on the fast-path to prevent duplicate daemon execution.
+        // CRITICAL: If ACK fails, we must NOT proceed with local execution to avoid duplicates.
+        try {
+          const ackRes = await fetch(`${RELAY_API_URL}/api/approvals/${approvalId}/ack`, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
+          });
+          if (!ackRes.ok) {
+            throw new Error(`ACK returned ${ackRes.status}`);
+          }
+        } catch (e) {
+          log(`ERROR: Failed to ack approval ${approvalId}: ${e.message} - aborting to prevent duplicate execution`);
+          // Return early without allowing - let daemon handle it instead
+          const out = {
+            hookSpecificOutput: {
+              hookEventName: 'PermissionRequest',
+              permissionDecision: 'deny',
+              permissionDecisionReason: '⚠️ Teleportation: Approval received but acknowledgment failed. Request handed to daemon to prevent duplicate execution.'
+            },
+            suppressOutput: true
+          };
+          stdout.write(JSON.stringify(out));
+          return exit(0);
+        }
         const out = {
           hookSpecificOutput: {
             hookEventName: 'PermissionRequest',
@@ -270,25 +294,6 @@ const fetchJson = async (url, opts) => {
         log('Approval was invalidated - letting Claude Code handle');
         return exit(0);
       }
-
-      // Auto-set away after timeout (if not already away)
-      if (!hasSetAutoAway && (Date.now() - startTime) > AUTO_AWAY_TIMEOUT_MS) {
-        const timeoutMinutes = Math.round(AUTO_AWAY_TIMEOUT_MS / 1000 / 60);
-        log(`Approval waiting >${timeoutMinutes} minutes - auto-setting away mode`);
-        try {
-          await fetchJson(`${RELAY_API_URL}/api/sessions/${session_id}/daemon-state`, {
-            method: 'PATCH',
-            headers: {
-              'Content-Type': 'application/json',
-              'Authorization': `Bearer ${RELAY_API_KEY}`
-            },
-            body: JSON.stringify({ is_away: true })
-          });
-          hasSetAutoAway = true;
-        } catch (e) {
-          log(`Failed to auto-set away: ${e.message}`);
-        }
-      }
     } catch (e) {
       consecutiveFailures++;
       if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
@@ -301,7 +306,31 @@ const fetchJson = async (url, opts) => {
     await sleep(POLLING_INTERVAL_MS);
   }
 
-  // Timeout - let Claude Code handle it
-  log('Approval timeout - letting Claude Code handle');
+  // Fast-path timeout: do NOT fall back to local permission prompts while user is away.
+  // Instead, hand off to daemon (background) and inform Claude.
+  log('Fast-path approval timeout - handing off to daemon');
+
+  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({ last_approval_location: 'daemon_handoff', is_away: true })
+    });
+  } catch (e) {
+    log(`Warning: Failed to update daemon-state for handoff: ${e.message}`);
+  }
+
+  const out = {
+    hookSpecificOutput: {
+      hookEventName: 'PermissionRequest',
+      permissionDecision: 'deny',
+      permissionDecisionReason: '⏳ Teleportation: waiting for mobile approval timed out. This request was handed off to the daemon and will run in the background once approved. You will see a Daemon Work Update here when it completes.'
+    },
+    suppressOutput: true
+  };
+  stdout.write(JSON.stringify(out));
   return exit(0);
 })();

package/.claude/hooks/pre_tool_use.mjs

@@ -79,6 +79,7 @@ const fetchJson = async (url, opts) => {
   }
 
   let { session_id, tool_name, tool_input } = input || {};
+  tool_input = tool_input && typeof tool_input === 'object' ? tool_input : {};
   let claude_session_id = session_id; // Keep original ID
 
   log(`Session ID: ${session_id}, Tool: ${tool_name}, Input: ${JSON.stringify(tool_input).substring(0, 100)}`);
@@ -418,10 +419,36 @@ const fetchJson = async (url, opts) => {
     }
   };
 
+  if (tool_input.__teleportation_away) {
+    await updateSessionState({ is_away: true });
+    const out = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: '✅ Teleportation: Away mode enabled.'
+      },
+      suppressOutput: true
+    };
+    stdout.write(JSON.stringify(out));
+    return exit(0);
+  }
+
+  if (tool_input.__teleportation_back) {
+    await updateSessionState({ is_away: false });
+    const out = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: '✅ Teleportation: Away mode disabled.'
+      },
+      suppressOutput: true
+    };
+    stdout.write(JSON.stringify(out));
+    return exit(0);
+  }
+
   // SMART AWAY MODE: Auto-mark as present ("back") on any activity
   // If the user is typing commands locally, they are clearly not away.
-  await updateSessionState({ is_away: false });
-
   // Note: Approval invalidation is handled by PermissionRequest hook
   // to avoid race conditions and duplicate API calls
 

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

@@ -145,19 +145,78 @@ export async function ensureSessionRegistered(session_id, cwd, config) {
 
           // Check if heartbeat is already running for this session
           const { tmpdir } = await import('os');
-          const { readFile } = await import('fs/promises');
+          const { readFile, unlink } = 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;
+            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
           }
 
           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}`);
+              }
+            }
+
             const heartbeat = spawn('node', [heartbeatPath, session_id], {
               detached: true,
               stdio: 'ignore',

package/.claude/hooks/stop.mjs

@@ -29,6 +29,9 @@ const isValidSessionId = (id) => {
 // Max length for assistant response preview (characters)
 const ASSISTANT_RESPONSE_MAX_LENGTH = 2000;
 
+// Max size for full transcript (bytes) - 500KB
+const MAX_TRANSCRIPT_SIZE = 500 * 1024;
+
 // Retry configuration
 const MAX_RETRIES = 3;
 const RETRY_DELAY_MS = 1000;
@@ -150,6 +153,178 @@ const extractLastAssistantMessage = async (transcriptPath, log) => {
   }
 };
 
+/**
+ * Extract the full conversation transcript from the transcript file
+ * Returns all user and assistant messages with turn_index
+ * @returns {Object|null} - { messages: [{ role, content, turn_index }], total_turns: number, truncated: boolean, original_size: number } or null
+ */
+const extractFullTranscript = async (transcriptPath, log) => {
+  try {
+    if (!transcriptPath) {
+      log('No transcript_path provided for full extraction');
+      return null;
+    }
+
+    // Read file directly
+    let content;
+    try {
+      content = await readFile(transcriptPath, 'utf8');
+    } catch (e) {
+      if (e.code === 'ENOENT') {
+        log(`Transcript file not found: ${transcriptPath}`);
+        return null;
+      }
+      if (e.code === 'EACCES' || e.code === 'EPERM') {
+        log(`Permission denied reading transcript: ${transcriptPath}`);
+        return null;
+      }
+      log(`Error reading transcript for full extraction: ${e.code || e.message}`);
+      return null;
+    }
+
+    let transcript;
+
+    // Try parsing as JSON array first
+    try {
+      transcript = JSON.parse(content);
+      log('Parsed transcript as JSON array for full extraction');
+    } catch (e) {
+      // Try parsing as JSONL (newline-delimited JSON)
+      log('JSON parse failed for full extraction, trying JSONL format');
+      const lines = content.trim().split('\n').filter(l => l.trim());
+      transcript = lines.map(line => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter(Boolean);
+      log(`Parsed transcript as JSONL (${transcript.length} messages) for full extraction`);
+    }
+
+    if (!Array.isArray(transcript)) {
+      log(`Transcript is not an array for full extraction: ${typeof transcript}`);
+      return null;
+    }
+
+    log(`Full transcript has ${transcript.length} raw messages`);
+
+    // Extract all user and assistant messages
+    const messages = [];
+    let turnIndex = 0;
+
+    for (const msg of transcript) {
+      const role = msg.role || msg.type || '';
+      const isAssistant = role === 'assistant' || role === 'model' || msg.isAssistant;
+      const isUser = role === 'user' || role === 'human' || msg.isUser;
+
+      if (!isAssistant && !isUser) continue;
+
+      // Extract content
+      let text = '';
+      if (typeof msg.content === 'string') {
+        text = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        // Content blocks format: [{ type: 'text', text: '...' }, ...]
+        text = msg.content
+          .filter(block => block.type === 'text' && block.text)
+          .map(block => block.text)
+          .join('\n\n');
+      } else if (msg.text) {
+        text = msg.text;
+      } else if (msg.message && typeof msg.message === 'string') {
+        text = msg.message;
+      }
+
+      if (text && text.trim()) {
+        messages.push({
+          role: isAssistant ? 'assistant' : 'user',
+          content: text.trim(),
+          turn_index: turnIndex
+        });
+        turnIndex++;
+      }
+    }
+
+    log(`Extracted ${messages.length} messages from transcript`);
+
+    if (messages.length === 0) {
+      log('No valid messages found in transcript');
+      return null;
+    }
+
+    // Check size and truncate if needed (reliability requirement: 500KB limit)
+    let result = {
+      messages,
+      total_turns: messages.length,
+      truncated: false,
+      original_size: 0
+    };
+
+    const jsonSize = JSON.stringify(result).length;
+    result.original_size = jsonSize;
+
+    if (jsonSize > MAX_TRANSCRIPT_SIZE) {
+      log(`Transcript size ${jsonSize} exceeds limit ${MAX_TRANSCRIPT_SIZE}, truncating...`);
+
+      // Use size estimation to avoid O(n²) repeated JSON.stringify calls
+      // Estimate average message size and calculate how many to keep
+      const metadataOverhead = 100; // Approximate overhead for result wrapper
+      const avgMsgSize = (jsonSize - metadataOverhead) / messages.length;
+      const targetCount = Math.max(1, Math.floor((MAX_TRANSCRIPT_SIZE - metadataOverhead) / avgMsgSize));
+
+      // Keep the most recent messages (slice from end)
+      let truncatedMessages = messages.slice(-targetCount);
+
+      // Verify size with a single stringify check
+      let testResult = {
+        messages: truncatedMessages,
+        total_turns: messages.length,
+        truncated: true,
+        original_size: jsonSize
+      };
+
+      // If still too large (estimation was off), remove a few more messages
+      while (truncatedMessages.length > 1 && JSON.stringify(testResult).length > MAX_TRANSCRIPT_SIZE) {
+        truncatedMessages = truncatedMessages.slice(1); // Remove oldest of remaining
+        testResult = {
+          messages: truncatedMessages,
+          total_turns: messages.length,
+          truncated: true,
+          original_size: jsonSize
+        };
+      }
+
+      result = testResult;
+
+      // If still too large with just one message, truncate the message content
+      if (truncatedMessages.length === 0) {
+        log('All messages truncated - transcript too large for any message');
+        return null;
+      }
+
+      if (JSON.stringify(result).length > MAX_TRANSCRIPT_SIZE) {
+        const lastMsg = { ...truncatedMessages[truncatedMessages.length - 1] }; // Clone to avoid mutation
+        const maxContentLen = Math.floor(MAX_TRANSCRIPT_SIZE * 0.8); // Leave room for metadata
+        lastMsg.content = lastMsg.content.substring(0, maxContentLen) + '... [truncated]';
+        result = {
+          messages: [lastMsg],
+          total_turns: messages.length,
+          truncated: true,
+          original_size: jsonSize
+        };
+      }
+
+      log(`Truncated transcript to ${result.messages.length} messages`);
+    }
+
+    return result;
+  } catch (e) {
+    log(`Error extracting full transcript: ${e.message}`);
+    return null;
+  }
+};
+
 (async () => {
   const hookLogFile = env.TELEPORTATION_HOOK_LOG || '/tmp/teleportation-hook.log';
   const log = (msg) => {
@@ -242,7 +417,36 @@ const extractLastAssistantMessage = async (transcriptPath, log) => {
     log('Skipping assistant response log (stop_hook_active=true)');
   }
 
-  // 2. Check for pending messages from mobile app (existing functionality)
+  // 2. Store full transcript for session (new feature: PRD-0011 Phase 2)
+  // Only store if not in a recursive stop hook call
+  if (!stop_hook_active) {
+    try {
+      const transcriptData = await extractFullTranscript(transcript_path, log);
+
+      if (transcriptData && transcriptData.messages && transcriptData.messages.length > 0) {
+        await fetchJsonWithRetry(`${RELAY_API_URL}/api/sessions/${session_id}/transcript`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${RELAY_API_KEY}`
+          },
+          body: JSON.stringify({
+            messages: transcriptData.messages,
+            total_turns: transcriptData.total_turns,
+            truncated: transcriptData.truncated,
+            original_size: transcriptData.original_size,
+            stored_at: Date.now()
+          })
+        }, log);
+        log(`Stored full transcript (${transcriptData.messages.length} messages, ${transcriptData.total_turns} total turns, truncated: ${transcriptData.truncated})`);
+      }
+    } catch (e) {
+      // Reliability: Log but don't fail hook if transcript storage fails
+      log(`Failed to store full transcript: ${e.message}`);
+    }
+  }
+
+  // 3. Check for pending messages from mobile app (existing functionality)
   try {
     const res = await fetch(`${RELAY_API_URL}/api/messages/pending?session_id=${encodeURIComponent(session_id)}`, {
       headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }