devchain-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,782 @@
+#!/usr/bin/env node
+/**
+ * Devchain CLI
+ * start command: boots the local app API + UI, picks a port, and opens browser.
+ */
+
+/* eslint-disable no-console */
+
+const { Command } = require('commander');
+const getPort = require('get-port');
+const open = require('open');
+const { join, dirname, basename } = require('path');
+const { existsSync, writeFileSync, readFileSync, unlinkSync, mkdirSync } = require('fs');
+const { homedir, platform } = require('os');
+const { spawn, execSync } = require('child_process');
+const { InteractiveCLI } = require('./lib/interactive-cli');
+
+async function waitForHealth(url, { timeoutMs = 15000, intervalMs = 250 } = {}) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(url);
+      if (res.ok) {
+        return true;
+      }
+    } catch (_) {
+      // not ready yet
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return false;
+}
+
+function resolveOpenOptions() {
+  const val = process.env.DEVCHAIN_BROWSER || process.env.BROWSER;
+  if (val && typeof val === 'string' && val.trim()) {
+    const parts = val.trim().split(/\s+/);
+    return { app: { name: parts[0], arguments: parts.slice(1) } };
+  }
+  return {};
+}
+
+async function fetchWithTimeout(url, options = {}, timeoutMs = 2000) {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, { ...(options || {}), signal: controller.signal });
+    return res;
+  } finally {
+    clearTimeout(id);
+  }
+}
+
+function isBinaryInstalled(cmd) {
+  try {
+    const out = execSync(`which ${cmd}`, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+      .trim();
+    return out || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function detectInstalledProviders() {
+  const detected = new Map();
+  const codexPath = isBinaryInstalled('codex');
+  const claudePath = isBinaryInstalled('claude');
+  if (codexPath) detected.set('codex', codexPath);
+  if (claudePath) detected.set('claude', claudePath);
+  return detected; // Map<name, absolutePath>
+}
+
+async function ensureProvidersInDb(baseUrl, detected, log) {
+  try {
+    const res = await fetch(`${baseUrl}/api/providers`);
+    if (!res.ok) {
+      log('warn', 'Failed to fetch providers; skipping ensure');
+      return;
+    }
+    const data = await res.json();
+    const existing = new Set((data?.items || []).map((p) => p.name));
+    const toCreate = Array.from(detected.keys()).filter((n) => !existing.has(n));
+    for (const name of toCreate) {
+      const body = {
+        name,
+        // pass command name to allow normalization; controller validates presence on PATH
+        binPath: name,
+      };
+      try {
+        const createRes = await fetch(`${baseUrl}/api/providers`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(body),
+        });
+        if (createRes.ok) {
+          log('info', 'Created provider', { name });
+        } else {
+          const errText = await createRes.text();
+          log('warn', 'Failed to create provider', { name, status: createRes.status, errText });
+        }
+      } catch (e) {
+        log('warn', 'Error creating provider', { name, error: e instanceof Error ? e.message : String(e) });
+      }
+    }
+  } catch (e) {
+    log('warn', 'Provider DB ensure failed', { error: e instanceof Error ? e.message : String(e) });
+  }
+}
+
+async function validateMcpForProviders(baseUrl, cli, opts, log, projectPath) {
+  try {
+    // Fetch all providers
+    const res = await fetch(`${baseUrl}/api/providers`);
+    if (!res.ok) {
+      if (opts.foreground) {
+        log('warn', 'Failed to fetch providers for MCP validation; skipping', { status: res.status });
+      } else {
+        cli.warn('Skipping MCP validation (failed to fetch providers)');
+      }
+      return;
+    }
+
+    const data = await res.json();
+    const providers = data?.items || [];
+    if (providers.length === 0) {
+      if (opts.foreground) {
+        log('info', 'No providers to validate for MCP');
+      }
+      return;
+    }
+
+    // Interactive: show spinner
+    const spinner = opts.foreground ? null : cli.spinner('Validating MCP');
+    if (spinner) spinner.start();
+
+    const results = [];
+    for (const provider of providers) {
+      try {
+        const body = projectPath ? JSON.stringify({ projectPath }) : JSON.stringify({});
+        const ensureRes = await fetch(`${baseUrl}/api/providers/${provider.id}/mcp/ensure`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body,
+        });
+
+        if (ensureRes.ok) {
+          const result = await ensureRes.json();
+          results.push({
+            name: provider.name,
+            action: result.action,
+            success: true,
+            endpoint: result.endpoint,
+          });
+
+          if (opts.foreground) {
+            log('info', 'MCP validation complete', {
+              provider: provider.name,
+              action: result.action,
+              endpoint: result.endpoint,
+            });
+          }
+        } else {
+          const errText = await ensureRes.text();
+          results.push({
+            name: provider.name,
+            success: false,
+            error: errText,
+          });
+
+          if (opts.foreground) {
+            log('warn', 'MCP validation failed', {
+              provider: provider.name,
+              status: ensureRes.status,
+              error: errText,
+            });
+          }
+        }
+      } catch (e) {
+        results.push({
+          name: provider.name,
+          success: false,
+          error: e instanceof Error ? e.message : String(e),
+        });
+
+        if (opts.foreground) {
+          log('warn', 'MCP validation error', {
+            provider: provider.name,
+            error: e instanceof Error ? e.message : String(e),
+          });
+        }
+      }
+    }
+
+    if (spinner) spinner.stop('✓');
+
+    // Display results in interactive mode
+    if (!opts.foreground) {
+      for (const result of results) {
+        if (result.success) {
+          const actionText = {
+            added: 'configured',
+            fixed_mismatch: 'fixed',
+            already_configured: 'ready',
+          }[result.action] || result.action;
+          cli.success(`${result.name}: ${actionText}`);
+        } else {
+          cli.error(`${result.name}: validation failed`);
+        }
+      }
+    }
+  } catch (e) {
+    if (opts.foreground) {
+      log('warn', 'MCP validation step failed', { error: e instanceof Error ? e.message : String(e) });
+    } else {
+      cli.warn('MCP validation failed');
+    }
+  }
+}
+
+function parseDbPath(db) {
+  if (!db) return {};
+  // If a directory was provided, use it as DB_PATH and keep default filename
+  // If a file path was provided, split into dir + filename
+  try {
+    const dir = dirname(db);
+    const file = basename(db);
+    const looksLikeFile = /\.[a-zA-Z0-9]+$/.test(file);
+    if (looksLikeFile) {
+      return { DB_PATH: dir, DB_FILENAME: file };
+    }
+    return { DB_PATH: db };
+  } catch {
+    return {};
+  }
+}
+
+function getPidFilePath() {
+  const devchainDir = join(homedir(), '.devchain');
+  if (!existsSync(devchainDir)) {
+    mkdirSync(devchainDir, { recursive: true });
+  }
+  return join(devchainDir, 'devchain.pid');
+}
+
+function writePidFile(port) {
+  const pidFile = getPidFilePath();
+  const data = JSON.stringify({ pid: process.pid, port, timestamp: Date.now() });
+  writeFileSync(pidFile, data, 'utf8');
+}
+
+function readPidFile() {
+  const pidFile = getPidFilePath();
+  if (!existsSync(pidFile)) {
+    return null;
+  }
+  try {
+    const data = readFileSync(pidFile, 'utf8');
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+function removePidFile() {
+  const pidFile = getPidFilePath();
+  if (existsSync(pidFile)) {
+    unlinkSync(pidFile);
+  }
+}
+
+function isProcessRunning(pid) {
+  try {
+    // Sending signal 0 checks if process exists without killing it
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isTmuxInstalled() {
+  try {
+    execSync('which tmux', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getOSType() {
+  const plat = platform();
+  if (plat === 'darwin') return 'macos';
+  if (plat === 'win32') return 'windows';
+
+  // Detect Linux distribution
+  try {
+    const release = execSync('cat /etc/os-release', { encoding: 'utf8' });
+    if (/debian|ubuntu/i.test(release)) return 'debian';
+    if (/fedora/i.test(release)) return 'fedora';
+    if (/rhel|centos|rocky|alma/i.test(release)) return 'rhel';
+    if (/arch/i.test(release)) return 'arch';
+  } catch {
+    // Fallback if /etc/os-release doesn't exist
+  }
+
+  return 'linux-generic';
+}
+
+function getTmuxErrorMessage(osType) {
+  const baseMessage = 'Error: tmux is not installed\n\n' +
+    'Devchain requires tmux for terminal session management.\n\n';
+
+  const verifyMessage = '\nAfter installation, verify with:\n' +
+    '  which tmux\n\n' +
+    'For advanced users: bypass this check with DEVCHAIN_SKIP_TMUX_CHECK=1\n';
+
+  switch (osType) {
+    case 'macos':
+      return baseMessage +
+        'To install tmux on macOS, run:\n' +
+        '  brew install tmux' +
+        verifyMessage;
+
+    case 'debian':
+      return baseMessage +
+        'To install tmux on Debian/Ubuntu, run:\n' +
+        '  sudo apt update && sudo apt install tmux' +
+        verifyMessage;
+
+    case 'fedora':
+      return baseMessage +
+        'To install tmux on Fedora, run:\n' +
+        '  sudo dnf install tmux' +
+        verifyMessage;
+
+    case 'rhel':
+      return baseMessage +
+        'To install tmux on RHEL/CentOS, run:\n' +
+        '  sudo yum install tmux' +
+        verifyMessage;
+
+    case 'arch':
+      return baseMessage +
+        'To install tmux on Arch Linux, run:\n' +
+        '  sudo pacman -S tmux' +
+        verifyMessage;
+
+    case 'linux-generic':
+    default:
+      return baseMessage +
+        'To install tmux, use your distribution\'s package manager:\n' +
+        '  - Debian/Ubuntu: sudo apt install tmux\n' +
+        '  - Fedora:        sudo dnf install tmux\n' +
+        '  - RHEL/CentOS:   sudo yum install tmux\n' +
+        '  - Arch:          sudo pacman -S tmux\n\n' +
+        'Or visit: https://github.com/tmux/tmux/wiki/Installing' +
+        verifyMessage;
+  }
+}
+
+async function main(argv) {
+  const program = new Command();
+  program
+    .name('devchain')
+    .description('Devchain — Local-first AI agent orchestration')
+    .version('0.1.0');
+
+  const startCommand = program
+    .command('start [args...]')
+    .description('Start the Devchain local app')
+    .option('-p, --port <number>', 'Port to listen on (default: 3000 or next free)')
+    .option('-f, --foreground', 'Run in foreground with interactive output (default). Shows user-friendly startup with colors and spinners.')
+    .option('-d, --detach', 'Run in background as a detached process. Use "devchain stop" to stop it.')
+    .option('--no-open', 'Do not open a browser window')
+    .option('--db <path>', 'Path to database directory or file (overrides DB_PATH/DB_FILENAME)')
+    .option('--project <path>', 'Initial project root path; creates project if missing')
+    .option(
+      '--log-level <level>',
+      'Set log verbosity: error (errors only), warn, info, debug, or trace. ' +
+      'Default: "error" (clean) in interactive mode, "info" in foreground. ' +
+      'Respects LOG_LEVEL env var if set.'
+    )
+    .action(async (args, opts) => {
+      // Check if "help" was passed as an argument
+      if (args && args.length > 0 && args[0] === 'help') {
+        startCommand.help();
+        return;
+      }
+      // Normalize defaults for negatable options (Commander may leave undefined)
+      if (typeof opts.open === 'undefined') {
+        opts.open = true;
+      }
+      // Detached mode only if explicitly requested
+      const shouldDetach = opts.detach === true;
+
+      // If detached mode, respawn as a background process
+      if (shouldDetach) {
+        const args = process.argv.slice(2).filter(arg => arg !== '-d' && arg !== '--detach');
+        // Add internal flag to prevent infinite respawning
+        args.push('--internal-detached-child');
+
+        const child = spawn(process.execPath, [__filename, ...args], {
+          detached: true,
+          stdio: 'ignore',
+        });
+
+        child.unref();
+
+        console.log(`Devchain is starting in background (PID ${child.pid})...`);
+        console.log('Use "devchain stop" to stop it.');
+        process.exit(0);
+      }
+
+      // Initialize interactive CLI (user-friendly output unless in foreground mode)
+      const cli = new InteractiveCLI({
+        interactive: !opts.foreground,
+        colors: true,
+        spinners: true
+      });
+
+      const log = (level, msg, extra) => {
+        const entry = { level, msg, time: new Date().toISOString(), ...(extra || {}) };
+        console.log(JSON.stringify(entry));
+      };
+
+      // Show startup banner (interactive mode only)
+      if (!opts.foreground) {
+        cli.blank();
+        cli.info('Starting Devchain...');
+        cli.blank();
+      }
+
+      // Tmux preflight check
+      const skipTmuxCheck = process.env.DEVCHAIN_SKIP_TMUX_CHECK === '1';
+      if (skipTmuxCheck) {
+        if (opts.foreground) {
+          log('info', 'Skipping tmux check (DEVCHAIN_SKIP_TMUX_CHECK=1)', { skipReason: 'env_var' });
+        } else {
+          cli.info('Skipping tmux check (DEVCHAIN_SKIP_TMUX_CHECK=1)');
+        }
+      } else {
+        const osType = getOSType();
+
+        if (osType === 'windows') {
+          if (opts.foreground) {
+            log('info', 'Skipping tmux check on Windows', { skipReason: 'windows', platform: 'win32' });
+          } else {
+            cli.info('Skipping tmux check on Windows');
+          }
+        } else {
+          // Interactive: show step
+          if (!opts.foreground) {
+            cli.step('Checking tmux');
+          }
+
+          // Check if tmux is installed
+          if (!isTmuxInstalled()) {
+            if (opts.foreground) {
+              log('error', 'tmux not found; aborting startup', { platform: osType, checked: 'which tmux' });
+            } else {
+              cli.stepDone('✗ not found');
+              cli.blank();
+            }
+            console.error('\n' + getTmuxErrorMessage(osType));
+            process.exit(1);
+          }
+
+          // tmux found, log success
+          try {
+            const tmuxPath = execSync('which tmux', { encoding: 'utf8' }).trim();
+            if (opts.foreground) {
+              log('info', 'tmux found', { tmuxPath });
+            } else {
+              cli.stepDone('✓ found');
+            }
+          } catch {
+            // Shouldn't happen since we just checked, but handle gracefully
+            if (opts.foreground) {
+              log('info', 'tmux check passed');
+            } else {
+              cli.stepDone('✓');
+            }
+          }
+        }
+      }
+
+      // Provider detection (Linux/macOS only)
+      const skipProviderCheck = process.env.DEVCHAIN_SKIP_PROVIDER_CHECK === '1';
+      const plat = platform();
+      if (skipProviderCheck) {
+        if (opts.foreground) {
+          log('info', 'Skipping provider check (DEVCHAIN_SKIP_PROVIDER_CHECK=1)', {
+            skipReason: 'env_var',
+          });
+        } else {
+          cli.info('Skipping provider check (DEVCHAIN_SKIP_PROVIDER_CHECK=1)');
+        }
+      } else if (plat === 'win32') {
+        if (opts.foreground) {
+          log('info', 'Skipping provider check on Windows', { skipReason: 'windows' });
+        } else {
+          cli.info('Skipping provider check on Windows');
+        }
+      } else {
+        // Interactive: show step
+        if (!opts.foreground) {
+          cli.step('Detecting providers');
+        }
+
+        const providersDetected = detectInstalledProviders();
+        if (providersDetected.size === 0) {
+          // Provide guidance and exit prior to server startup
+          const guide = [
+            'No provider binaries detected on PATH. Install at least one provider and retry.',
+            'Checked: "which codex" and "which claude"',
+            'Examples:',
+            '  - Install Codex:   npm i -g @twitech/codex-cli (example) or follow provider docs',
+            '  - Install Claude:  brew install claude-cli (example) or follow provider docs',
+            'Advanced: bypass with DEVCHAIN_SKIP_PROVIDER_CHECK=1',
+          ].join('\n');
+          if (opts.foreground) {
+            log('error', 'No providers found; aborting startup', {
+              checked: ['which codex', 'which claude'],
+            });
+          } else {
+            cli.stepDone('✗ none found');
+            cli.blank();
+          }
+          console.error('\n' + guide + '\n');
+          process.exit(1);
+        }
+
+        // stash on opts for later ensure step after server ready
+        opts.__providersDetected = providersDetected;
+        const providerNames = Array.from(providersDetected.keys());
+
+        if (opts.foreground) {
+          log('info', 'Detected providers', {
+            providers: Array.from(providersDetected.entries()).map(([name, p]) => ({ name, path: p })),
+          });
+        } else {
+          cli.stepDone(`✓ ${providerNames.join(', ')}`);
+        }
+      }
+
+      const preferPort = opts.port ? Number(opts.port) : 3000;
+      const port = await getPort({ port: preferPort });
+
+      // Apply env before requiring the server
+      process.env.PORT = String(port);
+      process.env.HOST = process.env.HOST || '127.0.0.1';
+      process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+      const dbEnv = parseDbPath(opts.db);
+      if (dbEnv.DB_PATH) process.env.DB_PATH = dbEnv.DB_PATH;
+      if (dbEnv.DB_FILENAME) process.env.DB_FILENAME = dbEnv.DB_FILENAME;
+
+      // Set log level with priority: --log-level flag > existing env/dotenv > mode defaults
+      if (opts.logLevel) {
+        // Highest priority: explicit CLI flag always wins
+        process.env.LOG_LEVEL = opts.logLevel;
+      } else if (!process.env.LOG_LEVEL) {
+        // No LOG_LEVEL set anywhere: use mode defaults
+        // Interactive mode: only show errors (clean output)
+        // Foreground mode: show all logs (debugging)
+        // Use Pino log levels: silent, fatal, error, warn, info, debug, trace
+        process.env.LOG_LEVEL = opts.foreground ? 'info' : 'error';
+      }
+      // If LOG_LEVEL is already set in env or .env file, respect it
+
+      // Ensure built server exists
+      // Prefer bundled server in dist/server (copied at pack-time); fallback to workspace path.
+      let serverEntry = join(__dirname, '..', 'dist', 'server', 'main.js');
+      if (!existsSync(serverEntry)) {
+        serverEntry = join(__dirname, '..', 'apps', 'local-app', 'dist', 'main.js');
+      }
+      if (!existsSync(serverEntry)) {
+        log('error', 'Built server not found. Please build first (pnpm --filter local-app build).', {
+          expected: serverEntry,
+        });
+        process.exit(1);
+      }
+
+      // Start server (main.js bootstraps immediately)
+      const spinner = opts.foreground ? null : cli.spinner('Starting server');
+      if (spinner) spinner.start();
+
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      require(serverEntry);
+
+      const baseUrl = `http://${process.env.HOST}:${port}`;
+      const ready = await waitForHealth(`${baseUrl}/health`);
+      if (!ready) {
+        log('error', 'Server did not become ready in time', { url: baseUrl });
+        if (spinner) {
+          spinner.stop('✗ timeout');
+          cli.blank();
+        }
+        process.exit(1);
+      }
+
+      if (spinner) {
+        spinner.stop('✓ ready', true);
+      }
+
+      if (opts.foreground) {
+        log('info', `Devchain is running at ${baseUrl}`);
+        log('info', `API docs: ${baseUrl}/api/docs`);
+        console.log(`\nDevchain is running at ${baseUrl}`);
+        console.log(`API docs: ${baseUrl}/api/docs`);
+        console.log('Press Ctrl+C to stop.\n');
+      } else {
+        cli.blank();
+        cli.success(`Server ready at ${baseUrl}`);
+        cli.info(`API docs: ${baseUrl}/api/docs`);
+      }
+
+      // Ensure provider rows exist (idempotent) before opening UI
+      if (opts.__providersDetected && opts.__providersDetected.size > 0) {
+        await ensureProvidersInDb(baseUrl, opts.__providersDetected, log);
+      }
+
+      // Determine startup path for MCP validation and URL
+      const startupPath = opts.project && typeof opts.project === 'string' && opts.project.trim()
+        ? opts.project.trim()
+        : process.cwd();
+
+      // Validate MCP for all providers (with project context)
+      await validateMcpForProviders(baseUrl, cli, opts, log, startupPath);
+
+      // Determine URL to open based on project path
+      let urlToOpen = baseUrl;
+      try {
+        const byPathUrl = `${baseUrl}/api/projects/by-path?path=${encodeURIComponent(startupPath)}`;
+        const resByPath = await fetchWithTimeout(byPathUrl, {}, 2500);
+        if (resByPath.ok) {
+          const project = await resByPath.json();
+          urlToOpen = `${baseUrl}/projects?projectId=${encodeURIComponent(project.id)}`;
+          if (opts.foreground) {
+            log('info', 'Resolved startup path to existing project', { startupPath, projectId: project.id });
+          } else if (opts.open) {
+            cli.info(`Opening project: ${project.name}`);
+          }
+        } else {
+          // 404 or invalid — fall back to newProjectPath to prefill dialog
+          urlToOpen = `${baseUrl}/projects?newProjectPath=${encodeURIComponent(startupPath)}`;
+          if (opts.foreground) {
+            log('info', 'No project at startup path; prefill create dialog', { startupPath });
+          } else if (opts.open) {
+            cli.info('Opening Projects page (create new project)');
+          }
+        }
+      } catch (e) {
+        // Network/timeouts: still prefer prefilled create dialog
+        urlToOpen = `${baseUrl}/projects?newProjectPath=${encodeURIComponent(startupPath)}`;
+        if (opts.foreground) {
+          log('warn', 'Failed to resolve startup path; opening create dialog', {
+            error: e instanceof Error ? e.message : String(e),
+          });
+        } else if (opts.open) {
+          cli.info('Opening Projects page (create new project)');
+        }
+      }
+
+      // Always print the App URL so the user can click/copy it
+      if (opts.foreground) {
+        console.log(`App: ${urlToOpen}`);
+      } else {
+        cli.info(`App: ${urlToOpen}`);
+      }
+
+      // Final blank line for clean output
+      if (!opts.foreground) {
+        cli.blank();
+      }
+
+      // Write PID file for stop command
+      writePidFile(port);
+
+      // Clean up PID file on exit
+      process.on('SIGINT', () => {
+        console.log('\nShutting down Devchain...');
+        removePidFile();
+        process.exit(0);
+      });
+
+      process.on('SIGTERM', () => {
+        console.log('\nShutting down Devchain...');
+        removePidFile();
+        process.exit(0);
+      });
+
+      if (opts.open) {
+        if (!opts.foreground) {
+          cli.info(`Opening ${urlToOpen}`);
+        }
+        try {
+          const openOpts = resolveOpenOptions();
+          await open(urlToOpen, openOpts);
+        } catch (e) {
+          // Fall back to printing URL without failing the process
+          const msg = e instanceof Error ? e.message : String(e);
+          if (opts.foreground) {
+            log('warn', 'Failed to open browser automatically', { error: msg, url: urlToOpen });
+          } else {
+            cli.warn('Failed to open browser automatically');
+            console.log(`Open this URL in your browser: ${urlToOpen}`);
+          }
+          // Linux fallback to xdg-open when available
+          try {
+            if (platform() === 'linux') {
+              spawn('xdg-open', [urlToOpen], { stdio: 'ignore', detached: true }).unref();
+            }
+          } catch (_) {
+            // ignore
+          }
+        }
+      }
+    });
+
+  program
+    .command('stop')
+    .description('Stop the running Devchain instance')
+    .action(() => {
+      const pidData = readPidFile();
+
+      if (!pidData) {
+        console.log('No running Devchain instance found.');
+        process.exit(1);
+      }
+
+      const { pid, port } = pidData;
+
+      if (!isProcessRunning(pid)) {
+        console.log(`Devchain process (PID ${pid}) is not running. Cleaning up stale PID file.`);
+        removePidFile();
+        process.exit(1);
+      }
+
+      console.log(`Stopping Devchain (PID ${pid}, port ${port})...`);
+
+      try {
+        process.kill(pid, 'SIGTERM');
+
+        // Wait a bit for graceful shutdown
+        let attempts = 0;
+        const checkInterval = setInterval(() => {
+          attempts++;
+          if (!isProcessRunning(pid)) {
+            clearInterval(checkInterval);
+            removePidFile();
+            console.log('Devchain stopped successfully.');
+            process.exit(0);
+          }
+
+          if (attempts > 20) {
+            // After 2 seconds, force kill
+            clearInterval(checkInterval);
+            console.log('Graceful shutdown timed out, forcing...');
+            try {
+              process.kill(pid, 'SIGKILL');
+              removePidFile();
+              console.log('Devchain stopped (forced).');
+            } catch (err) {
+              console.error('Failed to stop Devchain:', err.message);
+              process.exit(1);
+            }
+            process.exit(0);
+          }
+        }, 100);
+      } catch (err) {
+        console.error('Failed to stop Devchain:', err.message);
+        process.exit(1);
+      }
+    });
+
+  await program.parseAsync(argv);
+}
+
+main(process.argv).catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});