teleportation-cli 1.1.3 → 1.1.4

package/.claude/hooks/permission_request.mjs

@@ -84,7 +84,16 @@ const isValidSessionId = (id) => {
 
 const fetchJson = async (url, opts) => {
   const res = await fetch(url, opts);
-  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  if (!res.ok) {
+    let errorBody = '';
+    try {
+      const errorData = await res.json();
+      errorBody = JSON.stringify(errorData);
+    } catch (e) {
+      errorBody = await res.text();
+    }
+    throw new Error(`HTTP ${res.status}: ${errorBody}`);
+  }
   return res.json();
 };
 
@@ -246,27 +255,36 @@ const fetchJson = async (url, opts) => {
   // Create approval request with metadata and context (PRD-0013)
   let approvalId;
   try {
+    const payload = {
+      session_id,
+      tool_name,
+      tool_input,
+      meta,
+      tool_use_id: effective_tool_use_id,
+    };
+    // Only include conversation_context if not null
+    // API validation expects it to be an object, not null
+    if (conversation_context !== null) {
+      payload.conversation_context = conversation_context;
+    }
+    // Phase 2 fields - not implemented yet, so don't include them
+    // if (task_description !== null) payload.task_description = task_description;
+    // if (transcript_excerpt !== null) payload.transcript_excerpt = transcript_excerpt;
+
+    log(`Creating approval with payload: ${JSON.stringify(payload).substring(0, 500)}`);
     const created = await fetchJson(`${RELAY_API_URL}/api/approvals`, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
         'Authorization': `Bearer ${RELAY_API_KEY}`
       },
-      body: JSON.stringify({
-        session_id,
-        tool_name,
-        tool_input,
-        meta,
-        tool_use_id: effective_tool_use_id,
-        conversation_context,
-        task_description: null, // Phase 2: infer multi-step tasks
-        transcript_excerpt: null // Phase 2: include recent messages
-      })
+      body: JSON.stringify(payload)
     });
     approvalId = created.id;
     log(`Approval created: ${approvalId} (tool_use_id: ${effective_tool_use_id})`);
   } catch (e) {
     log(`ERROR creating approval: ${e.message}`);
+    log(`Error stack: ${e.stack}`);
     return exit(0); // Let Claude Code handle it
   }
 

package/.claude/hooks/post_tool_use.mjs

@@ -1,11 +1,16 @@
 #!/usr/bin/env bun
 /**
  * PostToolUse Hook
- * 
+ *
  * This hook fires AFTER a tool has been executed.
  * If we get here, the tool was approved (either auto or manually) and ran.
- * 
+ *
  * Purpose: Record tool executions to the timeline for activity history.
+ *
+ * PRD-0015: Approval Execution Feedback Loop
+ * - Logs tool_completed events for successful executions
+ * - Logs tool_failed events for failed executions
+ * - Includes exit_code, duration_ms, stdout, stderr, and approval_id linking
  */
 
 import { stdin, stdout, exit, env } from 'node:process';
@@ -24,6 +29,7 @@ const isValidSessionId = (id) => {
 };
 
 const TIMELINE_OUTPUT_PREVIEW_MAX_LENGTH = 500;
