@dynamicu/chromedebug-mcp 2.2.0

package/src/services/process-tracker.js

@@ -0,0 +1,574 @@
+/**
+ * Process Tracker - Safe process management for ChromeDebug MCP
+ * Only tracks and manages processes explicitly registered by this application
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+// Global session ID for this process
+let currentSessionId = null;
+
+/**
+ * Get or generate a session ID for this process
+ */
+function getSessionId() {
+  if (!currentSessionId) {
+    currentSessionId = crypto.randomBytes(8).toString('hex');
+  }
+  return currentSessionId;
+}
+
+/**
+ * Set a custom session ID (used for coordinated multi-session environments)
+ */
+export function setSessionId(sessionId) {
+  if (typeof sessionId === 'string' && sessionId.match(/^[a-zA-Z0-9_-]+$/)) {
+    currentSessionId = sessionId;
+    console.log(`ChromeDebug session ID set to: ${sessionId}`);
+  } else {
+    throw new Error('Session ID must be alphanumeric with dashes/underscores only');
+  }
+}
+
+/**
+ * Get the session-specific PID file path
+ */
+function getPidFilePath() {
+  const sessionId = getSessionId();
+  return path.join(os.tmpdir(), `.chromedebug-pids-${sessionId}.json`);
+}
+
+/**
+ * Safely validates a process ID to prevent injection attacks
+ */
+function validateProcessId(pid) {
+  const pidStr = String(pid).trim();
+  if (!/^\d+$/.test(pidStr)) {
+    return null;
+  }
+
+  const numericPid = parseInt(pidStr, 10);
+  if (isNaN(numericPid) || numericPid <= 0 || numericPid > 4194304) {
+    return null;
+  }
+  return numericPid;
+}
+
+/**
+ * Read the PID tracking file for this session
+ */
+function readPidFile() {
+  const pidFilePath = getPidFilePath();
+  try {
+    if (fs.existsSync(pidFilePath)) {
+      const data = fs.readFileSync(pidFilePath, 'utf8');
+      const parsed = JSON.parse(data);
+      return {
+        processes: parsed.processes || [],
+        sessionId: parsed.sessionId || getSessionId(),
+        lastUpdated: parsed.lastUpdated || new Date().toISOString()
+      };
+    }
+  } catch (error) {
+    console.error(`Failed to read PID file ${pidFilePath}:`, error);
+  }
+  return {
+    processes: [],
+    sessionId: getSessionId(),
+    lastUpdated: new Date().toISOString()
+  };
+}
+
+/**
+ * Write the PID tracking file for this session
+ */
+function writePidFile(data) {
+  const pidFilePath = getPidFilePath();
+  try {
+    const content = {
+      ...data,
+      sessionId: getSessionId(),
+      lastUpdated: new Date().toISOString()
+    };
+    fs.writeFileSync(pidFilePath, JSON.stringify(content, null, 2));
+  } catch (error) {
+    console.error(`Failed to write PID file ${pidFilePath}:`, error);
+  }
+}
+
+/**
+ * Register a process for tracking
+ */
+export function registerProcess(pid, type = 'unknown') {
+  const validatedPid = validateProcessId(pid);
+  if (!validatedPid) {
+    console.error(`Cannot register invalid process ID: ${pid}`);
+    return false;
+  }
+
+  const data = readPidFile();
+
+  // Check if already registered
+  const existing = data.processes.find(p => p.pid === validatedPid);
+  if (existing) {
+    return true;
+  }
+
+  // Add new process
+  data.processes.push({
+    pid: validatedPid,
+    type,
+    startTime: new Date().toISOString(),
+    command: process.argv.join(' ')
+  });
+
+  writePidFile(data);
+  console.log(`Registered ChromeDebug process: PID ${validatedPid} (${type})`);
+  return true;
+}
+
+/**
+ * Unregister a process from tracking
+ */
+export function unregisterProcess(pid) {
+  const validatedPid = validateProcessId(pid);
+  if (!validatedPid) {
+    return false;
+  }
+
+  const data = readPidFile();
+  const initialLength = data.processes.length;
+  data.processes = data.processes.filter(p => p.pid !== validatedPid);
+
+  if (data.processes.length < initialLength) {
+    writePidFile(data);
+    console.log(`Unregistered ChromeDebug process: PID ${validatedPid}`);
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Get all registered processes
+ */
+export function getRegisteredProcesses() {
+  return readPidFile().processes;
+}
+
+/**
+ * Check if a process is still running
+ */
+function isProcessRunning(pid) {
+  try {
+    // process.kill with signal 0 checks if process exists without killing it
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Clean up dead processes from tracking file
+ */
+export function cleanupDeadProcesses() {
+  const data = readPidFile();
+  const initialCount = data.processes.length;
+
+  if (initialCount === 0) {
+    return 0;
+  }
+
+  const aliveProcesses = [];
+  let removedCount = 0;
+
+  for (const proc of data.processes) {
+    if (isProcessRunning(proc.pid)) {
+      aliveProcesses.push(proc);
+    } else {
+      console.log(`Removing dead process from tracking: PID ${proc.pid} (${proc.type})`);
+      removedCount++;
+    }
+  }
+
+  if (removedCount > 0) {
+    data.processes = aliveProcesses;
+    writePidFile(data);
+    console.log(`Cleaned up ${removedCount} dead processes from tracking`);
+  }
+
+  return removedCount;
+}
+
+/**
+ * Kill a registered process safely
+ */
+export async function killRegisteredProcess(pid, signal = 'SIGTERM') {
+  const validatedPid = validateProcessId(pid);
+  if (!validatedPid) {
+    return false;
+  }
+
+  // Check if process is registered
+  const data = readPidFile();
+  const registered = data.processes.find(p => p.pid === validatedPid);
+  if (!registered) {
+    console.error(`Process ${validatedPid} is not registered with ChromeDebug`);
+    return false;
+  }
+
+  try {
+    process.kill(validatedPid, signal);
+    console.log(`Sent ${signal} to registered ChromeDebug process: PID ${validatedPid}`);
+
+    // If successful and using SIGKILL, unregister immediately
+    if (signal === 'SIGKILL') {
+      unregisterProcess(validatedPid);
+    }
+
+    return true;
+  } catch (error) {
+    if (error.code === 'ESRCH') {
+      // Process doesn't exist, remove from tracking
+      unregisterProcess(validatedPid);
+      return true;
+    } else if (error.code === 'EPERM') {
+      console.error(`Permission denied killing process ${validatedPid}`);
+      return false;
+    } else {
+      console.error(`Error killing process ${validatedPid}: ${error.message}`);
+      return false;
+    }
+  }
+}
+
+/**
+ * Kill all registered ChromeDebug processes
+ */
+export async function killAllRegisteredProcesses() {
+  const processes = getRegisteredProcesses();
+  const results = {
+    killed: [],
+    failed: [],
+    total: processes.length
+  };
+
+  if (processes.length === 0) {
+    console.log('No registered ChromeDebug processes to kill');
+    return results;
+  }
+
+  console.log(`Found ${processes.length} registered ChromeDebug processes, cleaning up...`);
+
+  // First try SIGTERM for graceful shutdown
+  for (const proc of processes) {
+    const success = await killRegisteredProcess(proc.pid, 'SIGTERM');
+    if (success) {
+      results.killed.push(proc.pid);
+    } else {
+      results.failed.push(proc.pid);
+    }
+  }
+
+  // Wait for graceful shutdown
+  if (results.failed.length > 0) {
+    console.log('Waiting 2 seconds for graceful shutdown...');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // Try SIGKILL for remaining processes
+    const stillRunning = results.failed.slice();
+    results.failed = [];
+
+    for (const pid of stillRunning) {
+      const success = await killRegisteredProcess(pid, 'SIGKILL');
+      if (success) {
+        const index = results.killed.indexOf(pid);
+        if (index === -1) {
+          results.killed.push(pid);
+        }
+      } else {
+        results.failed.push(pid);
+      }
+    }
+  }
+
+  // Clean up the tracking file
+  cleanupDeadProcesses();
+
+  return results;
+}
+
+/**
+ * Find ChromeDebug processes using pattern matching (for untracked processes)
+ * This is a fallback for processes started before tracking was implemented
+ */
+export async function findUntrackedChromePilotProcesses() {
+  const currentPid = process.pid;
+  const foundProcesses = [];
+
+  try {
+    const { spawn } = await import('child_process');
+
+    return new Promise((resolve) => {
+      const ps = spawn('ps', ['aux'], { stdio: ['ignore', 'pipe', 'ignore'] });
+      let stdout = '';
+
+      ps.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      ps.on('close', (code) => {
+        if (code !== 0) {
+          console.error('Failed to get process list');
+          resolve([]);
+          return;
+        }
+
+        const lines = stdout.trim().split('\n');
+        const registeredPids = new Set(getRegisteredProcesses().map(p => p.pid));
+
+        for (const line of lines) {
+          const parts = line.trim().split(/\s+/);
+          if (parts.length < 2) continue;
+
+          const pid = validateProcessId(parts[1]);
+          if (!pid || pid === currentPid) continue;
+
+          // Skip processes that are already registered
+          if (registeredPids.has(pid)) continue;
+
+          // Check if it's a ChromeDebug/ChromePilot process
+          let processType = '';
+          if (line.includes('src/index.js')) {
+            processType = 'untracked-mcp-server';
+          } else if (line.includes('src/http-server.js')) {
+            processType = 'untracked-http-server';
+          } else if (line.includes('standalone-server.js')) {
+            processType = 'untracked-standalone-server';
+          } else if (line.includes('chromedebug-mcp') && line.includes('node')) {
+            processType = 'untracked-chromedebug-process';
+          }
+
+          if (processType) {
+            foundProcesses.push({
+              pid,
+              type: processType,
+              description: `${processType} (PID: ${pid})`,
+              commandLine: line
+            });
+          }
+        }
+
+        resolve(foundProcesses);
+      });
+
+      ps.on('error', (error) => {
+        console.error('Error running ps command:', error);
+        resolve([]);
+      });
+    });
+  } catch (error) {
+    console.error('Error finding untracked ChromePilot processes:', error);
+    return [];
+  }
+}
+
+/**
+ * Kill untracked ChromeDebug processes (emergency cleanup)
+ */
+export async function killUntrackedChromePilotProcesses() {
+  const untrackedProcesses = await findUntrackedChromePilotProcesses();
+  const results = {
+    found: untrackedProcesses,
+    killed: [],
+    failed: [],
+    total: untrackedProcesses.length
+  };
+
+  if (untrackedProcesses.length === 0) {
+    console.log('No untracked ChromeDebug processes found');
+    return results;
+  }
+
+  console.log(`Found ${untrackedProcesses.length} untracked ChromeDebug processes:`);
+  untrackedProcesses.forEach(proc => {
+    console.log(`  - ${proc.description}`);
+  });
+
+  // Try SIGTERM first
+  for (const proc of untrackedProcesses) {
+    try {
+      process.kill(proc.pid, 'SIGTERM');
+      console.log(`Sent SIGTERM to untracked process: PID ${proc.pid}`);
+      results.killed.push(proc.pid);
+    } catch (error) {
+      if (error.code === 'ESRCH') {
+        // Process doesn't exist, count as success
+        results.killed.push(proc.pid);
+      } else {
+        console.error(`Failed to kill process ${proc.pid}: ${error.message}`);
+        results.failed.push(proc.pid);
+      }
+    }
+  }
+
+  // Wait for graceful shutdown
+  if (results.failed.length > 0) {
+    console.log('Waiting 2 seconds for graceful shutdown...');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // Try SIGKILL for remaining processes
+    const stillFailed = [];
+    for (const pid of results.failed) {
+      try {
+        process.kill(pid, 'SIGKILL');
+        console.log(`Sent SIGKILL to stubborn process: PID ${pid}`);
+        // Move from failed to killed
+        const index = results.failed.indexOf(pid);
+        results.failed.splice(index, 1);
+        if (!results.killed.includes(pid)) {
+          results.killed.push(pid);
+        }
+      } catch (error) {
+        if (error.code !== 'ESRCH') {
+          stillFailed.push(pid);
+        }
+      }
+    }
+    results.failed = stillFailed;
+  }
+
+  return results;
+}
+
+/**
+ * Register current process and set up cleanup on exit
+ */
+export function setupProcessTracking(type = 'mcp-server') {
+  const currentPid = process.pid;
+
+  // Clean up any dead processes first
+  cleanupDeadProcesses();
+
+  // Register this process
+  const registered = registerProcess(currentPid, type);
+  if (!registered) {
+    console.error(`Failed to register process ${currentPid} for tracking`);
+    return currentPid;
+  }
+
+  // Set up robust cleanup on process exit
+  const cleanup = (reason = 'unknown') => {
+    try {
+      console.log(`Process ${currentPid} exiting (${reason}), cleaning up...`);
+      unregisterProcess(currentPid);
+    } catch (error) {
+      console.error(`Error during process cleanup: ${error.message}`);
+    }
+  };
+
+  // Handle various exit scenarios
+  process.on('exit', () => cleanup('exit'));
+  process.on('SIGINT', () => {
+    cleanup('SIGINT');
+    process.exit(0);
+  });
+  process.on('SIGTERM', () => {
+    cleanup('SIGTERM');
+    process.exit(0);
+  });
+  process.on('SIGHUP', () => {
+    cleanup('SIGHUP');
+    process.exit(0);
+  });
+  process.on('uncaughtException', (error) => {
+    console.error('Uncaught exception:', error);
+    cleanup('uncaughtException');
+    process.exit(1);
+  });
+  process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled rejection at:', promise, 'reason:', reason);
+    cleanup('unhandledRejection');
+    process.exit(1);
+  });
+
+  console.log(`Process tracking setup complete for PID ${currentPid} (${type}) [Session: ${getSessionId()}]`);
+  return currentPid;
+}
+
+/**
+ * Setup process tracking with enhanced session isolation options
+ */
+export function setupProcessTrackingWithOptions(type = 'mcp-server', options = {}) {
+  const {
+    sessionId,
+    skipCleanup = false,
+    verbose = false
+  } = options;
+
+  // Set session ID if provided
+  if (sessionId) {
+    setSessionId(sessionId);
+  }
+
+  const currentSessionId = getSessionId();
+
+  if (verbose) {
+    console.log(`ChromeDebug MCP starting with session ID: ${currentSessionId}`);
+    console.log(`Skip cleanup: ${skipCleanup}`);
+  }
+
+  // Optionally skip cleanup of dead processes
+  if (!skipCleanup) {
+    const removedCount = cleanupDeadProcesses();
+    if (removedCount > 0 && verbose) {
+      console.log(`Cleaned up ${removedCount} dead processes from session ${currentSessionId}`);
+    }
+  }
+
+  // Setup tracking for this process
+  return setupProcessTracking(type);
+}
+
+/**
+ * Get current session information
+ */
+export function getSessionInfo() {
+  const sessionId = getSessionId();
+  const data = readPidFile();
+  return {
+    sessionId,
+    pidFile: getPidFilePath(),
+    processes: data.processes,
+    processCount: data.processes.length,
+    lastUpdated: data.lastUpdated
+  };
+}
+
+/**
+ * Clean up all session files and processes for this session
+ */
+export async function cleanupCurrentSession() {
+  const sessionId = getSessionId();
+  console.log(`Cleaning up session: ${sessionId}`);
+
+  // Kill all processes in this session
+  const results = await killAllRegisteredProcesses();
+
+  // Remove the PID file
+  const pidFilePath = getPidFilePath();
+  try {
+    if (fs.existsSync(pidFilePath)) {
+      fs.unlinkSync(pidFilePath);
+      console.log(`Removed session PID file: ${pidFilePath}`);
+    }
+  } catch (error) {
+    console.error(`Failed to remove PID file: ${error.message}`);
+  }
+
+  return results;
+}