onbuzz 3.3.0

package/bin/cli.js

@@ -0,0 +1,556 @@
+#!/usr/bin/env node
+
+/**
+ * Loxia Autopilot One - CLI Entry Point
+ *
+ * Commands:
+ *   loxia web            - Start server (serves Web UI) + open browser
+ *   loxia serve          - Start server only (no UI)
+ *   loxia terminal       - Start Terminal UI only (server must be running)
+ *   loxia plus-web       - Alias for 'web'
+ *   loxia plus-terminal  - Start server (background) + Terminal UI (foreground)
+ *   loxia trigger-schedule <id> - Trigger a scheduled task (wakes server if needed)
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { spawn } from 'child_process';
+import { readFileSync } from 'fs';
+import http from 'http';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Default configuration
+const DEFAULT_PORT = 8080;
+// Use 127.0.0.1 instead of 'localhost' to avoid IPv6 issues in WSL2
+const DEFAULT_HOST = '127.0.0.1';
+const SERVER_STARTUP_TIMEOUT = 15000;
+const SERVER_CHECK_INTERVAL = 500;
+
+// Parse CLI arguments
+const args = process.argv.slice(2);
+const command = args[0] && !args[0].startsWith('--') ? args[0] : null;
+const flags = {
+  port: null,
+  host: null,
+  help: args.includes('--help') || args.includes('-h'),
+  version: args.includes('--version') || args.includes('-v')
+};
+
+// Extract port and host if provided
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--port' && args[i + 1]) {
+    flags.port = parseInt(args[i + 1], 10);
+  }
+  if (args[i] === '--host' && args[i + 1]) {
+    flags.host = args[i + 1];
+  }
+}
+
+// Only use default port if explicitly specified, otherwise let server choose
+const explicitPort = flags.port;
+const host = flags.host || DEFAULT_HOST;
+
+// Show version
+if (flags.version) {
+  const pkgPath = join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  console.log(`Loxia Autopilot One v${pkg.version}`);
+  process.exit(0);
+}
+
+// Show help
+if (flags.help || !command) {
+  const pkgPath = join(__dirname, '..', 'package.json');
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+
+  console.log(`
+Loxia Autopilot One v${pkg.version} - AI Agent System
+
+Usage:
+  loxia <command> [options]
+
+Commands:
+  web                       Start server + open Web UI in browser
+  serve                     Start server only (no UI opened)
+  terminal                  Start Terminal UI (server must be running)
+  plus-web                  Alias for 'web'
+  plus-terminal             Start server + Terminal UI together
+  trigger-schedule <id>     Trigger a scheduled task (wakes server if needed)
+
+Options:
+  --port <number>   Specify port (default: auto-select starting from ${DEFAULT_PORT})
+  --host <host>     Specify host (default: ${DEFAULT_HOST})
+  -h, --help        Show this help message
+  -v, --version     Show version number
+
+Examples:
+  loxia web                # Start server + open browser
+  loxia serve              # Start server only (headless)
+  loxia terminal           # Connect Terminal UI to running server
+  loxia plus-terminal      # Start server + Terminal UI
+  loxia web --port 3000    # Use specific port
+
+Quick Start:
+  1. Run 'loxia web' to start with Web UI
+  2. Or run 'loxia plus-terminal' for Terminal UI experience
+  3. Or run 'loxia serve' for headless server (connect remotely)
+
+Note: If no port is specified, the server will automatically find
+an available port. The Terminal UI will discover the server port
+automatically from the port registry.
+
+Documentation:
+  https://autopilot.loxia.ai
+
+`);
+  process.exit(0);
+}
+
+/**
+ * Dynamically import the port registry
+ */
+async function getPortRegistry() {
+  const { getPortRegistry } = await import('../src/services/portRegistry.js');
+  return getPortRegistry();
+}
+
+/**
+ * Discover backend from port registry
+ * @returns {Promise<{host: string, port: number}|null>}
+ */
+async function discoverBackend() {
+  try {
+    const portRegistry = await getPortRegistry();
+    await portRegistry.cleanupStaleEntries();
+    const backendInfo = await portRegistry.getService('backend');
+
+    if (backendInfo) {
+      return {
+        host: backendInfo.host || 'localhost',
+        port: backendInfo.port,
+        pid: backendInfo.pid
+      };
+    }
+    return null;
+  } catch (error) {
+    // Registry may not exist yet
+    return null;
+  }
+}
+
+/**
+ * Check if server is running at the specified host:port
+ */
+async function checkServerRunning(host, port, maxAttempts = 1) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const isRunning = await new Promise((resolve) => {
+      const req = http.get(`http://${host}:${port}/api/health`, (res) => {
+        resolve(res.statusCode === 200);
+      });
+      req.on('error', () => resolve(false));
+      req.setTimeout(2000, () => {
+        req.destroy();
+        resolve(false);
+      });
+    });
+
+    if (isRunning) return true;
+
+    if (i < maxAttempts - 1) {
+      await new Promise(resolve => setTimeout(resolve, SERVER_CHECK_INTERVAL));
+    }
+  }
+  return false;
+}
+
+/**
+ * Wait for server to become ready by polling the port registry
+ * @returns {Promise<{host: string, port: number}|null>}
+ */
+async function waitForServerWithDiscovery(timeout = SERVER_STARTUP_TIMEOUT) {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeout) {
+    // Try to discover backend from registry
+    const backend = await discoverBackend();
+
+    if (backend) {
+      // Verify with health check
+      const isHealthy = await checkServerRunning(backend.host, backend.port);
+      if (isHealthy) {
+        return backend;
+      }
+    }
+
+    await new Promise(resolve => setTimeout(resolve, SERVER_CHECK_INTERVAL));
+  }
+
+  return null;
+}
+
+/**
+ * Wait for server at specific port (when port is explicitly specified)
+ */
+async function waitForServerAtPort(host, port, timeout = SERVER_STARTUP_TIMEOUT) {
+  const maxAttempts = Math.ceil(timeout / SERVER_CHECK_INTERVAL);
+  const isReady = await checkServerRunning(host, port, maxAttempts);
+  return isReady ? { host, port } : null;
+}
+
+/**
+ * Open URL in default browser
+ * Uses spawn instead of exec for better security (no shell interpolation)
+ */
+function openBrowser(url) {
+  let cmd, args;
+
+  if (process.platform === 'darwin') {
+    cmd = 'open';
+    args = [url];
+  } else if (process.platform === 'win32') {
+    cmd = 'cmd';
+    args = ['/c', 'start', '""', url];
+  } else {
+    cmd = 'xdg-open';
+    args = [url];
+  }
+
+  const child = spawn(cmd, args, {
+    detached: true,
+    stdio: 'ignore'
+  });
+  child.unref();
+
+  child.on('error', () => {
+    console.log(`Could not open browser automatically.`);
+    console.log(`Please open manually: ${url}`);
+  });
+}
+
+/**
+ * Start the backend server
+ * @param {boolean} silent - If true, suppress server output
+ * @returns {ChildProcess}
+ */
+function startServer(silent = false) {
+  const env = { ...process.env };
+
+  // Only set port environment variables if explicitly specified
+  // Otherwise, let the server dynamically allocate a port
+  if (explicitPort) {
+    env.LOXIA_PORT = explicitPort.toString();
+    env.PORT = explicitPort.toString();
+  }
+
+  if (flags.host) {
+    env.LOXIA_HOST = flags.host;
+  }
+
+  const mainScript = join(__dirname, '..', 'src', 'index.js');
+
+  const child = spawn('node', [mainScript], {
+    cwd: join(__dirname, '..'),
+    env,
+    stdio: silent ? ['ignore', 'ignore', 'ignore'] : 'inherit',
+    detached: silent
+  });
+
+  if (silent) {
+    child.unref();
+  }
+
+  return child;
+}
+
+/**
+ * Start Terminal UI with discovered port
+ */
+function startTerminalUIProcess(discoveredHost, discoveredPort) {
+  const terminalScript = join(__dirname, 'loxia-terminal.js');
+
+  const env = {
+    ...process.env,
+    LOXIA_PORT: discoveredPort.toString(),
+    LOXIA_HOST: discoveredHost
+  };
+
+  const child = spawn('node', [terminalScript], {
+    cwd: join(__dirname, '..'),
+    env,
+    stdio: 'inherit'
+  });
+
+  return child;
+}
+
+// Command handlers
+const commands = {
+  // 'web' and 'plus-web': Start server + open browser
+  'web': async () => {
+    console.log('Starting Loxia server...\n');
+
+    const serverProcess = startServer(false);
+
+    // Wait for server to be ready
+    console.log('Waiting for server to start...');
+
+    let backend;
+    if (explicitPort) {
+      backend = await waitForServerAtPort(host, explicitPort);
+    } else {
+      backend = await waitForServerWithDiscovery();
+    }
+
+    if (backend) {
+      const serverUrl = `http://${backend.host}:${backend.port}`;
+      console.log(`\nOpening Web UI at ${serverUrl}`);
+      openBrowser(serverUrl);
+    } else {
+      console.log(`\nServer may still be starting. Check the port registry or logs.`);
+    }
+
+    // Forward signals
+    process.on('SIGINT', () => serverProcess.kill('SIGINT'));
+    process.on('SIGTERM', () => serverProcess.kill('SIGTERM'));
+
+    serverProcess.on('exit', (code) => process.exit(code || 0));
+  },
+
+  'plus-web': async () => {
+    // Alias for 'web'
+    await commands['web']();
+  },
+
+  // 'serve': Start server only (no UI)
+  'serve': async () => {
+    console.log('Starting Loxia server...\n');
+
+    const serverProcess = startServer(false);
+
+    // Wait for server to be ready
+    console.log('Waiting for server to start...');
+
+    let backend;
+    if (explicitPort) {
+      backend = await waitForServerAtPort(host, explicitPort);
+    } else {
+      backend = await waitForServerWithDiscovery();
+    }
+
+    if (backend) {
+      const serverUrl = `http://${backend.host}:${backend.port}`;
+      console.log(`\n✓ Server running at ${serverUrl}`);
+      console.log(`\n  Web UI:       ${serverUrl}`);
+      console.log(`  Terminal UI:  loxia terminal`);
+      console.log(`  API Health:   ${serverUrl}/api/health\n`);
+    } else {
+      console.log(`\nServer started but may still be initializing.`);
+      console.log(`Run 'loxia terminal' to connect when ready.`);
+    }
+
+    // Forward signals for graceful shutdown
+    process.on('SIGINT', () => serverProcess.kill('SIGINT'));
+    process.on('SIGTERM', () => serverProcess.kill('SIGTERM'));
+
+    serverProcess.on('exit', (code) => process.exit(code || 0));
+  },
+
+  // 'terminal': Start Terminal UI only (server must be running)
+  'terminal': async () => {
+    console.log('Looking for running server...');
+
+    // First try to discover from registry
+    let backend = await discoverBackend();
+
+    // If explicit port specified, use that instead
+    if (explicitPort) {
+      backend = { host, port: explicitPort };
+    }
+
+    if (!backend) {
+      console.error(`\nNo running server found in the port registry.`);
+      console.error('\nPlease start the server first:');
+      console.error('  loxia web            # Start server + Web UI');
+      console.error('  loxia serve          # Start server only');
+      console.error('  loxia plus-terminal  # Start server + Terminal UI\n');
+      process.exit(1);
+    }
+
+    // Verify server is actually running
+    const isRunning = await checkServerRunning(backend.host, backend.port);
+
+    if (!isRunning) {
+      console.error(`\nServer registered at ${backend.host}:${backend.port} but not responding.`);
+      console.error('It may have crashed. Please restart it.');
+      process.exit(1);
+    }
+
+    console.log(`Server discovered at ${backend.host}:${backend.port}`);
+    console.log('Starting Terminal UI...\n');
+
+    const terminalProcess = startTerminalUIProcess(backend.host, backend.port);
+
+    process.on('SIGINT', () => terminalProcess.kill('SIGINT'));
+    process.on('SIGTERM', () => terminalProcess.kill('SIGTERM'));
+
+    terminalProcess.on('exit', (code) => process.exit(code || 0));
+  },
+
+  // 'plus-terminal': Start server (silent background) + Terminal UI (foreground)
+  'plus-terminal': async () => {
+    console.log('Starting Loxia server in background...');
+
+    // Start server silently in background
+    const serverProcess = startServer(true);
+
+    // Wait for server to be ready
+    let backend;
+    if (explicitPort) {
+      backend = await waitForServerAtPort(host, explicitPort);
+    } else {
+      backend = await waitForServerWithDiscovery();
+    }
+
+    if (!backend) {
+      console.error('\nServer failed to start. Please check logs.');
+      process.exit(1);
+    }
+
+    console.log(`Server running at http://${backend.host}:${backend.port}`);
+    console.log('Starting Terminal UI...\n');
+
+    const terminalProcess = startTerminalUIProcess(backend.host, backend.port);
+
+    // When Terminal UI exits, also kill the server
+    terminalProcess.on('exit', (code) => {
+      console.log('\nShutting down server...');
+
+      // Try to kill the server process
+      try {
+        process.kill(serverProcess.pid, 'SIGTERM');
+      } catch (e) {
+        // Server may have already exited
+      }
+
+      process.exit(code || 0);
+    });
+
+    process.on('SIGINT', () => {
+      terminalProcess.kill('SIGINT');
+    });
+
+    process.on('SIGTERM', () => {
+      terminalProcess.kill('SIGTERM');
+    });
+  },
+
+  // 'trigger-schedule': Trigger a scheduled task, waking server if needed
+  'trigger-schedule': async () => {
+    const scheduleId = args[1];
+    if (!scheduleId) {
+      console.error('Usage: loxia trigger-schedule <schedule-id>');
+      process.exit(1);
+    }
+
+    // Try to find a running server
+    let backend = await discoverBackend();
+    let weStartedServer = false;
+
+    if (backend) {
+      const isRunning = await checkServerRunning(backend.host, backend.port);
+      if (!isRunning) backend = null;
+    }
+
+    if (!backend) {
+      // No running server — wake one up silently
+      console.log('No running server found. Starting Loxia in background...');
+      startServer(true);
+      weStartedServer = true;
+
+      // Wait for it to come up
+      if (explicitPort) {
+        backend = await waitForServerAtPort(host, explicitPort, 30000);
+      } else {
+        backend = await waitForServerWithDiscovery(30000);
+      }
+
+      if (!backend) {
+        console.error('Failed to start server within 30s. Check logs.');
+        process.exit(1);
+      }
+      console.log(`Server started at ${backend.host}:${backend.port}`);
+    }
+
+    // Trigger the schedule via API
+    const triggerUrl = `http://${backend.host}:${backend.port}/api/schedules/${encodeURIComponent(scheduleId)}/trigger`;
+
+    try {
+      const result = await new Promise((resolve, reject) => {
+        const postData = JSON.stringify({});
+        const req = http.request(triggerUrl, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(postData) }
+        }, (res) => {
+          let data = '';
+          res.on('data', chunk => data += chunk);
+          res.on('end', () => {
+            try {
+              resolve(JSON.parse(data));
+            } catch {
+              reject(new Error(`Invalid response: ${data}`));
+            }
+          });
+        });
+        req.on('error', reject);
+        req.setTimeout(60000, () => { req.destroy(); reject(new Error('Request timed out')); });
+        req.write(postData);
+        req.end();
+      });
+
+      if (result.success) {
+        console.log(`Schedule "${result.scheduleName || scheduleId}" triggered successfully.`);
+      } else {
+        console.error(`Failed to trigger schedule: ${result.error}`);
+        process.exit(1);
+      }
+    } catch (err) {
+      console.error(`Failed to trigger schedule: ${err.message}`);
+      process.exit(1);
+    }
+
+    // If we started the server, set idle shutdown timer
+    if (weStartedServer) {
+      const idleUrl = `http://${backend.host}:${backend.port}/api/system/idle-shutdown`;
+      try {
+        const postData = JSON.stringify({ timeoutMinutes: 10 });
+        await new Promise((resolve) => {
+          const req = http.request(idleUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(postData) }
+          }, (res) => { res.on('data', () => {}); res.on('end', resolve); });
+          req.on('error', resolve); // Non-critical, ignore errors
+          req.write(postData);
+          req.end();
+        });
+      } catch {
+        // Non-critical
+      }
+    }
+
+    process.exit(0);
+  }
+};
+
+// Execute command
+if (commands[command]) {
+  commands[command]().catch((error) => {
+    console.error('Error:', error.message);
+    process.exit(1);
+  });
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.error('Run "loxia --help" for usage information.');
+  process.exit(1);
+}

