servherd 0.0.1 → 1.0.0

package/dist/mcp/tools/info.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { executeInfo } from "../../cli/commands/info.js";
+export const infoToolName = "servherd_info";
+export const infoToolDescription = "Get detailed information about a specific server. " +
+    "Use this tool when you need comprehensive details about a server's configuration, health, or resource usage. " +
+    "Returns status, port, URL, working directory, command, process ID, uptime (raw and formatted), restart count, memory usage (raw bytes and formatted), CPU percentage, tags, description, and log file paths. " +
+    "This provides more detail than servherd_list which gives a summary of all servers.";
+export const infoToolSchema = z.object({
+    name: z.string().describe("Name of the server to get info for, e.g., 'frontend-dev' or 'brave-tiger'"),
+});
+function formatUptime(ms) {
+    if (ms === undefined) {
+        return undefined;
+    }
+    const seconds = Math.floor((Date.now() - ms) / 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`;
+    }
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m`;
+    }
+    if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+}
+function formatMemory(bytes) {
+    if (bytes === undefined) {
+        return undefined;
+    }
+    const mb = bytes / 1024 / 1024;
+    return `${mb.toFixed(1)} MB`;
+}
+export async function handleInfoTool(input) {
+    const result = await executeInfo({
+        name: input.name,
+    });
+    return {
+        name: result.name,
+        status: result.status,
+        url: result.url,
+        cwd: result.cwd,
+        command: result.command,
+        resolvedCommand: result.resolvedCommand,
+        port: result.port,
+        hostname: result.hostname,
+        protocol: result.protocol,
+        pid: result.pid,
+        uptime: result.uptime,
+        uptimeFormatted: formatUptime(result.uptime),
+        restarts: result.restarts,
+        memory: result.memory,
+        memoryFormatted: formatMemory(result.memory),
+        cpu: result.cpu,
+        tags: result.tags,
+        description: result.description,
+        createdAt: result.createdAt,
+        pm2Name: result.pm2Name,
+        outLogPath: result.outLogPath,
+        errLogPath: result.errLogPath,
+    };
+}

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const listToolName = "servherd_list";
+export declare const listToolDescription: string;
+export declare const listToolSchema: z.ZodObject<{
+    running: z.ZodOptional<z.ZodBoolean>;
+    tag: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    cmd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    cwd?: string | undefined;
+    tag?: string | undefined;
+    cmd?: string | undefined;
+    running?: boolean | undefined;
+}, {
+    cwd?: string | undefined;
+    tag?: string | undefined;
+    cmd?: string | undefined;
+    running?: boolean | undefined;
+}>;
+export type ListToolInput = z.infer<typeof listToolSchema>;
+export interface ServerInfo {
+    name: string;
+    status: string;
+    port: number;
+    url: string;
+    cwd: string;
+    command: string;
+    tags?: string[];
+    hasDrift?: boolean;
+}
+export interface ListToolResult {
+    servers: ServerInfo[];
+    count: number;
+    summary: string;
+}
+export declare function handleListTool(input: ListToolInput): Promise<ListToolResult>;

