teleportation-cli 1.0.0

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

@@ -0,0 +1,329 @@
+/**
+ * Claude Code Adapter
+ * 
+ * Adapter for Claude Code CLI. Uses the existing hook system for approvals.
+ * 
+ * Key characteristics:
+ * - Hooks handle approval via Teleportation Relay
+ * - Supports session resume via --resume
+ * - Uses --dangerously-skip-permissions for auto-approve mode
+ */
+
+import { spawn } from 'child_process';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import { MachineCoder, CODER_NAMES } from './interface.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if a command exists on the system
+ * @param {string} command
+ * @returns {Promise<boolean>}
+ */
+async function commandExists(command) {
+  try {
+    await execAsync(`which ${command}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Claude Code Adapter
+ */
+export class ClaudeCodeAdapter extends MachineCoder {
+  name = CODER_NAMES.CLAUDE_CODE;
+  displayName = 'Claude Code';
+  
+  // Track running processes for stop()
+  #runningProcesses = new Map();
+  
+  /**
+   * Check if Claude Code CLI is available
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    return commandExists('claude');
+  }
+  
+  /**
+   * Get Claude Code status
+   * @returns {Promise<Object>}
+   */
+  async getStatus() {
+    const available = await this.isAvailable();
+    
+    if (!available) {
+      return { available: false };
+    }
+    
+    try {
+      const { stdout } = await execAsync('claude --version');
+      return {
+        available: true,
+        version: stdout.trim(),
+      };
+    } catch {
+      return { available: true };
+    }
+  }
+  
+  /**
+   * Execute a task with Claude Code
+   * 
+   * Note: Claude Code uses hooks for approval, so we don't handle
+   * onToolCall here. The hooks communicate with Relay directly.
+   * 
+   * @param {Object} options
+   * @returns {Promise<Object>}
+   */
+  async execute(options) {
+    const {
+      projectPath,
+      sessionId,
+      prompt,
+      onProgress,
+      timeoutMs = 600000, // 10 min default
+      autoApprove = false,
+    } = options;
+    
+    const executionId = `claude-${Date.now()}`;
+    const args = [];
+    
+    // Add prompt
+    args.push('-p', prompt);
+    
+    // Auto-approve mode (dangerous - skips all permission checks)
+    if (autoApprove) {
+      args.push('--dangerously-skip-permissions');
+    }
+    
+    // Output format for parsing
+    args.push('--output-format', 'json');
+    
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let stdout = '';
+      let stderr = '';
+      const toolCalls = [];
+      
+      const proc = spawn('claude', args, {
+        cwd: projectPath,
+        env: {
+          ...process.env,
+          // Pass session ID to hooks
+          TELEPORTATION_SESSION_ID: sessionId,
+        },
+      });
+      
+      this.#runningProcesses.set(executionId, 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({
+                id: event.tool_use_id || `tool-${toolCalls.length}`,
+                tool: event.tool_name,
+                input: event.tool_input,
+                timestamp: Date.now(),
+              });
+            }
+            
+            onProgress?.({
+              type: event.type,
+              timestamp: Date.now(),
+              data: event,
+            });
+          }
+        } catch {
+          // Not JSON, just raw output
+          onProgress?.({
+            type: 'output',
+            timestamp: Date.now(),
+            data: { text: chunk },
+          });
+        }
+      });
+      
+      proc.stderr.on('data', (data) => {
+        stderr += data.toString();
+        onProgress?.({
+          type: 'error',
+          timestamp: Date.now(),
+          data: { text: data.toString() },
+        });
+      });
+      
+      proc.on('close', (code) => {
+        clearTimeout(timeout);
+        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;
+          if (result.usage) {
+            stats.tokensUsed = result.usage.total_tokens;
+          }
+          if (result.cost) {
+            stats.cost = result.cost;
+          }
+          if (result.model) {
+            stats.model = result.model;
+          }
+        } catch {
+          // Not JSON, use raw output
+        }
+        
+        resolve({
+          success: code === 0,
+          output,
+          error: code !== 0 ? stderr || `Exit code: ${code}` : undefined,
+          toolCalls,
+          stats,
+          executionId,
+        });
+      });
+      
+      proc.on('error', (err) => {
+        clearTimeout(timeout);
+        this.#runningProcesses.delete(executionId);
+        reject(err);
+      });
+    });
+  }
+  
+  /**
+   * Resume a Claude Code session with a new prompt
+   * @param {string} sessionId - Claude session ID to resume
+   * @param {string} prompt - New prompt
+   * @param {Object} options - Additional options
+   * @returns {Promise<Object>}
+   */
+  async resume(sessionId, prompt, options = {}) {
+    const {
+      projectPath = process.cwd(),
+      onProgress,
+      timeoutMs = 600000,
+      autoApprove = false,
+    } = options;
+    
+    const executionId = `claude-resume-${Date.now()}`;
+    const args = ['--resume', sessionId, '-p', prompt];
+    
+    if (autoApprove) {
+      args.push('--dangerously-skip-permissions');
+    }
+    
+    args.push('--output-format', 'json');
+    
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      let stdout = '';
+      let stderr = '';
+      const toolCalls = [];
+      
+      const proc = spawn('claude', args, {
+        cwd: projectPath,
+        env: {
+          ...process.env,
+          TELEPORTATION_SESSION_ID: sessionId,
+        },
+      });
+      
+      this.#runningProcesses.set(executionId, 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() },
+        });
+      });
+      
+      proc.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+      
+      proc.on('close', (code) => {
+        clearTimeout(timeout);
+        this.#runningProcesses.delete(executionId);
+        
+        resolve({
+          success: code === 0,
+          output: stdout,
+          error: code !== 0 ? stderr || `Exit code: ${code}` : undefined,
+          toolCalls,
+          stats: { durationMs: Date.now() - startTime },
+          executionId,
+        });
+      });
+      
+      proc.on('error', (err) => {
+        clearTimeout(timeout);
+        this.#runningProcesses.delete(executionId);
+        reject(err);
+      });
+    });
+  }
+  
+  /**
+   * Stop a running execution
+   * @param {string} executionId
+   * @returns {Promise<boolean>}
+   */
+  async stop(executionId) {
+    const proc = this.#runningProcesses.get(executionId);
+    if (proc) {
+      proc.kill('SIGTERM');
+      this.#runningProcesses.delete(executionId);
+      return true;
+    }
+    return false;
+  }
+  
+  /**
+   * Get capabilities
+   * @returns {Object}
+   */
+  getCapabilities() {
+    return {
+      supportsResume: true,
+      supportsStreaming: true,
+      hasNativeApproval: true, // Via hooks
+      supportsModelSelection: true,
+      maxContextTokens: 200000, // Claude 3.5 Sonnet
+      supportedTools: ['Bash', 'Read', 'Edit', 'Write', 'Glob', 'Grep', 'LS', 'MultiEdit'],
+    };
+  }
+}
+
+export default ClaudeCodeAdapter;

package/lib/machine-coders/example.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+/**
+ * Machine Coders Example / Test Script
+ * 
+ * Demonstrates the unified machine coder interface.
+ * 
+ * Usage:
+ *   node lib/machine-coders/example.js status
+ *   node lib/machine-coders/example.js list
+ *   node lib/machine-coders/example.js run <coder> <prompt>
+ *   node lib/machine-coders/example.js test
+ */
+
+import { getAvailableCoders, getBestCoder } from './index.js';
+import { ClaudeCodeAdapter } from './claude-code-adapter.js';
+import { GeminiCliAdapter } from './gemini-cli-adapter.js';
+
+const projectPath = process.cwd();
+const sessionId = process.env.TELEPORT_SESSION_ID || `test-${Date.now()}`;
+
+async function showStatus() {
+  console.log('=== Machine Coders Status ===\n');
+  
+  const coders = [
+    new ClaudeCodeAdapter(),
+    new GeminiCliAdapter(),
+  ];
+  
+  for (const coder of coders) {
+    const status = await coder.getStatus();
+    const caps = coder.getCapabilities();
+    
+    console.log(`${coder.displayName} (${coder.name}):`);
+    console.log(`  Available: ${status.available ? '✓' : '✗'}`);
+    if (status.version) {
+      console.log(`  Version: ${status.version}`);
+    }
+    if (status.models) {
+      console.log(`  Models: ${status.models.join(', ')}`);
+    }
+    console.log(`  Capabilities:`);
+    console.log(`    - Resume: ${caps.supportsResume ? '✓' : '✗'}`);
+    console.log(`    - Streaming: ${caps.supportsStreaming ? '✓' : '✗'}`);
+    console.log(`    - Native Approval: ${caps.hasNativeApproval ? '✓' : '✗'}`);
+    console.log(`    - Model Selection: ${caps.supportsModelSelection ? '✓' : '✗'}`);
+    console.log(`    - Max Context: ${(caps.maxContextTokens / 1000).toFixed(0)}K tokens`);
+    console.log(`    - Tools: ${caps.supportedTools.join(', ')}`);
+    console.log('');
+  }
+}
+
+async function listAvailable() {
+  console.log('=== Available Machine Coders ===\n');
+  
+  const available = await getAvailableCoders();
+  
+  if (available.length === 0) {
+    console.log('No machine coders available on this system.');
+    console.log('Install one of: claude, gemini, goose');
+    return;
+  }
+  
+  console.log(`Found ${available.length} available coder(s):\n`);
+  
+  for (const coder of available) {
+    const status = await coder.getStatus();
+    console.log(`  • ${coder.displayName}`);
+    console.log(`    Name: ${coder.name}`);
+    if (status.version) {
+      console.log(`    Version: ${status.version}`);
+    }
+  }
+  
+  console.log('');
+  
+  // Show best coder
+  const best = await getBestCoder();
+  if (best) {
+    console.log(`Best coder (default priority): ${best.displayName}`);
+  }
+  
+  const bestLargeContext = await getBestCoder({ largeContext: true });
+  if (bestLargeContext) {
+    console.log(`Best for large context: ${bestLargeContext.displayName}`);
+  }
+}
+
+async function runCoder(coderName, prompt) {
+  console.log(`=== Running ${coderName} ===\n`);
+  console.log(`Project: ${projectPath}`);
+  console.log(`Session: ${sessionId}`);
+  console.log(`Prompt: ${prompt}`);
+  console.log('');
+  
+  let coder;
+  switch (coderName) {
+    case 'claude':
+    case 'claude-code':
+      coder = new ClaudeCodeAdapter();
+      break;
+    case 'gemini':
+    case 'gemini-cli':
+      coder = new GeminiCliAdapter();
+      break;
+    default:
+      console.error(`Unknown coder: ${coderName}`);
+      console.log('Available: claude, gemini');
+      process.exit(1);
+  }
+  
+  const available = await coder.isAvailable();
+  if (!available) {
+    console.error(`${coder.displayName} is not available on this system.`);
+    process.exit(1);
+  }
+  
+  console.log(`Using: ${coder.displayName}`);
+  console.log('');
+  console.log('--- Output ---');
+  
+  try {
+    const result = await coder.execute({
+      projectPath,
+      sessionId,
+      prompt,
+      autoApprove: true, // For testing
+      onProgress: (event) => {
+        switch (event.type) {
+          case 'init':
+            console.log(`[init] Session: ${event.data.sessionId}, Model: ${event.data.model}`);
+            break;
+          case 'message':
+            if (event.data.role === 'assistant') {
+              console.log(`[assistant] ${event.data.content?.substring(0, 200)}...`);
+            }
+            break;
+          case 'tool_use':
+            console.log(`[tool] ${event.data.tool}: ${JSON.stringify(event.data.input).substring(0, 100)}`);
+            break;
+          case 'tool_result':
+            console.log(`[result] ${event.data.status}: ${event.data.output?.substring(0, 100)}`);
+            break;
+          case 'error':
+            console.log(`[error] ${event.data.message}`);
+            break;
+          case 'done':
+            console.log(`[done] Tokens: ${event.data.tokensUsed}, Duration: ${event.data.durationMs}ms`);
+            break;
+        }
+      },
+      onToolCall: async (tool) => {
+        // For testing, auto-allow all tools
+        console.log(`[approval] Tool ${tool.tool} auto-allowed (test mode)`);
+        return 'allow';
+      },
+    });
+    
+    console.log('');
+    console.log('--- Result ---');
+    console.log(`Success: ${result.success}`);
+    console.log(`Tool Calls: ${result.toolCalls.length}`);
+    if (result.stats) {
+      console.log(`Tokens: ${result.stats.tokensUsed || 'N/A'}`);
+      console.log(`Duration: ${result.stats.durationMs}ms`);
+      console.log(`Model: ${result.stats.model || 'N/A'}`);
+    }
+    if (result.error) {
+      console.log(`Error: ${result.error}`);
+    }
+    console.log('');
+    console.log('Output:');
+    console.log(result.output?.substring(0, 500) || '(no output)');
+    
+  } catch (err) {
+    console.error(`\nExecution failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function runTest() {
+  console.log('=== Machine Coders Test ===\n');
+  
+  // Test 1: Check availability
+  console.log('Test 1: Checking availability...');
+  const available = await getAvailableCoders();
+  console.log(`  Found ${available.length} available coder(s)`);
+  
+  if (available.length === 0) {
+    console.log('\n✗ No coders available - cannot run further tests');
+    return;
+  }
+  
+  // Test 2: Get best coder
+  console.log('\nTest 2: Getting best coder...');
+  const best = await getBestCoder();
+  console.log(`  Best coder: ${best?.displayName || 'none'}`);
+  
+  // Test 3: Get capabilities
+  console.log('\nTest 3: Checking capabilities...');
+  for (const coder of available) {
+    const caps = coder.getCapabilities();
+    console.log(`  ${coder.displayName}:`);
+    console.log(`    Max context: ${(caps.maxContextTokens / 1000).toFixed(0)}K`);
+    console.log(`    Native approval: ${caps.hasNativeApproval}`);
+  }
+  
+  console.log('\n✓ All tests passed');
+}
+
+// Main
+const command = process.argv[2] || 'status';
+const arg1 = process.argv[3];
+const arg2 = process.argv.slice(4).join(' ');
+
+switch (command) {
+  case 'status':
+    await showStatus();
+    break;
+  case 'list':
+    await listAvailable();
+    break;
+  case 'run':
+    if (!arg1 || !arg2) {
+      console.log('Usage: node example.js run <coder> <prompt>');
+      console.log('Example: node example.js run gemini "List files in current directory"');
+      process.exit(1);
+    }
+    await runCoder(arg1, arg2);
+    break;
+  case 'test':
+    await runTest();
+    break;
+  default:
+    console.log('Usage:');
+    console.log('  node lib/machine-coders/example.js status');
+    console.log('  node lib/machine-coders/example.js list');
+    console.log('  node lib/machine-coders/example.js run <coder> <prompt>');
+    console.log('  node lib/machine-coders/example.js test');
+}