jfl 0.1.0 → 0.2.0

package/dist/commands/service-manager.js

@@ -0,0 +1,967 @@
+/**
+ * Service Manager API Server
+ *
+ * HTTP API for managing services across all JFL projects.
+ * Provides unified service status and control interface.
+ *
+ * @purpose Service Manager API daemon for TUI and external integration
+ */
+import chalk from "chalk";
+import ora from "ora";
+import { execSync, spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as http from "http";
+import { homedir } from "os";
+import { promisify } from "util";
+import { exec } from "child_process";
+import { JFL_PATHS, JFL_FILES } from "../utils/jfl-paths.js";
+const execAsync = promisify(exec);
+const DEFAULT_PORT = 3402;
+const PID_FILE = ".jfl/service-manager.pid";
+const LOG_FILE = ".jfl/logs/service-manager.log";
+const CONFIG_FILE = path.join(JFL_PATHS.config, "service-manager.json");
+const GLOBAL_SERVICES_FILE = path.join(JFL_PATHS.data, "services.json");
+// ============================================================================
+// Config Management
+// ============================================================================
+function loadConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        const defaultConfig = { port: DEFAULT_PORT };
+        saveConfig(defaultConfig);
+        return defaultConfig;
+    }
+    try {
+        const content = fs.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return { port: DEFAULT_PORT };
+    }
+}
+function saveConfig(config) {
+    const dir = path.dirname(CONFIG_FILE);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getPort() {
+    if (process.env.JFL_SERVICE_MANAGER_PORT) {
+        return parseInt(process.env.JFL_SERVICE_MANAGER_PORT, 10);
+    }
+    return loadConfig().port;
+}
+// ============================================================================
+// Service Detection
+// ============================================================================
+function loadGlobalServices() {
+    if (!fs.existsSync(GLOBAL_SERVICES_FILE)) {
+        return { version: "1.0", services: {} };
+    }
+    const content = fs.readFileSync(GLOBAL_SERVICES_FILE, "utf-8");
+    return JSON.parse(content);
+}
+function loadProjectServices(projectRoot) {
+    const projectServicesFile = path.join(projectRoot, ".jfl", "services.json");
+    if (!fs.existsSync(projectServicesFile)) {
+        return { version: "1.0", services: {} };
+    }
+    const content = fs.readFileSync(projectServicesFile, "utf-8");
+    return JSON.parse(content);
+}
+function substituteVariables(str, vars) {
+    let result = str;
+    for (const [key, value] of Object.entries(vars)) {
+        result = result.replace(new RegExp(`\\$\\{${key}\\}`, "g"), value);
+    }
+    return result;
+}
+async function isServiceRunning(service) {
+    try {
+        const vars = {
+            PORT: service.port?.toString() || "",
+            HOME: homedir(),
+        };
+        const detectionCmd = substituteVariables(service.detection_command, vars);
+        const { stdout } = await execAsync(detectionCmd);
+        const pidStr = stdout.trim();
+        if (pidStr) {
+            const pid = parseInt(pidStr.split('\n')[0], 10);
+            if (!isNaN(pid)) {
+                return { running: true, pid };
+            }
+            return { running: true };
+        }
+        return { running: false };
+    }
+    catch (error) {
+        return { running: false };
+    }
+}
+function getServiceStartTime(service) {
+    if (!service.pid_file)
+        return null;
+    const vars = {
+        HOME: homedir(),
+    };
+    const pidFile = substituteVariables(service.pid_file, vars);
+    if (!fs.existsSync(pidFile))
+        return null;
+    try {
+        const stats = fs.statSync(pidFile);
+        return stats.mtime;
+    }
+    catch {
+        return null;
+    }
+}
+async function getServiceStatus(name, service) {
+    const running = await isServiceRunning(service);
+    const startTime = getServiceStartTime(service);
+    let uptime;
+    let started_at;
+    if (running.running && startTime) {
+        const now = new Date();
+        const diffMs = now.getTime() - startTime.getTime();
+        const hours = Math.floor(diffMs / (1000 * 60 * 60));
+        const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60));
+        uptime = hours > 0 ? `${hours}h${minutes}m` : `${minutes}m`;
+        started_at = startTime.toISOString();
+    }
+    const vars = {
+        HOME: homedir(),
+        PORT: service.port?.toString() || "",
+    };
+    return {
+        name,
+        status: running.running ? "running" : "stopped",
+        pid: running.pid,
+        port: service.port,
+        uptime,
+        started_at,
+        description: service.description,
+        log_path: service.log_file ? substituteVariables(service.log_file, vars) : undefined,
+        health_url: service.health_url ? substituteVariables(service.health_url, vars) : undefined
+    };
+}
+async function getAllServiceStatuses() {
+    const globalServices = loadGlobalServices();
+    const projectRoot = process.cwd();
+    const projectServices = loadProjectServices(projectRoot);
+    const statuses = [];
+    // Get global services
+    for (const [name, service] of Object.entries(globalServices.services)) {
+        const status = await getServiceStatus(name, service);
+        statuses.push(status);
+    }
+    // Get project services
+    for (const [name, service] of Object.entries(projectServices.services)) {
+        const status = await getServiceStatus(name, service);
+        statuses.push(status);
+    }
+    return statuses;
+}
+// ============================================================================
+// Service Control
+// ============================================================================
+async function startServiceByName(serviceName) {
+    const globalServices = loadGlobalServices();
+    const projectRoot = process.cwd();
+    const projectServices = loadProjectServices(projectRoot);
+    let service = globalServices.services[serviceName] || projectServices.services[serviceName];
+    if (!service) {
+        return { success: false, message: `Service not found: ${serviceName}` };
+    }
+    // Check if already running
+    const running = await isServiceRunning(service);
+    if (running.running) {
+        return { success: true, message: `Service already running (PID: ${running.pid})` };
+    }
+    const vars = {
+        PORT: service.port?.toString() || "",
+        HOME: homedir(),
+        WORKSPACE: projectRoot,
+    };
+    const startCmd = substituteVariables(service.start_command, vars);
+    try {
+        await execAsync(startCmd, { cwd: projectRoot });
+        return { success: true, message: `Started ${serviceName}` };
+    }
+    catch (error) {
+        return { success: false, message: `Failed to start: ${error.message}` };
+    }
+}
+async function stopServiceByName(serviceName) {
+    const globalServices = loadGlobalServices();
+    const projectRoot = process.cwd();
+    const projectServices = loadProjectServices(projectRoot);
+    let service = globalServices.services[serviceName] || projectServices.services[serviceName];
+    if (!service) {
+        return { success: false, message: `Service not found: ${serviceName}` };
+    }
+    const vars = {
+        PORT: service.port?.toString() || "",
+        HOME: homedir(),
+    };
+    const stopCmd = substituteVariables(service.stop_command, vars);
+    try {
+        await execAsync(stopCmd);
+        return { success: true, message: `Stopped ${serviceName}` };
+    }
+    catch (error) {
+        return { success: false, message: `Failed to stop: ${error.message}` };
+    }
+}
+async function restartServiceByName(serviceName) {
+    await stopServiceByName(serviceName);
+    await new Promise(resolve => setTimeout(resolve, 500));
+    return startServiceByName(serviceName);
+}
+// ============================================================================
+// Service Tool Execution (Auto-Generated MCP)
+// ============================================================================
+async function executeServiceTool(serviceName, service, toolName, args) {
+    // Check for custom .jfl-mcp.js file first
+    const servicePath = service.path;
+    if (servicePath) {
+        const customMcpPath = path.join(servicePath, '.jfl-mcp.js');
+        if (fs.existsSync(customMcpPath)) {
+            // Use custom MCP server
+            return await executeCustomMCP(customMcpPath, toolName, args);
+        }
+    }
+    // Fall back to auto-generated tools from services.json
+    return await executeAutoGeneratedTool(serviceName, service, toolName, args);
+}
+async function executeCustomMCP(mcpPath, toolName, args) {
+    // Spawn the custom MCP server and send JSON-RPC request
+    const { spawn } = await import("child_process");
+    return new Promise((resolve, reject) => {
+        const child = spawn("node", [mcpPath]);
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`MCP server exited with code ${code}: ${stderr}`));
+            }
+            else {
+                try {
+                    // Parse JSON-RPC response
+                    const lines = stdout.split('\n').filter(l => l.trim());
+                    const lastLine = lines[lines.length - 1];
+                    const response = JSON.parse(lastLine);
+                    if (response.result?.content?.[0]?.text) {
+                        resolve(response.result.content[0].text);
+                    }
+                    else if (response.error) {
+                        reject(new Error(response.error.message));
+                    }
+                    else {
+                        resolve(JSON.stringify(response.result));
+                    }
+                }
+                catch (error) {
+                    reject(new Error(`Failed to parse MCP response: ${error}`));
+                }
+            }
+        });
+        // Send JSON-RPC requests
+        const requests = [
+            JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize" }),
+            JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/call", params: { name: toolName, arguments: args } })
+        ];
+        requests.forEach(req => child.stdin.write(req + '\n'));
+        child.stdin.end();
+    });
+}
+async function executeAutoGeneratedTool(serviceName, service, toolName, args) {
+    // Handle standard tools
+    switch (toolName) {
+        case "status":
+            return await handleStatus(serviceName, service);
+        case "logs":
+            return await handleLogs(serviceName, service, args?.lines || 50);
+        case "health":
+            return await handleHealth(serviceName, service);
+        case "start":
+            const startResult = await startServiceByName(serviceName);
+            return startResult.message;
+        case "stop":
+            const stopResult = await stopServiceByName(serviceName);
+            return stopResult.message;
+        case "restart":
+            const restartResult = await restartServiceByName(serviceName);
+            return restartResult.message;
+    }
+    // Handle custom tools from services.json
+    if (service.mcp?.tools) {
+        const customTool = service.mcp.tools.find((t) => t.name === toolName);
+        if (customTool) {
+            return await executeCustomTool(serviceName, service, customTool, args);
+        }
+    }
+    throw new Error(`Unknown tool: ${toolName}`);
+}
+async function handleStatus(serviceName, service) {
+    const status = await getServiceStatus(serviceName, service);
+    const lines = [
+        `Service: ${status.name}`,
+        `Status: ${status.status}`,
+        `Description: ${status.description}`,
+    ];
+    if (status.port)
+        lines.push(`Port: ${status.port}`);
+    if (status.pid)
+        lines.push(`PID: ${status.pid}`);
+    if (status.uptime)
+        lines.push(`Uptime: ${status.uptime}`);
+    if (status.started_at)
+        lines.push(`Started: ${status.started_at}`);
+    if (status.log_path)
+        lines.push(`Logs: ${status.log_path}`);
+    if (status.health_url)
+        lines.push(`Health URL: ${status.health_url}`);
+    return lines.join('\n');
+}
+async function handleLogs(serviceName, service, lines) {
+    const vars = {
+        PORT: service.port?.toString() || "",
+        HOME: homedir(),
+    };
+    const logFile = service.log_file ? substituteVariables(service.log_file, vars) : undefined;
+    if (!logFile || !fs.existsSync(logFile)) {
+        return "No logs available";
+    }
+    try {
+        const { stdout } = await execAsync(`tail -n ${lines} "${logFile}"`);
+        return stdout || "No logs";
+    }
+    catch (error) {
+        return `Error reading logs: ${error.message}`;
+    }
+}
+async function handleHealth(serviceName, service) {
+    if (!service.health_url) {
+        return `Health check not configured for ${serviceName}`;
+    }
+    const vars = {
+        PORT: service.port?.toString() || "",
+    };
+    const healthUrl = substituteVariables(service.health_url, vars);
+    try {
+        const response = await fetch(healthUrl, {
+            method: "GET",
+            signal: AbortSignal.timeout(5000),
+        });
+        if (response.ok) {
+            const data = await response.text();
+            return `Health check passed for ${serviceName}\n${data}`;
+        }
+        else {
+            return `Health check failed for ${serviceName}: HTTP ${response.status}`;
+        }
+    }
+    catch (error) {
+        return `Health check failed for ${serviceName}: ${error.message}`;
+    }
+}
+async function executeCustomTool(serviceName, service, tool, args) {
+    const vars = {
+        SERVICE_NAME: serviceName,
+        PORT: service.port?.toString() || "",
+        HOME: homedir(),
+        SERVICE_PATH: service.path || process.cwd(),
+    };
+    // Substitute variables in command
+    let command = tool.command;
+    for (const [key, value] of Object.entries(vars)) {
+        command = command.replace(new RegExp(`\\$\\{${key}\\}`, "g"), value);
+    }
+    // Substitute any arguments passed to the tool
+    if (args) {
+        for (const [key, value] of Object.entries(args)) {
+            command = command.replace(new RegExp(`\\$\\{${key}\\}`, "g"), String(value));
+        }
+    }
+    const timeout = tool.timeout || 120000; // 2 minutes default
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            timeout,
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+        });
+        let result = "";
+        if (stdout)
+            result += stdout;
+        if (stderr)
+            result += `\nStderr:\n${stderr}`;
+        return result || "Command completed successfully (no output)";
+    }
+    catch (error) {
+        throw new Error(`Command failed: ${error.message}\nCommand: ${command}`);
+    }
+}
+async function removeServiceByName(serviceName) {
+    const globalServices = loadGlobalServices();
+    const projectRoot = process.cwd();
+    const projectServices = loadProjectServices(projectRoot);
+    // Check global services
+    if (globalServices.services[serviceName]) {
+        delete globalServices.services[serviceName];
+        fs.writeFileSync(GLOBAL_SERVICES_FILE, JSON.stringify(globalServices, null, 2));
+        return { success: true, message: `Removed ${serviceName} from global services` };
+    }
+    // Check project services
+    const projectServicesFile = path.join(projectRoot, ".jfl", "services.json");
+    if (projectServices.services[serviceName]) {
+        delete projectServices.services[serviceName];
+        fs.writeFileSync(projectServicesFile, JSON.stringify(projectServices, null, 2));
+        return { success: true, message: `Removed ${serviceName} from project services` };
+    }
+    return { success: false, message: `Service not found: ${serviceName}` };
+}
+// ============================================================================
+// HTTP Server
+// ============================================================================
+function createServer(port) {
+    const server = http.createServer(async (req, res) => {
+        // CORS
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        const url = new URL(req.url || "/", `http://localhost:${port}`);
+        // Health check
+        if (url.pathname === "/health" && req.method === "GET") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "ok", port }));
+            return;
+        }
+        // List all services
+        if (url.pathname === "/services" && req.method === "GET") {
+            try {
+                const services = await getAllServiceStatuses();
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ services }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Start service
+        const startMatch = url.pathname.match(/^\/services\/([^/]+)\/start$/);
+        if (startMatch && req.method === "POST") {
+            const serviceName = startMatch[1];
+            const result = await startServiceByName(serviceName);
+            res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(result));
+            return;
+        }
+        // Stop service
+        const stopMatch = url.pathname.match(/^\/services\/([^/]+)\/stop$/);
+        if (stopMatch && req.method === "POST") {
+            const serviceName = stopMatch[1];
+            const result = await stopServiceByName(serviceName);
+            res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(result));
+            return;
+        }
+        // Restart service
+        const restartMatch = url.pathname.match(/^\/services\/([^/]+)\/restart$/);
+        if (restartMatch && req.method === "POST") {
+            const serviceName = restartMatch[1];
+            const result = await restartServiceByName(serviceName);
+            res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(result));
+            return;
+        }
+        // Get service logs
+        const logsMatch = url.pathname.match(/^\/services\/([^/]+)\/logs$/);
+        if (logsMatch && req.method === "GET") {
+            const serviceName = logsMatch[1];
+            const lines = parseInt(url.searchParams.get("lines") || "50", 10);
+            try {
+                const globalServices = loadGlobalServices();
+                const projectRoot = process.cwd();
+                const projectServices = loadProjectServices(projectRoot);
+                const service = globalServices.services[serviceName] || projectServices.services[serviceName];
+                if (!service) {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: `Service not found: ${serviceName}` }));
+                    return;
+                }
+                const vars = {
+                    PORT: service.port?.toString() || "",
+                    HOME: homedir(),
+                };
+                const logFile = service.log_file ? substituteVariables(service.log_file, vars) : undefined;
+                if (!logFile || !fs.existsSync(logFile)) {
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ logs: "No logs available" }));
+                    return;
+                }
+                // Read last N lines using tail
+                try {
+                    const { stdout } = await execAsync(`tail -n ${lines} "${logFile}"`);
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ logs: stdout }));
+                }
+                catch (error) {
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ logs: `Error reading logs: ${error.message}` }));
+                }
+            }
+            catch (error) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: error.message }));
+            }
+            return;
+        }
+        // Remove service
+        const removeMatch = url.pathname.match(/^\/services\/([^/]+)$/);
+        if (removeMatch && req.method === "DELETE") {
+            const serviceName = removeMatch[1];
+            const result = await removeServiceByName(serviceName);
+            res.writeHead(result.success ? 200 : 500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(result));
+            return;
+        }
+        // ========================================================================
+        // Service Registry API (for service mesh)
+        // ========================================================================
+        // List all services in registry
+        if (url.pathname === "/registry" && req.method === "GET") {
+            try {
+                const services = await getAllServiceStatuses();
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ services }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Get specific service info
+        const registryGetMatch = url.pathname.match(/^\/registry\/([^/]+)$/);
+        if (registryGetMatch && req.method === "GET") {
+            const serviceName = registryGetMatch[1];
+            try {
+                const services = await getAllServiceStatuses();
+                const service = services.find(s => s.name === serviceName);
+                if (!service) {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: `Service not found: ${serviceName}` }));
+                    return;
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ service }));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: err.message }));
+            }
+            return;
+        }
+        // Call a service's tool (proxy to service MCP server)
+        const registryCallMatch = url.pathname.match(/^\/registry\/([^/]+)\/call$/);
+        if (registryCallMatch && req.method === "POST") {
+            const serviceName = registryCallMatch[1];
+            let body = "";
+            req.on("data", chunk => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const { tool, args } = JSON.parse(body);
+                    // Get service info
+                    const globalServices = loadGlobalServices();
+                    const projectRoot = process.cwd();
+                    const projectServices = loadProjectServices(projectRoot);
+                    const service = globalServices.services[serviceName] || projectServices.services[serviceName];
+                    if (!service) {
+                        res.writeHead(404, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: `Service not found: ${serviceName}` }));
+                        return;
+                    }
+                    // Execute the tool
+                    const result = await executeServiceTool(serviceName, service, tool, args);
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ result }));
+                }
+                catch (error) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: error.message }));
+                }
+            });
+            return;
+        }
+        // Register a service (for service-local MCP servers)
+        if (url.pathname === "/registry/register" && req.method === "POST") {
+            let body = "";
+            req.on("data", chunk => { body += chunk.toString(); });
+            req.on("end", async () => {
+                try {
+                    const { name, description, version, path: servicePath, mcpServerPath } = JSON.parse(body);
+                    // Add to global services (or project services if in a GTM project)
+                    const globalServices = loadGlobalServices();
+                    // Check if service already exists
+                    if (globalServices.services[name]) {
+                        // Update existing
+                        globalServices.services[name].description = description;
+                        if (mcpServerPath) {
+                            globalServices.services[name].mcp = {
+                                enabled: true,
+                                serverPath: mcpServerPath
+                            };
+                        }
+                    }
+                    else {
+                        // Create new (minimal config - can be enhanced later)
+                        globalServices.services[name] = {
+                            name,
+                            type: "process",
+                            description,
+                            start_command: `cd ${servicePath} && npm start`,
+                            stop_command: "echo 'Manual stop required'",
+                            detection_command: "echo ''",
+                            mcp: {
+                                enabled: true,
+                                serverPath: mcpServerPath
+                            }
+                        };
+                    }
+                    fs.writeFileSync(GLOBAL_SERVICES_FILE, JSON.stringify(globalServices, null, 2));
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ success: true, message: `Registered ${name}` }));
+                }
+                catch (error) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: error.message }));
+                }
+            });
+            return;
+        }
+        // 404
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+    });
+    return server;
+}
+// ============================================================================
+// Daemon Management
+// ============================================================================
+function getPidFile() {
+    const pidDir = JFL_FILES.servicesPids;
+    if (!fs.existsSync(pidDir)) {
+        fs.mkdirSync(pidDir, { recursive: true });
+    }
+    return path.join(pidDir, "service-manager.pid");
+}
+function getLogFile() {
+    const logDir = JFL_FILES.servicesLogs;
+    if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true });
+    }
+    return path.join(logDir, "service-manager.log");
+}
+function isRunning() {
+    const pidFile = getPidFile();
+    if (!fs.existsSync(pidFile)) {
+        return { running: false };
+    }
+    const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+    try {
+        process.kill(pid, 0); // Check if process exists
+        return { running: true, pid };
+    }
+    catch {
+        // Process doesn't exist, clean up stale PID file
+        fs.unlinkSync(pidFile);
+        return { running: false };
+    }
+}
+async function isPortInUse(port) {
+    return new Promise((resolve) => {
+        const server = http.createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(true);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(false);
+        });
+        server.listen(port);
+    });
+}
+async function startDaemon(port) {
+    const status = isRunning();
+    if (status.running) {
+        return { success: true, message: `Service Manager already running (PID: ${status.pid})` };
+    }
+    // Check if port is in use
+    const portInUse = await isPortInUse(port);
+    if (portInUse) {
+        return { success: false, message: `Port ${port} is already in use` };
+    }
+    const logFile = getLogFile();
+    const pidFile = getPidFile();
+    // Find jfl command
+    let jflCmd = "jfl";
+    try {
+        execSync("which jfl", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        jflCmd = process.argv[1];
+    }
+    // Start as detached process
+    const child = spawn(jflCmd, ["service-manager", "serve", "--port", String(port)], {
+        detached: true,
+        stdio: ["ignore", fs.openSync(logFile, "a"), fs.openSync(logFile, "a")],
+        env: { ...process.env, NODE_ENV: "production" }
+    });
+    child.unref();
+    // Wait for startup
+    await new Promise(resolve => setTimeout(resolve, 500));
+    // Write PID file
+    if (child.pid) {
+        try {
+            process.kill(child.pid, 0);
+            fs.writeFileSync(pidFile, String(child.pid));
+            return { success: true, message: `Started (PID: ${child.pid})` };
+        }
+        catch {
+            return { success: false, message: "Process started but immediately exited" };
+        }
+    }
+    return { success: false, message: "Failed to spawn daemon process" };
+}
+async function stopDaemon() {
+    const status = isRunning();
+    if (!status.running || !status.pid) {
+        return { success: true, message: "Service Manager is not running" };
+    }
+    const pidFile = getPidFile();
+    try {
+        // Send SIGTERM first
+        process.kill(status.pid, "SIGTERM");
+        // Wait up to 3 seconds for graceful shutdown
+        let attempts = 0;
+        while (attempts < 6) {
+            await new Promise(resolve => setTimeout(resolve, 500));
+            try {
+                process.kill(status.pid, 0);
+                attempts++;
+            }
+            catch {
+                break;
+            }
+        }
+        // If still running, force kill
+        try {
+            process.kill(status.pid, 0);
+            process.kill(status.pid, "SIGKILL");
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        catch {
+            // Process is gone
+        }
+        // Clean up PID file
+        if (fs.existsSync(pidFile)) {
+            fs.unlinkSync(pidFile);
+        }
+        return { success: true, message: "Service Manager stopped" };
+    }
+    catch (err) {
+        return { success: false, message: `Failed to stop: ${err}` };
+    }
+}
+// ============================================================================
+// CLI Command
+// ============================================================================
+export async function serviceManagerCommand(action, options = {}) {
+    const port = options.port || getPort();
+    switch (action) {
+        case "start": {
+            const spinner = ora("Starting Service Manager...").start();
+            const result = await startDaemon(port);
+            if (result.success) {
+                if (result.message.includes("already running")) {
+                    spinner.info(result.message);
+                }
+                else {
+                    spinner.succeed(`Service Manager started on port ${port}`);
+                }
+            }
+            else {
+                spinner.fail(result.message);
+            }
+            break;
+        }
+        case "stop": {
+            const spinner = ora("Stopping Service Manager...").start();
+            const result = await stopDaemon();
+            if (result.success) {
+                spinner.succeed(result.message);
+            }
+            else {
+                spinner.fail(result.message);
+            }
+            break;
+        }
+        case "restart": {
+            await serviceManagerCommand("stop", options);
+            await new Promise(resolve => setTimeout(resolve, 500));
+            await serviceManagerCommand("start", options);
+            break;
+        }
+        case "status": {
+            const status = isRunning();
+            if (status.running) {
+                console.log(chalk.green(`\n  Service Manager is running`));
+                console.log(chalk.gray(`  PID: ${status.pid}`));
+                console.log(chalk.gray(`  Port: ${port}`));
+                console.log();
+            }
+            else {
+                console.log(chalk.yellow("\n  Service Manager is not running"));
+                console.log(chalk.gray("  Run: jfl service-manager start\n"));
+            }
+            break;
+        }
+        case "ensure": {
+            const status = isRunning();
+            if (status.running) {
+                // Already running, verify it's healthy
+                try {
+                    const response = await fetch(`http://localhost:${port}/health`, {
+                        signal: AbortSignal.timeout(2000)
+                    });
+                    if (response.ok) {
+                        // Healthy and running, nothing to do
+                        return;
+                    }
+                }
+                catch {
+                    // Process exists but not responding, fall through to restart
+                }
+            }
+            // Check if port is blocked by orphaned process
+            const portInUse = await isPortInUse(port);
+            if (portInUse) {
+                // Port is in use - check if it's actually Service Manager
+                try {
+                    const response = await fetch(`http://localhost:${port}/health`, {
+                        signal: AbortSignal.timeout(2000)
+                    });
+                    if (response.ok) {
+                        // It's a healthy Service Manager but PID file is missing/wrong
+                        // Don't kill it - just return
+                        return;
+                    }
+                }
+                catch {
+                    // Process on port is not responding to health check
+                }
+                // Port in use but not responding - try to clean up
+                try {
+                    const lsofOutput = execSync(`lsof -ti :${port}`, { encoding: 'utf-8' }).trim();
+                    if (lsofOutput) {
+                        const orphanedPid = parseInt(lsofOutput.split('\n')[0], 10);
+                        // Only kill if it's different from our tracked PID
+                        if (!status.pid || orphanedPid !== status.pid) {
+                            process.kill(orphanedPid, 'SIGTERM');
+                            await new Promise(resolve => setTimeout(resolve, 500));
+                        }
+                    }
+                }
+                catch {
+                    // lsof failed or process already gone
+                }
+            }
+            // Start silently
+            await startDaemon(port);
+            break;
+        }
+        case "serve": {
+            // Run server in foreground (used by daemon)
+            const server = createServer(port);
+            let isListening = false;
+            process.on("uncaughtException", (err) => {
+                console.error(`Uncaught exception: ${err.message}`);
+                console.error(err.stack);
+            });
+            process.on("unhandledRejection", (reason, promise) => {
+                console.error(`Unhandled rejection at ${promise}: ${reason}`);
+            });
+            server.on("error", (err) => {
+                console.error(`Server error: ${err.message}`);
+                if (err.code === "EADDRINUSE") {
+                    console.error(`Port ${port} is already in use. Exiting.`);
+                    process.exit(1);
+                }
+            });
+            server.listen(port, () => {
+                isListening = true;
+                console.log(`Service Manager listening on port ${port}`);
+                console.log(`PID: ${process.pid}`);
+                console.log(`Ready to serve requests`);
+            });
+            const shutdown = () => {
+                if (!isListening) {
+                    process.exit(0);
+                    return;
+                }
+                console.log("Shutting down...");
+                server.close(() => {
+                    console.log("Server closed");
+                    process.exit(0);
+                });
+                setTimeout(() => {
+                    console.log("Force exit after timeout");
+                    process.exit(1);
+                }, 5000);
+            };
+            process.on("SIGTERM", shutdown);
+            process.on("SIGINT", shutdown);
+            const heartbeat = setInterval(() => {
+                if (isListening && Date.now() % 300000 < 60000) {
+                    console.log(`Heartbeat: Still running (PID: ${process.pid})`);
+                }
+            }, 60000);
+            process.on("exit", () => {
+                clearInterval(heartbeat);
+            });
+            break;
+        }
+        default: {
+            console.log(chalk.bold("\n  Service Manager - API for JFL services\n"));
+            console.log(chalk.gray("  Commands:"));
+            console.log("    jfl service-manager start     Start the daemon");
+            console.log("    jfl service-manager stop      Stop the daemon");
+            console.log("    jfl service-manager restart   Restart the daemon");
+            console.log("    jfl service-manager status    Check if running");
+            console.log("    jfl service-manager ensure    Start if not running (for hooks)");
+            console.log();
+            console.log(chalk.gray("  Options:"));
+            console.log("    --port <port>   Port to run on (default: 3402)");
+            console.log();
+        }
+    }
+}
+//# sourceMappingURL=service-manager.js.map