@profoundlogic/coderflow-cli 0.2.1

package/lib/commands/server.js

@@ -0,0 +1,537 @@
+/**
+ * Server management commands
+ *
+ * NOTE: This command requires the server package to be installed locally.
+ * It manages a local CoderFlow server instance on the same machine.
+ */
+
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import {
+  saveCoderSetupPath,
+  getCoderSetupPath,
+  saveServerPort,
+  getServerPort,
+  getServerUrl
+} from '../config.js';
+
+const PID_FILE = path.join(os.homedir(), '.coder', 'server.pid');
+const LOG_FILE = path.join(os.homedir(), '.coder', 'server.log');
+
+/**
+ * Get the server package directory and entry script
+ * Returns { packagePath, scriptPath } or null if server package is not installed
+ */
+async function getServerPackageInfo() {
+  // In development, prefer source (start.js) over dist for easier iteration
+  // Use CODER_USE_DIST=1 to force using dist in development
+  const useDistInDev = process.env.CODER_USE_DIST === '1';
+
+  // First, try to find server package installed via npm (or via workspaces)
+  try {
+    const require = createRequire(import.meta.url);
+    const serverPkgPath = require.resolve('@profoundlogic/coderflow-server/package.json');
+    const packagePath = path.dirname(serverPkgPath);
+    const srcScript = path.join(packagePath, 'start.js');
+    const distScript = path.join(packagePath, 'dist', 'start.js');
+
+    // Check if source exists (indicates development/workspace setup)
+    let sourceExists = false;
+    try {
+      await fs.access(srcScript);
+      sourceExists = true;
+    } catch {
+      // Source doesn't exist - this is a truly installed package
+    }
+
+    // Prefer source in development unless CODER_USE_DIST=1
+    if (sourceExists && !useDistInDev) {
+      return { packagePath, scriptPath: srcScript };
+    }
+
+    // Use dist (for installed packages or when CODER_USE_DIST=1)
+    try {
+      await fs.access(distScript);
+      return { packagePath, scriptPath: distScript };
+    } catch {
+      // dist/start.js not found
+    }
+
+    // Fall back to source if dist doesn't exist
+    if (sourceExists) {
+      return { packagePath, scriptPath: srcScript };
+    }
+  } catch {
+    // Not installed as npm package, try monorepo development path
+  }
+
+  // Try relative path for monorepo development (fallback if require.resolve fails)
+  const currentFile = fileURLToPath(import.meta.url);
+  const cliDir = path.dirname(path.dirname(path.dirname(currentFile)));
+  const monorepoServerPath = path.join(cliDir, '..', 'server');
+
+  const srcScript = path.join(monorepoServerPath, 'start.js');
+  const distScript = path.join(monorepoServerPath, 'dist', 'start.js');
+
+  if (!useDistInDev) {
+    // Prefer source for development
+    try {
+      await fs.access(srcScript);
+      return { packagePath: monorepoServerPath, scriptPath: srcScript };
+    } catch {
+      // source doesn't exist, try dist
+    }
+  }
+
+  try {
+    await fs.access(distScript);
+    return { packagePath: monorepoServerPath, scriptPath: distScript };
+  } catch {
+    // dist doesn't exist either
+  }
+
+  // If useDistInDev was set but dist doesn't exist, fall back to source
+  if (useDistInDev) {
+    try {
+      await fs.access(srcScript);
+      return { packagePath: monorepoServerPath, scriptPath: srcScript };
+    } catch {
+      // Server package not found
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if server package is available and show error if not
+ * Returns { packagePath, scriptPath }
+ */
+async function requireServerPackage() {
+  const serverInfo = await getServerPackageInfo();
+  if (!serverInfo) {
+    console.error('Error: Server package is not installed locally.');
+    console.error('');
+    console.error('The `coder server` command manages a local CoderFlow server.');
+    console.error('To use this command, install the server package:');
+    console.error('');
+    console.error('  npm install -g @profoundlogic/coderflow-server');
+    console.error('');
+    console.error('If you want to connect to a remote server instead, use:');
+    console.error('  coder config set serverUrl http://your-server:3000');
+    console.error('  coder login');
+    process.exit(1);
+  }
+  return serverInfo;
+}
+
+/**
+ * Check if server is running
+ */
+async function isServerRunning() {
+  try {
+    const pidData = await fs.readFile(PID_FILE, 'utf-8');
+    const pid = parseInt(pidData.trim(), 10);
+
+    // Check if process exists
+    try {
+      process.kill(pid, 0); // Signal 0 just checks if process exists
+      return { running: true, pid };
+    } catch {
+      // Process doesn't exist, clean up PID file
+      await fs.unlink(PID_FILE).catch(() => {});
+      return { running: false, pid: null };
+    }
+  } catch {
+    return { running: false, pid: null };
+  }
+}
+
+/**
+ * Get server process info
+ */
+async function getServerInfo() {
+  const { running, pid } = await isServerRunning();
+  const setupPath = await getCoderSetupPath();
+  const port = await getServerPort();
+  const serverUrl = await getServerUrl();
+
+  return {
+    running,
+    pid,
+    setupPath,
+    port,
+    serverUrl
+  };
+}
+
+/**
+ * Start the server
+ */
+async function startServer(args) {
+  const { running, pid } = await isServerRunning();
+
+  if (running) {
+    console.log(`Server is already running (PID: ${pid})`);
+    console.log(`URL: ${await getServerUrl()}`);
+    return;
+  }
+
+  // Parse arguments
+  let setupPath = null;
+  let port = null;
+  let daemon = false;
+
+  for (const arg of args) {
+    if (arg.startsWith('--setup-path=')) {
+      setupPath = arg.substring('--setup-path='.length);
+    } else if (arg.startsWith('--port=')) {
+      port = parseInt(arg.substring('--port='.length), 10);
+    } else if (arg === '--daemon' || arg === '-d') {
+      daemon = true;
+    }
+  }
+
+  // Get setup path from args, config, or env
+  if (!setupPath) {
+    setupPath = await getCoderSetupPath();
+  }
+
+  if (!setupPath) {
+    console.error('Error: No coder-setup path configured');
+    console.error('');
+    console.error('Please provide a setup path:');
+    console.error('  coder server start --setup-path=/path/to/coder-setup');
+    console.error('');
+    console.error('Or set environment variable:');
+    console.error('  export CODER_SETUP_PATH=/path/to/coder-setup');
+    process.exit(1);
+  }
+
+  // Resolve to absolute path
+  setupPath = path.resolve(setupPath);
+
+  // Verify setup path exists
+  try {
+    const stat = await fs.stat(setupPath);
+    if (!stat.isDirectory()) {
+      console.error(`Error: Setup path is not a directory: ${setupPath}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Error: Setup path does not exist: ${setupPath}`);
+    process.exit(1);
+  }
+
+  // Save setup path to config for future use
+  await saveCoderSetupPath(setupPath);
+  console.log(`✓ Saved setup path to config: ${setupPath}`);
+
+  // Get port from args, config, or default
+  if (!port) {
+    port = await getServerPort();
+  }
+
+  // Save port to config
+  if (port !== 3000) {
+    await saveServerPort(port);
+    console.log(`✓ Saved server port to config: ${port}`);
+  }
+
+  // Ensure server package is installed (scriptPath already verified to exist)
+  const { scriptPath: serverScript } = await requireServerPackage();
+
+  console.log('');
+  console.log('Starting CoderFlow Server...');
+  console.log(`  Setup Path: ${setupPath}`);
+  console.log(`  Port:       ${port}`);
+  console.log(`  Mode:       ${daemon ? 'daemon' : 'foreground'}`);
+  console.log('');
+
+  const env = {
+    ...process.env,
+    CODER_SETUP_PATH: setupPath,
+    PORT: port.toString()
+  };
+
+  const spawnArgs = [serverScript];
+
+  // Allow the coder server itself to be debugged.
+  if (typeof process.env.CODER_SERVER_INSPECT === "string" && process.env.CODER_SERVER_INSPECT.length > 0) {
+    spawnArgs.unshift('--inspect');
+  }
+
+  if (daemon) {
+    // Start server as daemon
+    const logStream = await fs.open(LOG_FILE, 'a');
+
+    const serverProcess = spawn('node', spawnArgs, {
+      env,
+      detached: true,
+      stdio: ['ignore', logStream.fd, logStream.fd]
+    });
+
+    serverProcess.unref();
+
+    // Save PID
+    const pidDir = path.dirname(PID_FILE);
+    await fs.mkdir(pidDir, { recursive: true });
+    await fs.writeFile(PID_FILE, serverProcess.pid.toString(), 'utf-8');
+
+    console.log(`✓ Server started in daemon mode (PID: ${serverProcess.pid})`);
+    console.log(`  URL:  http://localhost:${port}`);
+    console.log(`  Logs: ${LOG_FILE}`);
+    console.log('');
+    console.log('Use "coder server status" to check server status');
+    console.log('Use "coder server stop" to stop the server');
+    console.log('Use "coder server logs" to view logs');
+  } else {
+    // Start server in foreground
+    const serverProcess = spawn('node', spawnArgs, {
+      env,
+      stdio: 'inherit'
+    });
+
+    // Save PID
+    const pidDir = path.dirname(PID_FILE);
+    await fs.mkdir(pidDir, { recursive: true });
+    await fs.writeFile(PID_FILE, serverProcess.pid.toString(), 'utf-8');
+
+    // Handle termination
+    const cleanup = async () => {
+      await fs.unlink(PID_FILE).catch(() => {});
+    };
+
+    serverProcess.on('exit', cleanup);
+    process.on('SIGINT', () => {
+      cleanup().then(() => process.exit(0));
+    });
+    process.on('SIGTERM', () => {
+      cleanup().then(() => process.exit(0));
+    });
+  }
+}
+
+/**
+ * Stop the server
+ */
+async function stopServer() {
+  const { running, pid } = await isServerRunning();
+
+  if (!running) {
+    console.log('Server is not running');
+    return;
+  }
+
+  console.log(`Stopping server (PID: ${pid})...`);
+
+  try {
+    process.kill(pid, 'SIGTERM');
+
+    // Wait for process to exit (max 5 seconds)
+    for (let i = 0; i < 50; i++) {
+      try {
+        process.kill(pid, 0);
+        await new Promise(resolve => setTimeout(resolve, 100));
+      } catch {
+        // Process exited
+        break;
+      }
+    }
+
+    // Check if still running, force kill if needed
+    try {
+      process.kill(pid, 0);
+      console.log('Server did not stop gracefully, forcing...');
+      process.kill(pid, 'SIGKILL');
+    } catch {
+      // Already stopped
+    }
+
+    // Clean up PID file
+    await fs.unlink(PID_FILE).catch(() => {});
+
+    console.log('✓ Server stopped');
+  } catch (error) {
+    console.error(`Error stopping server: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show server status
+ */
+async function showStatus() {
+  const info = await getServerInfo();
+
+  console.log('CoderFlow Server Status:');
+  console.log('');
+  console.log(`  Status:      ${info.running ? '✓ Running' : '✗ Not running'}`);
+
+  if (info.running) {
+    console.log(`  PID:         ${info.pid}`);
+    console.log(`  URL:         ${info.serverUrl}`);
+  }
+
+  if (info.setupPath) {
+    console.log(`  Setup Path:  ${info.setupPath}`);
+  } else {
+    console.log(`  Setup Path:  (not configured)`);
+  }
+
+  console.log(`  Port:        ${info.port}`);
+  console.log('');
+
+  if (!info.running && info.setupPath) {
+    console.log('Start the server with:');
+    console.log('  coder server start');
+  } else if (!info.running) {
+    console.log('Configure and start the server with:');
+    console.log('  coder server start --setup-path=/path/to/coder-setup');
+  } else {
+    console.log('Stop the server with:');
+    console.log('  coder server stop');
+  }
+}
+
+/**
+ * Show server logs
+ */
+async function showLogs(args) {
+  const { running } = await isServerRunning();
+
+  if (!running) {
+    console.log('Server is not running');
+    return;
+  }
+
+  // Parse arguments
+  let follow = false;
+  let lines = null;
+
+  for (const arg of args) {
+    if (arg === '--follow' || arg === '-f') {
+      follow = true;
+    } else if (arg.startsWith('--tail=')) {
+      lines = parseInt(arg.substring('--tail='.length), 10);
+    }
+  }
+
+  try {
+    const logContent = await fs.readFile(LOG_FILE, 'utf-8');
+    const logLines = logContent.split('\n');
+
+    if (lines) {
+      console.log(logLines.slice(-lines).join('\n'));
+    } else {
+      console.log(logContent);
+    }
+
+    if (follow) {
+      console.log('\n--- Following logs (Ctrl+C to stop) ---\n');
+
+      // Simple tail -f implementation
+      let lastSize = (await fs.stat(LOG_FILE)).size;
+
+      const interval = setInterval(async () => {
+        try {
+          const currentSize = (await fs.stat(LOG_FILE)).size;
+          if (currentSize > lastSize) {
+            const stream = await fs.open(LOG_FILE, 'r');
+            const buffer = Buffer.alloc(currentSize - lastSize);
+            await stream.read(buffer, 0, buffer.length, lastSize);
+            await stream.close();
+            process.stdout.write(buffer.toString('utf-8'));
+            lastSize = currentSize;
+          }
+        } catch (error) {
+          clearInterval(interval);
+        }
+      }, 500);
+
+      process.on('SIGINT', () => {
+        clearInterval(interval);
+        process.exit(0);
+      });
+    }
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      console.log('No log file found');
+      console.log('Server may have been started in foreground mode');
+    } else {
+      console.error(`Error reading logs: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Restart the server
+ */
+async function restartServer(args) {
+  const { running } = await isServerRunning();
+
+  if (running) {
+    console.log('Stopping server...');
+    await stopServer();
+    console.log('');
+  }
+
+  console.log('Starting server...');
+  await startServer(args);
+}
+
+/**
+ * Handle server commands
+ */
+export async function handleServer(args) {
+  const subcommand = args[0];
+
+  // Check for server package availability for commands that need it
+  // (start, restart require the package; stop/status/logs work with running server)
+  if (subcommand === 'start' || subcommand === 'restart') {
+    await requireServerPackage();
+  }
+
+  switch (subcommand) {
+    case 'start':
+      await startServer(args.slice(1));
+      break;
+
+    case 'stop':
+      await stopServer();
+      break;
+
+    case 'status':
+      await showStatus();
+      break;
+
+    case 'logs':
+      await showLogs(args.slice(1));
+      break;
+
+    case 'restart':
+      await restartServer(args.slice(1));
+      break;
+
+    case undefined:
+      console.error('Error: No subcommand provided');
+      console.error('');
+      console.error('Available subcommands:');
+      console.error('  coder server start [--setup-path=PATH] [--port=PORT] [--daemon]');
+      console.error('  coder server stop');
+      console.error('  coder server status');
+      console.error('  coder server logs [--follow] [--tail=N]');
+      console.error('  coder server restart [--setup-path=PATH] [--port=PORT] [--daemon]');
+      process.exit(1);
+      break;
+
+    default:
+      console.error(`Error: Unknown subcommand "${subcommand}"`);
+      console.error('Run "coder server" for available subcommands');
+      process.exit(1);
+  }
+}

package/lib/commands/status.js

@@ -0,0 +1,39 @@
+/**
+ * Command: coder status - Check status of a task
+ */
+
+import { request } from '../http-client.js';
+
+export async function getStatus(taskId) {
+  if (!taskId) {
+    console.error('Error: Task ID required');
+    console.error('Usage: coder status <task-id>');
+    process.exit(1);
+  }
+
+  console.log(`Fetching status for task ${taskId}...`);
+
+  const data = await request(`/tasks/${taskId}`);
+
+  console.log(`\nTask Status:`);
+  console.log(`  Task ID:      ${data.taskId}`);
+  console.log(`  Status:       ${data.status}`);
+  console.log(`  Created:      ${data.createdAt}`);
+
+  if (data.finishedAt) {
+    console.log(`  Finished:     ${data.finishedAt}`);
+  }
+
+  if (data.exitCode !== undefined) {
+    console.log(`  Exit Code:    ${data.exitCode}`);
+  }
+
+  if (data.status === 'completed') {
+    console.log(`\n✓ Task completed successfully`);
+    console.log(`Use "coder results ${taskId}" to get full results`);
+  } else if (data.status === 'failed') {
+    console.log(`\n✗ Task failed`);
+  } else if (data.status === 'running') {
+    console.log(`\n⋯ Task is still running`);
+  }
+}