teleportation-cli 1.4.3 → 1.4.5

package/lib/daemon/teleportation-daemon.js

@@ -294,6 +294,13 @@ const sessionPidCache = new Map();   // sessionId -> number (claude_pid)
 const lastPidCheck = new Map();      // sessionId -> number (timestamp of last check)
 const PID_CHECK_INTERVAL_MS = parseInt(process.env.DAEMON_PID_CHECK_INTERVAL_MS || '30000', 10); // 30s default
 
+// Sessions discovered from the session log on daemon restart get a grace period
+// to receive a fresh hook registration (with a PID marker file). If no PID marker
+// appears within LOG_RECOVERY_GRACE_MS, the session is treated as stale and removed.
+// This prevents ghost sessions from other projects being heartbeated indefinitely.
+const logRecoveredSessions = new Set();  // sessionIds recovered from session-events.log
+const LOG_RECOVERY_GRACE_MS = parseInt(process.env.DAEMON_LOG_RECOVERY_GRACE_MS || '300000', 10); // 5 min default
+
 // Transcript ingestion throttling: Prevents concurrent ingestion runs per session
 // Map<session_id, Promise> tracks in-progress ingestion promises
 // If ingestion takes >5 seconds, prevents stacking multiple concurrent calls
@@ -844,6 +851,8 @@ async function handleRequest(req, res) {
       // Clear stale PID cache so the new session's PID is read fresh from marker file
       sessionPidCache.delete(session_id);
       lastPidCheck.delete(session_id);
+      // Fresh registration clears the log-recovery flag — this session now has a live hook
+      logRecoveredSessions.delete(session_id);
 
       const sessionEntry = {
         session_id,
@@ -1653,6 +1662,7 @@ async function cleanupDeadSession(session_id, pid) {
   sessionPidCache.delete(session_id);
   lastPidCheck.delete(session_id);
   ingestionInProgress.delete(session_id);
+  logRecoveredSessions.delete(session_id);
   stoppedSessions.add(session_id); // Prevent re-activation from stale registration attempts
 
   // Delete marker file
@@ -1721,7 +1731,21 @@ async function pollRelayAPI() {
           await cleanupDeadSession(session_id, pid);
           continue;
         }
-        // PID is alive (or no PID file exists - backward compat: treat as alive)
+        if (pid === null && logRecoveredSessions.has(session_id)) {
+          // Session was recovered from the log but has no PID marker file yet.
+          // Give it a grace period to receive a fresh hook registration.
+          // After that, treat it as stale and clean it up to prevent ghost sessions
+          // from other projects being heartbeated indefinitely.
+          const sessionData = sessions.get(session_id);
+          const age = pidCheckNow - (sessionData?.registered_at || pidCheckNow);
+          if (age > LOG_RECOVERY_GRACE_MS) {
+            logInfo(`[daemon] Log-recovered session ${session_id.slice(0, 8)}... has no PID marker after ${Math.round(age / 60000)}min — removing as stale`);
+            await cleanupDeadSession(session_id, null);
+            continue;
+          }
+          // Still within grace period — treat as alive, but don't reset the log-recovery flag
+        }
+        // PID is alive (or no PID file, still within grace period)
         sessionActivity.set(session_id, pidCheckNow);
       }
       // Between PID checks, do NOT refresh sessionActivity - let the cleanup
@@ -3047,6 +3071,10 @@ async function discoverSessionsFromLog() {
     for (const session of activeSessions) {
       sessions.set(session.session_id, session);
       sessionActivity.set(session.session_id, session.last_heartbeat);
+      // Mark as log-recovered so PID check can apply a grace period.
+      // A fresh session_start.mjs hook registration (which creates a PID marker file)
+      // will clear this flag — the session is then treated as fully live.
+      logRecoveredSessions.add(session.session_id);
     }
 
     if (activeSessions.length > 0) {

package/lib/daemon/transcript-ingestion.js

@@ -12,7 +12,6 @@ import { homedir, tmpdir } from 'os';
 import { join } from 'path';
 import { createHash } from 'node:crypto';
 import { sanitizeEventData } from '../utils/log-sanitizer.js';
-import { normalizeTranscriptEvents, normalizeTranscriptEntry } from '../intelligence/schema.js';
 
 // ============================================================================
 // Configuration Constants
@@ -591,13 +590,10 @@ function extractTimelineEvents(transcript, fromIndex = 0, sessionId = '') {
  * @param {Object} context - Normalization context
  * @returns {Array} Normalized intelligence events
  */
-function normalizeTimelineEventsForIntelligence(events, context = {}) {
-  try {
-    return normalizeTranscriptEvents(events, context);
-  } catch (error) {
-    console.warn(`[transcript] Intelligence normalization failed: ${error.message}`);
-    return [];
-  }
+function normalizeTimelineEventsForIntelligence(_events, _context = {}) {
+  // TODO(transcript-intelligence): re-enable when ../intelligence/schema.js lands.
+  // Callers handle empty arrays safely (no-op pipeline).
+  return [];
 }
 
 /**
@@ -887,16 +883,9 @@ export async function getTranscriptLength(claude_session_id) {
  * Extract normalized transcript entries for the intelligence pipeline.
  * Operates on raw transcript messages (not timeline events).
  */
-function extractNormalizedTranscriptEntries(transcript, fromIndex = 0, sessionId = '', harness = 'claude-code') {
-  const normalized = [];
-  for (let i = fromIndex; i < transcript.length; i++) {
-    normalized.push(normalizeTranscriptEntry(transcript[i], {
-      sessionId,
-      messageIndex: i,
-      harness,
-    }));
-  }
-  return normalized;
+function extractNormalizedTranscriptEntries(_transcript, _fromIndex = 0, _sessionId = '', _harness = 'claude-code') {
+  // TODO(transcript-intelligence): re-enable when ../intelligence/schema.js lands.
+  return [];
 }
 
 function toSessionFilename(sessionId) {

package/lib/install/uhr-installer.js

@@ -100,28 +100,36 @@ export async function installViaUhr(manifestPath, hooksDir, options = {}) {
     return { success: false, reason: 'UHR CLI not found (checked PATH and node_modules/.bin/uhr)' };
   }
 
+  // Pass all supported platforms so UHR lockfile includes cursor + gemini-cli.
+  // Without this, UHR only tracks claude-code and warns that cursor/gemini-cli
+  // hooks are "not in lockfile platforms" (uhr.gm bug report, PR #10 fix).
+  const platforms = 'claude-code,gemini-cli,cursor';
+
   const warnings = [];
   try {
-    const output = execSync(`"${uhrBin}" install "${tempManifestPath}"`, {
+    const result = execSync(`"${uhrBin}" install "${tempManifestPath}" --platforms ${platforms}`, {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'pipe'],
       timeout: 30000,
     });
 
-    // Collect any warning lines from stdout
-    if (output) {
-      const lines = output.split('\n').filter(Boolean);
-      for (const line of lines) {
-        if (/warn/i.test(line)) {
-          warnings.push(line.trim());
-        }
+    // Collect warning lines from both stdout and stderr (UHR emits warnings to stderr)
+    for (const output of [result, result?.stderr]) {
+      if (!output) continue;
+      for (const line of output.split('\n').filter(Boolean)) {
+        if (/warn/i.test(line)) warnings.push(line.trim());
       }
     }
 
     return { success: true, warnings };
   } catch (err) {
+    // execSync throws when exit code != 0; collect stderr for diagnostics
+    const stderr = err?.stderr || '';
+    for (const line of stderr.split('\n').filter(Boolean)) {
+      if (/warn/i.test(line)) warnings.push(line.trim());
+    }
     const msg = err instanceof Error ? err.message : String(err);
-    return { success: false, reason: msg || 'uhr install failed' };
+    return { success: false, reason: msg || 'uhr install failed', warnings };
   }
 }
 

package/package.json

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

package/teleportation-cli.cjs

@@ -3466,6 +3466,20 @@ async function commandInstallHooks() {
             uhrResult.warnings.forEach(w => console.log(c.yellow(`  ⚠️  ${w}`)));
           }
           installed = true;
+
+          // UHR only handles Claude Code — also install Cursor hooks via 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 {
           console.log(c.yellow(`  ⚠️  UHR install failed: ${uhrResult.reason}`));
           console.log(c.dim('  Falling back to legacy installer...'));
@@ -3492,6 +3506,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"
+  }
+}