servherd 0.0.1 → 1.0.0

package/dist/mcp/index.js

@@ -0,0 +1,352 @@
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { startToolName, startToolDescription, startToolSchema, handleStartTool, } from "./tools/start.js";
+import { stopToolName, stopToolDescription, stopToolSchema, handleStopTool, } from "./tools/stop.js";
+import { restartToolName, restartToolDescription, restartToolSchema, handleRestartTool, } from "./tools/restart.js";
+import { listToolName, listToolDescription, listToolSchema, handleListTool, } from "./tools/list.js";
+import { infoToolName, infoToolDescription, infoToolSchema, handleInfoTool, } from "./tools/info.js";
+import { logsToolName, logsToolDescription, logsToolSchema, handleLogsTool, } from "./tools/logs.js";
+import { configToolName, configToolDescription, configToolSchema, handleConfigTool, } from "./tools/config.js";
+import { removeToolName, removeToolDescription, removeToolSchema, handleRemoveTool, } from "./tools/remove.js";
+import { refreshToolName, refreshToolDescription, refreshToolSchema, handleRefreshTool, } from "./tools/refresh.js";
+import { listServerResources, readServerResource, } from "./resources/servers.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Create and configure an MCP server for servherd
+ */
+export function createMCPServer(options = {}) {
+    const name = options.name || "servherd";
+    const version = options.version || "0.1.0";
+    const server = new McpServer({ name, version }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+        },
+        instructions: "servherd is a tool for managing development servers. " +
+            "Use servherd_start to start a server, servherd_stop to stop it, " +
+            "servherd_list to see all servers, and servherd_info to get details about a specific server.",
+    });
+    // Register tools
+    registerTools(server);
+    // Register resources
+    registerResources(server);
+    return server;
+}
+/**
+ * Register all tools with the MCP server
+ */
+function registerTools(server) {
+    // Start tool
+    server.registerTool(startToolName, {
+        description: startToolDescription,
+        inputSchema: startToolSchema,
+    }, async (args) => {
+        try {
+            const result = await handleStartTool(args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({ error }, "MCP start tool failed");
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Stop tool
+    server.registerTool(stopToolName, {
+        description: stopToolDescription,
+        inputSchema: stopToolSchema,
+    }, async (args) => {
+        try {
+            const result = await handleStopTool(args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({ error }, "MCP stop tool failed");
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Restart tool
+    server.registerTool(restartToolName, {
+        description: restartToolDescription,
+        inputSchema: restartToolSchema,
+    }, async (args) => {
+        try {
+            const result = await handleRestartTool(args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({ error }, "MCP restart tool failed");
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // List tool
+    server.registerTool(listToolName, {
+        description: listToolDescription,
+        inputSchema: listToolSchema,
+    }, async (args) => {
+        try {
+            const result = await handleListTool(args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({ error }, "MCP list tool failed");
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Info tool
+    server.registerTool(infoToolName, {
+        description: infoToolDescription,
+        inputSchema: infoToolSchema,
+    }, async (args) => {
+        try {
+            const result = await handleInfoTool(args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({ error }, "MCP info tool failed");
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Logs tool
+    server.registerTool(logsToolName, {
+        description: logsToolDescription,
+        inputSchema: logsToolSchema,
+    }, async (args) => {
+        try {
+            const result = await handleLogsTool(args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({ error }, "MCP logs tool failed");
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Config tool
+    server.registerTool(configToolName, {
+        description: configToolDescription,
+        inputSchema: configToolSchema,
+    }, async (args) => {
+        try {
+            const result = await handleConfigTool(args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({ error }, "MCP config tool failed");
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Remove tool
+    server.registerTool(removeToolName, {
+        description: removeToolDescription,
+        inputSchema: removeToolSchema,
+    }, async (args) => {
+        try {
+            const result = await handleRemoveTool(args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({ error }, "MCP remove tool failed");
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    // Refresh tool
+    server.registerTool(refreshToolName, {
+        description: refreshToolDescription,
+        inputSchema: refreshToolSchema,
+    }, async (args) => {
+        try {
+            const result = await handleRefreshTool(args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error({ error }, "MCP refresh tool failed");
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+/**
+ * Register resources with the MCP server
+ */
+function registerResources(server) {
+    // Register server resource template for individual servers
+    const serverTemplate = new ResourceTemplate("servherd://servers/{name}", {
+        list: async () => {
+            const resources = await listServerResources();
+            // Filter to only include server resources (not logs)
+            const serverResources = resources.filter((r) => !r.uri.endsWith("/logs"));
+            return {
+                resources: serverResources.map((r) => ({
+                    uri: r.uri,
+                    name: r.name,
+                    description: r.description,
+                    mimeType: r.mimeType,
+                })),
+            };
+        },
+    });
+    server.registerResource("Server Details", serverTemplate, {
+        description: "Get details about a specific managed server",
+        mimeType: "application/json",
+    }, async (uri) => {
+        const content = await readServerResource(uri.toString());
+        return {
+            contents: [
+                {
+                    uri: uri.toString(),
+                    mimeType: "application/json",
+                    text: content,
+                },
+            ],
+        };
+    });
+    // Register server logs resource template
+    const logsTemplate = new ResourceTemplate("servherd://servers/{name}/logs", {
+        list: async () => {
+            const resources = await listServerResources();
+            // Filter to only include log resources
+            const logResources = resources.filter((r) => r.uri.endsWith("/logs"));
+            return {
+                resources: logResources.map((r) => ({
+                    uri: r.uri,
+                    name: r.name,
+                    description: r.description,
+                    mimeType: r.mimeType,
+                })),
+            };
+        },
+    });
+    server.registerResource("Server Logs", logsTemplate, {
+        description: "Get output logs from a managed server",
+        mimeType: "text/plain",
+    }, async (uri) => {
+        const content = await readServerResource(uri.toString());
+        return {
+            contents: [
+                {
+                    uri: uri.toString(),
+                    mimeType: "text/plain",
+                    text: content,
+                },
+            ],
+        };
+    });
+}
+/**
+ * Start the MCP server in stdio mode
+ */
+export async function startStdioServer() {
+    const server = createMCPServer();
+    const transport = new StdioServerTransport();
+    logger.info("Starting MCP server in stdio mode");
+    await server.connect(transport);
+    // Handle shutdown
+    process.on("SIGINT", async () => {
+        logger.info("Shutting down MCP server");
+        await server.close();
+        process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+        logger.info("Shutting down MCP server");
+        await server.close();
+        process.exit(0);
+    });
+}
+export { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/dist/mcp/resources/servers.d.ts

@@ -0,0 +1,14 @@
+export interface ServerResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+/**
+ * List all available server resources
+ */
+export declare function listServerResources(): Promise<ServerResource[]>;
+/**
+ * Read a server resource by URI
+ */
+export declare function readServerResource(uri: string): Promise<string>;

package/dist/mcp/resources/servers.js

@@ -0,0 +1,128 @@
+import { RegistryService } from "../../services/registry.service.js";
+import { ProcessService } from "../../services/process.service.js";
+import { executeLogs } from "../../cli/commands/logs.js";
+/**
+ * List all available server resources
+ */
+export async function listServerResources() {
+    const registryService = new RegistryService();
+    try {
+        await registryService.load();
+        const servers = registryService.listServers();
+        const resources = [];
+        for (const server of servers) {
+            // Add server resource
+            resources.push({
+                uri: `servherd://servers/${server.name}`,
+                name: server.name,
+                description: server.description || `Server at ${server.cwd}`,
+                mimeType: "application/json",
+            });
+            // Add logs resource
+            resources.push({
+                uri: `servherd://servers/${server.name}/logs`,
+                name: `${server.name} logs`,
+                description: `Output logs for server ${server.name}`,
+                mimeType: "text/plain",
+            });
+        }
+        return resources;
+    }
+    catch {
+        // Return empty list if registry can't be loaded
+        return [];
+    }
+}
+/**
+ * Read a server resource by URI
+ */
+export async function readServerResource(uri) {
+    // Parse URI
+    const match = uri.match(/^servherd:\/\/servers\/([^/]+)(\/logs)?$/);
+    if (!match) {
+        throw new Error(`Invalid resource URI: ${uri}`);
+    }
+    const serverName = match[1];
+    const isLogs = match[2] === "/logs";
+    if (isLogs) {
+        return readServerLogs(serverName);
+    }
+    return readServerDetails(serverName);
+}
+/**
+ * Read server details as JSON
+ */
+async function readServerDetails(name) {
+    const registryService = new RegistryService();
+    const processService = new ProcessService();
+    try {
+        await registryService.load();
+        await processService.connect();
+        const server = registryService.findByName(name);
+        if (!server) {
+            throw new Error(`Server "${name}" not found`);
+        }
+        // Get process status
+        let status = "unknown";
+        let pid;
+        let uptime;
+        let memory;
+        let cpu;
+        try {
+            const procDesc = await processService.describe(server.pm2Name);
+            if (procDesc) {
+                const pm2Env = procDesc.pm2_env;
+                status = pm2Env.status === "online" ? "online"
+                    : pm2Env.status === "stopped" || pm2Env.status === "stopping" ? "stopped"
+                        : pm2Env.status === "errored" ? "errored"
+                            : "unknown";
+                pid = procDesc.pid;
+                uptime = pm2Env.pm_uptime;
+                if (procDesc.monit) {
+                    memory = procDesc.monit.memory;
+                    cpu = procDesc.monit.cpu;
+                }
+            }
+        }
+        catch {
+            // Ignore PM2 errors, just report unknown status
+        }
+        const serverDetails = {
+            name: server.name,
+            status,
+            port: server.port,
+            url: `${server.protocol}://${server.hostname}:${server.port}`,
+            cwd: server.cwd,
+            command: server.command,
+            resolvedCommand: server.resolvedCommand,
+            hostname: server.hostname,
+            protocol: server.protocol,
+            tags: server.tags,
+            description: server.description,
+            env: server.env,
+            createdAt: server.createdAt,
+            pm2Name: server.pm2Name,
+            pid,
+            uptime,
+            memory,
+            cpu,
+        };
+        return JSON.stringify(serverDetails, null, 2);
+    }
+    finally {
+        processService.disconnect();
+    }
+}
+/**
+ * Read server logs
+ */
+async function readServerLogs(name) {
+    const result = await executeLogs({
+        name,
+        lines: 100, // Get more lines for resource reading
+    });
+    if (!result.logs || result.logs.trim() === "") {
+        return "(no logs available)";
+    }
+    return result.logs;
+}

package/dist/mcp/tools/config.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export declare const configToolName = "servherd_config";
+export declare const configToolDescription: string;
+export declare const configToolSchema: z.ZodObject<{
+    show: z.ZodOptional<z.ZodBoolean>;
+    get: z.ZodOptional<z.ZodString>;
+    set: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+    reset: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    value?: string | undefined;
+    set?: string | undefined;
+    reset?: boolean | undefined;
+    show?: boolean | undefined;
+    get?: string | undefined;
+}, {
+    value?: string | undefined;
+    set?: string | undefined;
+    reset?: boolean | undefined;
+    show?: boolean | undefined;
+    get?: string | undefined;
+}>;
+export type ConfigToolInput = z.infer<typeof configToolSchema>;
+export interface ConfigToolResult {
+    action: "show" | "get" | "set" | "reset";
+    success: boolean;
+    config?: Record<string, unknown>;
+    key?: string;
+    value?: unknown;
+    error?: string;
+    message: string;
+}
+export declare function handleConfigTool(input: ConfigToolInput): Promise<ConfigToolResult>;

package/dist/mcp/tools/config.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { executeConfig } from "../../cli/commands/config.js";
+export const configToolName = "servherd_config";
+export const configToolDescription = "View or modify servherd global configuration settings. " +
+    "Use this tool to check current settings, change configuration values like hostname or port range, or reset to defaults. " +
+    "Can show all configuration values, get a specific setting by key, set a new value, or reset all settings to defaults. " +
+    "Returns the action performed, success status, relevant configuration data, and a descriptive message. " +
+    "Configuration changes persist across sessions and affect all future server operations.";
+export const configToolSchema = z.object({
+    show: z.boolean().optional().describe("Set to true to show all configuration values"),
+    get: z.string().optional().describe("Get a specific configuration value by key, e.g., 'hostname', 'protocol', or 'portRange.min'"),
+    set: z.string().optional().describe("Configuration key to set, e.g., 'hostname' or 'portRange.max'. Requires 'value' parameter"),
+    value: z.string().optional().describe("Value to set for the key, e.g., '127.0.0.1' for hostname or '9999' for portRange.max"),
+    reset: z.boolean().optional().describe("Set to true to reset all configuration to default values"),
+});
+export async function handleConfigTool(input) {
+    // Determine action
+    let action = "show";
+    if (input.get) {
+        action = "get";
+    }
+    else if (input.set) {
+        action = "set";
+    }
+    else if (input.reset) {
+        action = "reset";
+    }
+    // For reset, we force it since MCP can't prompt
+    const result = await executeConfig({
+        show: action === "show",
+        get: input.get,
+        set: input.set,
+        value: input.value,
+        reset: input.reset,
+        force: input.reset ? true : undefined, // Force reset without prompting in MCP context
+    });
+    // Handle errors
+    if (result.error) {
+        return {
+            action,
+            success: false,
+            error: result.error,
+            message: result.error,
+        };
+    }
+    // Handle cancelled reset
+    if (result.cancelled) {
+        return {
+            action: "reset",
+            success: false,
+            message: "Reset was cancelled",
+        };
+    }
+    // Build response based on action
+    switch (action) {
+        case "get":
+            return {
+                action: "get",
+                success: true,
+                key: result.key,
+                value: result.value,
+                message: `${result.key} = ${JSON.stringify(result.value)}`,
+            };
+        case "set":
+            return {
+                action: "set",
+                success: result.updated === true,
+                key: result.key,
+                value: result.value,
+                message: result.updated ? `Set ${result.key} to ${JSON.stringify(result.value)}` : "Failed to set value",
+            };
+        case "reset":
+            return {
+                action: "reset",
+                success: result.reset === true,
+                config: result.config,
+                message: "Configuration reset to defaults",
+            };
+        case "show":
+        default:
+            return {
+                action: "show",
+                success: true,
+                config: result.config,
+                message: `Configuration loaded from ${result.configPath || "defaults"}`,
+            };
+    }
+}

package/dist/mcp/tools/info.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const infoToolName = "servherd_info";
+export declare const infoToolDescription: string;
+export declare const infoToolSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+export type InfoToolInput = z.infer<typeof infoToolSchema>;
+export interface InfoToolResult {
+    name: string;
+    status: string;
+    url: string;
+    cwd: string;
+    command: string;
+    resolvedCommand: string;
+    port: number;
+    hostname: string;
+    protocol: string;
+    pid?: number;
+    uptime?: number;
+    uptimeFormatted?: string;
+    restarts?: number;
+    memory?: number;
+    memoryFormatted?: string;
+    cpu?: number;
+    tags?: string[];
+    description?: string;
+    createdAt: string;
+    pm2Name: string;
+    outLogPath?: string;
+    errLogPath?: string;
+}
+export declare function handleInfoTool(input: InfoToolInput): Promise<InfoToolResult>;