package/bin/loxia-terminal-v2.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+/**
+ * Loxia Terminal UI Launcher (Ink-based)
+ * Cross-platform compatible including Windows
+ */
+
+import { spawn } from 'child_process';
+import net from 'net';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.dirname(__dirname);
+
+// Configuration
+const DEFAULT_PORT = 8080;
+const DEFAULT_HOST = 'localhost';
+const SERVER_STARTUP_TIMEOUT = 10000;
+
+/**
+ * Check if server is running
+ */
+async function isServerRunning(host, port) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    socket.setTimeout(2000);
+
+    socket.on('connect', () => {
+      socket.destroy();
+      resolve(true);
+    });
+
+    socket.on('timeout', () => {
+      socket.destroy();
+      resolve(false);
+    });
+
+    socket.on('error', () => {
+      socket.destroy();
+      resolve(false);
+    });
+
+    socket.connect(port, host);
+  });
+}
+
+/**
+ * Start the Loxia server
+ */
+async function startServer(host, port) {
+  console.log('🚀 Starting Loxia server...');
+
+  return new Promise((resolve, reject) => {
+    const serverProcess = spawn('node', [
+      path.join(projectRoot, 'bin/cli.js'),
+      '--ui', 'web',
+      '--host', host,
+      '--port', port.toString()
+    ], {
+      detached: false,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    serverProcess.stdout.on('data', () => {
+      // Silently consume
+    });
+
+    serverProcess.stderr.on('data', () => {
+      // Silently consume
+    });
+
+    serverProcess.on('error', (error) => {
+      console.error('Failed to start server:', error.message);
+      reject(error);
+    });
+
+    // Wait for server to start
+    const startTime = Date.now();
+    const checkInterval = setInterval(async () => {
+      const running = await isServerRunning(host, port);
+
+      if (running) {
+        clearInterval(checkInterval);
+        console.log(`✓ Server started at ${host}:${port}`);
+        resolve();
+      } else if (Date.now() - startTime > SERVER_STARTUP_TIMEOUT) {
+        clearInterval(checkInterval);
+        serverProcess.kill();
+        reject(new Error('Server startup timeout'));
+      }
+    }, 500);
+  });
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  try {
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('  Loxia Autopilot One - Terminal UI');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('');
+
+    // Parse command line arguments
+    const args = process.argv.slice(2);
+    let host = DEFAULT_HOST;
+    let port = DEFAULT_PORT;
+
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === '--host' && args[i + 1]) {
+        host = args[i + 1];
+        i++;
+      } else if (args[i] === '--port' && args[i + 1]) {
+        port = parseInt(args[i + 1], 10);
+        i++;
+      }
+    }
+
+    // Check if server is running
+    console.log(`🔍 Checking if server is running at ${host}:${port}...`);
+    const serverRunning = await isServerRunning(host, port);
+
+    if (!serverRunning) {
+      console.log('✗ Server is not running');
+      await startServer(host, port);
+    } else {
+      console.log(`✓ Server is already running at ${host}:${port}`);
+    }
+
+    console.log('');
+    console.log('🎨 Launching Ink-based Terminal UI...');
+    console.log('');
+
+    // Small delay
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Set environment variables for Ink app
+    process.env.LOXIA_HOST = host;
+    process.env.LOXIA_PORT = port.toString();
+
+    // Launch Terminal UI
+    await import('../src/interfaces/terminal/index.js');
+
+  } catch (error) {
+    console.error('');
+    console.error('❌ Failed to start Terminal UI:');
+    console.error('  ', error.message);
+    console.error('');
+    console.error('💡 Troubleshooting:');
+    console.error('   1. Make sure no other process is using port 8080');
+    console.error('   2. Try running the server manually: node bin/cli.js');
+    console.error('   3. Check logs for more details');
+    console.error('');
+    process.exit(1);
+  }
+}
+
+// Run
+main();