servherd 0.0.1 → 1.0.0

package/dist/types/errors.js

@@ -0,0 +1,197 @@
+/**
+ * Error codes for servherd operations.
+ * Grouped by category:
+ * - 1xxx: Server-related errors
+ * - 2xxx: Port-related errors
+ * - 3xxx: PM2/Process-related errors
+ * - 4xxx: Configuration errors
+ * - 5xxx: Registry errors
+ * - 6xxx: Template errors
+ * - 7xxx: Command/CLI errors
+ * - 9xxx: Unknown/Other errors
+ */
+export var ServherdErrorCode;
+(function (ServherdErrorCode) {
+    // Server errors (1xxx)
+    ServherdErrorCode[ServherdErrorCode["SERVER_NOT_FOUND"] = 1001] = "SERVER_NOT_FOUND";
+    ServherdErrorCode[ServherdErrorCode["SERVER_ALREADY_EXISTS"] = 1002] = "SERVER_ALREADY_EXISTS";
+    ServherdErrorCode[ServherdErrorCode["SERVER_NOT_RUNNING"] = 1003] = "SERVER_NOT_RUNNING";
+    ServherdErrorCode[ServherdErrorCode["SERVER_ALREADY_RUNNING"] = 1004] = "SERVER_ALREADY_RUNNING";
+    // Port errors (2xxx)
+    ServherdErrorCode[ServherdErrorCode["PORT_UNAVAILABLE"] = 2001] = "PORT_UNAVAILABLE";
+    ServherdErrorCode[ServherdErrorCode["PORT_OUT_OF_RANGE"] = 2002] = "PORT_OUT_OF_RANGE";
+    ServherdErrorCode[ServherdErrorCode["PORT_ALLOCATION_FAILED"] = 2003] = "PORT_ALLOCATION_FAILED";
+    // PM2/Process errors (3xxx)
+    ServherdErrorCode[ServherdErrorCode["PM2_CONNECTION_FAILED"] = 3001] = "PM2_CONNECTION_FAILED";
+    ServherdErrorCode[ServherdErrorCode["PM2_START_FAILED"] = 3002] = "PM2_START_FAILED";
+    ServherdErrorCode[ServherdErrorCode["PM2_STOP_FAILED"] = 3003] = "PM2_STOP_FAILED";
+    ServherdErrorCode[ServherdErrorCode["PM2_DELETE_FAILED"] = 3004] = "PM2_DELETE_FAILED";
+    ServherdErrorCode[ServherdErrorCode["PM2_RESTART_FAILED"] = 3005] = "PM2_RESTART_FAILED";
+    ServherdErrorCode[ServherdErrorCode["PM2_DESCRIBE_FAILED"] = 3006] = "PM2_DESCRIBE_FAILED";
+    // Configuration errors (4xxx)
+    ServherdErrorCode[ServherdErrorCode["CONFIG_LOAD_FAILED"] = 4001] = "CONFIG_LOAD_FAILED";
+    ServherdErrorCode[ServherdErrorCode["CONFIG_SAVE_FAILED"] = 4002] = "CONFIG_SAVE_FAILED";
+    ServherdErrorCode[ServherdErrorCode["CONFIG_INVALID"] = 4003] = "CONFIG_INVALID";
+    ServherdErrorCode[ServherdErrorCode["CONFIG_KEY_NOT_FOUND"] = 4004] = "CONFIG_KEY_NOT_FOUND";
+    ServherdErrorCode[ServherdErrorCode["CONFIG_VALIDATION_FAILED"] = 4005] = "CONFIG_VALIDATION_FAILED";
+    // Registry errors (5xxx)
+    ServherdErrorCode[ServherdErrorCode["REGISTRY_LOAD_FAILED"] = 5001] = "REGISTRY_LOAD_FAILED";
+    ServherdErrorCode[ServherdErrorCode["REGISTRY_SAVE_FAILED"] = 5002] = "REGISTRY_SAVE_FAILED";
+    ServherdErrorCode[ServherdErrorCode["REGISTRY_CORRUPT"] = 5003] = "REGISTRY_CORRUPT";
+    // Template errors (6xxx)
+    ServherdErrorCode[ServherdErrorCode["TEMPLATE_INVALID"] = 6001] = "TEMPLATE_INVALID";
+    ServherdErrorCode[ServherdErrorCode["TEMPLATE_MISSING_VARIABLE"] = 6002] = "TEMPLATE_MISSING_VARIABLE";
+    // Command/CLI errors (7xxx)
+    ServherdErrorCode[ServherdErrorCode["COMMAND_INVALID"] = 7001] = "COMMAND_INVALID";
+    ServherdErrorCode[ServherdErrorCode["COMMAND_MISSING_ARGUMENT"] = 7002] = "COMMAND_MISSING_ARGUMENT";
+    ServherdErrorCode[ServherdErrorCode["COMMAND_CONFLICT"] = 7003] = "COMMAND_CONFLICT";
+    ServherdErrorCode[ServherdErrorCode["INTERACTIVE_NOT_AVAILABLE"] = 7004] = "INTERACTIVE_NOT_AVAILABLE";
+    // Unknown/Other errors (9xxx)
+    ServherdErrorCode[ServherdErrorCode["UNKNOWN_ERROR"] = 9999] = "UNKNOWN_ERROR";
+})(ServherdErrorCode || (ServherdErrorCode = {}));
+/**
+ * Map of error codes to their string names for display purposes.
+ */
+const ERROR_CODE_NAMES = {
+    [ServherdErrorCode.SERVER_NOT_FOUND]: "SERVER_NOT_FOUND",
+    [ServherdErrorCode.SERVER_ALREADY_EXISTS]: "SERVER_ALREADY_EXISTS",
+    [ServherdErrorCode.SERVER_NOT_RUNNING]: "SERVER_NOT_RUNNING",
+    [ServherdErrorCode.SERVER_ALREADY_RUNNING]: "SERVER_ALREADY_RUNNING",
+    [ServherdErrorCode.PORT_UNAVAILABLE]: "PORT_UNAVAILABLE",
+    [ServherdErrorCode.PORT_OUT_OF_RANGE]: "PORT_OUT_OF_RANGE",
+    [ServherdErrorCode.PORT_ALLOCATION_FAILED]: "PORT_ALLOCATION_FAILED",
+    [ServherdErrorCode.PM2_CONNECTION_FAILED]: "PM2_CONNECTION_FAILED",
+    [ServherdErrorCode.PM2_START_FAILED]: "PM2_START_FAILED",
+    [ServherdErrorCode.PM2_STOP_FAILED]: "PM2_STOP_FAILED",
+    [ServherdErrorCode.PM2_DELETE_FAILED]: "PM2_DELETE_FAILED",
+    [ServherdErrorCode.PM2_RESTART_FAILED]: "PM2_RESTART_FAILED",
+    [ServherdErrorCode.PM2_DESCRIBE_FAILED]: "PM2_DESCRIBE_FAILED",
+    [ServherdErrorCode.CONFIG_LOAD_FAILED]: "CONFIG_LOAD_FAILED",
+    [ServherdErrorCode.CONFIG_SAVE_FAILED]: "CONFIG_SAVE_FAILED",
+    [ServherdErrorCode.CONFIG_INVALID]: "CONFIG_INVALID",
+    [ServherdErrorCode.CONFIG_KEY_NOT_FOUND]: "CONFIG_KEY_NOT_FOUND",
+    [ServherdErrorCode.CONFIG_VALIDATION_FAILED]: "CONFIG_VALIDATION_FAILED",
+    [ServherdErrorCode.REGISTRY_LOAD_FAILED]: "REGISTRY_LOAD_FAILED",
+    [ServherdErrorCode.REGISTRY_SAVE_FAILED]: "REGISTRY_SAVE_FAILED",
+    [ServherdErrorCode.REGISTRY_CORRUPT]: "REGISTRY_CORRUPT",
+    [ServherdErrorCode.TEMPLATE_INVALID]: "TEMPLATE_INVALID",
+    [ServherdErrorCode.TEMPLATE_MISSING_VARIABLE]: "TEMPLATE_MISSING_VARIABLE",
+    [ServherdErrorCode.COMMAND_INVALID]: "COMMAND_INVALID",
+    [ServherdErrorCode.COMMAND_MISSING_ARGUMENT]: "COMMAND_MISSING_ARGUMENT",
+    [ServherdErrorCode.COMMAND_CONFLICT]: "COMMAND_CONFLICT",
+    [ServherdErrorCode.INTERACTIVE_NOT_AVAILABLE]: "INTERACTIVE_NOT_AVAILABLE",
+    [ServherdErrorCode.UNKNOWN_ERROR]: "UNKNOWN_ERROR",
+};
+/**
+ * Custom error class for servherd operations.
+ * Includes error codes for programmatic handling and optional details.
+ */
+export class ServherdError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = "ServherdError";
+        this.code = code;
+        this.details = details;
+        // Maintains proper stack trace for where our error was thrown (V8 only)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ServherdError);
+        }
+    }
+    /**
+     * Serialize error to JSON for logging or API responses.
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            details: this.details,
+        };
+    }
+    /**
+     * Get the string name of the error code.
+     */
+    getCodeName() {
+        return ERROR_CODE_NAMES[this.code] || "UNKNOWN_ERROR";
+    }
+}
+/**
+ * Type guard to check if an error is a ServherdError.
+ */
+export function isServherdError(error) {
+    return error instanceof ServherdError;
+}
+/**
+ * Format an error for CLI display.
+ * Includes color codes and proper formatting for terminal output.
+ */
+export function formatErrorForCLI(error) {
+    if (isServherdError(error)) {
+        let message = `\x1b[31mError [${error.code}]: ${error.message}\x1b[0m`;
+        if (error.details) {
+            if (error.details.stderr) {
+                message += `\n\x1b[90m${error.details.stderr}\x1b[0m`;
+            }
+            if (error.details.stdout) {
+                message += `\n\x1b[90m${error.details.stdout}\x1b[0m`;
+            }
+        }
+        return message;
+    }
+    if (error instanceof Error) {
+        return `\x1b[31mError: ${error.message}\x1b[0m`;
+    }
+    return "\x1b[31mUnknown error occurred\x1b[0m";
+}
+/**
+ * Format an error for MCP tool response.
+ * Returns a structured error response compatible with MCP protocol.
+ */
+export function formatErrorForMCP(error) {
+    if (isServherdError(error)) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: error.getCodeName(),
+                        code: error.code,
+                        message: error.message,
+                        details: error.details,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "UNKNOWN_ERROR",
+                        code: ServherdErrorCode.UNKNOWN_ERROR,
+                        message: error.message,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    return {
+        isError: true,
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    error: "UNKNOWN_ERROR",
+                    code: ServherdErrorCode.UNKNOWN_ERROR,
+                    message: "An unknown error occurred",
+                }, null, 2),
+            },
+        ],
+    };
+}

