servherd 0.0.1 → 1.0.0

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

@@ -0,0 +1,35 @@
+import { type ConfigResult } from "../output/formatters.js";
+export interface ConfigCommandOptions {
+    show?: boolean;
+    get?: string;
+    set?: string;
+    value?: string;
+    reset?: boolean;
+    force?: boolean;
+    refresh?: string;
+    refreshAll?: boolean;
+    tag?: string;
+    dryRun?: boolean;
+}
+/**
+ * Execute the config command
+ */
+export declare function executeConfig(options: ConfigCommandOptions): Promise<ConfigResult>;
+/**
+ * Run the interactive configuration wizard
+ * Prompts the user for all configuration values interactively
+ * @throws ServherdError if running in CI mode
+ */
+export declare function runConfigWizard(): Promise<void>;
+/**
+ * CLI action handler for config command
+ */
+export declare function configAction(options: {
+    show?: boolean;
+    get?: string;
+    set?: string;
+    value?: string;
+    reset?: boolean;
+    force?: boolean;
+    json?: boolean;
+}): Promise<void>;

package/dist/cli/commands/config.js

@@ -0,0 +1,336 @@
+import { confirm, input, select } from "@inquirer/prompts";
+import { ConfigService } from "../../services/config.service.js";
+import { RegistryService } from "../../services/registry.service.js";
+import { formatConfigResult } from "../output/formatters.js";
+import { formatAsJson, formatErrorAsJson } from "../output/json-formatter.js";
+import { logger } from "../../utils/logger.js";
+import { CIDetector } from "../../utils/ci-detector.js";
+import { ServherdError, ServherdErrorCode } from "../../types/errors.js";
+import { findServersUsingConfigKey } from "../../utils/config-drift.js";
+import { executeRefresh } from "./refresh.js";
+// Valid top-level config keys
+const VALID_TOP_LEVEL_KEYS = ["version", "hostname", "protocol", "portRange", "tempDir", "pm2", "httpsCert", "httpsKey", "refreshOnChange"];
+const VALID_NESTED_KEYS = ["portRange.min", "portRange.max", "pm2.logDir", "pm2.pidDir"];
+// Config keys that can affect server commands (used for drift detection)
+const SERVER_AFFECTING_KEYS = ["hostname", "httpsCert", "httpsKey"];
+function isValidKey(key) {
+    return VALID_TOP_LEVEL_KEYS.includes(key) || VALID_NESTED_KEYS.includes(key);
+}
+function getNestedValue(config, key) {
+    const parts = key.split(".");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let current = config;
+    for (const part of parts) {
+        if (current && typeof current === "object" && part in current) {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
+function setNestedValue(config, key, value) {
+    const parts = key.split(".");
+    const result = { ...config };
+    if (parts.length === 1) {
+        // Top-level key
+        result[key] = value;
+    }
+    else if (parts.length === 2) {
+        // Nested key (e.g., portRange.min)
+        const [parentKey, childKey] = parts;
+        if (parentKey === "portRange") {
+            result.portRange = { ...result.portRange, [childKey]: value };
+        }
+        else if (parentKey === "pm2") {
+            result.pm2 = { ...result.pm2, [childKey]: value };
+        }
+    }
+    return result;
+}
+/**
+ * Handle server refresh after a config change based on refreshOnChange setting
+ */
+async function handleConfigChangeRefresh(config, changedKey) {
+    // Only handle server-affecting keys
+    if (!SERVER_AFFECTING_KEYS.includes(changedKey)) {
+        return { refreshed: false };
+    }
+    const refreshOnChange = config.refreshOnChange ?? "on-start";
+    // manual and on-start modes don't auto-refresh
+    if (refreshOnChange === "manual" || refreshOnChange === "on-start") {
+        return { refreshed: false };
+    }
+    // Find servers that use this config key
+    const registryService = new RegistryService();
+    await registryService.load();
+    const allServers = registryService.listServers();
+    const affectedServers = findServersUsingConfigKey(allServers, changedKey);
+    if (affectedServers.length === 0) {
+        return { refreshed: false };
+    }
+    const serverNames = affectedServers.map(s => s.name).join(", ");
+    if (refreshOnChange === "prompt") {
+        // Don't prompt in CI mode
+        if (CIDetector.isCI()) {
+            return {
+                refreshed: false,
+                message: `${affectedServers.length} server(s) use this config value. Run "servherd refresh" to apply changes.`,
+            };
+        }
+        // Prompt user
+        const shouldRefresh = await confirm({
+            message: `${affectedServers.length} server(s) use this config value (${serverNames}). Restart them now?`,
+        });
+        if (!shouldRefresh) {
+            return {
+                refreshed: false,
+                message: "Run \"servherd refresh\" later to apply changes to affected servers.",
+            };
+        }
+    }
+    // Execute refresh for all servers (will filter to those with drift)
+    try {
+        await executeRefresh({ all: true });
+        return {
+            refreshed: true,
+            message: `Refreshed ${affectedServers.length} server(s): ${serverNames}`,
+        };
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return {
+            refreshed: false,
+            message: `Failed to refresh servers: ${errorMsg}`,
+        };
+    }
+}
+/**
+ * Execute the config command
+ */
+export async function executeConfig(options) {
+    const configService = new ConfigService();
+    // Load current config
+    await configService.load();
+    // Handle --refresh or --refresh-all
+    if (options.refresh || options.refreshAll) {
+        const refreshResults = await executeRefresh({
+            name: options.refresh,
+            all: options.refreshAll,
+            tag: options.tag,
+            dryRun: options.dryRun,
+        });
+        return {
+            refreshResults,
+            dryRun: options.dryRun,
+        };
+    }
+    // Handle --get
+    if (options.get) {
+        const key = options.get;
+        if (!isValidKey(key)) {
+            return {
+                error: `Unknown configuration key: "${key}"`,
+            };
+        }
+        const config = await configService.load();
+        const value = getNestedValue(config, key);
+        return {
+            key,
+            value,
+        };
+    }
+    // Handle --set
+    if (options.set) {
+        const key = options.set;
+        if (options.value === undefined) {
+            return {
+                updated: false,
+                error: "--value is required when using --set",
+            };
+        }
+        if (!isValidKey(key)) {
+            return {
+                updated: false,
+                error: `Unknown configuration key: "${key}"`,
+            };
+        }
+        // Validate and convert value based on key
+        let parsedValue = options.value;
+        if (key === "protocol") {
+            if (options.value !== "http" && options.value !== "https") {
+                return {
+                    updated: false,
+                    error: "Invalid protocol value. Must be \"http\" or \"https\"",
+                };
+            }
+        }
+        else if (key === "refreshOnChange") {
+            const validModes = ["manual", "prompt", "auto", "on-start"];
+            if (!validModes.includes(options.value)) {
+                return {
+                    updated: false,
+                    error: `Invalid refreshOnChange value. Must be one of: ${validModes.join(", ")}`,
+                };
+            }
+        }
+        else if (key === "portRange.min" || key === "portRange.max") {
+            const num = parseInt(options.value, 10);
+            if (isNaN(num)) {
+                return {
+                    updated: false,
+                    error: "Invalid port value. Must be a number",
+                };
+            }
+            if (num < 1 || num > 65535) {
+                return {
+                    updated: false,
+                    error: "Invalid port value. Must be between 1 and 65535",
+                };
+            }
+            parsedValue = num;
+        }
+        // Handle nested keys vs top-level keys
+        let updatedConfig;
+        if (key.includes(".")) {
+            const config = await configService.load();
+            updatedConfig = setNestedValue(config, key, parsedValue);
+            await configService.save(updatedConfig);
+        }
+        else {
+            await configService.set(key, parsedValue);
+            updatedConfig = await configService.load();
+        }
+        // Handle refresh behavior after config change
+        const refreshResult = await handleConfigChangeRefresh(updatedConfig, key);
+        return {
+            updated: true,
+            key,
+            value: parsedValue,
+            refreshMessage: refreshResult.message,
+        };
+    }
+    // Handle --reset
+    if (options.reset) {
+        if (!options.force) {
+            const confirmed = await confirm({
+                message: "Are you sure you want to reset configuration to defaults?",
+            });
+            if (!confirmed) {
+                return {
+                    reset: false,
+                    cancelled: true,
+                };
+            }
+        }
+        const defaults = configService.getDefaults();
+        await configService.save(defaults);
+        return {
+            reset: true,
+            config: defaults,
+        };
+    }
+    // Handle --show (default)
+    const config = await configService.load();
+    const configPath = configService.getLoadedConfigPath();
+    const globalConfigPath = configService.getConfigPath();
+    return {
+        config,
+        configPath,
+        globalConfigPath,
+    };
+}
+/**
+ * Run the interactive configuration wizard
+ * Prompts the user for all configuration values interactively
+ * @throws ServherdError if running in CI mode
+ */
+export async function runConfigWizard() {
+    if (CIDetector.isCI()) {
+        throw new ServherdError(ServherdErrorCode.INTERACTIVE_NOT_AVAILABLE, "Interactive config not available in CI mode. Use \"servherd config --set <key> --value <value>\"");
+    }
+    const configService = new ConfigService();
+    await configService.load();
+    const currentConfig = await configService.load();
+    // Prompt for hostname
+    const hostname = await input({
+        message: "Default hostname:",
+        default: currentConfig.hostname,
+    });
+    // Prompt for protocol
+    const protocol = await select({
+        message: "Default protocol:",
+        choices: [
+            { name: "HTTP", value: "http" },
+            { name: "HTTPS", value: "https" },
+        ],
+        default: currentConfig.protocol,
+    });
+    // If HTTPS, prompt for cert and key paths
+    let httpsCert;
+    let httpsKey;
+    if (protocol === "https") {
+        httpsCert = await input({
+            message: "Path to HTTPS certificate:",
+            default: currentConfig.httpsCert,
+        });
+        httpsKey = await input({
+            message: "Path to HTTPS key:",
+            default: currentConfig.httpsKey,
+        });
+    }
+    // Prompt for port range
+    const portMinStr = await input({
+        message: "Minimum port:",
+        default: String(currentConfig.portRange.min),
+        validate: (v) => !isNaN(parseInt(v)) || "Must be a number",
+    });
+    const portMaxStr = await input({
+        message: "Maximum port:",
+        default: String(currentConfig.portRange.max),
+        validate: (v) => !isNaN(parseInt(v)) || "Must be a number",
+    });
+    // Save the configuration
+    const newConfig = {
+        ...currentConfig,
+        hostname,
+        protocol,
+        httpsCert,
+        httpsKey,
+        portRange: {
+            min: parseInt(portMinStr, 10),
+            max: parseInt(portMaxStr, 10),
+        },
+    };
+    await configService.save(newConfig);
+    console.log("✓ Configuration saved");
+}
+/**
+ * CLI action handler for config command
+ */
+export async function configAction(options) {
+    try {
+        const result = await executeConfig(options);
+        if (options.json) {
+            console.log(formatAsJson(result));
+        }
+        else {
+            console.log(formatConfigResult(result));
+        }
+        if (result.error) {
+            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 }, "Config command failed");
+        process.exitCode = 1;
+    }
+}

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

@@ -0,0 +1,37 @@
+import type { ServerStatus } from "../../types/registry.js";
+export interface InfoCommandOptions {
+    name: string;
+}
+export interface InfoCommandResult {
+    name: string;
+    status: ServerStatus;
+    url: string;
+    cwd: string;
+    command: string;
+    resolvedCommand: string;
+    port: number;
+    hostname: string;
+    protocol: string;
+    pid?: number;
+    uptime?: number;
+    restarts?: number;
+    memory?: number;
+    cpu?: number;
+    tags?: string[];
+    description?: string;
+    env?: Record<string, string>;
+    createdAt: string;
+    pm2Name: string;
+    outLogPath?: string;
+    errLogPath?: string;
+}
+/**
+ * Execute the info command
+ */
+export declare function executeInfo(options: InfoCommandOptions): Promise<InfoCommandResult>;
+/**
+ * CLI action handler for info command
+ */
+export declare function infoAction(name: string, options?: {
+    json?: boolean;
+}): Promise<void>;

package/dist/cli/commands/info.js

@@ -0,0 +1,98 @@
+import { RegistryService } from "../../services/registry.service.js";
+import { ProcessService } from "../../services/process.service.js";
+import { formatServerInfo } from "../output/formatters.js";
+import { formatAsJson, formatErrorAsJson } from "../output/json-formatter.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * Execute the info command
+ */
+export async function executeInfo(options) {
+    const registryService = new RegistryService();
+    const processService = new ProcessService();
+    try {
+        // Load registry
+        await registryService.load();
+        // Find server by name
+        const server = registryService.findByName(options.name);
+        if (!server) {
+            throw new Error(`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);
+        // Build result
+        const result = {
+            name: server.name,
+            status: "unknown",
+            url: `${server.protocol}://${server.hostname}:${server.port}`,
+            cwd: server.cwd,
+            command: server.command,
+            resolvedCommand: server.resolvedCommand,
+            port: server.port,
+            hostname: server.hostname,
+            protocol: server.protocol,
+            tags: server.tags,
+            description: server.description,
+            env: server.env,
+            createdAt: server.createdAt,
+            pm2Name: server.pm2Name,
+        };
+        if (procDesc) {
+            // Process exists in PM2
+            const pm2Env = procDesc.pm2_env;
+            result.status = pm2Env.status === "online" ? "online"
+                : pm2Env.status === "stopped" || pm2Env.status === "stopping" ? "stopped"
+                    : pm2Env.status === "errored" ? "errored"
+                        : "unknown";
+            result.pid = procDesc.pid;
+            result.uptime = pm2Env.pm_uptime;
+            result.restarts = pm2Env.restart_time;
+            result.outLogPath = pm2Env.pm_out_log_path;
+            result.errLogPath = pm2Env.pm_err_log_path;
+            if (procDesc.monit) {
+                result.memory = procDesc.monit.memory;
+                result.cpu = procDesc.monit.cpu;
+            }
+        }
+        return result;
+    }
+    finally {
+        processService.disconnect();
+    }
+}
+/**
+ * CLI action handler for info command
+ */
+export async function infoAction(name, options) {
+    try {
+        if (!name) {
+            if (options?.json) {
+                console.log(formatErrorAsJson(new Error("Server name is required")));
+            }
+            else {
+                console.error("Error: Server name is required");
+            }
+            process.exitCode = 1;
+            return;
+        }
+        const result = await executeInfo({ name });
+        if (options?.json) {
+            console.log(formatAsJson(result));
+        }
+        else {
+            console.log(formatServerInfo(result));
+        }
+    }
+    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 }, "Info command failed");
+        process.exitCode = 1;
+    }
+}

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

