teleportation-cli 1.3.0 → 1.4.1

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

@@ -34,9 +34,10 @@ async function loadVersionInfo() {
  * @param {string} session_id - Session ID (also Claude session ID)
  * @param {string} cwd - Current working directory
  * @param {object} config - Config object with relayApiUrl and relayApiKey
+ * @param {object} [preExtractedMetadata] - Pre-extracted metadata to avoid duplicate extraction
  * @returns {Promise<boolean|object>} - True if registered successfully, or error object if orphan
  */
-export async function ensureSessionRegistered(session_id, cwd, config) {
+export async function ensureSessionRegistered(session_id, cwd, config, preExtractedMetadata = null) {
   const RELAY_API_URL = config.relayApiUrl || '';
   const RELAY_API_KEY = config.relayApiKey || '';
 
@@ -65,36 +66,50 @@ export async function ensureSessionRegistered(session_id, cwd, config) {
     console.error(`[SessionRegister] Registering session ${session_id}`);
   }
 
-  // Extract enhanced session metadata
-  let metadata = { cwd, claude_session_id: session_id };
-  try {
-    // Try to load metadata extraction module
-    const possiblePaths = [
-      join(__dirname, '..', '..', 'lib', 'session', 'metadata.js'),
-      join(process.env.HOME || process.env.USERPROFILE || '', '.teleportation', 'lib', 'session', 'metadata.js'),
-      './lib/session/metadata.js'
-    ];
+  // Use pre-extracted metadata if provided (avoids duplicate git subprocess calls)
+  let metadata;
+  if (preExtractedMetadata && Object.keys(preExtractedMetadata).length > 0) {
+    const client = preExtractedMetadata.client || 'claude-code';
+    const clientSessionField = client === 'cursor'
+      ? { cursor_conversation_id: session_id }
+      : { claude_session_id: session_id };
+    metadata = { ...preExtractedMetadata, session_id, ...clientSessionField };
+    if (env.DEBUG) {
+      console.error('[SessionRegister] Using pre-extracted metadata (skipping re-extraction)');
+    }
+  } else {
+    // Fallback: extract metadata (for callers that don't provide it)
+    metadata = { cwd, claude_session_id: session_id, client: 'claude-code' };
+    try {
+      const possiblePaths = [
+        join(__dirname, '..', '..', 'lib', 'session', 'metadata.js'),
+        join(process.env.HOME || process.env.USERPROFILE || '', '.teleportation', 'lib', 'session', 'metadata.js'),
+        './lib/session/metadata.js'
+      ];
 
-    let metadataModule = null;
-    for (const path of possiblePaths) {
-      try {
-        metadataModule = await import('file://' + path);
-        break;
-      } catch (e) {
-        // Try next path
+      let metadataModule = null;
+      for (const path of possiblePaths) {
+        try {
+          metadataModule = await import('file://' + path);
+          break;
+        } catch (e) {
+          // Try next path
+        }
       }
-    }
 
-    if (metadataModule && metadataModule.extractSessionMetadata && cwd) {
-      const extracted = await metadataModule.extractSessionMetadata(cwd);
-      extracted.session_id = session_id;
-      extracted.claude_session_id = session_id; // Include Claude session ID for autonomous task resumption
-      metadata = extracted;
-    }
-  } catch (e) {
-    // If metadata extraction fails, fall back to basic metadata
-    if (env.DEBUG) {
-      console.error('[SessionRegister] Failed to extract metadata:', e.message);
+      if (metadataModule && metadataModule.extractSessionMetadata && cwd) {
+        const extracted = await metadataModule.extractSessionMetadata(cwd);
+        extracted.session_id = session_id;
+        extracted.client = extracted.client || 'claude-code';
+        const clientSessionField = extracted.client === 'cursor'
+          ? { cursor_conversation_id: session_id }
+          : { claude_session_id: session_id };
+        metadata = { ...extracted, ...clientSessionField };
+      }
+    } catch (e) {
+      if (env.DEBUG) {
+        console.error('[SessionRegister] Failed to extract metadata:', e.message);
+      }
     }
   }
 
@@ -149,7 +164,7 @@ export async function ensureSessionRegistered(session_id, cwd, config) {
         'Content-Type': 'application/json',
         'Authorization': `Bearer ${RELAY_API_KEY}`
       },
-      body: JSON.stringify({ session_id, meta: metadata })
+      body: JSON.stringify({ session_id, meta: metadata, cwd: metadata.working_directory || cwd })
     });
 
     if (response.ok || response.status === 200) {

package/.claude/hooks/session_end.mjs

@@ -40,9 +40,7 @@ const readStdin = () => new Promise((resolve, reject) => {
   const DAEMON_PORT = config.daemonPort || env.TELEPORTATION_DAEMON_PORT || '3050';
   const DAEMON_ENABLED = config.daemonEnabled !== false && env.TELEPORTATION_DAEMON_ENABLED !== 'false';
 
-  // Detect message source
-  const isAutonomousTask = env.TELEPORTATION_TASK_MODE === 'true' || !!env.TELEPORTATION_PARENT_SESSION_ID;
-  const source = isAutonomousTask ? 'autonomous_task' : 'cli_interactive';
+  const source = 'cli_interactive';
 
   const updateSessionDaemonState = async (updates) => {
     if (!session_id || !RELAY_API_URL || !RELAY_API_KEY) return;
@@ -92,6 +90,34 @@ const readStdin = () => new Promise((resolve, reject) => {
       }
     }
 
+    // Mark PID-based session file as ended so daemon stops heartbeating immediately
+    try {
+      const { homedir } = await import('node:os');
+      const { fileURLToPath } = await import('node:url');
+      const { dirname } = await import('node:path');
+      const __hookDir = dirname(fileURLToPath(import.meta.url));
+      const registryPaths = [
+        join(homedir(), '.teleportation', 'lib', 'daemon', 'session-file-registry.js'),
+        // Relative path — consistent with session_start.mjs (__dirname-based, not URL-based)
+        join(__hookDir, '..', '..', 'lib', 'daemon', 'session-file-registry.js'),
+      ];
+      let marked = false;
+      for (const p of registryPaths) {
+        try {
+          const { markSessionEnded } = await import(p);
+          await markSessionEnded(session_id);
+          if (env.DEBUG) console.error(`[SessionEnd] Marked session file ended: ${session_id}`);
+          marked = true;
+          break;
+        } catch { /* try next */ }
+      }
+      if (!marked) {
+        console.error(`[SessionEnd] WARN: Could not mark session file ended — session-file-registry not found at any path`);
+      }
+    } catch (e) {
+      if (env.DEBUG) console.error(`[SessionEnd] Failed to mark session ended: ${e.message}`);
+    }
+
     // Delete registration marker file
     try {
       const registrationMarker = join(tmpdir(), `teleportation-session-${session_id}.registered`);

package/.claude/hooks/session_start.mjs

@@ -128,6 +128,17 @@ function updateSessionMarker(sessionId) {
   } catch {}
 
   let { session_id, cwd } = input || {};
+  // Cursor's sessionStart provides session_id (same as conversation_id) but cwd
+  // comes from workspace_roots, not a top-level cwd field
+  cwd = cwd || input?.workspace_roots?.[0];
+  // Detect client and capture Cursor-specific session context
+  const client = input?.cursor_version ? 'cursor' : 'claude-code';
+  const cursorMeta = client === 'cursor' ? {
+    client,
+    is_background_agent: input?.is_background_agent ?? false,
+    composer_mode: input?.composer_mode || null,
+    cursor_version: input?.cursor_version || null,
+  } : { client };
   const claude_session_id = session_id;
 
   // Check if credentials changed since last session start - user may need to restart
@@ -277,10 +288,55 @@ function updateSessionMarker(sessionId) {
           console.error(`[SessionStart] Captured model: ${meta.current_model}`);
         }
 
+        // If this session was spawned by the task executor as a child of a parent session,
+        // record the parent_session_id so the UI can hide child sessions from the list.
+        const parentSessionId = env.TELEPORTATION_PARENT_SESSION_ID;
+        const taskMeta = parentSessionId ? { parent_session_id: parentSessionId } : {};
+
+        const fullMeta = { ...meta, ...cursorMeta, ...taskMeta };
+
+        // PRIMARY: Write session file for daemon to discover via PID-based polling.
+        // This is fire-and-forget — no timeout, no network, survives daemon restarts.
+        // Cursor sessions use conversation_id not a real claude PID, so skip for them.
+        if (client === 'claude-code' && process.ppid) {
+          try {
+            const registryPaths = [
+              join(homedir(), '.teleportation', 'lib', 'daemon', 'session-file-registry.js'),
+              join(__dirname, '..', '..', 'lib', 'daemon', 'session-file-registry.js'),
+            ];
+            let writeSessionFile = null;
+            for (const p of registryPaths) {
+              try {
+                const mod = await import(p);
+                writeSessionFile = mod.writeSessionFile;
+                break;
+              } catch { /* try next */ }
+            }
+            if (writeSessionFile) {
+              await writeSessionFile({ session_id, claude_pid: process.ppid, cwd: cwd || process.cwd(), meta: fullMeta });
+              if (env.DEBUG) {
+                // Log the parent process name so we can verify ppid points to `claude`
+                // and not an intermediate shell (sh -c "bun hook") in some environments.
+                try {
+                  const { execFile } = await import('node:child_process');
+                  const { promisify: pify } = await import('node:util');
+                  const { stdout } = await pify(execFile)('ps', ['-p', String(process.ppid), '-o', 'comm='], { timeout: 1000 });
+                  console.error(`[SessionStart] Session file written (PID: ${process.ppid}, comm: ${stdout.trim()})`);
+                } catch {
+                  console.error(`[SessionStart] Session file written (PID: ${process.ppid})`);
+                }
+              }
+            }
+          } catch (fileErr) {
+            if (env.DEBUG) console.error(`[SessionStart] Session file write failed: ${fileErr.message}`);
+          }
+        }
+
+        // SECONDARY: HTTP registration with daemon (kept for backward compat with older daemons).
         await fetchWithTimeout(`${daemonUrl}/sessions/register`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ session_id, claude_session_id, cwd, meta })
+          body: JSON.stringify({ session_id, claude_session_id, cwd, meta: fullMeta })
         }, 2000);
 
         if (env.DEBUG) {