servherd 0.0.1 → 1.0.0

package/dist/cli/output/formatters.js

@@ -0,0 +1,454 @@
+import chalk from "chalk";
+import Table from "cli-table3";
+import boxen from "boxen";
+/**
+ * Format server status with color
+ */
+export function formatStatus(status) {
+    switch (status) {
+        case "online":
+            return chalk.green("● online");
+        case "stopped":
+            return chalk.gray("○ stopped");
+        case "errored":
+            return chalk.red("✖ errored");
+        default:
+            return chalk.yellow("? unknown");
+    }
+}
+/**
+ * Format URL for display
+ */
+export function formatUrl(protocol, hostname, port) {
+    return chalk.cyan(`${protocol}://${hostname}:${port}`);
+}
+/**
+ * Format server name for display
+ */
+export function formatName(name) {
+    return chalk.bold(name);
+}
+export function formatServerListTable(servers) {
+    if (servers.length === 0) {
+        return chalk.yellow("No servers registered");
+    }
+    const table = new Table({
+        head: [
+            chalk.bold("Name"),
+            chalk.bold("Status"),
+            chalk.bold("Port"),
+            chalk.bold("Command"),
+            chalk.bold("Working Directory"),
+        ],
+        style: {
+            head: [],
+            border: [],
+        },
+    });
+    for (const { server, status, hasDrift } of servers) {
+        // Add drift indicator to name if config has drifted
+        const nameDisplay = hasDrift
+            ? formatName(server.name) + chalk.yellow(" ⚡")
+            : formatName(server.name);
+        table.push([
+            nameDisplay,
+            formatStatus(status),
+            String(server.port),
+            truncateString(server.command, 30),
+            truncatePath(server.cwd, 30),
+        ]);
+    }
+    // Add legend if any server has drift
+    const anyDrift = servers.some(s => s.hasDrift);
+    let result = table.toString();
+    if (anyDrift) {
+        result += "\n\n" + chalk.yellow("⚡ = Config has changed since server started. Run `servherd refresh` to update.");
+    }
+    return result;
+}
+export function formatStartResult(result) {
+    const { action, server, status } = result;
+    const url = `${server.protocol}://${server.hostname}:${server.port}`;
+    const lines = [];
+    switch (action) {
+        case "started":
+            lines.push(chalk.green(`✓ Server "${server.name}" started`));
+            break;
+        case "existing":
+            lines.push(chalk.blue(`ℹ Server "${server.name}" already exists`));
+            break;
+        case "restarted":
+            lines.push(chalk.green(`✓ Server "${server.name}" restarted`));
+            break;
+        case "renamed":
+            lines.push(chalk.green(`✓ Server renamed from "${result.previousName}" to "${server.name}"`));
+            break;
+    }
+    lines.push(`  ${chalk.bold("Name:")}   ${server.name}`);
+    lines.push(`  ${chalk.bold("Port:")}   ${server.port}`);
+    lines.push(`  ${chalk.bold("URL:")}    ${chalk.cyan(url)}`);
+    lines.push(`  ${chalk.bold("Status:")} ${formatStatus(status)}`);
+    lines.push(`  ${chalk.bold("CWD:")}    ${server.cwd}`);
+    return lines.join("\n");
+}
+export function formatStopResult(results) {
+    if (results.length === 0) {
+        return chalk.yellow("No servers to stop");
+    }
+    const lines = [];
+    for (const result of results) {
+        if (result.success) {
+            lines.push(chalk.green(`✓ Server "${result.name}" stopped`));
+        }
+        else {
+            lines.push(chalk.red(`✖ Failed to stop "${result.name}": ${result.message}`));
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Format error message
+ */
+export function formatError(message) {
+    return chalk.red(`✖ Error: ${message}`);
+}
+/**
+ * Format success message
+ */
+export function formatSuccess(message) {
+    return chalk.green(`✓ ${message}`);
+}
+/**
+ * Format info message
+ */
+export function formatInfo(message) {
+    return chalk.blue(`ℹ ${message}`);
+}
+/**
+ * Format warning message
+ */
+export function formatWarning(message) {
+    return chalk.yellow(`⚠ ${message}`);
+}
+/**
+ * Truncate a string for display
+ */
+function truncateString(str, maxLength) {
+    if (str.length <= maxLength) {
+        return str;
+    }
+    return str.slice(0, maxLength - 3) + "...";
+}
+/**
+ * Truncate a path for display
+ */
+function truncatePath(path, maxLength) {
+    if (path.length <= maxLength) {
+        return path;
+    }
+    const parts = path.split("/");
+    let result = "";
+    // Start from the end and work backward
+    for (let i = parts.length - 1; i >= 0; i--) {
+        const candidate = parts.slice(i).join("/");
+        if (candidate.length <= maxLength - 3) {
+            result = "..." + (i > 0 ? "/" : "") + candidate;
+            break;
+        }
+    }
+    if (!result) {
+        // If even the last part is too long, just truncate
+        result = "..." + path.slice(-(maxLength - 3));
+    }
+    return result;
+}
+/**
+ * Format bytes to human readable string
+ */
+function formatBytes(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    else if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    }
+    else if (bytes < 1024 * 1024 * 1024) {
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    }
+    else {
+        return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+    }
+}
+/**
+ * Format uptime to human readable string
+ */
+function formatUptime(uptimeMs) {
+    const now = Date.now();
+    const durationMs = now - uptimeMs;
+    const seconds = Math.floor(durationMs / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+        return `${days}d ${hours % 24}h`;
+    }
+    else if (hours > 0) {
+        return `${hours}h ${minutes % 60}m`;
+    }
+    else if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    }
+    else {
+        return `${seconds}s`;
+    }
+}
+/**
+ * Format server info as a boxed display
+ */
+export function formatServerInfo(info) {
+    const lines = [];
+    // Header
+    lines.push(chalk.bold.cyan(`Server: ${info.name}`));
+    lines.push("");
+    // Status and basic info
+    lines.push(`${chalk.bold("Status:")}      ${formatStatus(info.status)}`);
+    lines.push(`${chalk.bold("URL:")}         ${chalk.cyan(info.url)}`);
+    lines.push(`${chalk.bold("Port:")}        ${info.port}`);
+    lines.push(`${chalk.bold("Hostname:")}    ${info.hostname}`);
+    lines.push(`${chalk.bold("Protocol:")}    ${info.protocol}`);
+    lines.push("");
+    // Process info
+    if (info.pid) {
+        lines.push(`${chalk.bold("PID:")}         ${info.pid}`);
+    }
+    if (info.uptime) {
+        lines.push(`${chalk.bold("Uptime:")}      ${formatUptime(info.uptime)}`);
+    }
+    if (info.restarts !== undefined) {
+        lines.push(`${chalk.bold("Restarts:")}    ${info.restarts}`);
+    }
+    if (info.memory !== undefined) {
+        lines.push(`${chalk.bold("Memory:")}      ${formatBytes(info.memory)}`);
+    }
+    if (info.cpu !== undefined) {
+        lines.push(`${chalk.bold("CPU:")}         ${info.cpu.toFixed(1)}%`);
+    }
+    lines.push("");
+    // Command info
+    lines.push(`${chalk.bold("Command:")}     ${info.command}`);
+    lines.push(`${chalk.bold("Resolved:")}    ${info.resolvedCommand}`);
+    lines.push(`${chalk.bold("CWD:")}         ${info.cwd}`);
+    lines.push(`${chalk.bold("PM2 Name:")}    ${info.pm2Name}`);
+    lines.push("");
+    // Optional fields
+    if (info.description) {
+        lines.push(`${chalk.bold("Description:")} ${info.description}`);
+    }
+    if (info.tags && info.tags.length > 0) {
+        lines.push(`${chalk.bold("Tags:")}        ${info.tags.join(", ")}`);
+    }
+    // Log paths
+    if (info.outLogPath) {
+        lines.push(`${chalk.bold("Out Log:")}     ${info.outLogPath}`);
+    }
+    if (info.errLogPath) {
+        lines.push(`${chalk.bold("Err Log:")}     ${info.errLogPath}`);
+    }
+    // Environment variables
+    if (info.env && Object.keys(info.env).length > 0) {
+        lines.push("");
+        lines.push(chalk.bold("Environment:"));
+        for (const [key, value] of Object.entries(info.env)) {
+            lines.push(`  ${key}=${value}`);
+        }
+    }
+    // Created at
+    lines.push("");
+    lines.push(`${chalk.bold("Created:")}     ${new Date(info.createdAt).toLocaleString()}`);
+    return boxen(lines.join("\n"), {
+        padding: 1,
+        margin: 0,
+        borderStyle: "round",
+        borderColor: "cyan",
+    });
+}
+/**
+ * Format logs output
+ */
+export function formatLogs(result) {
+    const lines = [];
+    lines.push(chalk.bold.cyan(`Logs for: ${result.name}`));
+    lines.push(`${chalk.bold("Status:")} ${formatStatus(result.status)}`);
+    if (result.outLogPath) {
+        lines.push(`${chalk.bold("Log file:")} ${result.outLogPath}`);
+    }
+    lines.push(`${chalk.bold("Lines:")} ${result.lines}`);
+    lines.push("");
+    lines.push(chalk.gray("─".repeat(60)));
+    lines.push("");
+    if (result.logs) {
+        lines.push(result.logs);
+    }
+    else {
+        lines.push(chalk.gray("(no logs available)"));
+    }
+    return lines.join("\n");
+}
+export function formatRestartResult(results) {
+    if (results.length === 0) {
+        return chalk.yellow("No servers to restart");
+    }
+    const lines = [];
+    for (const result of results) {
+        if (result.success) {
+            if (result.configRefreshed) {
+                lines.push(chalk.green(`✓ Server "${result.name}" restarted with updated config`));
+            }
+            else {
+                lines.push(chalk.green(`✓ Server "${result.name}" restarted`));
+            }
+            if (result.status) {
+                lines.push(`  Status: ${formatStatus(result.status)}`);
+            }
+        }
+        else {
+            lines.push(chalk.red(`✖ Failed to restart "${result.name}": ${result.message}`));
+        }
+    }
+    return lines.join("\n");
+}
+function formatRefreshResult(results, dryRun) {
+    // Check if this is a "no drift" result
+    if (results.length === 1 && results[0].skipped && results[0].name === "") {
+        return chalk.blue(`ℹ ${results[0].message}`);
+    }
+    const lines = [];
+    if (dryRun) {
+        lines.push(chalk.yellow("Dry run mode - no changes made"));
+        lines.push("");
+    }
+    for (const result of results) {
+        if (result.skipped && dryRun) {
+            lines.push(chalk.yellow(`⚠ Server "${result.name}" would be refreshed`));
+            if (result.driftDetails) {
+                lines.push(chalk.gray(`  ${result.driftDetails.split("\n").join("\n  ")}`));
+            }
+        }
+        else if (result.success) {
+            lines.push(chalk.green(`✓ Server "${result.name}" refreshed with updated config`));
+            if (result.status) {
+                lines.push(`  Status: ${formatStatus(result.status)}`);
+            }
+        }
+        else {
+            lines.push(chalk.red(`✖ Failed to refresh "${result.name}": ${result.message}`));
+        }
+    }
+    return lines.join("\n");
+}
+export function formatRemoveResult(results) {
+    if (results.length === 0) {
+        return chalk.yellow("No servers to remove");
+    }
+    const lines = [];
+    for (const result of results) {
+        if (result.success) {
+            lines.push(chalk.green(`✓ Server "${result.name}" removed`));
+        }
+        else if (result.cancelled) {
+            lines.push(chalk.yellow(`⚠ Removal of "${result.name}" cancelled`));
+        }
+        else {
+            lines.push(chalk.red(`✖ Failed to remove "${result.name}": ${result.message}`));
+        }
+    }
+    return lines.join("\n");
+}
+export function formatConfigResult(result) {
+    const lines = [];
+    // Handle error
+    if (result.error) {
+        return formatError(result.error);
+    }
+    // Handle --refresh / --refresh-all
+    if (result.refreshResults) {
+        return formatRefreshResult(result.refreshResults, result.dryRun);
+    }
+    // Handle --get
+    if (result.key !== undefined && result.value !== undefined && result.updated === undefined && result.reset === undefined) {
+        return `${chalk.bold(result.key)}: ${formatValue(result.value)}`;
+    }
+    // Handle --set
+    if (result.updated !== undefined) {
+        if (result.updated) {
+            let message = formatSuccess(`Configuration "${result.key}" set to ${formatValue(result.value)}`);
+            if (result.refreshMessage) {
+                message += "\n" + chalk.blue(`ℹ ${result.refreshMessage}`);
+            }
+            return message;
+        }
+        return formatError(result.error || "Failed to update configuration");
+    }
+    // Handle --reset
+    if (result.reset !== undefined) {
+        if (result.reset) {
+            return formatSuccess("Configuration reset to defaults");
+        }
+        if (result.cancelled) {
+            return formatWarning("Reset cancelled");
+        }
+        return formatError("Failed to reset configuration");
+    }
+    // Handle --show (default)
+    if (result.config) {
+        lines.push(chalk.bold.cyan("Current Configuration"));
+        lines.push("");
+        if (result.configPath) {
+            lines.push(`${chalk.bold("Loaded from:")} ${result.configPath}`);
+        }
+        else if (result.globalConfigPath) {
+            lines.push(`${chalk.bold("Global config:")} ${result.globalConfigPath}`);
+        }
+        lines.push("");
+        const table = new Table({
+            head: [chalk.bold("Setting"), chalk.bold("Value")],
+            style: { head: [], border: [] },
+        });
+        // Flatten config for display
+        const flatConfig = flattenConfig(result.config);
+        for (const [key, value] of Object.entries(flatConfig)) {
+            table.push([key, formatValue(value)]);
+        }
+        lines.push(table.toString());
+        return lines.join("\n");
+    }
+    return "";
+}
+/**
+ * Format a value for display
+ */
+function formatValue(value) {
+    if (value === null || value === undefined) {
+        return chalk.gray("(not set)");
+    }
+    if (typeof value === "object") {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+/**
+ * Flatten a nested config object for display
+ */
+function flattenConfig(obj, prefix = "") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+            Object.assign(result, flattenConfig(value, fullKey));
+        }
+        else {
+            result[fullKey] = value;
+        }
+    }
+    return result;
+}