package/dist/mcp/tools/list.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { executeList } from "../../cli/commands/list.js";
+export const listToolName = "servherd_list";
+export const listToolDescription = "List all managed development servers with their current status. " +
+    "Use this tool to get an overview of all servers, check which servers are running, or find servers by tag, location, or command. " +
+    "Can filter to show only running servers, servers with a specific tag, servers in a particular directory, or servers matching a command pattern (e.g., '*storybook*'). " +
+    "Returns an array of server objects with name, status (online/stopped/errored), port, URL, working directory, command, and tags. " +
+    "Also includes a count and summary message.";
+export const listToolSchema = z.object({
+    running: z.boolean().optional().describe("Set to true to only show servers that are currently running"),
+    tag: z.string().optional().describe("Filter by tag, e.g., 'frontend' or 'api'"),
+    cwd: z.string().optional().describe("Filter by working directory, e.g., '/home/user/projects/my-app'"),
+    cmd: z.string().optional().describe("Filter by command pattern using glob syntax, e.g., '*storybook*' or '*vite*'"),
+});
+export async function handleListTool(input) {
+    const result = await executeList({
+        running: input.running,
+        tag: input.tag,
+        cwd: input.cwd,
+        cmd: input.cmd,
+    });
+    const servers = result.servers.map((item) => ({
+        name: item.server.name,
+        status: item.status,
+        port: item.server.port,
+        url: `${item.server.protocol}://${item.server.hostname}:${item.server.port}`,
+        cwd: item.server.cwd,
+        command: item.server.command,
+        tags: item.server.tags,
+        hasDrift: item.hasDrift,
+    }));
+    const runningCount = servers.filter((s) => s.status === "online").length;
+    const driftCount = servers.filter((s) => s.hasDrift).length;
+    let summary;
+    if (servers.length === 0) {
+        summary = "No servers found";
+    }
+    else {
+        summary = `${servers.length} server${servers.length !== 1 ? "s" : ""} (${runningCount} running)`;
+        if (driftCount > 0) {
+            summary += `. ${driftCount} server${driftCount !== 1 ? "s have" : " has"} config drift - use servherd_restart to apply new config`;
+        }
+    }
+    return {
+        servers,
+        count: servers.length,
+        summary,
+    };
+}

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

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export declare const logsToolName = "servherd_logs";
+export declare const logsToolDescription: string;
+export declare const logsToolSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    lines: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodBoolean>;
+    since: z.ZodOptional<z.ZodString>;
+    head: z.ZodOptional<z.ZodNumber>;
+    flush: z.ZodOptional<z.ZodBoolean>;
+    all: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    error?: boolean | undefined;
+    flush?: boolean | undefined;
+    name?: string | undefined;
+    all?: boolean | undefined;
+    lines?: number | undefined;
+    head?: number | undefined;
+    since?: string | undefined;
+}, {
+    error?: boolean | undefined;
+    flush?: boolean | undefined;
+    name?: string | undefined;
+    all?: boolean | undefined;
+    lines?: number | undefined;
+    head?: number | undefined;
+    since?: string | undefined;
+}>;
+export type LogsToolInput = z.infer<typeof logsToolSchema>;
+export interface LogsToolResult {
+    name: string;
+    status: string;
+    logs: string;
+    lineCount: number;
+    logType: "output" | "error";
+    logPath?: string;
+}
+export interface FlushToolResult {
+    flushed: boolean;
+    name?: string;
+    all?: boolean;
+    message: string;
+}
+export declare function handleLogsTool(input: LogsToolInput): Promise<LogsToolResult | FlushToolResult>;

