servherd 0.0.1 → 1.0.0

package/dist/cli/commands/logs.js

@@ -0,0 +1,292 @@
+import { readFile } from "fs/promises";
+import { pathExists } from "fs-extra/esm";
+import { RegistryService } from "../../services/registry.service.js";
+import { ProcessService } from "../../services/process.service.js";
+import { formatLogs, formatError, formatWarning, formatSuccess } from "../output/formatters.js";
+import { formatAsJson, formatErrorAsJson } from "../output/json-formatter.js";
+import { logger } from "../../utils/logger.js";
+import { followLog } from "../../utils/log-follower.js";
+import { parseTimeFilter, filterLogsByTime } from "../../utils/time-parser.js";
+import { ServherdError, ServherdErrorCode } from "../../types/errors.js";
+const DEFAULT_LINES = 50;
+/**
+ * Parse timestamp from PM2-style log lines.
+ * PM2 outputs timestamps in ISO 8601 format: 2026-01-11T09:51:49.598-08:00: message
+ * Returns null if no timestamp is found.
+ */
+function parseLogTimestamp(line) {
+    // PM2 format: "2026-01-11T09:51:49.598-08:00: message"
+    // Extract everything before the first ": " as potential timestamp
+    const colonIndex = line.indexOf(": ");
+    if (colonIndex === -1) {
+        return null;
+    }
+    const potentialTimestamp = line.substring(0, colonIndex);
+    const date = new Date(potentialTimestamp);
+    if (!isNaN(date.getTime())) {
+        return date;
+    }
+    return null;
+}
+/**
+ * Execute flush command to clear logs
+ */
+export async function executeFlush(options) {
+    const registryService = new RegistryService();
+    const processService = new ProcessService();
+    try {
+        await processService.connect();
+        if (options.all) {
+            await processService.flush();
+            return {
+                flushed: true,
+                all: true,
+                message: "Logs flushed for all servers",
+            };
+        }
+        if (!options.name) {
+            throw new ServherdError(ServherdErrorCode.COMMAND_MISSING_ARGUMENT, "Server name is required (or use --all to flush all logs)");
+        }
+        // Load registry to verify server exists
+        await registryService.load();
+        const server = registryService.findByName(options.name);
+        if (!server) {
+            throw new ServherdError(ServherdErrorCode.SERVER_NOT_FOUND, `Server "${options.name}" not found`);
+        }
+        await processService.flush(server.pm2Name);
+        return {
+            flushed: true,
+            name: options.name,
+            message: `Logs flushed for server "${options.name}"`,
+        };
+    }
+    finally {
+        processService.disconnect();
+    }
+}
+/**
+ * Execute the logs command
+ */
+export async function executeLogs(options) {
+    const registryService = new RegistryService();
+    const processService = new ProcessService();
+    if (!options.name) {
+        throw new ServherdError(ServherdErrorCode.COMMAND_MISSING_ARGUMENT, "Server name is required");
+    }
+    try {
+        // Load registry
+        await registryService.load();
+        // Find server by name
+        const server = registryService.findByName(options.name);
+        if (!server) {
+            throw new ServherdError(ServherdErrorCode.SERVER_NOT_FOUND, `Server "${options.name}" not found`);
+        }
+        // Connect to PM2 to get process details
+        await processService.connect();
+        // Get process info from PM2
+        const procDesc = await processService.describe(server.pm2Name);
+        const lines = options.lines ?? DEFAULT_LINES;
+        let outLogPath;
+        let errLogPath;
+        let status = "unknown";
+        let logs = "";
+        if (procDesc) {
+            const pm2Env = procDesc.pm2_env;
+            outLogPath = pm2Env.pm_out_log_path;
+            errLogPath = pm2Env.pm_err_log_path;
+            status = pm2Env.status === "online" ? "online"
+                : pm2Env.status === "stopped" || pm2Env.status === "stopping" ? "stopped"
+                    : pm2Env.status === "errored" ? "errored"
+                        : "unknown";
+            // Read the appropriate log file
+            const logPath = options.error ? errLogPath : outLogPath;
+            if (logPath) {
+                try {
+                    const exists = await pathExists(logPath);
+                    if (exists) {
+                        const content = await readFile(logPath, "utf-8");
+                        // Filter out empty strings caused by trailing newlines
+                        let allLines = content.split("\n").filter((line) => line.length > 0);
+                        // Apply --since filter if specified
+                        if (options.since) {
+                            const sinceDate = parseTimeFilter(options.since);
+                            allLines = filterLogsByTime(allLines, sinceDate, parseLogTimestamp);
+                        }
+                        // Apply --head or --lines
+                        if (options.head !== undefined) {
+                            // --head shows first N lines
+                            const headLines = allLines.slice(0, options.head);
+                            logs = headLines.join("\n");
+                        }
+                        else {
+                            // Default: --lines shows last N lines
+                            const lastLines = allLines.slice(-lines);
+                            logs = lastLines.join("\n");
+                        }
+                    }
+                    else {
+                        logs = "(log file does not exist)";
+                    }
+                }
+                catch (error) {
+                    logger.debug({ error, logPath }, "Failed to read log file");
+                    logs = "(failed to read log file)";
+                }
+            }
+            else {
+                logs = "(no log path available)";
+            }
+        }
+        else {
+            logs = "(process not found in PM2)";
+        }
+        return {
+            name: options.name,
+            status,
+            logs,
+            lines: options.head ?? lines,
+            outLogPath,
+            errLogPath,
+        };
+    }
+    finally {
+        processService.disconnect();
+    }
+}
+/**
+ * CLI action handler for logs command
+ */
+export async function logsAction(name, options) {
+    try {
+        // Handle --flush option
+        if (options.flush) {
+            const result = await executeFlush({ name, all: options.all });
+            if (options.json) {
+                console.log(formatAsJson(result));
+            }
+            else {
+                console.log(formatSuccess(result.message));
+            }
+            return;
+        }
+        // Validate that name is provided for non-flush operations
+        if (!name) {
+            const error = new ServherdError(ServherdErrorCode.COMMAND_MISSING_ARGUMENT, "Server name is required");
+            if (options.json) {
+                console.log(formatErrorAsJson(error));
+            }
+            else {
+                console.error(formatError(error.message));
+            }
+            process.exitCode = 1;
+            return;
+        }
+        // Handle --follow option
+        if (options.follow && !options.json) {
+            await handleFollowMode(name, options);
+            return;
+        }
+        if (options.follow && options.json) {
+            // Follow mode doesn't work well with JSON output
+            console.log(formatWarning("The --follow flag is not supported with --json output. Showing static logs."));
+        }
+        const result = await executeLogs({
+            name,
+            lines: options.lines,
+            error: options.error,
+            follow: options.follow,
+            since: options.since,
+            head: options.head,
+        });
+        if (options.json) {
+            console.log(formatAsJson(result));
+        }
+        else {
+            console.log(formatLogs(result));
+        }
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(formatErrorAsJson(error));
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(formatError(message));
+        }
+        logger.error({ error }, "Logs command failed");
+        process.exitCode = 1;
+    }
+}
+/**
+ * Handle follow mode for logs
+ */
+async function handleFollowMode(name, options) {
+    const registryService = new RegistryService();
+    const processService = new ProcessService();
+    try {
+        await registryService.load();
+        const server = registryService.findByName(name);
+        if (!server) {
+            console.error(formatError(`Server "${name}" not found`));
+            process.exitCode = 1;
+            return;
+        }
+        await processService.connect();
+        const procDesc = await processService.describe(server.pm2Name);
+        if (!procDesc) {
+            console.error(formatError(`Process not found in PM2 for "${name}"`));
+            process.exitCode = 1;
+            return;
+        }
+        const logPath = options.error
+            ? procDesc.pm2_env.pm_err_log_path
+            : procDesc.pm2_env.pm_out_log_path;
+        if (!logPath) {
+            console.error(formatError("No log path available"));
+            process.exitCode = 1;
+            return;
+        }
+        const exists = await pathExists(logPath);
+        if (!exists) {
+            console.error(formatError(`Log file does not exist: ${logPath}`));
+            process.exitCode = 1;
+            return;
+        }
+        console.log(formatWarning(`Following logs for "${name}" (Ctrl+C to stop)...`));
+        console.log("");
+        // Set up abort controller for graceful shutdown
+        const controller = new AbortController();
+        // Handle SIGINT (Ctrl+C)
+        const handleSignal = () => {
+            controller.abort();
+        };
+        process.on("SIGINT", handleSignal);
+        process.on("SIGTERM", handleSignal);
+        // Optional: parse --since for filtering live logs
+        let sinceDate;
+        if (options.since) {
+            sinceDate = parseTimeFilter(options.since);
+        }
+        try {
+            await followLog(logPath, controller.signal, (line) => {
+                // Filter by time if --since is specified
+                if (sinceDate) {
+                    const timestamp = parseLogTimestamp(line);
+                    if (timestamp && timestamp < sinceDate) {
+                        return; // Skip old lines
+                    }
+                }
+                console.log(line);
+            });
+        }
+        finally {
+            process.off("SIGINT", handleSignal);
+            process.off("SIGTERM", handleSignal);
+        }
+        console.log("");
+        console.log(formatSuccess("Stopped following logs."));
+    }
+    finally {
+        processService.disconnect();
+    }
+}

