teleportation-cli 1.1.5 → 1.2.0

package/lib/daemon/lifecycle.js

@@ -1,132 +1,74 @@
-import { spawn } from 'child_process';
+/**
+ * Daemon Lifecycle Management
+ *
+ * Thin adapter over @derivativelabs/agent-process.
+ * Provides startDaemon/stopDaemon/restartDaemon/getDaemonStatus
+ * for the CLI and daemon-commands module.
+ *
+ * PRD-0025: Replaced custom pid-manager.js with agent-process platform-native
+ * service management (launchd/systemd/pm2).
+ */
+
+import { agentStart, agentStop, agentStatus } from '@derivativelabs/agent-process';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import {
-  checkDaemonStatus,
-  acquirePidLock,
-  releasePidLock,
-  isProcessRunning
-} from './pid-manager.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-// Path to daemon entry point (relative to lifecycle.js location)
+const AGENT_NAME = 'teleportation-daemon';
 const DAEMON_SCRIPT = join(__dirname, 'teleportation-daemon.js');
 
 /**
- * Start the daemon process
- * @param {Object} options - Start options
- * @param {boolean} options.detached - Run daemon as detached process (default: true)
- * @param {boolean} options.silent - Suppress output (default: true)
+ * Start the daemon process via agent-process
+ * @param {Object} options - Start options (kept for backward compat)
+ * @param {boolean} options.detached - Ignored (agent-process handles this)
+ * @param {boolean} options.silent - Ignored (agent-process handles this)
  * @returns {Promise<{pid: number, success: boolean}>}
  */
 export async function startDaemon(options = {}) {
-  const { detached = true, silent = true } = options;
-
-  // Check if daemon is already running
-  const status = await checkDaemonStatus();
-  if (status.running) {
-    throw new Error(`Daemon already running with PID ${status.pid}`);
-  }
-
-  // Clean up stale PID file if exists
-  if (status.stale) {
-    await releasePidLock(status.pid);
+  // Check if already running
+  const current = await getDaemonStatus();
+  if (current.running) {
+    throw new Error(`Daemon already running with PID ${current.pid}`);
   }
 
-  // Spawn daemon process
-  const child = spawn(
-    process.execPath, // Use same Node.js executable
-    [DAEMON_SCRIPT],
-    {
-      detached,
-      stdio: silent ? 'ignore' : 'inherit',
-      env: {
-        ...process.env,
-        TELEPORTATION_DAEMON: 'true'
-      }
+  const result = await agentStart({
+    name: AGENT_NAME,
+    script: DAEMON_SCRIPT,
+    env: {
+      ...process.env,
+      TELEPORTATION_DAEMON: 'true',
+      DAEMON_IDLE_TIMEOUT_MS: process.env.DAEMON_IDLE_TIMEOUT_MS || '0'
     }
-  );
-
-  // Detach from parent if requested
-  if (detached) {
-    child.unref();
-  }
-
-  // Wait a moment to ensure process started (increase wait time for CI)
-  await new Promise(resolve => setTimeout(resolve, 1000));
-
-  // Verify daemon is running (check multiple times for slow CI)
-  let newStatus = await checkDaemonStatus();
-  if (!newStatus.running) {
-    // Wait a bit more and check again
-    await new Promise(resolve => setTimeout(resolve, 1000));
-    newStatus = await checkDaemonStatus();
-    if (!newStatus.running) {
-      throw new Error('Daemon failed to start');
-    }
-  }
+  });
 
   return {
-    pid: child.pid,
+    pid: result.pid || null,
     success: true
   };
 }
 
 /**
- * Stop the daemon process
+ * Stop the daemon process via agent-process
  * @param {Object} options - Stop options
  * @param {number} options.timeout - Timeout in ms for graceful shutdown (default: 5000)
  * @param {boolean} options.force - Force kill if graceful shutdown fails (default: true)
  * @returns {Promise<{success: boolean, forced: boolean}>}
  */
 export async function stopDaemon(options = {}) {
-  const { timeout = 5000, force = true } = options;
-
-  // Check daemon status
-  const status = await checkDaemonStatus();
-  if (!status.running) {
+  const current = await getDaemonStatus();
+  if (!current.running) {
     return { success: true, forced: false };
   }
 
-  const { pid } = status;
-
   try {
-    // Send SIGTERM for graceful shutdown
-    process.kill(pid, 'SIGTERM');
-
-    // Wait for process to exit
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
-      if (!isProcessRunning(pid)) {
-        await releasePidLock(pid);
-        return { success: true, forced: false };
-      }
-      await new Promise(resolve => setTimeout(resolve, 100));
-    }
-
-    // Timeout reached, force kill if requested
-    if (force) {
-      process.kill(pid, 'SIGKILL');
-
-      // Wait a moment for kill to take effect
-      await new Promise(resolve => setTimeout(resolve, 200));
-
-      if (!isProcessRunning(pid)) {
-        await releasePidLock(pid);
-        return { success: true, forced: true };
-      }
-
-      throw new Error('Failed to kill daemon process');
-    }
-
-    return { success: false, forced: false };
+    await agentStop(AGENT_NAME);
+    return { success: true, forced: false };
   } catch (err) {
-    // Process might have already exited
-    if (err.code === 'ESRCH') {
-      await releasePidLock(pid);
-      return { success: true, forced: false };
+    if (options.force !== false) {
+      // agent-process handles force kill internally
+      return { success: true, forced: true };
     }
     throw err;
   }
@@ -142,16 +84,13 @@ export async function stopDaemon(options = {}) {
 export async function restartDaemon(options = {}) {
   const { stopTimeout = 5000, force = true } = options;
 
-  // Check if daemon is running
-  const status = await checkDaemonStatus();
-  const wasRunning = status.running;
+  const current = await getDaemonStatus();
+  const wasRunning = current.running;
 
-  // Stop daemon if running
   if (wasRunning) {
     await stopDaemon({ timeout: stopTimeout, force });
   }
 
-  // Start daemon
   const result = await startDaemon();
 
   return {
@@ -192,7 +131,7 @@ async function updateSessionDaemonState(sessionId, updates) {
 }
 
 export async function startDaemonIfNeeded(sessionId, reason = 'manual') {
-  const status = await checkDaemonStatus();
+  const status = await getDaemonStatus();
 
   if (!status.running) {
     await startDaemon();
@@ -207,12 +146,11 @@ export async function startDaemonIfNeeded(sessionId, reason = 'manual') {
 }
 
 export async function stopDaemonIfNeeded(sessionId, reason = 'manual_stop') {
-  const status = await checkDaemonStatus();
+  const status = await getDaemonStatus();
   if (!status.running) {
     return { stopped: false, reason: 'not_running' };
   }
 
-  // If relay is configured, check if other sessions still have daemon running
   const { url, key } = getRelayConfig();
   if (url && key) {
     try {
@@ -232,20 +170,17 @@ export async function stopDaemonIfNeeded(sessionId, reason = 'manual_stop') {
         }
       }
     } catch (err) {
-      // Fail open: if we can't query sessions, we still attempt to stop daemon
       if (process.env.DEBUG) {
         console.error('[lifecycle] Failed to query sessions before stop:', err.message);
       }
     }
   }
 
-  // Update daemon_state before stopping
   if (sessionId) {
     await updateSessionDaemonState(sessionId, {
       status: 'stopped',
       started_reason: null,
       is_away: false
-      // stopped_reason could be added later if DaemonState schema is extended
     });
   }
 
@@ -254,83 +189,33 @@ export async function stopDaemonIfNeeded(sessionId, reason = 'manual_stop') {
 }
 
 /**
- * Get daemon status
+ * Get daemon status via agent-process
  * @returns {Promise<{running: boolean, pid: number|null, uptime: number|null}>}
  */
 export async function getDaemonStatus() {
-  const status = await checkDaemonStatus();
-
-  // TODO: Add uptime calculation once daemon stores start time
-  // For now, we can only report running status and PID
-  return {
-    running: status.running,
-    pid: status.pid,
-    uptime: null // Will be implemented when daemon stores start timestamp
-  };
+  try {
+    const status = await agentStatus(AGENT_NAME);
+    return {
+      running: status.state === 'online' || status.running || false,
+      pid: status.pid || null,
+      uptime: status.uptime || null
+    };
+  } catch (err) {
+    return { running: false, pid: null, uptime: null };
+  }
 }
 
 /**
- * Setup signal handlers for graceful daemon shutdown
- * @param {Function} cleanupCallback - Async function to call before exit
+ * Alias for getDaemonStatus (backward compat with pid-manager API)
  */
-export function setupSignalHandlers(cleanupCallback) {
-  const handleSignal = async (signal) => {
-    console.log(`Received ${signal}, shutting down gracefully...`);
-
-    try {
-      // Run cleanup callback
-      if (cleanupCallback) {
-        await cleanupCallback();
-      }
-
-      // Release PID lock
-      await releasePidLock(process.pid);
-
-      process.exit(0);
-    } catch (err) {
-      console.error('Error during cleanup:', err);
-      process.exit(1);
-    }
-  };
-
-  // Handle termination signals
-  process.on('SIGTERM', () => handleSignal('SIGTERM'));
-  process.on('SIGINT', () => handleSignal('SIGINT'));
-
-  // Handle uncaught errors
-  process.on('uncaughtException', async (err) => {
-    console.error('Uncaught exception:', err);
-    try {
-      if (cleanupCallback) {
-        await cleanupCallback();
-      }
-      await releasePidLock(process.pid);
-    } catch (cleanupErr) {
-      console.error('Error during cleanup:', cleanupErr);
-    }
-    process.exit(1);
-  });
-
-  process.on('unhandledRejection', async (reason) => {
-    console.error('Unhandled rejection:', reason);
-    try {
-      if (cleanupCallback) {
-        await cleanupCallback();
-      }
-      await releasePidLock(process.pid);
-    } catch (cleanupErr) {
-      console.error('Error during cleanup:', cleanupErr);
-    }
-    process.exit(1);
-  });
-}
+export const checkDaemonStatus = getDaemonStatus;
 
 export default {
   startDaemon,
   stopDaemon,
   restartDaemon,
   getDaemonStatus,
-  setupSignalHandlers,
+  checkDaemonStatus,
   startDaemonIfNeeded,
   stopDaemonIfNeeded
 };

package/lib/daemon/services/index.js

@@ -0,0 +1,3 @@
+export { SessionService } from './session-service.js';
+export { QueueService } from './queue-service.js';
+export { PollingService } from './polling-service.js';

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

@@ -0,0 +1,173 @@
+/**
+ * Polling Service
+ * 
+ * Periodically polls the relay API for updates.
+ */
+
+import { executeTaskTurn } from '../task-executor-v2.js';
+import { ingestTranscriptToTimeline } from '../transcript-ingestion.js';
+import { debugLog } from '../utils.js';
+
+export class PollingService {
+  constructor(state, config) {
+    this.name = 'polling';
+    this.state = state;
+    this.config = config;
+  }
+
+  async start(ctx) {
+    this.ctx = ctx;
+    console.log('[PollingService] Started');
+  }
+
+  async stop() {
+    console.log('[PollingService] Stopped');
+  }
+
+  getStats() {
+    return {
+      ingestionsInProgress: this.state.ingestionInProgress.size
+    };
+  }
+
+  /**
+   * Main polling loop iteration
+   */
+  async poll() {
+    if (this.state.isShuttingDown) return;
+
+    for (const [session_id, sessionData] of this.state.sessions) {
+      this.state.sessionActivity.set(session_id, Date.now());
+
+      // 1) Poll Approvals
+      await this.pollApprovals(session_id);
+
+      // 2) Poll Inbox Messages
+      await this.pollInbox(session_id);
+
+      // 3) Poll Tasks
+      await this.pollTasks(session_id);
+
+      // 4) Transcript Ingestion
+      await this.runTranscriptIngestion(session_id, sessionData);
+    }
+  }
+
+  async pollApprovals(session_id) {
+    if (!this.config.relayApiUrl || !this.config.relayApiKey) return;
+    try {
+      const response = await fetch(
+        `${this.config.relayApiUrl}/api/approvals?status=allowed&session_id=${session_id}`,
+        { headers: { 'Authorization': `Bearer ${this.config.relayApiKey}` } }
+      );
+
+      if (response.ok) {
+        const approvals = await response.json();
+        for (const approval of approvals) {
+          if (this.state.approvalQueue.find(a => a.approval_id === approval.id)) continue;
+          if (this.state.executions.has(approval.id)) continue;
+          if (approval.acknowledgedAt || approval.decision_location) continue;
+
+          this.state.approvalQueue.push({
+            approval_id: approval.id,
+            session_id: approval.session_id,
+            tool_name: approval.tool_name,
+            tool_input: approval.tool_input,
+            queued_at: Date.now(),
+            tool_use_id: approval.tool_use_id || null,
+            conversation_context: approval.conversation_context || null
+          });
+
+          console.log(`[PollingService] Approval discovered: ${approval.id} (${approval.tool_name})`);
+        }
+      }
+    } catch (err) {
+      console.error(`[PollingService] Approval polling error: ${err.message}`);
+    }
+  }
+
+  async pollInbox(session_id) {
+    if (!this.config.relayApiUrl || !this.config.relayApiKey) return;
+    try {
+      const response = await fetch(
+        `${this.config.relayApiUrl}/api/messages/pending?session_id=${encodeURIComponent(session_id)}&agent_id=daemon`,
+        { headers: { 'Authorization': `Bearer ${this.config.relayApiKey}` } }
+      );
+
+      if (response.ok) {
+        const inboxMessage = await response.json();
+        if (inboxMessage && inboxMessage.id && inboxMessage.text) {
+          // Note: handleInboxMessage logic should be here or in another service
+          // For now, we'll just log it. In a full refactor, we'd move the handler too.
+          console.log(`[PollingService] Inbox message discovered for ${session_id}: ${inboxMessage.id}`);
+        }
+      }
+    } catch (err) {
+      // 404 is expected if no pending messages
+      if (err.status !== 404) {
+        console.error(`[PollingService] Inbox polling error: ${err.message}`);
+      }
+    }
+  }
+
+  async pollTasks(session_id) {
+    if (!this.config.relayApiUrl || !this.config.relayApiKey) return;
+    try {
+      const response = await fetch(
+        `${this.config.relayApiUrl}/api/sessions/${encodeURIComponent(session_id)}/tasks`,
+        { headers: { 'Authorization': `Bearer ${this.config.relayApiKey}` } }
+      );
+
+      if (response.ok) {
+        const tasks = await response.json();
+        for (const task of tasks) {
+          if (task.status === 'stopped' || task.status === 'completed') continue;
+
+          try {
+            const result = await executeTaskTurn({
+              task_id: task.id,
+              session_id: task.session_id,
+              config: {
+                relayApiUrl: this.config.relayApiUrl,
+                apiKey: this.config.relayApiKey
+              }
+            });
+            
+            if (result.executed) {
+              console.log(`[PollingService] Task ${task.id.slice(0, 8)}... executed turn`);
+            }
+          } catch (err) {
+            console.error(`[PollingService] Task execution error: ${err.message}`);
+          }
+        }
+      }
+    } catch (err) {
+      console.error(`[PollingService] Task polling error: ${err.message}`);
+    }
+  }
+
+  async runTranscriptIngestion(session_id, sessionData) {
+    if (this.state.ingestionInProgress.has(session_id)) return;
+
+    const claude_session_id = sessionData.claude_session_id || session_id;
+    const cwd = sessionData.cwd || process.cwd();
+
+    const promise = ingestTranscriptToTimeline({
+      claude_session_id,
+      parent_session_id: session_id,
+      task_id: null,
+      cwd,
+      config: {
+        relayApiUrl: this.config.relayApiUrl,
+        apiKey: this.config.relayApiKey
+      },
+      maxEvents: 100
+    }).catch(err => {
+      console.error(`[PollingService] Ingestion error: ${err.message}`);
+    }).finally(() => {
+      this.state.ingestionInProgress.delete(session_id);
+    });
+
+    this.state.ingestionInProgress.set(session_id, promise);
+  }
+}