servherd 0.0.1 → 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,160 @@
+import { Command } from "commander";
+import { startAction } from "./commands/start.js";
+import { stopAction } from "./commands/stop.js";
+import { listAction } from "./commands/list.js";
+import { infoAction } from "./commands/info.js";
+import { logsAction } from "./commands/logs.js";
+import { restartAction } from "./commands/restart.js";
+import { removeAction } from "./commands/remove.js";
+import { configAction } from "./commands/config.js";
+import { mcpAction } from "./commands/mcp.js";
+/**
+ * Create the CLI program
+ */
+export function createProgram() {
+    const program = new Command();
+    program
+        .name("servherd")
+        .description("CLI tool and MCP server for managing development servers across projects")
+        .version("0.1.0")
+        .option("--json", "Output results as JSON")
+        .option("--ci", "Force CI mode behavior (sequential port allocation, no interactive prompts)")
+        .option("--no-ci", "Force non-CI mode behavior (overrides CI environment detection)");
+    // Start command
+    program
+        .command("start")
+        .description("Start a development server")
+        .argument("[command...]", "Command to run (use -- to separate from options)")
+        .option("-n, --name <name>", "Name for the server")
+        .option("-p, --port <port>", "Port for the server (overrides deterministic assignment)", parseInt)
+        .option("--protocol <protocol>", "Protocol to use (http or https)", (value) => {
+        if (value !== "http" && value !== "https") {
+            throw new Error("Protocol must be 'http' or 'https'");
+        }
+        return value;
+    })
+        .option("-t, --tag <tag...>", "Tags for the server")
+        .option("-d, --description <description>", "Description of the server")
+        .option("-e, --env <KEY=VALUE...>", "Environment variables (supports {{port}}, {{hostname}}, {{url}}, {{https-cert}}, {{https-key}} templates)")
+        .action(async (commandArgs, options, cmd) => {
+        const globalOpts = cmd.parent?.opts() ?? {};
+        await startAction(commandArgs, { ...options, json: globalOpts.json });
+    });
+    // Stop command
+    program
+        .command("stop")
+        .description("Stop a development server")
+        .argument("[name]", "Name of the server to stop")
+        .option("-a, --all", "Stop all servers")
+        .option("-t, --tag <tag>", "Stop servers with this tag")
+        .option("-f, --force", "Force stop using SIGKILL")
+        .action(async (name, options, cmd) => {
+        const globalOpts = cmd.parent?.opts() ?? {};
+        await stopAction(name, { ...options, json: globalOpts.json });
+    });
+    // List command
+    program
+        .command("list")
+        .alias("ls")
+        .description("List all managed servers")
+        .option("-r, --running", "Only show running servers")
+        .option("-s, --stopped", "Only show stopped servers")
+        .option("-t, --tag <tag>", "Filter by tag")
+        .option("-c, --cwd <path>", "Filter by working directory")
+        .option("--cmd <pattern>", "Filter by command pattern (glob syntax, e.g., '*storybook*')")
+        .action(async (options, cmd) => {
+        const globalOpts = cmd.parent?.opts() ?? {};
+        await listAction({ ...options, json: globalOpts.json });
+    });
+    // Info command
+    program
+        .command("info")
+        .description("Show detailed information about a server")
+        .argument("<name>", "Name of the server")
+        .action(async (name, options, cmd) => {
+        const globalOpts = cmd.parent?.opts() ?? {};
+        await infoAction(name, { json: globalOpts.json });
+    });
+    // Logs command
+    program
+        .command("logs")
+        .description("View server logs")
+        .argument("[name]", "Name of the server")
+        .option("-n, --lines <number>", "Number of lines to show (from end)", "50")
+        .option("-e, --error", "Show error logs instead of output logs")
+        .option("-f, --follow", "Follow logs in real-time")
+        .option("--since <time>", "Show logs since time (e.g., 1h, 30m, 2024-01-15)")
+        .option("--head <number>", "Show first N lines (instead of last)")
+        .option("--flush", "Clear logs instead of displaying")
+        .option("-a, --all", "Apply to all servers (with --flush)")
+        .action(async (name, options, cmd) => {
+        const globalOpts = cmd.parent?.opts() ?? {};
+        await logsAction(name, {
+            lines: options.lines ? parseInt(options.lines, 10) : undefined,
+            error: options.error,
+            follow: options.follow,
+            since: options.since,
+            head: options.head ? parseInt(options.head, 10) : undefined,
+            flush: options.flush,
+            all: options.all,
+            json: globalOpts.json,
+        });
+    });
+    // Restart command
+    program
+        .command("restart")
+        .description("Restart a development server")
+        .argument("[name]", "Name of the server to restart")
+        .option("-a, --all", "Restart all servers")
+        .option("-t, --tag <tag>", "Restart servers with this tag")
+        .action(async (name, options, cmd) => {
+        const globalOpts = cmd.parent?.opts() ?? {};
+        await restartAction(name, { ...options, json: globalOpts.json });
+    });
+    // Remove command
+    program
+        .command("remove")
+        .alias("rm")
+        .description("Remove a server from the registry (stops it first)")
+        .argument("[name]", "Name of the server to remove")
+        .option("-a, --all", "Remove all servers")
+        .option("-t, --tag <tag>", "Remove servers with this tag")
+        .option("-f, --force", "Skip confirmation prompt")
+        .action(async (name, options, cmd) => {
+        const globalOpts = cmd.parent?.opts() ?? {};
+        await removeAction(name, { ...options, json: globalOpts.json });
+    });
+    // Config command
+    program
+        .command("config")
+        .description("View and modify configuration")
+        .option("-s, --show", "Show current configuration (default)")
+        .option("-g, --get <key>", "Get a specific configuration value")
+        .option("--set <key>", "Set a configuration value (use with --value)")
+        .option("--value <value>", "Value to set (use with --set)")
+        .option("-r, --reset", "Reset configuration to defaults")
+        .option("-f, --force", "Skip confirmation prompt for reset")
+        .option("--refresh <name>", "Refresh a specific server with config drift")
+        .option("--refresh-all", "Refresh all servers with config drift")
+        .option("-t, --tag <tag>", "Refresh servers with this tag (use with --refresh-all)")
+        .option("--dry-run", "Show what would be refreshed without making changes")
+        .action(async (options, cmd) => {
+        const globalOpts = cmd.parent?.opts() ?? {};
+        await configAction({ ...options, json: globalOpts.json });
+    });
+    // MCP command
+    program
+        .command("mcp")
+        .description("Start the MCP server (for use with Claude Code or other MCP clients)")
+        .action(async () => {
+        await mcpAction();
+    });
+    return program;
+}
+/**
+ * Run the CLI
+ */
+export async function runCLI(args = process.argv) {
+    const program = createProgram();
+    await program.parseAsync(args);
+}