@@ -0,0 +1,26 @@
+import { type ServerListItem } from "../output/formatters.js";
+export interface ListCommandOptions {
+    running?: boolean;
+    stopped?: boolean;
+    tag?: string;
+    cwd?: string;
+    cmd?: string;
+}
+export interface ListCommandResult {
+    servers: ServerListItem[];
+}
+/**
+ * Execute the list command
+ */
+export declare function executeList(options: ListCommandOptions): Promise<ListCommandResult>;
+/**
+ * CLI action handler for list command
+ */
+export declare function listAction(options: {
+    running?: boolean;
+    stopped?: boolean;
+    tag?: string;
+    cwd?: string;
+    cmd?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/cli/commands/list.js

@@ -0,0 +1,86 @@
+import { RegistryService } from "../../services/registry.service.js";
+import { ProcessService } from "../../services/process.service.js";
+import { ConfigService } from "../../services/config.service.js";
+import { formatServerListTable } from "../output/formatters.js";
+import { formatAsJson, formatErrorAsJson } from "../output/json-formatter.js";
+import { logger } from "../../utils/logger.js";
+import { ServherdError, ServherdErrorCode } from "../../types/errors.js";
+import { detectDrift } from "../../utils/config-drift.js";
+/**
+ * Execute the list command
+ */
+export async function executeList(options) {
+    // Validate mutually exclusive options
+    if (options.running && options.stopped) {
+        throw new ServherdError(ServherdErrorCode.COMMAND_CONFLICT, "Cannot specify both --running and --stopped");
+    }
+    const registryService = new RegistryService();
+    const processService = new ProcessService();
+    const configService = new ConfigService();
+    try {
+        await registryService.load();
+        await processService.connect();
+        const config = await configService.load();
+        // Get servers from registry with optional filters
+        const servers = registryService.listServers({
+            tag: options.tag,
+            cwd: options.cwd,
+            cmd: options.cmd,
+        });
+        // Get status for each server
+        const serverListItems = [];
+        for (const server of servers) {
+            const status = await processService.getStatus(server.pm2Name);
+            // Filter by running status if requested
+            if (options.running && status !== "online") {
+                continue;
+            }
+            // Filter by stopped status if requested
+            if (options.stopped && status !== "stopped") {
+                continue;
+            }
+            // Detect config drift
+            const drift = detectDrift(server, config);
+            serverListItems.push({
+                server,
+                status,
+                hasDrift: drift.hasDrift,
+            });
+        }
+        return { servers: serverListItems };
+    }
+    finally {
+        processService.disconnect();
+    }
+}
+/**
+ * CLI action handler for list command
+ */
+export async function listAction(options) {
+    try {
+        const result = await executeList({
+            running: options.running,
+            stopped: options.stopped,
+            tag: options.tag,
+            cwd: options.cwd,
+            cmd: options.cmd,
+        });
+        if (options.json) {
+            console.log(formatAsJson(result));
+        }
+        else {
+            console.log(formatServerListTable(result.servers));
+        }
+    }
+    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 }, "List command failed");
+        process.exitCode = 1;
+    }
+}

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

@@ -0,0 +1,46 @@
+import type { ServerStatus } from "../../types/registry.js";
+export interface LogsCommandOptions {
+    name?: string;
+    lines?: number;
+    error?: boolean;
+    follow?: boolean;
+    since?: string;
+    head?: number;
+    flush?: boolean;
+    all?: boolean;
+}
+export interface LogsCommandResult {
+    name: string;
+    status: ServerStatus;
+    logs: string;
+    lines: number;
+    outLogPath?: string;
+    errLogPath?: string;
+}
+export interface FlushCommandResult {
+    flushed: boolean;
+    name?: string;
+    all?: boolean;
+    message: string;
+}
+/**
+ * Execute flush command to clear logs
+ */
+export declare function executeFlush(options: LogsCommandOptions): Promise<FlushCommandResult>;
+/**
+ * Execute the logs command
+ */
+export declare function executeLogs(options: LogsCommandOptions): Promise<LogsCommandResult>;
+/**
+ * CLI action handler for logs command
+ */
+export declare function logsAction(name: string | undefined, options: {
+    lines?: number;
+    error?: boolean;
+    follow?: boolean;
+    since?: string;
+    head?: number;
+    flush?: boolean;
+    all?: boolean;
+    json?: boolean;
+}): Promise<void>;