teleportation-cli 1.0.0 → 1.0.2

package/lib/machine-coders/claude-code-adapter.js

@@ -16,6 +16,51 @@ import { MachineCoder, CODER_NAMES } from './interface.js';
 
 const execAsync = promisify(exec);
 
+// Grace period before killing process after receiving result (allows hooks to finish)
+// Configurable via environment variable for production tuning
+const PROCESS_KILL_GRACE_MS = parseInt(process.env.TELEPORTATION_PROCESS_GRACE_MS || '50', 10);
+
+// Environment variables to pass to Claude Code process (allowlist for security)
+// Only pass essential env vars instead of spreading all of process.env
+const ALLOWED_ENV_VARS = [
+  'HOME',
+  'PATH',
+  'SHELL',
+  'USER',
+  'TERM',
+  'LANG',
+  'LC_ALL',
+  'TMPDIR',
+  'XDG_CONFIG_HOME',
+  'XDG_DATA_HOME',
+  'XDG_CACHE_HOME',
+  // Claude Code specific
+  'ANTHROPIC_API_KEY',
+  'CLAUDE_CODE_USE_BEDROCK',
+  'CLAUDE_CODE_USE_VERTEX',
+  // Node.js
+  'NODE_ENV',
+  'NODE_OPTIONS',
+];
+
+/**
+ * Build a filtered environment object for spawning Claude Code
+ * Uses allowlist approach for security - only passes essential env vars
+ * @param {string} sessionId - Teleportation session ID to pass
+ * @returns {Object} Environment object
+ */
+function buildSecureEnv(sessionId) {
+  const env = {};
+  for (const key of ALLOWED_ENV_VARS) {
+    if (process.env[key] !== undefined) {
+      env[key] = process.env[key];
+    }
+  }
+  // Always pass session ID to hooks
+  env.TELEPORTATION_SESSION_ID = sessionId;
+  return env;
+}
+
 /**
  * Check if a command exists on the system
  * @param {string} command
@@ -36,9 +81,25 @@ async function commandExists(command) {
 export class ClaudeCodeAdapter extends MachineCoder {
   name = CODER_NAMES.CLAUDE_CODE;
   displayName = 'Claude Code';
-  
+
   // Track running processes for stop()
   #runningProcesses = new Map();
+
+  /**
+   * Close stdin immediately to prevent Claude Code from hanging
+   * Claude Code waits for stdin to close when spawned - without this,
+   * the process hangs indefinitely waiting for possible input.
+   * @param {ChildProcess} proc - The spawned process
+   * @private
+   */
+  #closeStdinSafely(proc) {
+    try {
+      proc.stdin.end();
+    } catch (err) {
+      // Log but don't throw - stdin might already be closed or in error state
+      console.warn('[claude-adapter] Failed to close stdin:', err.message);
+    }
+  }
   
   /**
    * Check if Claude Code CLI is available
@@ -102,40 +163,39 @@ export class ClaudeCodeAdapter extends MachineCoder {
     
     // Output format for parsing
     args.push('--output-format', 'json');
-    
+
     return new Promise((resolve, reject) => {
       const startTime = Date.now();
       let stdout = '';
       let stderr = '';
       const toolCalls = [];
-      
+      let resolved = false; // Prevent double-resolution race condition
+      let killTimeout = null; // Track kill timeout for cleanup
+
       const proc = spawn('claude', args, {
         cwd: projectPath,
-        env: {
-          ...process.env,
-          // Pass session ID to hooks
-          TELEPORTATION_SESSION_ID: sessionId,
-        },
+        env: buildSecureEnv(sessionId),
       });
-      
+
       this.#runningProcesses.set(executionId, proc);
-      
+      this.#closeStdinSafely(proc);
+
       // Timeout handling
       const timeout = setTimeout(() => {
         proc.kill('SIGTERM');
         reject(new Error(`Execution timed out after ${timeoutMs}ms`));
       }, timeoutMs);
-      
+
       proc.stdout.on('data', (data) => {
         const chunk = data.toString();
         stdout += chunk;
-        
+
         // Try to parse JSON events for progress
         try {
           const lines = chunk.split('\n').filter(l => l.trim());
           for (const line of lines) {
             const event = JSON.parse(line);
-            
+
             // Track tool calls
             if (event.type === 'tool_use') {
               toolCalls.push({
@@ -145,12 +205,49 @@ export class ClaudeCodeAdapter extends MachineCoder {
                 timestamp: Date.now(),
               });
             }
-            
+
             onProgress?.({
               type: event.type,
               timestamp: Date.now(),
               data: event,
             });
+
+            // When we receive a final result, resolve early and kill the process
+            // This handles cases where hooks keep the process alive after completion
+            if (event.type === 'result') {
+              if (resolved) return; // Prevent double-resolution
+              resolved = true;
+
+              clearTimeout(timeout);
+              this.#runningProcesses.delete(executionId);
+
+              const durationMs = Date.now() - startTime;
+              const output = event.result || event.response || event.output || '';
+              const stats = { durationMs };
+
+              if (event.usage) {
+                stats.tokensUsed = event.usage.total_tokens;
+              }
+              if (event.cost || event.total_cost_usd) {
+                stats.cost = event.cost || event.total_cost_usd;
+              }
+              if (event.model) {
+                stats.model = event.model;
+              }
+
+              // Kill the process since we have the result (small delay for hooks to finish)
+              killTimeout = setTimeout(() => proc.kill('SIGTERM'), PROCESS_KILL_GRACE_MS);
+
+              resolve({
+                success: !event.is_error,
+                output,
+                error: event.is_error ? (event.error || 'Unknown error') : undefined,
+                toolCalls,
+                stats,
+                executionId,
+              });
+              return;
+            }
           }
         } catch {
           // Not JSON, just raw output
@@ -172,15 +269,19 @@ export class ClaudeCodeAdapter extends MachineCoder {
       });
       
       proc.on('close', (code) => {
+        if (resolved) return; // Prevent double-resolution
+        resolved = true;
+
         clearTimeout(timeout);
+        if (killTimeout) clearTimeout(killTimeout); // Clean up kill timeout if process exits naturally
         this.#runningProcesses.delete(executionId);
-        
+
         const durationMs = Date.now() - startTime;
-        
+
         // Try to parse final JSON output
         let output = stdout;
         let stats = { durationMs };
-        
+
         try {
           const result = JSON.parse(stdout);
           output = result.result || result.response || result.output || stdout;
@@ -196,7 +297,7 @@ export class ClaudeCodeAdapter extends MachineCoder {
         } catch {
           // Not JSON, use raw output
         }
-        
+
         resolve({
           success: code === 0,
           output,
@@ -238,45 +339,98 @@ export class ClaudeCodeAdapter extends MachineCoder {
     }
     
     args.push('--output-format', 'json');
-    
+
     return new Promise((resolve, reject) => {
       const startTime = Date.now();
       let stdout = '';
       let stderr = '';
       const toolCalls = [];
-      
+      let resolved = false; // Prevent double-resolution race condition
+      let killTimeout = null; // Track kill timeout for cleanup
+
       const proc = spawn('claude', args, {
         cwd: projectPath,
-        env: {
-          ...process.env,
-          TELEPORTATION_SESSION_ID: sessionId,
-        },
+        env: buildSecureEnv(sessionId),
       });
-      
+
       this.#runningProcesses.set(executionId, proc);
-      
+      this.#closeStdinSafely(proc);
+
       const timeout = setTimeout(() => {
         proc.kill('SIGTERM');
         reject(new Error(`Resume timed out after ${timeoutMs}ms`));
       }, timeoutMs);
-      
+
       proc.stdout.on('data', (data) => {
-        stdout += data.toString();
-        onProgress?.({
-          type: 'output',
-          timestamp: Date.now(),
-          data: { text: data.toString() },
-        });
+        const chunk = data.toString();
+        stdout += chunk;
+
+        // Try to parse JSON result
+        try {
+          const lines = chunk.split('\n').filter(l => l.trim());
+          for (const line of lines) {
+            const event = JSON.parse(line);
+
+            onProgress?.({
+              type: event.type || 'output',
+              timestamp: Date.now(),
+              data: event,
+            });
+
+            // When we receive a final result, resolve early and kill the process
+            if (event.type === 'result') {
+              if (resolved) return; // Prevent double-resolution
+              resolved = true;
+
+              clearTimeout(timeout);
+              this.#runningProcesses.delete(executionId);
+
+              const output = event.result || event.response || event.output || '';
+              const stats = { durationMs: Date.now() - startTime };
+
+              if (event.usage) {
+                stats.tokensUsed = event.usage.total_tokens;
+              }
+              if (event.cost || event.total_cost_usd) {
+                stats.cost = event.cost || event.total_cost_usd;
+              }
+
+              // Kill the process since we have the result (small delay for hooks to finish)
+              killTimeout = setTimeout(() => proc.kill('SIGTERM'), PROCESS_KILL_GRACE_MS);
+
+              resolve({
+                success: !event.is_error,
+                output,
+                error: event.is_error ? (event.error || 'Unknown error') : undefined,
+                toolCalls,
+                stats,
+                executionId,
+              });
+              return;
+            }
+          }
+        } catch {
+          // Not JSON, just raw output
+          onProgress?.({
+            type: 'output',
+            timestamp: Date.now(),
+            data: { text: chunk },
+          });
+        }
       });
-      
+
       proc.stderr.on('data', (data) => {
         stderr += data.toString();
       });
-      
+
       proc.on('close', (code) => {
+        if (resolved) return; // Prevent double-resolution
+        resolved = true;
+
         clearTimeout(timeout);
+        if (killTimeout) clearTimeout(killTimeout); // Clean up kill timeout if process exits naturally
         this.#runningProcesses.delete(executionId);
-        
+
         resolve({
           success: code === 0,
           output: stdout,
@@ -286,7 +440,7 @@ export class ClaudeCodeAdapter extends MachineCoder {
           executionId,
         });
       });
-      
+
       proc.on('error', (err) => {
         clearTimeout(timeout);
         this.#runningProcesses.delete(executionId);

package/lib/remote/code-sync.js

@@ -0,0 +1,213 @@
+/**
+ * CodeSync
+ *
+ * Manages git state synchronization between local and remote machines:
+ * - Capture local state (branch, commit, uncommitted changes)
+ * - Sync code to remote machine
+ * - Pull changes from remote
+ * - Conflict detection
+ *
+ * Integrates with existing GitHandoff system from lib/handoff/git-handoff.js
+ */
+
+import { GitHandoff } from '../handoff/git-handoff.js';
+
+/**
+ * Local state structure
+ * @typedef {Object} LocalState
+ * @property {string} branch - Current branch name
+ * @property {string} commit - Current commit hash
+ * @property {string} remoteUrl - Remote repository URL
+ * @property {Array<string>} uncommittedChanges - List of uncommitted files
+ * @property {boolean} hasUncommitted - Whether there are uncommitted changes
+ * @property {number} timestamp - Capture timestamp
+ */
+
+/**
+ * CodeSync class
+ */
+export class CodeSync {
+  /**
+   * @param {Object} options
+   * @param {string} options.repoPath - Path to git repository
+   * @param {string} options.sessionId - Session identifier
+   * @param {Object} [options.gitHandoff] - GitHandoff instance (optional, will create if not provided)
+   */
+  constructor(options) {
+    const { repoPath, sessionId, gitHandoff } = options;
+
+    if (!repoPath) {
+      throw new Error('repoPath is required');
+    }
+
+    if (!sessionId) {
+      throw new Error('sessionId is required');
+    }
+
+    this.repoPath = repoPath;
+    this.sessionId = sessionId;
+
+    // Use provided GitHandoff or create new one
+    this.gitHandoff = gitHandoff || new GitHandoff({
+      repoPath,
+      sessionId,
+      branchPrefix: 'teleport/wip-'
+    });
+  }
+
+  /**
+   * Capture current local git state
+   * @returns {Promise<LocalState>}
+   */
+  async captureLocalState() {
+    // Verify git repository
+    const isRepo = await this.gitHandoff.isGitRepo();
+    if (!isRepo) {
+      throw new Error(`Not a git repository: ${this.repoPath}`);
+    }
+
+    // Get current state
+    const branch = await this.gitHandoff.getCurrentBranch();
+    const commit = await this.gitHandoff.getCurrentCommit();
+    const remoteUrl = await this.gitHandoff.getRemoteUrl();
+
+    if (!remoteUrl) {
+      throw new Error('No remote URL configured');
+    }
+
+    const hasUncommitted = await this.gitHandoff.hasUncommittedChanges();
+    const uncommittedChanges = hasUncommitted
+      ? await this.gitHandoff.getChangedFiles()
+      : [];
+
+    return {
+      branch,
+      commit,
+      remoteUrl,
+      uncommittedChanges,
+      hasUncommitted,
+      timestamp: Date.now()
+    };
+  }
+
+  /**
+   * Sync code to remote machine
+   * @param {Object} options
+   * @param {string} options.machineId - Remote machine ID
+   * @param {LocalState} [options.localState] - Pre-captured local state (optional)
+   * @returns {Promise<Object>}
+   */
+  async syncToRemote(options) {
+    const { machineId, localState: providedState } = options;
+
+    // Use provided state or capture fresh
+    const localState = providedState || await this.captureLocalState();
+
+    // If there are uncommitted changes, commit them as WIP
+    let wipCommit = null;
+    if (localState.hasUncommitted) {
+      const hasChanges = await this.gitHandoff.hasUncommittedChanges();
+      if (hasChanges) {
+        const result = await this.gitHandoff.commitWip(
+          `Remote sync for session ${this.sessionId}`
+        );
+        wipCommit = result.commit;
+      }
+    }
+
+    // Push to WIP branch
+    await this.gitHandoff.pushToWipBranch(true); // force push
+
+    return {
+      success: true,
+      sessionId: this.sessionId,
+      machineId,
+      branch: localState.branch,
+      commit: localState.commit,
+      wipCommit,
+      syncedAt: Date.now()
+    };
+  }
+
+  /**
+   * Pull changes from remote machine
+   * @param {Object} options
+   * @param {string} [options.strategy='merge'] - Sync strategy ('merge' or 'rebase')
+   * @param {boolean} [options.stashLocal=true] - Stash local changes before pulling
+   * @returns {Promise<Object>}
+   */
+  async pullFromRemote(options = {}) {
+    const { strategy = 'merge', stashLocal = true } = options;
+
+    // Fetch WIP branch
+    await this.gitHandoff.fetchWipBranch();
+
+    // Check if there are remote changes
+    const remoteCheck = await this.gitHandoff.checkRemoteChanges();
+    if (!remoteCheck.hasChanges) {
+      return {
+        success: true,
+        hasChanges: false,
+        commit: remoteCheck.localCommit
+      };
+    }
+
+    // Sync from remote
+    const result = await this.gitHandoff.syncFromRemote({
+      strategy,
+      stashLocal
+    });
+
+    return {
+      success: result.success,
+      hasChanges: true,
+      commit: result.commit,
+      conflicts: result.conflicts
+    };
+  }
+
+  /**
+   * Get diff summary between local and remote
+   * @returns {Promise<Object>}
+   */
+  async getDiffSummary() {
+    await this.gitHandoff.fetchWipBranch();
+    return this.gitHandoff.getDiffSummary();
+  }
+
+  /**
+   * Detect potential conflicts between local and remote
+   * @returns {Promise<Object>}
+   */
+  async detectConflicts() {
+    // Check remote changes
+    const remoteCheck = await this.gitHandoff.checkRemoteChanges();
+
+    // Check local uncommitted changes
+    const hasUncommitted = await this.gitHandoff.hasUncommittedChanges();
+    const localChanges = hasUncommitted
+      ? await this.gitHandoff.getChangedFiles()
+      : [];
+
+    // Get diff summary
+    const diff = await this.getDiffSummary();
+
+    // Determine if branches diverged
+    const diverged = diff.ahead > 0 && diff.behind > 0;
+
+    // Find conflicting files (overlap between remote changes and local uncommitted)
+    const conflictingFiles = localChanges.filter((file) =>
+      diff.files.includes(file)
+    );
+
+    return {
+      hasConflicts: conflictingFiles.length > 0 || (remoteCheck.hasChanges && hasUncommitted),
+      diverged,
+      conflictingFiles,
+      remoteChanges: diff.files,
+      localChanges
+    };
+  }
+}
+
+export default CodeSync;