package/dist/cli/output/json-formatter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * JSON output formatting utilities for CLI commands.
+ */
+/**
+ * Standard JSON output wrapper for successful operations.
+ */
+export interface JsonOutput<T> {
+    success: boolean;
+    data: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Format data as a successful JSON response.
+ */
+export declare function formatAsJson<T>(data: T): string;
+/**
+ * Format an error as a JSON response.
+ */
+export declare function formatErrorAsJson(error: unknown): string;

package/dist/cli/output/json-formatter.js

@@ -0,0 +1,40 @@
+/**
+ * JSON output formatting utilities for CLI commands.
+ */
+import { isServherdError } from "../../types/errors.js";
+/**
+ * Format data as a successful JSON response.
+ */
+export function formatAsJson(data) {
+    const output = {
+        success: true,
+        data,
+    };
+    return JSON.stringify(output, null, 2);
+}
+/**
+ * Format an error as a JSON response.
+ */
+export function formatErrorAsJson(error) {
+    if (isServherdError(error)) {
+        const output = {
+            success: false,
+            data: null,
+            error: {
+                code: error.getCodeName(),
+                message: error.message,
+            },
+        };
+        return JSON.stringify(output, null, 2);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const output = {
+        success: false,
+        data: null,
+        error: {
+            code: "UNKNOWN_ERROR",
+            message,
+        },
+    };
+    return JSON.stringify(output, null, 2);
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * servherd - CLI tool and MCP server for managing development servers across projects
+ */
+export * from "./types/config.js";
+export * from "./types/registry.js";
+export * from "./types/pm2.js";
+export * from "./utils/ci-detector.js";
+export * from "./utils/logger.js";
+export * from "./utils/template.js";
+export { ConfigService } from "./services/config.service.js";
+export { RegistryService } from "./services/registry.service.js";
+export { PortService } from "./services/port.service.js";
+export { ProcessService } from "./services/process.service.js";
+export { runCLI, createProgram } from "./cli/index.js";

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * servherd - CLI tool and MCP server for managing development servers across projects
+ */
+import { runCLI } from "./cli/index.js";
+// Export types
+export * from "./types/config.js";
+export * from "./types/registry.js";
+export * from "./types/pm2.js";
+// Export utilities
+export * from "./utils/ci-detector.js";
+export * from "./utils/logger.js";
+export * from "./utils/template.js";
+// Export services
+export { ConfigService } from "./services/config.service.js";
+export { RegistryService } from "./services/registry.service.js";
+export { PortService } from "./services/port.service.js";
+export { ProcessService } from "./services/process.service.js";
+// Export CLI
+export { runCLI, createProgram } from "./cli/index.js";
+// Run CLI when executed directly
+runCLI().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/mcp/index.d.ts

@@ -0,0 +1,14 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export interface MCPServerOptions {
+    name?: string;
+    version?: string;
+}
+/**
+ * Create and configure an MCP server for servherd
+ */
+export declare function createMCPServer(options?: MCPServerOptions): McpServer;
+/**
+ * Start the MCP server in stdio mode
+ */
+export declare function startStdioServer(): Promise<void>;
+export { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";