package/dist/mcp/tools/logs.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { executeLogs, executeFlush } from "../../cli/commands/logs.js";
+export const logsToolName = "servherd_logs";
+export const logsToolDescription = "Get recent log output from a server. " +
+    "Use this tool to debug issues, monitor server activity, or check for errors in server output. " +
+    "Can retrieve standard output logs (default) or error logs (stderr) by setting the error parameter. " +
+    "Returns the server name, status, log content as a string, line count, log type (output or error), and the log file path. " +
+    "Default is 50 lines but can be adjusted with the lines parameter. " +
+    "Use the since parameter to filter logs by time (e.g., '1h', '30m', '2024-01-15'). " +
+    "Use the head parameter to get first N lines instead of last N lines. " +
+    "Use flush=true to clear logs instead of retrieving them.";
+export const logsToolSchema = z.object({
+    name: z.string().optional().describe("Name of the server to get logs for, e.g., 'frontend-dev' or 'api-server'. Required unless using flush with all=true."),
+    lines: z.number().optional().describe("Number of lines to retrieve from the end of the log. Defaults to 50. Ignored if head is specified."),
+    error: z.boolean().optional().describe("Set to true to get error logs (stderr) instead of standard output logs"),
+    since: z.string().optional().describe("Filter logs since this time. Accepts duration (e.g., '1h', '30m', '2d') or ISO date (e.g., '2024-01-15')"),
+    head: z.number().optional().describe("Get first N lines instead of last N lines"),
+    flush: z.boolean().optional().describe("Set to true to clear/flush logs instead of retrieving them"),
+    all: z.boolean().optional().describe("When flush=true, set this to true to flush logs for all servers"),
+});
+export async function handleLogsTool(input) {
+    // Handle flush mode
+    if (input.flush) {
+        const result = await executeFlush({
+            name: input.name,
+            all: input.all,
+        });
+        return {
+            flushed: result.flushed,
+            name: result.name,
+            all: result.all,
+            message: result.message,
+        };
+    }
+    // Handle normal logs mode
+    const result = await executeLogs({
+        name: input.name,
+        lines: input.lines,
+        error: input.error,
+        since: input.since,
+        head: input.head,
+    });
+    const logType = input.error ? "error" : "output";
+    const logPath = input.error ? result.errLogPath : result.outLogPath;
+    // Count actual lines in the logs
+    const lineCount = result.logs ? result.logs.split("\n").filter((line) => line.length > 0).length : 0;
+    return {
+        name: result.name,
+        status: result.status,
+        logs: result.logs,
+        lineCount,
+        logType,
+        logPath,
+    };
+}

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

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export declare const refreshToolName = "servherd_refresh";
+export declare const refreshToolDescription: string;
+export declare const refreshToolSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+    all: z.ZodOptional<z.ZodBoolean>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    tag?: string | undefined;
+    all?: boolean | undefined;
+    dryRun?: boolean | undefined;
+}, {
+    name?: string | undefined;
+    tag?: string | undefined;
+    all?: boolean | undefined;
+    dryRun?: boolean | undefined;
+}>;
+export type RefreshToolInput = z.infer<typeof refreshToolSchema>;
+export interface RefreshResult {
+    name: string;
+    success: boolean;
+    status?: string;
+    message?: string;
+    driftDetails?: string;
+    skipped?: boolean;
+}
+export interface RefreshToolResult {
+    results: RefreshResult[];
+    summary: string;
+}
+export declare function handleRefreshTool(input: RefreshToolInput): Promise<RefreshToolResult>;

package/dist/mcp/tools/refresh.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { executeRefresh } from "../../cli/commands/refresh.js";
+export const refreshToolName = "servherd_refresh";
+export const refreshToolDescription = "Refresh servers with updated configuration. " +
+    "Use this tool when global config values (like hostname, httpsCert, httpsKey) have changed and you want to apply those changes to running servers. " +
+    "Servers that use config values in their command templates will be restarted with the new values. " +
+    "Use the dryRun option to preview which servers would be affected without making changes. " +
+    "Returns a list of results for each server with success status and a summary message.";
+export const refreshToolSchema = z.object({
+    name: z.string().optional().describe("Name of a specific server to refresh, e.g., 'frontend-dev' or 'api-server'"),
+    tag: z.string().optional().describe("Refresh all servers with this tag that have drift, e.g., 'frontend' or 'development'"),
+    all: z.boolean().optional().describe("Set to true to refresh all servers with drift"),
+    dryRun: z.boolean().optional().describe("Set to true to preview what would be refreshed without making changes"),
+});
+export async function handleRefreshTool(input) {
+    const commandResults = await executeRefresh({
+        name: input.name,
+        tag: input.tag,
+        all: input.all,
+        dryRun: input.dryRun,
+    });
+    const results = commandResults.map((r) => ({
+        name: r.name,
+        success: r.success,
+        status: r.status,
+        message: r.message,
+        driftDetails: r.driftDetails,
+        skipped: r.skipped,
+    }));
+    // Check if this is a "no drift" result
+    if (results.length === 1 && results[0].skipped && results[0].name === "") {
+        return {
+            results: [],
+            summary: results[0].message || "No servers have config drift",
+        };
+    }
+    const successCount = results.filter((r) => r.success && !r.skipped).length;
+    const skippedCount = results.filter((r) => r.skipped).length;
+    const failedCount = results.filter((r) => !r.success).length;
+    let summary;
+    if (input.dryRun) {
+        summary = `Dry run: ${skippedCount} server${skippedCount !== 1 ? "s" : ""} would be refreshed`;
+    }
+    else if (failedCount > 0) {
+        summary = `Refreshed ${successCount} server${successCount !== 1 ? "s" : ""}, ${failedCount} failed`;
+    }
+    else {
+        summary = `Successfully refreshed ${successCount} server${successCount !== 1 ? "s" : ""}`;
+    }
+    return {
+        results,
+        summary,
+    };
+}

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { RemoveResult } from "../../cli/output/formatters.js";
+export declare const removeToolName = "servherd_remove";
+export declare const removeToolDescription: string;
+export declare const removeToolSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    all: z.ZodOptional<z.ZodBoolean>;
+    tag: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    tag?: string | undefined;
+    all?: boolean | undefined;
+}, {
+    name?: string | undefined;
+    tag?: string | undefined;
+    all?: boolean | undefined;
+}>;
+export type RemoveToolInput = z.infer<typeof removeToolSchema>;
+export interface RemoveToolResult {
+    results: RemoveResult[];
+    summary: string;
+}
+export declare function handleRemoveTool(input: RemoveToolInput): Promise<RemoveToolResult>;

