teleportation-cli 1.3.0 → 1.4.0

package/lib/daemon/timeline-analyzer.js

@@ -16,7 +16,7 @@
 export async function fetchTimeline(session_id, config) {
   const { relayApiUrl, apiKey } = config;
 
-  const response = await fetch(`${relayApiUrl}/api/timeline/${session_id}`, {
+  const response = await fetch(`${relayApiUrl}/api/sessions/${session_id}/timeline`, {
     headers: { 'Authorization': `Bearer ${apiKey}` }
   });
 
@@ -36,7 +36,7 @@ export async function fetchTimeline(session_id, config) {
  */
 export function analyzeTaskState(events, task_id) {
   // Filter events for this specific task
-  const taskEvents = events.filter(e => e.meta?.task_id === task_id);
+  const taskEvents = events.filter(e => e.data?.task_id === task_id);
 
   if (taskEvents.length === 0) {
     return {
@@ -53,16 +53,17 @@ export function analyzeTaskState(events, task_id) {
 
   const lastEvent = taskEvents[taskEvents.length - 1];
 
-  // Count turns (each assistant_response indicates a completed turn)
+  // Count turns (each assistant_response with matching task_id indicates a completed turn)
+  // Note: relay stores source inside data object, not at event top level
   const turn_count = taskEvents.filter(e =>
-    e.type === 'assistant_response' && e.source === 'autonomous_task'
+    e.type === 'assistant_response'
   ).length;
 
   // Find the latest claude_session_id from task execution
   let claude_session_id = null;
   for (let i = taskEvents.length - 1; i >= 0; i--) {
-    if (taskEvents[i].meta?.claude_session_id) {
-      claude_session_id = taskEvents[i].meta.claude_session_id;
+    if (taskEvents[i].data?.claude_session_id) {
+      claude_session_id = taskEvents[i].data.claude_session_id;
       break;
     }
   }
@@ -72,7 +73,7 @@ export function analyzeTaskState(events, task_id) {
     e.type === 'approval_requested' &&
     !taskEvents.some(later =>
       later.type === 'approval_decided' &&
-      later.meta?.approval_id === e.meta?.approval_id
+      later.data?.approval_id === e.data?.approval_id
     )
   );
 
@@ -93,7 +94,7 @@ export function analyzeTaskState(events, task_id) {
       state: 'paused',
       turn_count,
       ready_for_execution: false,
-      reason: lastEvent.meta?.reason || 'Task paused',
+      reason: lastEvent.data?.reason || 'Task paused',
       claude_session_id,
       waiting_for_user_message: true,
     };
@@ -105,7 +106,7 @@ export function analyzeTaskState(events, task_id) {
       state: 'stopped',
       turn_count,
       ready_for_execution: false,
-      reason: lastEvent.meta?.reason || 'Task stopped',
+      reason: lastEvent.data?.reason || 'Task stopped',
       claude_session_id,
     };
   }
@@ -134,7 +135,7 @@ export function analyzeTaskState(events, task_id) {
   // If last event is assistant_response, ready for next turn
   // Use stop_reason to determine if Claude is done (works like CLI)
   if (lastEvent.type === 'assistant_response') {
-    const stopReason = lastEvent.meta?.stop_reason;
+    const stopReason = lastEvent.data?.stop_reason;
 
     // Claude uses "end_turn" when it's done with the current turn and waiting for input
     // This is the natural stopping point, just like in the CLI
@@ -183,9 +184,14 @@ export function getNextPrompt(state, task) {
     return task.task;
   }
 
-  // If paused and resumed with user message, use that message
-  if (task.pending_question) {
-    return task.pending_question;
+  // If resumed with a user answer/message, use that as the prompt
+  if (task.pending_answer) {
+    return task.pending_answer;
+  }
+
+  // If redirected with new instructions, use those
+  if (task.pending_redirect) {
+    return task.pending_redirect;
   }
 
   // Default continuation prompt

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/package.json

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