package/dist/cli/commands/mcp.d.ts

@@ -0,0 +1,5 @@
+/**
+ * CLI action handler for mcp command
+ * Starts the MCP server in stdio mode for use with Claude Code or other MCP clients
+ */
+export declare function mcpAction(): Promise<void>;

package/dist/cli/commands/mcp.js

@@ -0,0 +1,17 @@
+import { startStdioServer } from "../../mcp/index.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * CLI action handler for mcp command
+ * Starts the MCP server in stdio mode for use with Claude Code or other MCP clients
+ */
+export async function mcpAction() {
+    try {
+        await startStdioServer();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        // Don't use console.error as it would interfere with stdio transport
+        logger.error({ error }, "MCP server failed: " + message);
+        process.exitCode = 1;
+    }
+}

package/dist/cli/commands/refresh.d.ts

@@ -0,0 +1,20 @@
+import type { ServerStatus } from "../../types/registry.js";
+export interface RefreshCommandOptions {
+    name?: string;
+    all?: boolean;
+    tag?: string;
+    dryRun?: boolean;
+}
+export interface RefreshResult {
+    name: string;
+    success: boolean;
+    status?: ServerStatus;
+    message?: string;
+    driftDetails?: string;
+    skipped?: boolean;
+}
+/**
+ * Execute the refresh command
+ * Finds servers with config drift and restarts them with updated config
+ */
+export declare function executeRefresh(options: RefreshCommandOptions): Promise<RefreshResult[]>;