package/dist/mcp/tools/remove.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { executeRemove } from "../../cli/commands/remove.js";
+export const removeToolName = "servherd_remove";
+export const removeToolDescription = "Permanently remove servers from the registry and process management. " +
+    "Use this tool when a server is no longer needed and should be completely removed, not just stopped. " +
+    "This stops the server process, removes it from PM2, and deletes it from the servherd registry. " +
+    "Can target a specific server by name, all servers with a particular tag, or all managed servers at once. " +
+    "Returns a list of results for each server with success status and a summary message. " +
+    "Unlike servherd_stop, removed servers cannot be restarted without starting them again from scratch.";
+export const removeToolSchema = z.object({
+    name: z.string().optional().describe("Name of the server to remove, e.g., 'frontend-dev' or 'brave-tiger'"),
+    all: z.boolean().optional().describe("Set to true to remove all managed servers"),
+    tag: z.string().optional().describe("Remove all servers with this tag, e.g., 'temporary' or 'test'"),
+});
+export async function handleRemoveTool(input) {
+    // Validate input
+    if (!input.name && !input.all && !input.tag) {
+        throw new Error("Either name, all, or tag must be provided");
+    }
+    // Always force in MCP context since we can't prompt
+    const results = await executeRemove({
+        name: input.name,
+        all: input.all,
+        tag: input.tag,
+        force: true, // MCP context can't prompt for confirmation
+    });
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = results.filter((r) => !r.success && !r.cancelled).length;
+    let summary;
+    if (results.length === 0) {
+        summary = "No servers found to remove";
+    }
+    else if (failCount === 0) {
+        summary = `Successfully removed ${successCount} server${successCount !== 1 ? "s" : ""}`;
+    }
+    else {
+        summary = `Removed ${successCount} server${successCount !== 1 ? "s" : ""}, ${failCount} failed`;
+    }
+    return {
+        results,
+        summary,
+    };
+}

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { RestartResult } from "../../cli/commands/restart.js";
+export declare const restartToolName = "servherd_restart";
+export declare const restartToolDescription: string;
+export declare const restartToolSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    all: z.ZodOptional<z.ZodBoolean>;
+    tag: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    tag?: string | undefined;
+    all?: boolean | undefined;
+}, {
+    name?: string | undefined;
+    tag?: string | undefined;
+    all?: boolean | undefined;
+}>;
+export type RestartToolInput = z.infer<typeof restartToolSchema>;
+export interface RestartToolResult {
+    results: RestartResult[];
+    summary: string;
+}
+export declare function handleRestartTool(input: RestartToolInput): Promise<RestartToolResult>;