package/dist/types/pm2.d.ts

@@ -0,0 +1,50 @@
+/**
+ * PM2-related type definitions
+ */
+export interface PM2StartOptions {
+    name: string;
+    script: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    instances?: number;
+    autorestart?: boolean;
+    watch?: boolean;
+    max_memory_restart?: string | number;
+    output?: string;
+    error?: string;
+    /** Format for log timestamps (moment.js format, e.g., "YYYY-MM-DD HH:mm:ss Z") */
+    log_date_format?: string;
+}
+export interface PM2ProcessEnv {
+    status: "online" | "stopped" | "errored" | "stopping" | "launching" | "one-launch-status";
+    pm_id: number;
+    name: string;
+    pm_uptime: number;
+    created_at: number;
+    restart_time: number;
+    unstable_restarts: number;
+    pm_cwd: string;
+    pm_exec_path: string;
+    exec_mode: "fork" | "cluster";
+    node_args: string[];
+    pm_out_log_path: string;
+    pm_err_log_path: string;
+    pm_pid_path: string;
+    env: Record<string, string>;
+}
+export interface PM2Monit {
+    memory: number;
+    cpu: number;
+}
+export interface PM2ProcessDescription {
+    pid: number;
+    name: string;
+    pm2_env: PM2ProcessEnv;
+    monit?: PM2Monit;
+}
+export interface PM2Process {
+    name: string;
+    pm_id: number;
+}
+export type PM2Callback<T> = (err: Error | null, result?: T) => void;

