teleportation-cli 1.2.2 → 1.4.0

package/lib/daemon/transcript-ingestion.js

@@ -7,7 +7,7 @@
  * @module lib/daemon/transcript-ingestion
  */
 
-import { readFile, readdir } from 'fs/promises';
+import { readFile, readdir, writeFile, mkdir } from 'fs/promises';
 import { homedir, tmpdir } from 'os';
 import { join } from 'path';
 
@@ -132,6 +132,49 @@ const RETRY_BASE_DELAY_MS = 100;
  */
 const DEBUG = process.env.TELEPORTATION_DEBUG === 'true';
 
+/**
+ * Local cursor directory for tracking last-processed transcript index.
+ * Persists across daemon restarts so we don't reprocess the entire transcript.
+ */
+const CURSOR_DIR = join(tmpdir(), 'teleportation-cursors');
+
+/**
+ * Read the local ingestion cursor for a session.
+ * Returns the last successfully processed transcript message count.
+ * @param {string} sessionId - Session ID
+ * @returns {Promise<number>} Last processed message count (0 if no cursor)
+ */
+async function readCursor(sessionId) {
+  try {
+    const cursorPath = join(CURSOR_DIR, `${sessionId}.json`);
+    const data = JSON.parse(await readFile(cursorPath, 'utf8'));
+    return data.lastMessageCount || 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Write the local ingestion cursor after successful push.
+ * @param {string} sessionId - Session ID
+ * @param {number} messageCount - Total transcript messages processed
+ * @param {number} eventsPushed - Events successfully pushed this cycle
+ */
+async function writeCursor(sessionId, messageCount, eventsPushed) {
+  try {
+    await mkdir(CURSOR_DIR, { recursive: true });
+    const cursorPath = join(CURSOR_DIR, `${sessionId}.json`);
+    await writeFile(cursorPath, JSON.stringify({
+      lastMessageCount: messageCount,
+      lastEventsPushed: eventsPushed,
+      updatedAt: new Date().toISOString()
+    }));
+  } catch (e) {
+    // Non-fatal — next cycle will just reprocess some events
+    console.warn(`[transcript] Failed to write cursor for ${sessionId}: ${e.message}`);
+  }
+}
+
 /**
  * Sleep helper for retry backoff
  * @param {number} ms - Milliseconds to sleep
@@ -328,7 +371,31 @@ function parseTimestamp(entry) {
     return Date.now();
   }
 
-  const parsed = new Date(entry.timestamp).getTime();
+  const ts = entry.timestamp;
+
+  // Handle numeric string timestamps (epoch ms as string, e.g. "1771211826406")
+  // new Date("1771211826406") returns Invalid Date, so detect and convert first
+  if (typeof ts === 'string' && /^\d+$/.test(ts)) {
+    const numeric = Number(ts);
+    const now = Date.now();
+    if (numeric > now - TIMESTAMP_MAX_AGE_MS && numeric < now + TIMESTAMP_MAX_AGE_MS) {
+      return numeric;
+    }
+    console.warn(`[transcript] Numeric string timestamp out of range: ${ts}, using current time`);
+    return Date.now();
+  }
+
+  // Handle numeric timestamps directly
+  if (typeof ts === 'number') {
+    const now = Date.now();
+    if (ts > now - TIMESTAMP_MAX_AGE_MS && ts < now + TIMESTAMP_MAX_AGE_MS) {
+      return ts;
+    }
+    console.warn(`[transcript] Numeric timestamp out of range: ${ts}, using current time`);
+    return Date.now();
+  }
+
+  const parsed = new Date(ts).getTime();
 
   // Validate timestamp is reasonable (not NaN, not in distant past/future)
   if (isNaN(parsed)) {
@@ -396,7 +463,7 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
       if (trimmedContent) {
         events.push({
           type: 'assistant_response',
-          source: entry.type === 'autonomous_task' ? 'autonomous_task' : 'cli_interactive',
+          source: 'cli_interactive',
           timestamp,
           meta: {
             message: trimmedContent.slice(0, MAX_ASSISTANT_RESPONSE_LENGTH),
@@ -418,7 +485,7 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
       for (const toolUse of toolUses) {
         events.push({
           type: 'tool_use',
-          source: entry.type === 'autonomous_task' ? 'autonomous_task' : 'cli_interactive',
+          source: 'cli_interactive',
           timestamp,
           meta: {
             tool_name: toolUse.name,
@@ -448,7 +515,7 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
 
         events.push({
           type: isError ? 'tool_failed' : 'tool_completed',
-          source: entry.type === 'autonomous_task' ? 'autonomous_task' : 'cli_interactive',
+          source: 'cli_interactive',
           timestamp,
           meta: {
             tool_use_id: toolResult.tool_use_id,
@@ -573,14 +640,22 @@ export async function ingestTranscriptToTimeline(options) {
   let fromIndex = 0;
 
   if (task_id) {
-    // For tasks: Use task's last ingested index
+    // For tasks: Use task's last ingested index, fall back to local cursor if fetchTask fails
     const task = await fetchTask(task_id, parent_session_id, config);
-    fromIndex = task?.last_transcript_index || 0;
-    console.log(`[transcript] Using task's last ingested index: ${fromIndex}`);
+    if (task?.last_transcript_index != null) {
+      fromIndex = task.last_transcript_index;
+      console.log(`[transcript] Using task's last ingested index: ${fromIndex}`);
+    } else {
+      // fetchTask returned null (network error) or task has no index — use local cursor
+      // Use claude_session_id as cursor key for tasks (each task has unique child session)
+      fromIndex = await readCursor(claude_session_id);
+      console.log(`[transcript] Task fetch failed or no index — using local cursor: ${fromIndex}`);
+    }
   } else {
-    // For regular sessions: Query timeline to find recent events for deduplication
-    // Queries last 50 events (not just 1) to catch concurrent hook/daemon ingestion
-    // This prevents duplicates when hook and daemon run simultaneously
+    // For regular sessions: Use local cursor as primary deduplication,
+    // with timeline query as validation
+    const cursorMessageCount = await readCursor(parent_session_id);
+    console.log(`[transcript] Local cursor: ${cursorMessageCount} messages previously processed`);
     console.log(`[transcript] Querying timeline for session ${parent_session_id} to find recent events...`);
     try {
       const timelineResponse = await fetch(
@@ -599,46 +674,69 @@ export async function ingestTranscriptToTimeline(options) {
         console.log(`[transcript] Timeline returned ${timelineEvents.length} events`);
 
         if (timelineEvents.length > 0 && timelineEvents[0].timestamp) {
-          const lastTimestamp = timelineEvents[0].timestamp;
-          console.log(`[transcript] Last timeline event timestamp: ${lastTimestamp} (${new Date(lastTimestamp).toISOString()})`);
-
-          // Sample first and last transcript timestamps
-          if (transcript.length > 0) {
-            const firstMsg = transcript[0];
-            const lastMsg = transcript[transcript.length - 1];
-            console.log(`[transcript] First transcript msg: ${firstMsg.timestamp}`);
-            console.log(`[transcript] Last transcript msg: ${lastMsg.timestamp}`);
-          }
-
-          // Find the index of the first message after this timestamp
-          fromIndex = transcript.findIndex(msg => {
-            const msgTimestamp = new Date(msg.timestamp || 0).getTime();
-            return msgTimestamp > lastTimestamp;
-          });
-
-          // If not found, start from end of transcript (all messages are older)
-          if (fromIndex === -1) {
-            log(`All messages older than last timeline event (${new Date(lastTimestamp).toISOString()}) - no new events`);
-            console.log(`[transcript] All ${transcript.length} messages are older than last timeline event - no new events to ingest`);
-            fromIndex = transcript.length;
+          // Timeline API returns timestamps as string epoch ms (e.g. "1771211826406")
+          // Must parse as number — new Date("1771211826406") returns Invalid Date
+          const rawTimestamp = timelineEvents[0].timestamp;
+          const lastTimestamp = typeof rawTimestamp === 'string' && /^\d+$/.test(rawTimestamp)
+            ? Number(rawTimestamp)
+            : typeof rawTimestamp === 'number'
+              ? rawTimestamp
+              : new Date(rawTimestamp).getTime();
+
+          if (isNaN(lastTimestamp)) {
+            console.log(`[transcript] Could not parse timeline timestamp: ${rawTimestamp} - using local cursor`);
+            fromIndex = cursorMessageCount;
           } else {
-            log(`Found ${transcript.length - fromIndex} new messages starting from index ${fromIndex}/${transcript.length}`);
-            console.log(`[transcript] Found ${transcript.length - fromIndex} new messages starting from index ${fromIndex}/${transcript.length}`);
+            console.log(`[transcript] Last timeline event timestamp: ${lastTimestamp} (${new Date(lastTimestamp).toISOString()})`);
+
+            // Find the index of the first message after this timestamp
+            fromIndex = transcript.findIndex(msg => {
+              const msgTs = msg.timestamp;
+              // Transcript timestamps are ISO strings like "2026-02-15T16:10:42.035Z"
+              // or may be missing (undefined)
+              const msgTimestamp = !msgTs ? 0
+                : typeof msgTs === 'number' ? msgTs
+                : typeof msgTs === 'string' && /^\d+$/.test(msgTs) ? Number(msgTs)
+                : new Date(msgTs).getTime() || 0;
+              return msgTimestamp > lastTimestamp;
+            });
+
+            // If not found, start from end of transcript (all messages are older)
+            if (fromIndex === -1) {
+              log(`All messages older than last timeline event (${new Date(lastTimestamp).toISOString()}) - no new events`);
+              console.log(`[transcript] All ${transcript.length} messages are older than last timeline event - no new events to ingest`);
+              fromIndex = transcript.length;
+            } else {
+              log(`Found ${transcript.length - fromIndex} new messages starting from index ${fromIndex}/${transcript.length}`);
+              console.log(`[transcript] Found ${transcript.length - fromIndex} new messages starting from index ${fromIndex}/${transcript.length}`);
+            }
           }
         } else {
-          console.log(`[transcript] No timeline events found - will process all transcript messages`);
-          fromIndex = 0;
+          // No timeline events — use local cursor to avoid reprocessing
+          fromIndex = cursorMessageCount;
+          if (cursorMessageCount > 0) {
+            console.log(`[transcript] No timeline events found - using local cursor (${cursorMessageCount})`);
+          } else {
+            console.log(`[transcript] No timeline events and no cursor - processing all transcript messages`);
+          }
         }
       } else {
-        console.log(`[transcript] Timeline query failed with status ${timelineResponse.status} - processing all messages`);
-        fromIndex = 0;
+        fromIndex = cursorMessageCount;
+        console.log(`[transcript] Timeline query failed (${timelineResponse.status}) - using local cursor (${cursorMessageCount})`);
       }
     } catch (error) {
-      console.log(`[transcript] Failed to query timeline: ${error.message}, processing all messages`);
-      fromIndex = 0;
+      fromIndex = cursorMessageCount;
+      console.log(`[transcript] Failed to query timeline: ${error.message} - using local cursor (${cursorMessageCount})`);
     }
   }
 
+  // Clamp fromIndex to transcript length to prevent stale cursors from
+  // skipping past the end of a shorter transcript (e.g., cursor=500, transcript has 100 messages)
+  if (fromIndex > transcript.length) {
+    console.warn(`[transcript] Clamping fromIndex from ${fromIndex} to transcript length ${transcript.length} — cursor may be stale or transcript truncated`);
+    fromIndex = transcript.length;
+  }
+
   // 3. Extract only NEW events from determined index
   const allEvents = extractTimelineEvents(transcript, fromIndex);
 
@@ -677,9 +775,16 @@ export async function ingestTranscriptToTimeline(options) {
   log(`===== INGESTION COMPLETE: ${successCount}/${events.length} events pushed (${failCount} failed) =====`);
   console.log(`[transcript] Pushed ${successCount}/${events.length} events (${failCount} failed)`);
 
-  // 6. Update last ingested index to prevent duplicates on next call (tasks only)
-  if (task_id && successCount > 0) {
-    await updateLastIngestedIndex(task_id, parent_session_id, transcript.length, config);
+  // 6. Update cursors to prevent duplicates on next call
+  if (successCount > 0) {
+    // Local cursor — use claude_session_id for tasks (unique per child session),
+    // parent_session_id for regular sessions (maps to transcript file)
+    const cursorKey = task_id ? claude_session_id : parent_session_id;
+    await writeCursor(cursorKey, transcript.length, successCount);
+    // Remote cursor (tasks only) — persists in relay
+    if (task_id) {
+      await updateLastIngestedIndex(task_id, parent_session_id, transcript.length, config);
+    }
   }
 
   return { events_pushed: successCount, events_failed: failCount };
@@ -694,3 +799,6 @@ export async function getTranscriptLength(claude_session_id) {
   const transcript = await readTranscript(claude_session_id);
   return transcript.length;
 }
+
+// Export internals for unit testing
+export { parseTimestamp, extractTimelineEvents, readCursor, writeCursor };

package/lib/install/installer.js

@@ -287,11 +287,11 @@ export async function installGeminiHooks(sourceGeminiHooksDir) {
   settings.hooks = settings.hooks || {};
   
   const hooksConfig = {
-    BeforeTool: [{ command: `node ${join(destHooksDir, 'before_tool.mjs')}`, timeout: 65000 }],
-    AfterTool: [{ command: `node ${join(destHooksDir, 'after_tool.mjs')}`, timeout: 10000 }],
-    SessionStart: [{ command: `node ${join(destHooksDir, 'session_start.mjs')}`, timeout: 15000 }],
-    AfterAgent: [{ command: `node ${join(destHooksDir, 'after_agent.mjs')}`, timeout: 15000 }],
-    SessionEnd: [{ command: `node ${join(destHooksDir, 'session_end.mjs')}`, timeout: 10000 }]
+    BeforeTool: [{ command: `bun ${join(destHooksDir, 'before_tool.mjs')}`, timeout: 65000 }],
+    AfterTool: [{ command: `bun ${join(destHooksDir, 'after_tool.mjs')}`, timeout: 10000 }],
+    SessionStart: [{ command: `bun ${join(destHooksDir, 'session_start.mjs')}`, timeout: 15000 }],
+    AfterAgent: [{ command: `bun ${join(destHooksDir, 'after_agent.mjs')}`, timeout: 15000 }],
+    SessionEnd: [{ command: `bun ${join(destHooksDir, 'session_end.mjs')}`, timeout: 10000 }]
   };
 
   // Standardize: Ensure BeforeAgent is also set if needed (parity with Claude's UserPromptSubmit)
@@ -316,7 +316,10 @@ export async function installDaemon() {
 
   const daemonFiles = [
     'teleportation-daemon.js',
-    'lifecycle.js'
+    'lifecycle.js',
+    'task-executor-v2.js',
+    'transcript-ingestion.js',
+    'timeline-analyzer.js',
   ];
 
   const installed = [];
@@ -352,7 +355,7 @@ export async function installDaemon() {
 
 /**
  * Copy daemon dependency modules to ~/.teleportation/
- * This includes machine-coders and router
+ * This includes machine-coders, router, utils, and auth
  */
 export async function installDaemonModules() {
   const sourceLibDir = join(getTeleportationDir(), 'lib');
@@ -377,6 +380,19 @@ export async function installDaemonModules() {
         'models.js',
         'mech-llms-client.js'
       ]
+    },
+    {
+      name: 'utils',
+      files: [
+        'logger.js',
+        'log-sanitizer.js'
+      ]
+    },
+    {
+      name: 'auth',
+      files: [
+        'credentials.js'
+      ]
     }
   ];
 
@@ -513,42 +529,56 @@ export async function createSettings() {
         matcher: ".*",
         hooks: [{
           type: "command",
-          command: `node ${join(projectHooksDir, 'pre_tool_use.mjs')}`
+          command: `bun ${join(projectHooksDir, 'pre_tool_use.mjs')}`
         }]
       }],
       Stop: [{
         matcher: ".*",
         hooks: [{
           type: "command",
-          command: `node ${join(projectHooksDir, 'stop.mjs')}`
+          command: `bun ${join(projectHooksDir, 'stop.mjs')}`
         }]
       }],
       SessionStart: [{
         matcher: ".*",
         hooks: [{
           type: "command",
-          command: `node ${join(projectHooksDir, 'session_start.mjs')}`
+          command: `bun ${join(projectHooksDir, 'session_start.mjs')}`
         }]
       }],
       SessionEnd: [{
         matcher: ".*",
         hooks: [{
           type: "command",
-          command: `node ${join(projectHooksDir, 'session_end.mjs')}`
+          command: `bun ${join(projectHooksDir, 'session_end.mjs')}`
         }]
       }],
       Notification: [{
         matcher: ".*",
         hooks: [{
           type: "command",
-          command: `node ${join(projectHooksDir, 'notification.mjs')}`
+          command: `bun ${join(projectHooksDir, 'notification.mjs')}`
         }]
       }],
       UserPromptSubmit: [{
         matcher: ".*",
         hooks: [{
           type: "command",
-          command: `node ${join(projectHooksDir, 'user_prompt_submit.mjs')}`
+          command: `bun ${join(projectHooksDir, 'user_prompt_submit.mjs')}`
+        }]
+      }],
+      PermissionRequest: [{
+        matcher: ".*",
+        hooks: [{
+          type: "command",
+          command: `bun ${join(projectHooksDir, 'permission_request.mjs')}`
+        }]
+      }],
+      PostToolUse: [{
+        matcher: ".*",
+        hooks: [{
+          type: "command",
+          command: `bun ${join(projectHooksDir, 'post_tool_use.mjs')}`
         }]
       }]
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teleportation-cli",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "description": "Remote approval system for Claude Code - approve AI coding changes from your phone",
   "type": "module",
   "main": "teleportation-cli.cjs",