package/dist/mcp/tools/restart.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { executeRestart } from "../../cli/commands/restart.js";
+export const restartToolName = "servherd_restart";
+export const restartToolDescription = "Restart one or more development servers. " +
+    "Use this tool when servers need to pick up configuration changes, clear memory, or recover from an error state. " +
+    "Can target a specific server by name, all servers with a particular tag, or all managed servers at once. " +
+    "Returns a list of results for each server with success status and a summary message. " +
+    "Servers maintain their assigned ports and configuration across restarts.";
+export const restartToolSchema = z.object({
+    name: z.string().optional().describe("Name of the server to restart, e.g., 'frontend-dev' or 'api-server'"),
+    all: z.boolean().optional().describe("Set to true to restart all managed servers"),
+    tag: z.string().optional().describe("Restart all servers with this tag, e.g., 'backend' or 'production'"),
+});
+export async function handleRestartTool(input) {
+    // Validate input
+    if (!input.name && !input.all && !input.tag) {
+        throw new Error("Either name, all, or tag must be provided");
+    }
+    const result = await executeRestart({
+        name: input.name,
+        all: input.all,
+        tag: input.tag,
+    });
+    // Normalize to array
+    const results = Array.isArray(result) ? result : [result];
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = results.length - successCount;
+    let summary;
+    if (results.length === 0) {
+        summary = "No servers found to restart";
+    }
+    else if (failCount === 0) {
+        summary = `Successfully restarted ${successCount} server${successCount !== 1 ? "s" : ""}`;
+    }
+    else {
+        summary = `Restarted ${successCount} server${successCount !== 1 ? "s" : ""}, ${failCount} failed`;
+    }
+    return {
+        results,
+        summary,
+    };
+}

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const startToolName = "servherd_start";
+export declare const startToolDescription: string;
+export declare const startToolSchema: z.ZodObject<{
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    description: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    name?: string | undefined;
+    cwd?: string | undefined;
+    env?: Record<string, string> | undefined;
+    tags?: string[] | undefined;
+    description?: string | undefined;
+}, {
+    command: string;
+    name?: string | undefined;
+    cwd?: string | undefined;
+    env?: Record<string, string> | undefined;
+    tags?: string[] | undefined;
+    description?: string | undefined;
+}>;
+export type StartToolInput = z.infer<typeof startToolSchema>;
+export interface StartToolResult {
+    action: "started" | "existing" | "restarted" | "renamed";
+    name: string;
+    port: number;
+    url: string;
+    status: string;
+    message: string;
+    portReassigned?: boolean;
+    originalPort?: number;
+    previousName?: string;
+}
+export declare function handleStartTool(input: StartToolInput): Promise<StartToolResult>;