package/dist/types/pm2.js

@@ -0,0 +1,4 @@
+/**
+ * PM2-related type definitions
+ */
+export {};

package/dist/types/registry.d.ts

@@ -0,0 +1,230 @@
+import { z } from "zod";
+export declare const ServerStatusSchema: z.ZodEnum<["online", "stopped", "errored", "unknown"]>;
+/**
+ * Snapshot of config values used when server was started.
+ * Used to detect config drift.
+ */
+export declare const ConfigSnapshotSchema: z.ZodObject<{
+    hostname: z.ZodOptional<z.ZodString>;
+    httpsCert: z.ZodOptional<z.ZodString>;
+    httpsKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    hostname?: string | undefined;
+    httpsCert?: string | undefined;
+    httpsKey?: string | undefined;
+}, {
+    hostname?: string | undefined;
+    httpsCert?: string | undefined;
+    httpsKey?: string | undefined;
+}>;
+export type ConfigSnapshot = z.infer<typeof ConfigSnapshotSchema>;
+export declare const ServerEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    command: z.ZodString;
+    resolvedCommand: z.ZodString;
+    cwd: z.ZodString;
+    port: z.ZodNumber;
+    protocol: z.ZodEnum<["http", "https"]>;
+    hostname: z.ZodString;
+    env: z.ZodRecord<z.ZodString, z.ZodString>;
+    createdAt: z.ZodString;
+    pm2Name: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    description: z.ZodOptional<z.ZodString>;
+    usedConfigKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    configSnapshot: z.ZodOptional<z.ZodObject<{
+        hostname: z.ZodOptional<z.ZodString>;
+        httpsCert: z.ZodOptional<z.ZodString>;
+        httpsKey: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        hostname?: string | undefined;
+        httpsCert?: string | undefined;
+        httpsKey?: string | undefined;
+    }, {
+        hostname?: string | undefined;
+        httpsCert?: string | undefined;
+        httpsKey?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    hostname: string;
+    protocol: "http" | "https";
+    id: string;
+    name: string;
+    command: string;
+    resolvedCommand: string;
+    cwd: string;
+    port: number;
+    env: Record<string, string>;
+    createdAt: string;
+    pm2Name: string;
+    tags?: string[] | undefined;
+    description?: string | undefined;
+    usedConfigKeys?: string[] | undefined;
+    configSnapshot?: {
+        hostname?: string | undefined;
+        httpsCert?: string | undefined;
+        httpsKey?: string | undefined;
+    } | undefined;
+}, {
+    hostname: string;
+    protocol: "http" | "https";
+    id: string;
+    name: string;
+    command: string;
+    resolvedCommand: string;
+    cwd: string;
+    port: number;
+    env: Record<string, string>;
+    createdAt: string;
+    pm2Name: string;
+    tags?: string[] | undefined;
+    description?: string | undefined;
+    usedConfigKeys?: string[] | undefined;
+    configSnapshot?: {
+        hostname?: string | undefined;
+        httpsCert?: string | undefined;
+        httpsKey?: string | undefined;
+    } | undefined;
+}>;
+export declare const RegistrySchema: z.ZodObject<{
+    version: z.ZodString;
+    servers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        command: z.ZodString;
+        resolvedCommand: z.ZodString;
+        cwd: z.ZodString;
+        port: z.ZodNumber;
+        protocol: z.ZodEnum<["http", "https"]>;
+        hostname: z.ZodString;
+        env: z.ZodRecord<z.ZodString, z.ZodString>;
+        createdAt: z.ZodString;
+        pm2Name: z.ZodString;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        description: z.ZodOptional<z.ZodString>;
+        usedConfigKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        configSnapshot: z.ZodOptional<z.ZodObject<{
+            hostname: z.ZodOptional<z.ZodString>;
+            httpsCert: z.ZodOptional<z.ZodString>;
+            httpsKey: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            hostname?: string | undefined;
+            httpsCert?: string | undefined;
+            httpsKey?: string | undefined;
+        }, {
+            hostname?: string | undefined;
+            httpsCert?: string | undefined;
+            httpsKey?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        hostname: string;
+        protocol: "http" | "https";
+        id: string;
+        name: string;
+        command: string;
+        resolvedCommand: string;
+        cwd: string;
+        port: number;
+        env: Record<string, string>;
+        createdAt: string;
+        pm2Name: string;
+        tags?: string[] | undefined;
+        description?: string | undefined;
+        usedConfigKeys?: string[] | undefined;
+        configSnapshot?: {
+            hostname?: string | undefined;
+            httpsCert?: string | undefined;
+            httpsKey?: string | undefined;
+        } | undefined;
+    }, {
+        hostname: string;
+        protocol: "http" | "https";
+        id: string;
+        name: string;
+        command: string;
+        resolvedCommand: string;
+        cwd: string;
+        port: number;
+        env: Record<string, string>;
+        createdAt: string;
+        pm2Name: string;
+        tags?: string[] | undefined;
+        description?: string | undefined;
+        usedConfigKeys?: string[] | undefined;
+        configSnapshot?: {
+            hostname?: string | undefined;
+            httpsCert?: string | undefined;
+            httpsKey?: string | undefined;
+        } | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    servers: {
+        hostname: string;
+        protocol: "http" | "https";
+        id: string;
+        name: string;
+        command: string;
+        resolvedCommand: string;
+        cwd: string;
+        port: number;
+        env: Record<string, string>;
+        createdAt: string;
+        pm2Name: string;
+        tags?: string[] | undefined;
+        description?: string | undefined;
+        usedConfigKeys?: string[] | undefined;
+        configSnapshot?: {
+            hostname?: string | undefined;
+            httpsCert?: string | undefined;
+            httpsKey?: string | undefined;
+        } | undefined;
+    }[];
+}, {
+    version: string;
+    servers: {
+        hostname: string;
+        protocol: "http" | "https";
+        id: string;
+        name: string;
+        command: string;
+        resolvedCommand: string;
+        cwd: string;
+        port: number;
+        env: Record<string, string>;
+        createdAt: string;
+        pm2Name: string;
+        tags?: string[] | undefined;
+        description?: string | undefined;
+        usedConfigKeys?: string[] | undefined;
+        configSnapshot?: {
+            hostname?: string | undefined;
+            httpsCert?: string | undefined;
+            httpsKey?: string | undefined;
+        } | undefined;
+    }[];
+}>;
+export type ServerStatus = z.infer<typeof ServerStatusSchema>;
+export type ServerEntry = z.infer<typeof ServerEntrySchema>;
+export type Registry = z.infer<typeof RegistrySchema>;
+export interface ServerFilter {
+    name?: string;
+    tag?: string;
+    cwd?: string;
+    cmd?: string;
+    running?: boolean;
+}
+export interface AddServerOptions {
+    command: string;
+    cwd: string;
+    port: number;
+    name?: string;
+    protocol?: "http" | "https";
+    hostname?: string;
+    env?: Record<string, string>;
+    tags?: string[];
+    description?: string;
+    usedConfigKeys?: string[];
+    configSnapshot?: ConfigSnapshot;
+}

package/dist/types/registry.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export const ServerStatusSchema = z.enum(["online", "stopped", "errored", "unknown"]);
+/**
+ * Snapshot of config values used when server was started.
+ * Used to detect config drift.
+ */
+export const ConfigSnapshotSchema = z.object({
+    hostname: z.string().optional(),
+    httpsCert: z.string().optional(),
+    httpsKey: z.string().optional(),
+});
+export const ServerEntrySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    command: z.string(),
+    resolvedCommand: z.string(),
+    cwd: z.string(),
+    port: z.number().int().min(1).max(65535),
+    protocol: z.enum(["http", "https"]),
+    hostname: z.string(),
+    env: z.record(z.string()),
+    createdAt: z.string(),
+    pm2Name: z.string(),
+    tags: z.array(z.string()).optional(),
+    description: z.string().optional(),
+    // Config tracking for drift detection
+    usedConfigKeys: z.array(z.string()).optional(),
+    configSnapshot: ConfigSnapshotSchema.optional(),
+});
+export const RegistrySchema = z.object({
+    version: z.string(),
+    servers: z.array(ServerEntrySchema),
+});