package/teleportation-cli.cjs

@@ -1295,7 +1295,63 @@ async function commandTest() {
     console.log(c.red('  ❌ FAIL - Hook execution error\n'));
     failed++;
   }
-  
+
+  // Test 6: Approval Round-Trip
+  console.log(c.yellow('Test 6: Approval Round-Trip'));
+  if (creds.RELAY_API_KEY && relayUrl) {
+    try {
+      // Create a test approval
+      const createRes = await fetch(`${relayUrl}/api/approvals`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${creds.RELAY_API_KEY}`
+        },
+        body: JSON.stringify({
+          session_id: 'test-smoke-' + Date.now(),
+          tool_name: 'Read',
+          tool_input: { file_path: '/tmp/smoke-test.txt' }
+        }),
+        signal: AbortSignal.timeout(10000)
+      });
+
+      if (!createRes.ok) throw new Error(`Create failed: ${createRes.status}`);
+      const { id: approvalId } = await createRes.json();
+
+      // Approve it
+      const decideRes = await fetch(`${relayUrl}/api/approvals/${approvalId}/decision`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${creds.RELAY_API_KEY}`
+        },
+        body: JSON.stringify({ decision: 'allow', reason: 'smoke test' }),
+        signal: AbortSignal.timeout(10000)
+      });
+
+      if (!decideRes.ok) throw new Error(`Decide failed: ${decideRes.status}`);
+
+      // Verify
+      const checkRes = await fetch(`${relayUrl}/api/approvals/${approvalId}`, {
+        headers: { 'Authorization': `Bearer ${creds.RELAY_API_KEY}` },
+        signal: AbortSignal.timeout(10000)
+      });
+      const approval = await checkRes.json();
+
+      if (approval.status === 'allowed') {
+        console.log(c.green('  ✅ PASS - Approval round-trip works\n'));
+        passed++;
+      } else {
+        throw new Error(`Expected status=allowed, got ${approval.status}`);
+      }
+    } catch (e) {
+      console.log(c.red(`  ❌ FAIL - Approval round-trip: ${e.message}\n`));
+      failed++;
+    }
+  } else {
+    console.log(c.yellow('  ⏭️  SKIP - No credentials for round-trip test\n'));
+  }
+
   // Summary
   console.log(c.purple('Test Summary:'));
   console.log(`  Passed: ${c.green(passed)}`);