+const COMPLETION_EVENT_OUTPUT_MAX_LENGTH = 500;
 
 const fetchJson = async (url, opts) => {
   const res = await fetch(url, opts);
@@ -31,7 +37,154 @@ const fetchJson = async (url, opts) => {
   return res.json();
 };
 
+// ============================================================================
+// PRD-0015: Utility Functions for Completion Events
+// ============================================================================
+
+/**
+ * Truncate output to a maximum length, adding ellipsis if truncated.
+ * Handles null/undefined gracefully.
+ *
+ * @param {string|null|undefined} text - The text to truncate
+ * @param {number} maxLength - Maximum length (default 500)
+ * @returns {string} Truncated text or empty string
+ */
+export function truncateOutput(text, maxLength = COMPLETION_EVENT_OUTPUT_MAX_LENGTH) {
+  if (text == null || text === '') return '';
+  const str = String(text);
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength) + '...';
+}
+
+/**
+ * Extract exit code from tool_output.
+ * - For Bash: uses exit_code property
+ * - For other tools: derives from is_error, error, or output patterns
+ *
+ * @param {object|string|null|undefined} tool_output - The tool output
+ * @returns {number} Exit code (0 for success, 1+ for failure)
+ */
+export function extractExitCode(tool_output) {
+  if (tool_output == null) return 0;
+
+  // Direct exit_code property (Bash commands)
+  if (typeof tool_output === 'object' && typeof tool_output.exit_code === 'number') {
+    return tool_output.exit_code;
+  }
+
+  // is_error flag
+  if (tool_output?.is_error === true) return 1;
+
+  // error property exists
+  if (tool_output?.error) return 1;
+
+  // Check for non-empty stderr (indicates error)
+  if (tool_output?.stderr && typeof tool_output.stderr === 'string' && tool_output.stderr.trim()) {
+    // Only treat as error if exit_code is explicitly non-zero
+    // Note: undefined/null exit_code with stderr is NOT an error (e.g., git push SSH warnings)
+    if (tool_output.exit_code !== undefined && tool_output.exit_code !== null && tool_output.exit_code !== 0) {
+      return 1;
+    }
+  }
+
+  // String output with error patterns
+  if (typeof tool_output === 'string') {
+    const lower = tool_output.toLowerCase();
+    if (lower.includes('error:') || lower.includes('exception:') || lower.includes('failed:')) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * Calculate duration in milliseconds from start time.
+ * Can use tool_output.duration_ms if available.
+ *
+ * @param {number|null} startTime - Start timestamp (Date.now())
+ * @param {number|null} endTime - End timestamp (default: now)
+ * @param {object|null} tool_output - Tool output (may contain duration_ms)
+ * @returns {number|null} Duration in ms or null if cannot be determined
+ */
+export function extractDurationMs(startTime, endTime = null, tool_output = null) {
+  // Check if tool_output provides duration
+  if (tool_output && typeof tool_output.duration_ms === 'number') {
+    return tool_output.duration_ms;
+  }
+
+  // Calculate from timestamps
+  if (startTime == null) return null;
+  const end = endTime ?? Date.now();
+  return end - startTime;
+}
+
+/**
+ * Extract stdout from tool_output, handling various formats.
+ *
+ * @param {object|string|null} tool_output - The tool output
+ * @returns {string} The stdout content or empty string
+ */
+function extractStdout(tool_output) {
+  if (tool_output == null) return '';
+  if (typeof tool_output === 'string') return tool_output;
+  if (typeof tool_output.stdout === 'string') return tool_output.stdout;
+  // For non-Bash tools, try to get readable content
+  if (tool_output.content) return String(tool_output.content);
+  if (tool_output.result) return String(tool_output.result);
+  return '';
+}
+
+/**
+ * Extract stderr from tool_output.
+ *
+ * @param {object|string|null} tool_output - The tool output
+ * @returns {string} The stderr content or empty string
+ */
+function extractStderr(tool_output) {
+  if (tool_output == null) return '';
+  if (typeof tool_output.stderr === 'string') return tool_output.stderr;
+  if (typeof tool_output.error === 'string') return tool_output.error;
+  return '';
+}
+
+/**
+ * Build error message for tool_failed events.
+ * Prioritizes stderr content.
+ *
+ * @param {object|string|null} tool_output - The tool output
+ * @returns {string} Error message
+ */
+function buildErrorMessage(tool_output) {
+  if (tool_output == null) return 'Tool execution failed';
+
+  // Prioritize stderr
+  const stderr = extractStderr(tool_output);
+  if (stderr) return stderr;
+
+  // Check for error property
+  if (tool_output?.error) {
+    return typeof tool_output.error === 'string'
+      ? tool_output.error
+      : JSON.stringify(tool_output.error);
+  }
+
+  // Check for string output with error patterns
+  if (typeof tool_output === 'string') {
+    return tool_output;
+  }
+
+  return 'Tool execution failed';
+}
+
+// ============================================================================
+// Main Hook Logic
+// ============================================================================
+
 (async () => {
+  // Track hook start time for duration calculation
+  const hookStartTime = Date.now();
+
   const hookLogFile = env.TELEPORTATION_HOOK_LOG || '/tmp/teleportation-hook.log';
   const log = (msg) => {
     const timestamp = new Date().toISOString();
@@ -44,15 +197,15 @@ const fetchJson = async (url, opts) => {
 
   const raw = await readStdin();
   let input;
-  try { 
-    input = JSON.parse(raw || '{}'); 
+  try {
+    input = JSON.parse(raw || '{}');
   } catch (e) {
     log(`ERROR: Invalid JSON: ${e.message}`);
     return exit(0);
   }
 
-  const { session_id, tool_name, tool_input, tool_output } = input || {};
-  log(`Session: ${session_id}, Tool: ${tool_name}`);
+  const { session_id, tool_name, tool_input, tool_output, tool_use_id } = input || {};
+  log(`Session: ${session_id}, Tool: ${tool_name}, tool_use_id: ${tool_use_id || 'none'}`);
 
   // Validate session_id
   if (!isValidSessionId(session_id)) {
@@ -102,23 +255,41 @@ const fetchJson = async (url, opts) => {
     log(`Failed to clear pending approvals: ${e.message}`);
   }
 
-  // Detect if this tool execution resulted in an error
-  const hasError = (() => {
-    if (!tool_output) return false;
-    // Check for is_error flag
-    if (tool_output?.is_error) return true;
-    // Check for error property
-    if (tool_output?.error) return true;
-    // Check for common error patterns in string output
-    if (typeof tool_output === 'string') {
-      const lower = tool_output.toLowerCase();
-      return lower.includes('error:') || lower.includes('exception:') || lower.includes('failed:');
+  // =========================================================================
+  // PRD-0015: Extract completion event data
+  // =========================================================================
+
+  const exitCode = extractExitCode(tool_output);
+  const hasError = exitCode !== 0;
+  const durationMs = extractDurationMs(hookStartTime, Date.now(), tool_output);
+  const rawStdout = extractStdout(tool_output);
+  const rawStderr = extractStderr(tool_output);
+
+  log(`Exit code: ${exitCode}, Has error: ${hasError}, Duration: ${durationMs}ms`);
+
+  // Lookup approval_id if tool_use_id is available
+  // The approval is linked via tool_use_id (set during PermissionRequest hook)
+  let approvalId = null;
+  if (tool_use_id && RELAY_API_URL && RELAY_API_KEY) {
+    try {
+      // Query for the most recent approval with this tool_use_id
+      const approvalResponse = await fetchJson(
+        `${RELAY_API_URL}/api/approvals?session_id=${session_id}&tool_use_id=${tool_use_id}&limit=1`,
+        {
+          headers: { 'Authorization': `Bearer ${RELAY_API_KEY}` }
+        }
+      );
+      if (approvalResponse && approvalResponse.length > 0) {
+        approvalId = approvalResponse[0].id;
+        log(`Found approval_id: ${approvalId} for tool_use_id: ${tool_use_id}`);
+      }
+    } catch (e) {
+      log(`Failed to lookup approval_id: ${e.message}`);
+      // Continue without approval_id - not a fatal error
     }
-    // Check for stderr content
-    if (tool_output?.stderr && tool_output.stderr.trim()) return true;
-    return false;
-  })();
+  }
 
+  // Backward compatibility: legacy outputPreview for tool_executed event
   const outputPreview = (() => {
     if (!tool_output) return null;
     try {
@@ -130,10 +301,57 @@ const fetchJson = async (url, opts) => {
     }
   })();
 
-  // If there's an error, log a separate tool_error event for visibility
+  // =========================================================================
+  // PRD-0015: Log tool_completed or tool_failed event
+  // =========================================================================
+
+  const completionEventType = hasError ? 'tool_failed' : 'tool_completed';
+  const completionEventData = {
+    tool_name,
+    tool_input,
+    exit_code: exitCode,
+    duration_ms: durationMs,
+    stdout: truncateOutput(rawStdout, COMPLETION_EVENT_OUTPUT_MAX_LENGTH),
+    stderr: truncateOutput(rawStderr, COMPLETION_EVENT_OUTPUT_MAX_LENGTH),
+    timestamp: Date.now()
+  };
+
+  // Add optional fields
+  if (approvalId) {
+    completionEventData.approval_id = approvalId;
+  }
+  if (tool_use_id) {
+    completionEventData.tool_use_id = tool_use_id;
+  }
+
+  // Add error_message for tool_failed events
+  if (hasError) {
+    completionEventData.error_message = truncateOutput(buildErrorMessage(tool_output), 1000);
+  }
+
+  try {
+    await fetchJson(`${RELAY_API_URL}/api/timeline`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${RELAY_API_KEY}`
+      },
+      body: JSON.stringify({
+        session_id,
+        type: completionEventType,
+        data: completionEventData
+      })
+    });
+    log(`Logged ${completionEventType} event for ${tool_name} (exit_code=${exitCode}, duration=${durationMs}ms)`);
+  } catch (e) {
+    log(`Failed to log ${completionEventType}: ${e.message}`);
+  }
+
+  // Legacy: Log tool_error event for backward compatibility
+  // (Some UI components may still expect this event type)
   if (hasError) {
     try {
-      const errorMessage = tool_output?.error || tool_output?.stderr || 
+      const errorMessage = tool_output?.error || tool_output?.stderr ||
         (typeof tool_output === 'string' ? tool_output.slice(0, 500) : 'Tool execution failed');
       await fetchJson(`${RELAY_API_URL}/api/timeline`, {
         method: 'POST',
@@ -152,13 +370,13 @@ const fetchJson = async (url, opts) => {
           }
         })
       });
-      log(`Logged tool_error event for ${tool_name}`);
+      log(`Logged legacy tool_error event for ${tool_name}`);
     } catch (e) {
-      log(`Failed to log tool_error: ${e.message}`);
+      log(`Failed to log legacy tool_error: ${e.message}`);
     }
   }
 
-  // Record tool execution to timeline
+  // Legacy: Record tool_executed event for backward compatibility
   try {
     await fetchJson(`${RELAY_API_URL}/api/timeline`, {
       method: 'POST',
@@ -178,9 +396,9 @@ const fetchJson = async (url, opts) => {
         }
       })
     });
-    log(`Recorded tool execution: ${tool_name}${hasError ? ' (with error)' : ''}`);
+    log(`Recorded legacy tool_executed: ${tool_name}${hasError ? ' (with error)' : ''}`);
   } catch (e) {
-    log(`Failed to record to timeline: ${e.message}`);
+    log(`Failed to record legacy tool_executed: ${e.message}`);
   }
 
   // PostToolUse hooks don't need to output anything

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

@@ -134,12 +134,12 @@ export async function ensureSessionRegistered(session_id, cwd, config) {
 
       // 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) {
+        // 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');
 

package/lib/config/manager.js

@@ -39,7 +39,6 @@ const DEFAULT_CONFIG = {
     timeout: 3600000, // 1 hour
     muteTimeout: 300000, // 5 minutes
     heartbeat: {
-      enabled: true,
       interval: 120000, // 2 minutes between heartbeats
       timeout: 300000, // 5 minutes without heartbeat = session dead
       startDelay: 5000, // Wait 5 seconds after session start before first heartbeat