teleportation-cli 1.4.4 → 1.5.0

package/lib/daemon/teleportation-daemon.js

@@ -40,7 +40,7 @@ import { spawn, exec } from 'child_process';
 import { promisify } from 'util';
 import { homedir, tmpdir } from 'os';
 import { existsSync, appendFileSync, readFileSync, unlinkSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, resolve } 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.
 
@@ -677,6 +677,13 @@ function validateSessionId(session_id) {
   return session_id;
 }
 
+// Strict UUID v4 validation — used for externally-supplied IDs to prevent
+// accidental relay requests to non-existent sessions from misconfigured env vars.
+function isValidUUID(id) {
+  return id && typeof id === 'string' &&
+    /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id);
+}
+
 function validateApprovalId(approval_id) {
   if (!approval_id || typeof approval_id !== 'string') {
     throw new Error('approval_id must be a non-empty string');
@@ -895,6 +902,91 @@ async function handleRequest(req, res) {
       return;
     }
 
+    // Stop-hook delegate: ingest transcript asynchronously so stop.mjs can exit immediately
+    if (method === 'POST' && pathname === '/sessions/stop') {
+      const body = await parseJSONBody(req);
+      const { session_id, transcript_path, parent_session_id } = body;
+
+      try {
+        validateSessionId(session_id);
+      } catch (validationError) {
+        sendJSON(res, 400, { error: validationError.message });
+        return;
+      }
+
+      if (!transcript_path || typeof transcript_path !== 'string') {
+        sendJSON(res, 400, { error: 'transcript_path must be a non-empty string' });
+        return;
+      }
+
+      // Path traversal guard: transcript_path must resolve inside ~/.claude/projects/.
+      // The daemon has no auth on localhost — any local process can POST to it, so we
+      // must not allow arbitrary filesystem reads via a crafted transcript_path value.
+      const resolvedTranscriptPath = resolve(transcript_path);
+      const allowedTranscriptRoot = join(homedir(), '.claude', 'projects');
+      if (!resolvedTranscriptPath.startsWith(allowedTranscriptRoot + '/')) {
+        sendJSON(res, 400, { error: 'transcript_path must be within ~/.claude/projects' });
+        return;
+      }
+
+      // Validate optional parent_session_id (UUID v4 only, must differ from session_id)
+      const validParentId = parent_session_id &&
+        isValidUUID(parent_session_id) &&
+        parent_session_id !== session_id
+        ? parent_session_id
+        : null;
+
+      // Respond immediately — processing is async (AC3)
+      sendJSON(res, 200, { queued: true });
+
+      // Fire-and-forget ingestion (AC3, AC5)
+      setImmediate(async () => {
+        const sessionEntry = sessions.get(session_id);
+        const claude_session_id = sessionEntry?.claude_session_id || session_id;
+        const cwd = sessionEntry?.cwd || process.cwd();
+
+        console.log(`[daemon] /sessions/stop: ingesting transcript for ${session_id} (transcript_path=${transcript_path})`);
+
+        try {
+          await ingestTranscriptToTimeline({
+            claude_session_id,
+            parent_session_id: session_id,
+            task_id: null,
+            cwd,
+            transcript_path, // AC4: use authoritative path from stop hook
+            config: {
+              relayApiUrl: RELAY_API_URL,
+              apiKey: RELAY_API_KEY
+            },
+            maxEvents: Infinity // AC5: no cap for triggered ingestion
+          });
+        } catch (err) {
+          console.error(`[daemon] /sessions/stop: child ingestion error for ${session_id}: ${err.message}`);
+        }
+
+        // AC6: Best-effort fan-out to parent session timeline
+        if (validParentId) {
+          try {
+            await ingestTranscriptToTimeline({
+              claude_session_id,
+              parent_session_id: validParentId,
+              task_id: null,
+              cwd,
+              transcript_path,
+              config: {
+                relayApiUrl: RELAY_API_URL,
+                apiKey: RELAY_API_KEY
+              },
+              maxEvents: Infinity
+            });
+          } catch (err) {
+            console.warn(`[daemon] ⚠️ Parent fan-out failed for session ${validParentId}: ${err.message} — missed events are NOT retried (best-effort)`);
+          }
+        }
+      });
+
+      return;
+    }
 
     // Queue approval for daemon handling
     if (method === 'POST' && pathname === '/approvals/handoff') {

package/lib/daemon/transcript-ingestion.js

@@ -665,7 +665,7 @@ async function updateLastIngestedIndex(task_id, session_id, lastIndex, config) {
  * @returns {Promise<Object>} Result { events_pushed: number }
  */
 export async function ingestTranscriptToTimeline(options) {
-  const { claude_session_id, parent_session_id, task_id, cwd, config, onNormalizedEvents, realTimeMode = false, maxEvents } = options;
+  const { claude_session_id, parent_session_id, task_id, cwd, config, onNormalizedEvents, realTimeMode = false, maxEvents, transcript_path } = options;
   const { relayApiUrl, apiKey } = config;
 
   // Determine max events based on mode
@@ -689,8 +689,25 @@ export async function ingestTranscriptToTimeline(options) {
   console.log(`[transcript] ===== INGESTION START =====`);
   console.log(`[transcript] claude_session: ${claude_session_id}, parent: ${parent_session_id}, task: ${task_id}`);
 
-  // 1. Read transcript with cwd for project slug derivation
-  const transcript = await readTranscript(claude_session_id, cwd);
+  // 1. Read transcript — use explicit path when provided (AC4), otherwise derive via cwd/project-slug.
+  // When transcript_path is supplied by the stop-hook delegate, the daemon skips path derivation
+  // entirely. The daemon's cursor (in /tmp/teleportation-cursors/) becomes the sole writer;
+  // any stale stop-hook cursors (~/.teleportation/.stop_hook_cursor_v2/) are silently superseded.
+  // ON CONFLICT DO NOTHING on the relay prevents duplicates on first-run reprocessing.
+  let transcript;
+  if (transcript_path) {
+    try {
+      const content = await readFile(transcript_path, 'utf8');
+      const lines = content.trim().split('\n').filter(Boolean);
+      transcript = lines.map(line => JSON.parse(line));
+      console.log(`[transcript] Loaded ${transcript.length} messages from explicit path: ${transcript_path}`);
+    } catch (e) {
+      console.error(`[transcript] Failed to read transcript at ${transcript_path}: ${e.message}`);
+      transcript = [];
+    }
+  } else {
+    transcript = await readTranscript(claude_session_id, cwd);
+  }
   log(`Read transcript: ${transcript.length} messages`);
   if (transcript.length === 0) {
     log(`No transcript found or empty - returning`);
@@ -717,6 +734,12 @@ export async function ingestTranscriptToTimeline(options) {
     // For regular sessions: Use local cursor as primary deduplication,
     // with timeline query as validation
     const cursorMessageCount = await readCursor(parent_session_id);
+    if (cursorMessageCount === 0 && transcript_path) {
+      // AC7: First daemon-triggered ingestion for this session. The stop-hook cursor
+      // (~/.teleportation/.stop_hook_cursor_v2/) is now stale. The daemon reprocesses
+      // from the start; server-side ON CONFLICT DO NOTHING prevents duplicates.
+      console.log(`[stop-delegate] First daemon ingestion for session ${parent_session_id} — reprocessing from start (dedup handles any duplicates)`);
+    }
     console.log(`[transcript] Local cursor: ${cursorMessageCount} messages previously processed`);
     console.log(`[transcript] Querying timeline for session ${parent_session_id} to find recent events...`);
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teleportation-cli",
-  "version": "1.4.4",
+  "version": "1.5.0",
   "description": "Remote approval system for Claude Code - approve AI coding changes from your phone",
   "type": "module",
   "main": "teleportation-cli.cjs",
@@ -55,6 +55,11 @@
     "!lib/**/*.log",
     ".claude/hooks/*.mjs",
     "!.claude/hooks/*.test.mjs",
+    ".gemini/hooks/*.mjs",
+    "!.gemini/hooks/*.test.mjs",
+    "!.gemini/hooks/test-hooks.mjs",
+    ".gemini/hooks/shared/*.mjs",
+    "teleportation.uhr.json",
     "scripts/sync-transcripts.sh",
     "teleportation-cli.cjs",
     "README.md",

package/teleportation-cli.cjs

@@ -335,6 +335,21 @@ async function commandOn() {
         if (uhrResult.warnings.length > 0) {
           uhrResult.warnings.forEach(w => console.log(c.yellow(`  ⚠️  ${w}`)));
         }
+
+        // UHR handles Claude Code + Gemini CLI via settings files, but Cursor IDE
+        // hooks require a separate write to ~/.cursor/hooks.json via the legacy installer
+        try {
+          const installerPath = path.join(TELEPORTATION_DIR, 'lib', 'install', 'installer.js');
+          const { checkCursorIde, installCursorHooks } = await import('file://' + installerPath);
+          if (checkCursorIde().valid) {
+            const sourceHooksDir = path.join(TELEPORTATION_DIR, '.claude', 'hooks');
+            await installCursorHooks(sourceHooksDir);
+            console.log(c.green('  ✅ Cursor IDE hooks installed'));
+            console.log(c.dim('     Config: ~/.cursor/hooks.json'));
+          }
+        } catch (e) {
+          // Cursor not installed or hooks install failed — non-fatal
+        }
       } else {
         if (uhrResult.success && !fs.existsSync(globalSettings)) {
           console.log(c.yellow('  ⚠️  UHR reported success but did not write ~/.claude/settings.json'));
@@ -3467,7 +3482,8 @@ async function commandInstallHooks() {
           }
           installed = true;
 
-          // UHR only handles Claude Code — also install Cursor hooks via legacy installer
+          // UHR handles Claude Code + Gemini CLI via settings files, but Cursor IDE
+          // hooks require a separate write to ~/.cursor/hooks.json via the legacy installer
           try {
             const installerPath = path.join(TELEPORTATION_DIR, 'lib', 'install', 'installer.js');
             const { checkCursorIde, installCursorHooks } = await import('file://' + installerPath);
@@ -3506,6 +3522,11 @@ async function commandInstallHooks() {
         console.log(c.dim('     Directory: ~/.gemini/hooks/'));
       }
 
+      if (result.cursorHooksInstalled > 0) {
+        console.log(c.green(`  ✅ Cursor IDE hooks installed`));
+        console.log(c.dim('     Config: ~/.cursor/hooks.json'));
+      }
+
       if (result.libFilesInstalled > 0) {
         console.log(c.green(`  ✅ ${result.libFilesInstalled} shared library files installed`));
       }

package/teleportation.uhr.json

@@ -0,0 +1,76 @@
+{
+  "$schema": "https://uhr.dev/schema/manifest.v1.json",
+  "name": "teleportation",
+  "version": "1.2.0",
+  "description": "Remote approval system for Claude Code — approve AI coding changes from any device",
+  "homepage": "https://github.com/dundas/teleportation-private",
+  "hooks": [
+    {
+      "id": "pre-tool-use",
+      "on": "beforeToolExecution",
+      "command": "bun __HOOKS_DIR__/pre_tool_use.mjs",
+      "tools": ["*"],
+      "blocking": true,
+      "timeout": 300000,
+      "platforms": ["claude-code", "gemini-cli", "cursor"]
+    },
+    {
+      "id": "session-start",
+      "on": "sessionStart",
+      "command": "bun __HOOKS_DIR__/session_start.mjs",
+      "platforms": ["claude-code", "gemini-cli", "cursor"]
+    },
+    {
+      "id": "session-end",
+      "on": "sessionEnd",
+      "command": "bun __HOOKS_DIR__/session_end.mjs",
+      "platforms": ["claude-code", "gemini-cli", "cursor"]
+    },
+    {
+      "id": "stop",
+      "on": "stop",
+      "command": "bun __HOOKS_DIR__/stop.mjs",
+      "platforms": ["claude-code", "cursor"]
+    },
+    {
+      "id": "notification",
+      "on": "notification",
+      "command": "bun __HOOKS_DIR__/notification.mjs",
+      "platforms": ["claude-code"]
+    },
+    {
+      "id": "user-prompt-submit",
+      "on": "beforePromptSubmit",
+      "command": "bun __HOOKS_DIR__/user_prompt_submit.mjs",
+      "platforms": ["claude-code", "cursor"]
+    },
+    {
+      "id": "permission-request",
+      "on": "permissionRequest",
+      "command": "bun __HOOKS_DIR__/permission_request.mjs",
+      "blocking": true,
+      "timeout": 300000,
+      "platforms": ["claude-code"]
+    },
+    {
+      "id": "post-tool-use",
+      "on": "afterToolExecution",
+      "command": "bun __HOOKS_DIR__/post_tool_use.mjs",
+      "tools": ["*"],
+      "platforms": ["claude-code", "cursor"]
+    }
+  ],
+  "permissions": {
+    "allow": ["read", "grep", "fetch"],
+    "deny": []
+  },
+  "ordering": {
+    "pre-tool-use": {
+      "runBefore": ["*"]
+    }
+  },
+  "meta": {
+    "minUhrVersion": "0.1.0",
+    "license": "MIT"
+  }
+}