package/dist/cli/output/formatters.d.ts

@@ -0,0 +1,117 @@
+import type { ServerEntry, ServerStatus } from "../../types/registry.js";
+import type { InfoCommandResult } from "../commands/info.js";
+import type { LogsCommandResult } from "../commands/logs.js";
+/**
+ * Format server status with color
+ */
+export declare function formatStatus(status: ServerStatus): string;
+/**
+ * Format URL for display
+ */
+export declare function formatUrl(protocol: string, hostname: string, port: number): string;
+/**
+ * Format server name for display
+ */
+export declare function formatName(name: string): string;
+/**
+ * Create a table showing server list
+ */
+export interface ServerListItem {
+    server: ServerEntry;
+    status: ServerStatus;
+    hasDrift?: boolean;
+}
+export declare function formatServerListTable(servers: ServerListItem[]): string;
+/**
+ * Format start result output
+ */
+export interface StartResult {
+    action: "started" | "existing" | "restarted" | "renamed";
+    server: ServerEntry;
+    status: ServerStatus;
+    previousName?: string;
+}
+export declare function formatStartResult(result: StartResult): string;
+/**
+ * Format stop result output
+ */
+export interface StopResult {
+    name: string;
+    success: boolean;
+    message?: string;
+}
+export declare function formatStopResult(results: StopResult[]): string;
+/**
+ * Format error message
+ */
+export declare function formatError(message: string): string;
+/**
+ * Format success message
+ */
+export declare function formatSuccess(message: string): string;
+/**
+ * Format info message
+ */
+export declare function formatInfo(message: string): string;
+/**
+ * Format warning message
+ */
+export declare function formatWarning(message: string): string;
+/**
+ * Format server info as a boxed display
+ */
+export declare function formatServerInfo(info: InfoCommandResult): string;
+/**
+ * Format logs output
+ */
+export declare function formatLogs(result: LogsCommandResult): string;
+/**
+ * Format restart result output
+ */
+export interface RestartResult {
+    name: string;
+    success: boolean;
+    status?: ServerStatus;
+    message?: string;
+    configRefreshed?: boolean;
+}
+export declare function formatRestartResult(results: RestartResult[]): string;
+/**
+ * Format refresh result output
+ */
+export interface RefreshResult {
+    name: string;
+    success: boolean;
+    status?: ServerStatus;
+    message?: string;
+    driftDetails?: string;
+    skipped?: boolean;
+}
+/**
+ * Format remove result output
+ */
+export interface RemoveResult {
+    name: string;
+    success: boolean;
+    cancelled?: boolean;
+    message?: string;
+}
+export declare function formatRemoveResult(results: RemoveResult[]): string;
+/**
+ * Format config result output
+ */
+export interface ConfigResult {
+    config?: Record<string, unknown>;
+    configPath?: string | null;
+    globalConfigPath?: string;
+    key?: string;
+    value?: unknown;
+    updated?: boolean;
+    refreshMessage?: string;
+    reset?: boolean;
+    cancelled?: boolean;
+    refreshResults?: RefreshResult[];
+    dryRun?: boolean;
+    error?: string;
+}
+export declare function formatConfigResult(result: ConfigResult): string;