teleportation-cli 1.1.5 → 1.2.1

package/lib/daemon/services/queue-service.js

@@ -0,0 +1,318 @@
+/**
+ * Queue Service
+ * 
+ * Manages approval queue and execution of approved tools.
+ */
+
+import { spawn } from 'child_process';
+import { truncateOutput, validateApprovalId, validateSessionId, validateToolName, buildToolPrompt } from '../utils.js';
+
+export class QueueService {
+  constructor(state, config) {
+    this.name = 'queue';
+    this.state = state;
+    this.config = config;
+    this.maxQueueSize = config.maxQueueSize || 1000;
+    this.maxExecutions = config.maxExecutions || 1000;
+    this.childTimeoutMs = config.childTimeoutMs || 600000;
+  }
+
+  async start(ctx) {
+    this.ctx = ctx;
+    const { server } = ctx;
+
+    // Register routes
+    server.addRoute('POST', '/approvals/handoff', (req) => this.handleHandoff(req));
+    server.addRoute('GET', '/executions/', (req) => this.handleGetExecution(req));
+
+    console.log('[QueueService] Started');
+  }
+
+  async stop() {
+    console.log('[QueueService] Stopped');
+  }
+
+  getStats() {
+    return {
+      queueSize: this.state.approvalQueue.length,
+      executionsCount: this.state.executions.size
+    };
+  }
+
+  async handleHandoff(req) {
+    try {
+      const body = await req.json();
+      const { approval_id, session_id, tool_name, tool_input } = body;
+
+      validateApprovalId(approval_id);
+      validateSessionId(session_id);
+      validateToolName(tool_name);
+
+      if (this.state.approvalQueue.length >= this.maxQueueSize) {
+        return Response.json({
+          error: 'Approval queue full',
+          queue_size: this.state.approvalQueue.length
+        }, { status: 503 });
+      }
+
+      if (!this.state.approvalQueue.find(a => a.approval_id === approval_id)) {
+        this.state.approvalQueue.push({
+          approval_id,
+          session_id,
+          tool_name,
+          tool_input,
+          queued_at: Date.now()
+        });
+        console.log(`[QueueService] Approval queued: ${approval_id} (${tool_name})`);
+      }
+
+      return Response.json({ ok: true, queued: true });
+    } catch (error) {
+      return Response.json({ error: error.message }, { status: 400 });
+    }
+  }
+
+  async handleGetExecution(req) {
+    const url = new URL(req.url);
+    const approval_id = url.pathname.split('/executions/')[1];
+    
+    if (!approval_id) {
+      return Response.json({ error: 'approval_id is required' }, { status: 400 });
+    }
+
+    const execution = this.state.executions.get(approval_id);
+    if (!execution) {
+      return Response.json({ error: 'not_found' }, { status: 404 });
+    }
+
+    return Response.json(execution);
+  }
+
+  /**
+   * Process one item from the queue
+   */
+  async processNext() {
+    if (this.state.approvalQueue.length === 0 || this.state.isShuttingDown) return;
+
+    const approval = this.state.approvalQueue.shift();
+    const { approval_id, session_id, tool_name, tool_input } = approval;
+
+    if (this.state.executions.has(approval_id)) {
+      if (this.state.executions.get(approval_id).status === 'executing') {
+        return;
+      }
+    }
+
+    // LRU cleanup
+    if (this.state.executions.size >= this.maxExecutions) {
+      let oldestKey = null;
+      let oldestTime = Infinity;
+      for (const [id, exec] of this.state.executions) {
+        if (exec.completed_at && exec.completed_at < oldestTime) {
+          oldestTime = exec.completed_at;
+          oldestKey = id;
+        }
+      }
+      if (oldestKey) this.state.executions.delete(oldestKey);
+    }
+
+    this.state.executions.set(approval_id, {
+      approval_id,
+      status: 'executing',
+      started_at: Date.now(),
+      completed_at: null,
+      exit_code: null,
+      stdout: '',
+      stderr: '',
+      error: null,
+      child_process: null
+    });
+
+    try {
+      // Acknowledge
+      await this.ackApproval(approval_id);
+
+      const prompt = buildToolPrompt(tool_name, tool_input);
+      const result = await this.spawnClaudeProcess(session_id, prompt, {
+        onSpawn: (child) => {
+          const exec = this.state.executions.get(approval_id);
+          if (exec) exec.child_process = child;
+        }
+      });
+
+      this.state.executions.set(approval_id, {
+        ...this.state.executions.get(approval_id),
+        status: result.success ? 'completed' : 'failed',
+        completed_at: Date.now(),
+        exit_code: result.exit_code,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        error: result.error
+      });
+
+      await this.reportExecutionStatus(approval_id, result);
+      await this.storeExecutionResult(session_id, approval_id, tool_name, tool_input?.command, result);
+
+    } catch (error) {
+      console.error(`[QueueService] Execution error: ${error.message}`);
+      this.state.executions.set(approval_id, {
+        ...this.state.executions.get(approval_id),
+        status: 'failed',
+        completed_at: Date.now(),
+        error: error.message
+      });
+    }
+  }
+
+  async ackApproval(approval_id) {
+    if (!this.config.relayApiUrl || !this.config.relayApiKey) return;
+    try {
+      await fetch(`${this.config.relayApiUrl}/api/approvals/${approval_id}/ack`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.config.relayApiKey}`
+        },
+        body: JSON.stringify({ processed: true })
+      });
+    } catch (err) {
+      console.error(`[QueueService] Ack failed: ${err.message}`);
+    }
+  }
+
+  async reportExecutionStatus(approval_id, result) {
+    if (!this.config.relayApiUrl || !this.config.relayApiKey) return;
+    try {
+      await fetch(`${this.config.relayApiUrl}/api/approvals/${approval_id}/executed`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.config.relayApiKey}`
+        },
+        body: JSON.stringify({
+          success: result.success,
+          exit_code: result.exit_code,
+          stdout: result.stdout?.slice(0, 10000),
+          stderr: result.stderr?.slice(0, 10000),
+          error: result.error,
+          duration_ms: result.duration_ms
+        })
+      });
+    } catch (err) {
+      console.error(`[QueueService] Status report failed: ${err.message}`);
+    }
+  }
+
+  async storeExecutionResult(session_id, approval_id, tool_name, command, result) {
+    if (!this.config.relayApiUrl || !this.config.relayApiKey) return;
+    const payload = {
+      approval_id,
+      command: command || '',
+      tool_name,
+      exit_code: result.exit_code ?? null,
+      stdout: (result.stdout || '').slice(0, 10000),
+      stderr: (result.stderr || '').slice(0, 10000),
+      executed_at: result.executed_at || Date.now()
+    };
+
+    try {
+      await fetch(`${this.config.relayApiUrl}/api/sessions/${encodeURIComponent(session_id)}/results`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.config.relayApiKey}`
+        },
+        body: JSON.stringify(payload)
+      });
+    } catch (err) {
+      console.error(`[QueueService] Result storage failed: ${err.message}`);
+    }
+  }
+
+  async spawnClaudeProcess(session_id, prompt, options = {}) {
+    const session = this.state.sessions.get(session_id);
+    if (!session) throw new Error(`Session not found: ${session_id}`);
+
+    return new Promise((resolve) => {
+      const cwd = session.cwd || process.cwd();
+      const startedAt = Date.now();
+      
+      let isToolExecution = false;
+      let commandToRun = '';
+      let agentPrompt = '';
+
+      try {
+        const promptObj = JSON.parse(prompt);
+        if (promptObj.parameters?.command) {
+          isToolExecution = true;
+          commandToRun = promptObj.parameters.command;
+        }
+      } catch (e) {}
+
+      if (!isToolExecution) agentPrompt = prompt;
+
+      let child;
+      if (isToolExecution) {
+        child = spawn('sh', ['-c', commandToRun], {
+          cwd,
+          stdio: 'pipe',
+          env: { ...process.env, TELEPORTATION_DAEMON_CHILD: 'true' }
+        });
+      } else {
+        const cliBin = process.env.CLAUDE_CLI_PATH || 'claude';
+        const resumeSessionId = session.claude_session_id || session_id;
+        const args = ['--resume', resumeSessionId, '-p', agentPrompt, '--dangerously-skip-permissions'];
+        
+        child = spawn(cliBin, args, {
+          cwd,
+          stdio: 'pipe',
+          env: { ...process.env, TELEPORTATION_DAEMON_CHILD: 'true', CI: 'true' }
+        });
+      }
+
+      if (options.onSpawn) options.onSpawn(child);
+      if (child.stdin) child.stdin.end();
+
+      let stdout = '';
+      let stderr = '';
+      let timedOut = false;
+
+      child.stdout.on('data', (data) => { stdout += data.toString(); });
+      child.stderr.on('data', (data) => { stderr += data.toString(); });
+
+      const timeout = setTimeout(() => {
+        timedOut = true;
+        child.kill('SIGTERM');
+      }, this.childTimeoutMs);
+
+      child.on('close', (code) => {
+        clearTimeout(timeout);
+        const executedAt = Date.now();
+        resolve({
+          success: code === 0 && !timedOut,
+          exit_code: code,
+          stdout: truncateOutput(stdout, 'STDOUT'),
+          stderr: truncateOutput(stderr, 'STDERR'),
+          error: timedOut ? 'Execution timed out' : null,
+          duration_ms: executedAt - startedAt,
+          started_at: startedAt,
+          executed_at: executedAt
+        });
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timeout);
+        resolve({
+          success: false,
+          exit_code: -1,
+          stdout: '',
+          stderr: '',
+          error: err.message,
+          duration_ms: 0,
+          started_at: startedAt,
+          executed_at: Date.now()
+        });
+      });
+    });
+  }
+}

package/lib/daemon/services/session-service.js

@@ -0,0 +1,115 @@
+/**
+ * Session Service
+ * 
+ * Manages Claude Code sessions, registration, and liveness monitoring.
+ */
+
+// NOTE: HeartbeatManager removed in PRD-0025 — daemon handles heartbeats inline.
+
+export class SessionService {
+  constructor(state, config) {
+    this.name = 'sessions';
+    this.state = state;
+    this.config = config;
+  }
+
+  async start(ctx) {
+    this.ctx = ctx;
+    const { server } = ctx;
+
+    // Register routes
+    server.addRoute('POST', '/sessions/register', (req) => this.handleRegister(req));
+    server.addRoute('POST', '/sessions/stop', (req) => this.handleStop(req));
+
+    console.log('[SessionService] Started');
+  }
+
+  async stop() {
+    console.log('[SessionService] Stopped');
+  }
+
+  getStats() {
+    return {
+      activeSessions: this.state.sessions.size,
+      stoppedSessions: this.state.stoppedSessions.size
+    };
+  }
+
+  async handleRegister(req) {
+    try {
+      const body = await req.json();
+      const { session_id, claude_session_id, cwd, meta } = body;
+
+      if (!session_id) {
+        return Response.json({ error: 'session_id is required' }, { status: 400 });
+      }
+
+      if (this.state.stoppedSessions.has(session_id)) {
+        return Response.json({
+          error: 'session_stopped',
+          message: 'This session has ended and cannot be re-activated'
+        }, { status: 403 });
+      }
+
+      this.state.sessions.set(session_id, {
+        session_id,
+        claude_session_id: claude_session_id || session_id,
+        cwd: cwd || process.cwd(),
+        meta: {
+          ...(meta || {}),
+          daemon_pid: process.pid
+        },
+        registered_at: Date.now()
+      });
+
+      this.state.sessionActivity.set(session_id, Date.now());
+      this.state.lastSessionActivityAt = Date.now();
+
+      console.log(`[SessionService] Session registered: ${session_id}`);
+
+      // Update daemon_state on relay
+      if (this.config.relayApiUrl && this.config.relayApiKey) {
+        fetch(
+          `${this.config.relayApiUrl}/api/sessions/${encodeURIComponent(session_id)}/daemon-state`,
+          {
+            method: 'PATCH',
+            headers: {
+              'Authorization': `Bearer ${this.config.relayApiKey}`,
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+              status: 'running',
+              started_reason: 'session_registered'
+            })
+          }
+        ).catch(err => {
+          console.error(`[SessionService] Failed to update daemon_state for ${session_id}: ${err.message}`);
+        });
+      }
+
+      return Response.json({ ok: true });
+    } catch (error) {
+      return Response.json({ error: error.message }, { status: 500 });
+    }
+  }
+
+  async handleStop(req) {
+    try {
+      const body = await req.json();
+      const { session_id } = body;
+
+      if (!session_id) {
+        return Response.json({ error: 'session_id is required' }, { status: 400 });
+      }
+
+      this.state.sessions.delete(session_id);
+      this.state.stoppedSessions.add(session_id);
+      
+      console.log(`[SessionService] Session stopped: ${session_id}`);
+      
+      return Response.json({ ok: true });
+    } catch (error) {
+      return Response.json({ error: error.message }, { status: 500 });
+    }
+  }
+}

package/lib/daemon/state.js

@@ -0,0 +1,35 @@
+/**
+ * Daemon State
+ * 
+ * Shared in-memory state for the teleportation daemon.
+ * This object is passed to services to allow them to share data.
+ */
+
+export const createDaemonState = () => ({
+  // In-memory registry of active teleportation sessions handled by this daemon
+  sessions: new Map(),
+
+  // Track sessions that have been explicitly stopped and should not be re-activated
+  stoppedSessions: new Set(),
+
+  // Session activity tracking for cleanup
+  sessionActivity: new Map(), // sessionId -> lastActivityTimestamp
+
+  // Heartbeat tracking: session_id -> { count, lastSent }
+  heartbeatState: new Map(),
+
+  // Transcript ingestion throttling: Map<session_id, Promise>
+  ingestionInProgress: new Map(),
+
+  // Approval queue: FIFO queue of pending approvals
+  approvalQueue: [],
+
+  // Execution tracking: approval_id -> execution details
+  executions: new Map(),
+
+  // Tracking last time we had any registered sessions
+  lastSessionActivityAt: Date.now(),
+  
+  // Shutdown flag
+  isShuttingDown: false
+});