package/dist/utils/ci-detector.d.ts

@@ -0,0 +1,31 @@
+/**
+ * CI Environment Detector
+ * Detects various CI/CD environments and provides information about them.
+ */
+export interface CIInfo {
+    isCI: boolean;
+    name: string | null;
+}
+/**
+ * Options for CI detection that can be passed from CLI flags
+ */
+export interface CIModeOptions {
+    ci?: boolean;
+    noCi?: boolean;
+}
+export declare class CIDetector {
+    /**
+     * Check if running in a CI environment
+     * @param options Optional CLI flags to override environment detection
+     */
+    static isCI(options?: CIModeOptions): boolean;
+    /**
+     * Get the name of the CI environment
+     * Returns null if not running in CI
+     */
+    static getCIName(): string | null;
+    /**
+     * Get complete CI information
+     */
+    static getInfo(): CIInfo;
+}

package/dist/utils/ci-detector.js

@@ -0,0 +1,68 @@
+/**
+ * CI Environment Detector
+ * Detects various CI/CD environments and provides information about them.
+ */
+const CI_ENVIRONMENTS = [
+    { name: "GitHub Actions", envVar: "GITHUB_ACTIONS" },
+    { name: "GitLab CI", envVar: "GITLAB_CI" },
+    { name: "CircleCI", envVar: "CIRCLECI" },
+    { name: "Travis CI", envVar: "TRAVIS" },
+    { name: "Jenkins", envVar: "JENKINS_URL" },
+    { name: "Buildkite", envVar: "BUILDKITE" },
+    { name: "Azure Pipelines", envVar: "AZURE_PIPELINES" },
+    { name: "TeamCity", envVar: "TEAMCITY_VERSION" },
+];
+export class CIDetector {
+    /**
+     * Check if running in a CI environment
+     * @param options Optional CLI flags to override environment detection
+     */
+    static isCI(options) {
+        // Explicit --no-ci flag takes highest precedence
+        if (options?.noCi) {
+            return false;
+        }
+        // Explicit --ci flag takes precedence over environment detection
+        if (options?.ci) {
+            return true;
+        }
+        // Fall back to environment variable detection
+        // Check for generic CI environment variable
+        if (process.env.CI) {
+            return true;
+        }
+        // Check for specific CI environments
+        for (const ci of CI_ENVIRONMENTS) {
+            if (process.env[ci.envVar]) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get the name of the CI environment
+     * Returns null if not running in CI
+     */
+    static getCIName() {
+        // Check for specific CI environments first
+        for (const ci of CI_ENVIRONMENTS) {
+            if (process.env[ci.envVar]) {
+                return ci.name;
+            }
+        }
+        // Check for generic CI environment variable
+        if (process.env.CI) {
+            return "Unknown CI";
+        }
+        return null;
+    }
+    /**
+     * Get complete CI information
+     */
+    static getInfo() {
+        return {
+            isCI: this.isCI(),
+            name: this.getCIName(),
+        };
+    }
+}

package/dist/utils/config-drift.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Utilities for detecting configuration drift in servers.
+ * Drift occurs when config values have changed since a server was started.
+ */
+import type { GlobalConfig } from "../types/config.js";
+import type { ServerEntry, ConfigSnapshot } from "../types/registry.js";
+/**
+ * Information about a drifted config value
+ */
+export interface DriftedValue {
+    /** The config key that has drifted */
+    configKey: string;
+    /** The template variable name */
+    templateVar: string;
+    /** The value when server was started */
+    startedWith: string | undefined;
+    /** The current config value */
+    currentValue: string | undefined;
+}
+/**
+ * Result of drift detection for a server
+ */
+export interface DriftResult {
+    /** Whether the server has config drift */
+    hasDrift: boolean;
+    /** List of drifted values */
+    driftedValues: DriftedValue[];
+}
+/**
+ * Extract the config keys used by a command template
+ * @param command - The command template string
+ * @returns Array of config keys used (e.g., ["hostname", "httpsCert"])
+ */
+export declare function extractUsedConfigKeys(command: string): string[];
+/**
+ * Create a config snapshot containing only the values used by a server
+ * @param config - Current global config
+ * @param usedConfigKeys - Config keys used by the server
+ * @returns Config snapshot with only relevant values
+ */
+export declare function createConfigSnapshot(config: GlobalConfig, usedConfigKeys: string[]): ConfigSnapshot;
+/**
+ * Detect config drift for a server
+ * @param server - Server entry from registry
+ * @param currentConfig - Current global config
+ * @returns Drift detection result
+ */
+export declare function detectDrift(server: ServerEntry, currentConfig: GlobalConfig): DriftResult;
+/**
+ * Find all servers that use a specific config key
+ * @param servers - Array of server entries
+ * @param configKey - The config key to search for
+ * @returns Array of servers using that config key
+ */
+export declare function findServersUsingConfigKey(servers: ServerEntry[], configKey: string): ServerEntry[];
+/**
+ * Find all servers with config drift
+ * @param servers - Array of server entries
+ * @param currentConfig - Current global config
+ * @returns Array of servers with drift and their drift details
+ */
+export declare function findServersWithDrift(servers: ServerEntry[], currentConfig: GlobalConfig): Array<{
+    server: ServerEntry;
+    drift: DriftResult;
+}>;
+/**
+ * Format drift information for display
+ * @param drift - Drift result to format
+ * @returns Formatted string describing the drift
+ */
+export declare function formatDrift(drift: DriftResult): string;