package/dist/mcp/tools/start.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { executeStart } from "../../cli/commands/start.js";
+import { ConfigService } from "../../services/config.service.js";
+import { findMissingVariables, getTemplateVariables, formatMissingVariablesForMCP, } from "../../utils/template.js";
+import { ServherdError, ServherdErrorCode } from "../../types/errors.js";
+export const startToolName = "servherd_start";
+export const startToolDescription = "Start a development server with automatic port assignment and process management. " +
+    "Use this tool when you need to launch a new server process or verify an existing server is running. " +
+    "The command can include {{port}}, {{hostname}}, and {{url}} template variables that will be substituted with actual values. " +
+    "Returns the server name, assigned port, full URL, and status (started, existing, or restarted). " +
+    "If an identical server is already running, it will return the existing server details rather than starting a duplicate.";
+export const startToolSchema = z.object({
+    command: z.string().describe("The command to run, e.g., 'npm start --port {{port}}' or 'python -m http.server {{port}}'"),
+    cwd: z.string().optional().describe("Working directory for the server, e.g., '/home/user/my-project'. Defaults to current directory"),
+    name: z.string().optional().describe("Human-readable name for the server, e.g., 'frontend-dev' or 'api-server'. Auto-generated if not provided"),
+    tags: z.array(z.string()).optional().describe("Tags for filtering/grouping servers, e.g., ['frontend', 'development']"),
+    description: z.string().optional().describe("Description of the server's purpose, e.g., 'React development server for the dashboard'"),
+    env: z.record(z.string()).optional().describe("Environment variables, e.g., {\"NODE_ENV\": \"development\", \"API_URL\": \"http://localhost:{{port}}\"}"),
+});
+export async function handleStartTool(input) {
+    // Load config and check for missing template variables before starting
+    const configService = new ConfigService();
+    const config = await configService.load();
+    // Use a placeholder port (0) to check for missing config-based variables
+    // The actual port will be assigned by PortService during executeStart
+    const templateVars = getTemplateVariables(config, 0);
+    const missingVars = findMissingVariables(input.command, templateVars);
+    // Filter to only configurable missing variables (ignore port/url which are auto-generated)
+    const configurableMissing = missingVars.filter(v => v.configurable);
+    if (configurableMissing.length > 0) {
+        const errorMessage = formatMissingVariablesForMCP(configurableMissing);
+        throw new ServherdError(ServherdErrorCode.CONFIG_VALIDATION_FAILED, errorMessage);
+    }
+    const result = await executeStart({
+        command: input.command,
+        cwd: input.cwd,
+        name: input.name,
+        tags: input.tags,
+        description: input.description,
+        env: input.env,
+    });
+    const url = `${result.server.protocol}://${result.server.hostname}:${result.server.port}`;
+    let message;
+    switch (result.action) {
+        case "started":
+            message = `Server "${result.server.name}" started at ${url}`;
+            break;
+        case "existing":
+            message = `Server "${result.server.name}" is already running at ${url}`;
+            break;
+        case "restarted":
+            message = `Server "${result.server.name}" restarted at ${url}`;
+            break;
+        case "renamed":
+            message = `Server renamed from "${result.previousName}" to "${result.server.name}" at ${url}`;
+            break;
+    }
+    // Add port reassignment info to message if applicable
+    if (result.portReassigned) {
+        message += ` (port ${result.originalPort} was unavailable, reassigned to ${result.server.port})`;
+    }
+    return {
+        action: result.action,
+        name: result.server.name,
+        port: result.server.port,
+        url,
+        status: result.status,
+        message,
+        portReassigned: result.portReassigned,
+        originalPort: result.originalPort,
+        previousName: result.previousName,
+    };
+}

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

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { StopResult } from "../../cli/output/formatters.js";
+export declare const stopToolName = "servherd_stop";
+export declare const stopToolDescription: string;
+export declare const stopToolSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    all: z.ZodOptional<z.ZodBoolean>;
+    tag: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    tag?: string | undefined;
+    all?: boolean | undefined;
+}, {
+    name?: string | undefined;
+    tag?: string | undefined;
+    all?: boolean | undefined;
+}>;
+export type StopToolInput = z.infer<typeof stopToolSchema>;
+export interface StopToolResult {
+    results: StopResult[];
+    summary: string;
+}
+export declare function handleStopTool(input: StopToolInput): Promise<StopToolResult>;

package/dist/mcp/tools/stop.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { executeStop } from "../../cli/commands/stop.js";
+export const stopToolName = "servherd_stop";
+export const stopToolDescription = "Stop one or more running development servers. " +
+    "Use this tool when you need to gracefully shut down servers that are no longer needed or before making configuration changes. " +
+    "Can target a specific server by name, all servers with a particular tag, or all managed servers at once. " +
+    "Returns a list of results for each server with success status and a summary message. " +
+    "Stopped servers remain in the registry and can be restarted later with servherd_start.";
+export const stopToolSchema = z.object({
+    name: z.string().optional().describe("Name of the server to stop, e.g., 'frontend-dev' or 'brave-tiger'"),
+    all: z.boolean().optional().describe("Set to true to stop all managed servers"),
+    tag: z.string().optional().describe("Stop all servers with this tag, e.g., 'frontend' or 'development'"),
+});
+export async function handleStopTool(input) {
+    // Validate input
+    if (!input.name && !input.all && !input.tag) {
+        throw new Error("Either name, all, or tag must be provided");
+    }
+    const results = await executeStop({
+        name: input.name,
+        all: input.all,
+        tag: input.tag,
+    });
+    const successCount = results.filter((r) => r.success).length;
+    const failCount = results.length - successCount;
+    let summary;
+    if (results.length === 0) {
+        summary = "No servers found to stop";
+    }
+    else if (failCount === 0) {
+        summary = `Successfully stopped ${successCount} server${successCount !== 1 ? "s" : ""}`;
+    }
+    else {
+        summary = `Stopped ${successCount} server${successCount !== 1 ? "s" : ""}, ${failCount} failed`;
+    }
+    return {
+        results,
+        summary,
+    };
+}