package/dist/cli/commands/refresh.js

@@ -0,0 +1,139 @@
+import { RegistryService } from "../../services/registry.service.js";
+import { ProcessService } from "../../services/process.service.js";
+import { ConfigService } from "../../services/config.service.js";
+import { renderTemplate, renderEnvTemplates, getTemplateVariables } from "../../utils/template.js";
+import { extractUsedConfigKeys, createConfigSnapshot, findServersWithDrift, formatDrift, } from "../../utils/config-drift.js";
+/**
+ * Re-resolve a server's command template with current config values
+ * Updates the registry with new resolved command and config snapshot
+ */
+async function refreshServerConfig(server, config, registryService) {
+    // Get template variables with current config
+    const templateVars = getTemplateVariables(config, server.port);
+    // Re-resolve the command template
+    const resolvedCommand = renderTemplate(server.command, templateVars);
+    // Re-resolve environment variables if any
+    const resolvedEnv = server.env
+        ? renderEnvTemplates(server.env, templateVars)
+        : {};
+    // Extract new used config keys and create new snapshot
+    const usedConfigKeys = extractUsedConfigKeys(server.command);
+    const configSnapshot = createConfigSnapshot(config, usedConfigKeys);
+    // Update the registry
+    await registryService.updateServer(server.id, {
+        resolvedCommand,
+        env: resolvedEnv,
+        usedConfigKeys,
+        configSnapshot,
+    });
+    return { resolvedCommand };
+}
+/**
+ * Execute the refresh command
+ * Finds servers with config drift and restarts them with updated config
+ */
+export async function executeRefresh(options) {
+    const registryService = new RegistryService();
+    const processService = new ProcessService();
+    const configService = new ConfigService();
+    try {
+        // Load registry and config
+        await registryService.load();
+        const config = await configService.load();
+        // Connect to PM2
+        await processService.connect();
+        // Determine which servers to check
+        let servers = [];
+        if (options.all) {
+            servers = registryService.listServers();
+        }
+        else if (options.tag) {
+            servers = registryService.listServers({ tag: options.tag });
+        }
+        else if (options.name) {
+            const server = registryService.findByName(options.name);
+            if (!server) {
+                throw new Error(`Server "${options.name}" not found`);
+            }
+            servers = [server];
+        }
+        else {
+            // Default: find all servers with drift
+            servers = registryService.listServers();
+        }
+        // Find servers with drift
+        const serversWithDrift = findServersWithDrift(servers, config);
+        // If no drift, return early
+        if (serversWithDrift.length === 0) {
+            return [{
+                    name: "",
+                    success: true,
+                    skipped: true,
+                    message: "No servers have config drift",
+                }];
+        }
+        const results = [];
+        for (const { server, drift } of serversWithDrift) {
+            const driftDetails = formatDrift(drift);
+            // Dry run mode - just report what would happen
+            if (options.dryRun) {
+                results.push({
+                    name: server.name,
+                    success: true,
+                    skipped: true,
+                    message: "Would refresh (dry-run mode)",
+                    driftDetails,
+                });
+                continue;
+            }
+            try {
+                // Re-resolve command with new config values
+                const { resolvedCommand } = await refreshServerConfig(server, config, registryService);
+                // Delete old process and start with new command
+                try {
+                    await processService.delete(server.pm2Name);
+                }
+                catch {
+                    // Process might not exist
+                }
+                // Parse the resolved command to extract script and args
+                const parts = resolvedCommand.trim().split(/\s+/);
+                const script = parts[0] || "node";
+                const args = parts.slice(1);
+                // Get the updated server entry for current env
+                const updatedServer = registryService.findById(server.id);
+                const env = updatedServer?.env ?? server.env;
+                await processService.start({
+                    name: server.pm2Name,
+                    script,
+                    args,
+                    cwd: server.cwd,
+                    env: {
+                        ...env,
+                        PORT: String(server.port),
+                    },
+                });
+                const status = await processService.getStatus(server.pm2Name);
+                results.push({
+                    name: server.name,
+                    success: true,
+                    status,
+                    driftDetails,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                results.push({
+                    name: server.name,
+                    success: false,
+                    message,
+                    driftDetails,
+                });
+            }
+        }
+        return results;
+    }
+    finally {
+        processService.disconnect();
+    }
+}

package/dist/cli/commands/remove.d.ts

@@ -0,0 +1,20 @@
+import { type RemoveResult } from "../output/formatters.js";
+export interface RemoveCommandOptions {
+    name?: string;
+    all?: boolean;
+    tag?: string;
+    force?: boolean;
+}
+/**
+ * Execute the remove command
+ */
+export declare function executeRemove(options: RemoveCommandOptions): Promise<RemoveResult[]>;
+/**
+ * CLI action handler for remove command
+ */
+export declare function removeAction(name: string | undefined, options: {
+    all?: boolean;
+    tag?: string;
+    force?: boolean;
+    json?: boolean;
+}): Promise<void>;

package/dist/cli/commands/remove.js

@@ -0,0 +1,144 @@
+import { confirm } from "@inquirer/prompts";
+import { RegistryService } from "../../services/registry.service.js";
+import { ProcessService } from "../../services/process.service.js";
+import { formatRemoveResult } from "../output/formatters.js";
+import { formatAsJson, formatErrorAsJson } from "../output/json-formatter.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * Execute the remove command
+ */
+export async function executeRemove(options) {
+    const registryService = new RegistryService();
+    const processService = new ProcessService();
+    const results = [];
+    try {
+        await registryService.load();
+        await processService.connect();
+        let serversToRemove = [];
+        if (options.all) {
+            serversToRemove = registryService.listServers();
+        }
+        else if (options.tag) {
+            serversToRemove = registryService.listServers({ tag: options.tag });
+        }
+        else if (options.name) {
+            const server = registryService.findByName(options.name);
+            if (server) {
+                serversToRemove = [server];
+            }
+            else {
+                return [{
+                        name: options.name,
+                        success: false,
+                        message: `Server "${options.name}" not found in registry`,
+                    }];
+            }
+        }
+        if (serversToRemove.length === 0) {
+            return [];
+        }
+        // Ask for confirmation unless --force is specified
+        if (!options.force) {
+            const serverNames = serversToRemove.map((s) => s.name).join(", ");
+            const message = serversToRemove.length === 1
+                ? `Are you sure you want to remove server "${serversToRemove[0].name}"?`
+                : `Are you sure you want to remove ${serversToRemove.length} servers (${serverNames})?`;
+            const confirmed = await confirm({ message });
+            if (!confirmed) {
+                return serversToRemove.map((server) => ({
+                    name: server.name,
+                    success: false,
+                    cancelled: true,
+                    message: "Cancelled by user",
+                }));
+            }
+        }
+        for (const server of serversToRemove) {
+            try {
+                // First try to delete from PM2
+                let pm2DeleteFailed = false;
+                try {
+                    await processService.delete(server.pm2Name);
+                }
+                catch (error) {
+                    // If PM2 delete fails due to process not found, we still want to remove from registry
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (!message.includes("not found") && !message.includes("process name not found")) {
+                        pm2DeleteFailed = true;
+                        results.push({
+                            name: server.name,
+                            success: false,
+                            message,
+                        });
+                        continue;
+                    }
+                    // Process not found in PM2 is okay - we'll still remove from registry
+                }
+                // Then remove from registry
+                if (!pm2DeleteFailed) {
+                    await registryService.removeServer(server.id);
+                    results.push({
+                        name: server.name,
+                        success: true,
+                    });
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                results.push({
+                    name: server.name,
+                    success: false,
+                    message,
+                });
+            }
+        }
+        return results;
+    }
+    finally {
+        processService.disconnect();
+    }
+}
+/**
+ * CLI action handler for remove command
+ */
+export async function removeAction(name, options) {
+    try {
+        if (!name && !options.all && !options.tag) {
+            if (options.json) {
+                console.log(formatErrorAsJson(new Error("Provide a server name, --all, or --tag")));
+            }
+            else {
+                console.error("Error: Provide a server name, --all, or --tag");
+            }
+            process.exitCode = 1;
+            return;
+        }
+        const results = await executeRemove({
+            name,
+            all: options.all,
+            tag: options.tag,
+            force: options.force,
+        });
+        if (options.json) {
+            console.log(formatAsJson({ results }));
+        }
+        else {
+            console.log(formatRemoveResult(results));
+        }
+        // Set exit code if any failures (excluding cancellations)
+        if (results.some((r) => !r.success && !r.cancelled)) {
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        if (options.json) {
+            console.log(formatErrorAsJson(error));
+        }
+        else {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`Error: ${message}`);
+        }
+        logger.error({ error }, "Remove command failed");
+        process.exitCode = 1;
+    }
+}

package/dist/cli/commands/restart.d.ts

@@ -0,0 +1,25 @@
+import type { ServerStatus } from "../../types/registry.js";
+export interface RestartCommandOptions {
+    name?: string;
+    all?: boolean;
+    tag?: string;
+}
+export interface RestartResult {
+    name: string;
+    success: boolean;
+    status?: ServerStatus;
+    message?: string;
+    configRefreshed?: boolean;
+}
+/**
+ * Execute the restart command for a single server
+ */
+export declare function executeRestart(options: RestartCommandOptions): Promise<RestartResult | RestartResult[]>;
+/**
+ * CLI action handler for restart command
+ */
+export declare function restartAction(name: string | undefined, options: {
+    all?: boolean;
+    tag?: string;
+    json?: boolean;
+}): Promise<void>;