@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/src/models/types.d.ts

@@ -0,0 +1,84 @@
+export declare const CMDErrors: {
+    readonly SystemErrors: {
+        readonly DATABASE_CONNECTION_FAILED: 1001;
+        readonly MEMORY_INSUFFICIENT: 1002;
+        readonly NETWORK_UNREACHABLE: 1003;
+        readonly DISK_FULL: 1004;
+        readonly SERVICE_UNAVAILABLE: 1005;
+        readonly INTERNAL_SERVER_ERROR: 1500;
+    };
+    readonly SecurityErrors: {
+        readonly UNAUTHORIZED: 2001;
+        readonly FORBIDDEN: 2003;
+        readonly TOKEN_EXPIRED: 2004;
+        readonly INVALID_CREDENTIALS: 2005;
+        readonly ACCESS_DENIED: 2006;
+        readonly RATE_LIMIT_EXCEEDED: 2007;
+    };
+    readonly BusinessErrors: {
+        readonly VALIDATION_FAILED: 3001;
+        readonly RESOURCE_NOT_FOUND: 3004;
+        readonly RESOURCE_ALREADY_EXISTS: 3009;
+        readonly INVALID_OPERATION: 3009;
+        readonly GROUP_CONSTRAINT_VIOLATION: 3010;
+        readonly SERVER_STATUS_CONFLICT: 3011;
+        readonly CONFIGURATION_INVALID: 3012;
+    };
+    readonly APIErrors: {
+        readonly INVALID_REQUEST_FORMAT: 4000;
+        readonly MISSING_REQUIRED_PARAMETER: 4001;
+        readonly INVALID_PARAMETER_VALUE: 4002;
+        readonly UNSUPPORTED_MEDIA_TYPE: 4003;
+        readonly BAD_REQUEST: 4000;
+    };
+    readonly MCPProtocolErrors: {
+        readonly MCP_SERVER_UNREACHABLE: -32001;
+        readonly MCP_REQUEST_TIMEOUT: -32002;
+        readonly MCP_INVALID_RESPONSE: -32003;
+        readonly MCP_TOOL_NOT_FOUND: -32801;
+        readonly MCP_EXECUTION_FAILED: -32802;
+        readonly MCP_INITIALIZATION_FAILED: -32803;
+        readonly MCP_INVALID_CONFIGURATION: -32804;
+        readonly MCP_RATE_LIMIT_EXCEEDED: -32805;
+        readonly MCP_AUTHENTICATION_FAILED: -32806;
+        readonly MCP_AUTHORIZATION_FAILED: -32807;
+        readonly MCP_RESOURCE_EXHAUSTED: -32808;
+        readonly MCP_PRECONDITION_FAILED: -32809;
+        readonly MCP_CONTENT_MODIFIED: -32810;
+        readonly MCP_LOOP_DETECTED: -32811;
+        readonly MCP_NOT_IMPLEMENTED: -32812;
+        readonly MCP_NOT_SUPPORTED: -32813;
+        readonly MCP_TOO_BUSY: -32814;
+        readonly MCP_SERVER_SHUTDOWN: -32815;
+    };
+};
+export type AllErrorCodes = (typeof CMDErrors.SystemErrors)[keyof typeof CMDErrors.SystemErrors] | (typeof CMDErrors.SecurityErrors)[keyof typeof CMDErrors.SecurityErrors] | (typeof CMDErrors.BusinessErrors)[keyof typeof CMDErrors.BusinessErrors] | (typeof CMDErrors.APIErrors)[keyof typeof CMDErrors.APIErrors] | (typeof CMDErrors.MCPProtocolErrors)[keyof typeof CMDErrors.MCPProtocolErrors] | 6000 | 6001 | 6002 | 6003 | 6004 | 6005;
+export interface CMDBaseResponse<T = unknown> {
+    code: number;
+    message: string;
+    data?: T;
+    timestamp: string;
+    requestId?: string;
+}
+export type CMDSuccess<T = unknown> = {
+    code: 200 | 201 | 204;
+    message: string;
+    data: T;
+    timestamp: string;
+    requestId?: string;
+};
+export type CMDError = {
+    code: AllErrorCodes;
+    message: string;
+    data: null;
+    timestamp: string;
+    requestId?: string;
+    error?: {
+        category: 'SYSTEM' | 'SECURITY' | 'BUSINESS' | 'API' | 'MCP_PROTOCOL';
+        severity: 'FATAL' | 'ERROR' | 'WARN' | 'INFO';
+        stack?: string;
+        context?: Record<string, unknown>;
+        httpStatus?: number;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/server/src/models/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/models/types.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEZ,CAAC;AAGX,MAAM,MAAM,aAAa,GACrB,CAAC,OAAO,SAAS,CAAC,YAAY,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,YAAY,CAAC,GACpE,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,cAAc,CAAC,GACxE,CAAC,OAAO,SAAS,CAAC,cAAc,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,cAAc,CAAC,GACxE,CAAC,OAAO,SAAS,CAAC,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,SAAS,CAAC,GAC9D,CAAC,OAAO,SAAS,CAAC,iBAAiB,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,iBAAiB,CAAC,GAC9E,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,CAAC;AAGT,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAGD,MAAM,MAAM,UAAU,CAAC,CAAC,GAAG,OAAO,IAAI;IACpC,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,CAAC,CAAC;IACR,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAGF,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,aAAa,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE;QAEN,QAAQ,EAAE,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,KAAK,GAAG,cAAc,CAAC;QAEtE,QAAQ,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;QAE9C,KAAK,CAAC,EAAE,MAAM,CAAC;QAEf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAElC,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH,CAAC"}

package/dist/server/src/models/types.js

@@ -0,0 +1,67 @@
+// CMD error type hierarchy definition
+export const CMDErrors = {
+    // === System-level errors (1000-1999) ===
+    // Infrastructure failures, runtime errors
+    SystemErrors: {
+        DATABASE_CONNECTION_FAILED: 1001,
+        MEMORY_INSUFFICIENT: 1002,
+        NETWORK_UNREACHABLE: 1003,
+        DISK_FULL: 1004,
+        SERVICE_UNAVAILABLE: 1005,
+        INTERNAL_SERVER_ERROR: 1500
+    },
+    // === Security errors (2000-2999) ===
+    // Authentication, authorization, security policy related
+    SecurityErrors: {
+        UNAUTHORIZED: 2001,
+        FORBIDDEN: 2003,
+        TOKEN_EXPIRED: 2004,
+        INVALID_CREDENTIALS: 2005,
+        ACCESS_DENIED: 2006,
+        RATE_LIMIT_EXCEEDED: 2007
+    },
+    // === Business logic errors (3000-3999) ===
+    // Business rule validation, resource status, etc.
+    BusinessErrors: {
+        VALIDATION_FAILED: 3001,
+        RESOURCE_NOT_FOUND: 3004,
+        RESOURCE_ALREADY_EXISTS: 3009,
+        INVALID_OPERATION: 3009,
+        GROUP_CONSTRAINT_VIOLATION: 3010,
+        SERVER_STATUS_CONFLICT: 3011,
+        CONFIGURATION_INVALID: 3012
+    },
+    // === API errors (4000-4999) ===
+    // Request format, parameter validation
+    APIErrors: {
+        INVALID_REQUEST_FORMAT: 4000,
+        MISSING_REQUIRED_PARAMETER: 4001,
+        INVALID_PARAMETER_VALUE: 4002,
+        UNSUPPORTED_MEDIA_TYPE: 4003,
+        BAD_REQUEST: 4000
+    },
+    // === MCP protocol errors (according to MCP standard specification) ===
+    // Error code definitions based on MCP protocol standard (https://modelcontextprotocol.io/specification/2025-11-25)
+    MCPProtocolErrors: {
+        // Standard JSON-RPC 2.0 error code range (-32099 to -32000)
+        MCP_SERVER_UNREACHABLE: -32001, // Service unreachable
+        MCP_REQUEST_TIMEOUT: -32002, // Request timeout
+        MCP_INVALID_RESPONSE: -32003, // Invalid response
+        // MCP specific error code range (-32899 to -32800)
+        MCP_TOOL_NOT_FOUND: -32801, // Tool not found (corresponds to toolNotFound in MCP specification)
+        MCP_EXECUTION_FAILED: -32802, // Execution failed
+        MCP_INITIALIZATION_FAILED: -32803, // Initialization failed
+        MCP_INVALID_CONFIGURATION: -32804, // Invalid configuration
+        MCP_RATE_LIMIT_EXCEEDED: -32805, // Rate limit exceeded
+        MCP_AUTHENTICATION_FAILED: -32806, // Authentication failed
+        MCP_AUTHORIZATION_FAILED: -32807, // Authorization failed
+        MCP_RESOURCE_EXHAUSTED: -32808, // Resource exhausted
+        MCP_PRECONDITION_FAILED: -32809, // Precondition failed
+        MCP_CONTENT_MODIFIED: -32810, // Content modified
+        MCP_LOOP_DETECTED: -32811, // Loop detected
+        MCP_NOT_IMPLEMENTED: -32812, // Not implemented
+        MCP_NOT_SUPPORTED: -32813, // Not supported
+        MCP_TOO_BUSY: -32814, // Overloaded
+        MCP_SERVER_SHUTDOWN: -32815 // Server shutdown
+    }
+};

package/dist/server/src/pid/file.d.ts

@@ -0,0 +1,26 @@
+/**
+ * PID file operation utilities
+ * Responsibility: Low-level PID file read/write/delete operations
+ */
+import type { PidFileOptions } from './types.js';
+/**
+ * Get PID file path
+ */
+export declare function getPidFilePath(options?: PidFileOptions): string;
+/**
+ * Write PID file
+ */
+export declare function writePidFile(pid: number, options?: PidFileOptions): void;
+/**
+ * Read PID file
+ */
+export declare function readPidFile(options?: PidFileOptions): number | null;
+/**
+ * Remove PID file
+ */
+export declare function removePidFile(options?: PidFileOptions): void;
+/**
+ * Check if PID file exists
+ */
+export declare function pidFileExists(options?: PidFileOptions): boolean;
+//# sourceMappingURL=file.d.ts.map

package/dist/server/src/pid/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../../src/pid/file.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAMjD;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAI/D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAUxE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI,CAanE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,CAS5D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAG/D"}

package/dist/server/src/pid/file.js

@@ -0,0 +1,68 @@
+/**
+ * PID file operation utilities
+ * Responsibility: Low-level PID file read/write/delete operations
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+// Config directory: Prefer using .mcp-hub-lite/config folder in user's home directory
+const DEFAULT_CONFIG_DIR = path.join(os.homedir(), '.mcp-hub-lite', 'config');
+const DEFAULT_PID_FILENAME = '.mcp-hub.pid';
+/**
+ * Get PID file path
+ */
+export function getPidFilePath(options) {
+    const configDir = options?.configDir || DEFAULT_CONFIG_DIR;
+    const filename = options?.filename || DEFAULT_PID_FILENAME;
+    return path.join(configDir, filename);
+}
+/**
+ * Write PID file
+ */
+export function writePidFile(pid, options) {
+    const filePath = getPidFilePath(options);
+    const configDir = path.dirname(filePath);
+    // Ensure config directory exists
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, pid.toString(), 'utf8');
+}
+/**
+ * Read PID file
+ */
+export function readPidFile(options) {
+    try {
+        const filePath = getPidFilePath(options);
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        const content = fs.readFileSync(filePath, 'utf8');
+        const pid = parseInt(content.trim(), 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove PID file
+ */
+export function removePidFile(options) {
+    try {
+        const filePath = getPidFilePath(options);
+        if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+        }
+    }
+    catch {
+        // Ignore deletion errors
+    }
+}
+/**
+ * Check if PID file exists
+ */
+export function pidFileExists(options) {
+    const filePath = getPidFilePath(options);
+    return fs.existsSync(filePath);
+}

package/dist/server/src/pid/manager.d.ts

@@ -0,0 +1,98 @@
+import type { PidFileOptions } from './types.js';
+export declare class PidManager {
+    /**
+     * Writes the current process PID to a PID file and registers cleanup hooks
+     * for graceful shutdown handling.
+     *
+     * This method should be called during service startup to create a PID file
+     * that tracks the running process. It automatically registers signal handlers
+     * for SIGINT, SIGTERM, and process exit events to ensure the PID file is
+     * properly cleaned up when the process terminates.
+     *
+     * @param options - Optional configuration for PID file location and behavior
+     * @throws Will log an error if PID file writing fails, but will not throw
+     *
+     * @example
+     * // Basic usage with default PID file location
+     * PidManager.writePid();
+     *
+     * // Custom PID file location
+     * PidManager.writePid({ pidFilePath: '/custom/path/mcp-hub.pid' });
+     */
+    static writePid(options?: PidFileOptions): void;
+    /**
+     * Removes the PID file from the filesystem.
+     *
+     * This method safely deletes the PID file, typically called during service
+     * shutdown or cleanup operations. It's automatically invoked by the signal
+     * handlers registered in `writePid()`.
+     *
+     * @param options - Optional configuration matching the options used when
+     * writing the PID file
+     *
+     * @example
+     * // Remove PID file with default options
+     * PidManager.removePid();
+     *
+     * // Remove PID file with custom path
+     * PidManager.removePid({ pidFilePath: '/custom/path/mcp-hub.pid' });
+     */
+    static removePid(options?: PidFileOptions): void;
+    /**
+     * Retrieves the PID stored in the PID file.
+     *
+     * Reads the PID file and returns the stored process ID if it exists and
+     * contains valid data. Returns null if the file doesn't exist, is empty,
+     * or contains invalid data.
+     *
+     * @param options - Optional configuration for PID file location
+     * @returns The stored process ID as a number, or null if no valid PID is found
+     *
+     * @example
+     * const pid = PidManager.getPid();
+     * if (pid) {
+     *   console.log(`Service is running with PID: ${pid}`);
+     * }
+     */
+    static getPid(options?: PidFileOptions): number | null;
+    /**
+     * Checks whether the process associated with the stored PID is currently running.
+     *
+     * This method first retrieves the PID from the PID file, then uses the
+     * `process.kill(pid, 0)` system call to verify if a process with that PID
+     * is still active. This is a safe operation that only checks process existence
+     * without sending any actual signal to terminate the process.
+     *
+     * @param options - Optional configuration for PID file location
+     * @returns true if a process with the stored PID is running, false otherwise
+     *
+     * @example
+     * if (PidManager.isRunning()) {
+     *   console.log('MCP Hub Lite service is already running');
+     *   process.exit(1);
+     * }
+     */
+    static isRunning(options?: PidFileOptions): boolean;
+    /**
+     * Checks whether the PID file exists on the filesystem.
+     *
+     * This method verifies the existence of the PID file without attempting to
+     * read its contents or validate the stored PID. It's useful for determining
+     * if a previous instance may have created a PID file, regardless of whether
+     * that process is still running.
+     *
+     * @param options - Optional configuration for PID file location
+     * @returns true if the PID file exists, false otherwise
+     *
+     * @example
+     * if (PidManager.pidFileExists()) {
+     *   console.log('PID file exists, checking if process is running...');
+     *   if (!PidManager.isRunning()) {
+     *     console.log('Stale PID file detected, cleaning up...');
+     *     PidManager.removePid();
+     *   }
+     * }
+     */
+    static pidFileExists(options?: PidFileOptions): boolean;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/server/src/pid/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../../../src/pid/manager.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,qBAAa,UAAU;IACrB;;;;;;;;;;;;;;;;;;OAkBG;WACW,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAmBtD;;;;;;;;;;;;;;;;OAgBG;WACW,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAIvD;;;;;;;;;;;;;;;OAeG;WACW,MAAM,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI;IAI7D;;;;;;;;;;;;;;;;OAgBG;WACW,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO;IAa1D;;;;;;;;;;;;;;;;;;;OAmBG;WACW,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO;CAG/D"}

package/dist/server/src/pid/manager.js

@@ -0,0 +1,158 @@
+/**
+ * PID Manager for MCP Hub Lite service lifecycle management.
+ *
+ * This class provides a centralized interface for managing process ID (PID) files
+ * that track the running state of the MCP Hub Lite service. It handles writing,
+ * reading, and cleaning up PID files, as well as registering appropriate signal
+ * handlers to ensure proper cleanup during process termination.
+ *
+ * The PID manager is primarily used by the CLI entry point and server runner
+ * to maintain service state awareness and prevent multiple instances from
+ * running simultaneously.
+ *
+ * @example
+ * // Write PID file at service startup
+ * PidManager.writePid();
+ *
+ * // Check if service is already running
+ * if (PidManager.isRunning()) {
+ *   console.log('Service is already running');
+ *   process.exit(1);
+ * }
+ *
+ * // Clean up PID file on shutdown
+ * PidManager.removePid();
+ */
+import { logger } from '../utils/logger.js';
+import { writePidFile, readPidFile, removePidFile, pidFileExists } from './file.js';
+export class PidManager {
+    /**
+     * Writes the current process PID to a PID file and registers cleanup hooks
+     * for graceful shutdown handling.
+     *
+     * This method should be called during service startup to create a PID file
+     * that tracks the running process. It automatically registers signal handlers
+     * for SIGINT, SIGTERM, and process exit events to ensure the PID file is
+     * properly cleaned up when the process terminates.
+     *
+     * @param options - Optional configuration for PID file location and behavior
+     * @throws Will log an error if PID file writing fails, but will not throw
+     *
+     * @example
+     * // Basic usage with default PID file location
+     * PidManager.writePid();
+     *
+     * // Custom PID file location
+     * PidManager.writePid({ pidFilePath: '/custom/path/mcp-hub.pid' });
+     */
+    static writePid(options) {
+        try {
+            writePidFile(process.pid, options);
+            // Register cleanup hooks for process exit
+            process.on('exit', () => this.removePid(options));
+            process.on('SIGINT', () => {
+                this.removePid(options);
+                process.exit();
+            });
+            process.on('SIGTERM', () => {
+                this.removePid(options);
+                process.exit();
+            });
+        }
+        catch (error) {
+            logger.error('Failed to write PID file:', error);
+        }
+    }
+    /**
+     * Removes the PID file from the filesystem.
+     *
+     * This method safely deletes the PID file, typically called during service
+     * shutdown or cleanup operations. It's automatically invoked by the signal
+     * handlers registered in `writePid()`.
+     *
+     * @param options - Optional configuration matching the options used when
+     * writing the PID file
+     *
+     * @example
+     * // Remove PID file with default options
+     * PidManager.removePid();
+     *
+     * // Remove PID file with custom path
+     * PidManager.removePid({ pidFilePath: '/custom/path/mcp-hub.pid' });
+     */
+    static removePid(options) {
+        removePidFile(options);
+    }
+    /**
+     * Retrieves the PID stored in the PID file.
+     *
+     * Reads the PID file and returns the stored process ID if it exists and
+     * contains valid data. Returns null if the file doesn't exist, is empty,
+     * or contains invalid data.
+     *
+     * @param options - Optional configuration for PID file location
+     * @returns The stored process ID as a number, or null if no valid PID is found
+     *
+     * @example
+     * const pid = PidManager.getPid();
+     * if (pid) {
+     *   console.log(`Service is running with PID: ${pid}`);
+     * }
+     */
+    static getPid(options) {
+        return readPidFile(options);
+    }
+    /**
+     * Checks whether the process associated with the stored PID is currently running.
+     *
+     * This method first retrieves the PID from the PID file, then uses the
+     * `process.kill(pid, 0)` system call to verify if a process with that PID
+     * is still active. This is a safe operation that only checks process existence
+     * without sending any actual signal to terminate the process.
+     *
+     * @param options - Optional configuration for PID file location
+     * @returns true if a process with the stored PID is running, false otherwise
+     *
+     * @example
+     * if (PidManager.isRunning()) {
+     *   console.log('MCP Hub Lite service is already running');
+     *   process.exit(1);
+     * }
+     */
+    static isRunning(options) {
+        const pid = this.getPid(options);
+        if (!pid)
+            return false;
+        try {
+            // process.kill(pid, 0) checks if process exists without actually killing it
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Checks whether the PID file exists on the filesystem.
+     *
+     * This method verifies the existence of the PID file without attempting to
+     * read its contents or validate the stored PID. It's useful for determining
+     * if a previous instance may have created a PID file, regardless of whether
+     * that process is still running.
+     *
+     * @param options - Optional configuration for PID file location
+     * @returns true if the PID file exists, false otherwise
+     *
+     * @example
+     * if (PidManager.pidFileExists()) {
+     *   console.log('PID file exists, checking if process is running...');
+     *   if (!PidManager.isRunning()) {
+     *     console.log('Stale PID file detected, cleaning up...');
+     *     PidManager.removePid();
+     *   }
+     * }
+     */
+    static pidFileExists(options) {
+        return pidFileExists(options);
+    }
+}

package/dist/server/src/pid/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PID management related type definitions
+ */
+export interface PidInfo {
+    pid: number;
+    timestamp: number;
+    port?: number;
+}
+export interface PidFileOptions {
+    configDir?: string;
+    filename?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/server/src/pid/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/pid/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB"}

package/dist/server/src/pid/types.js

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

package/dist/server/src/server/dev-server.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dev-server.d.ts.map

package/dist/server/src/server/dev-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-server.d.ts","sourceRoot":"","sources":["../../../../src/server/dev-server.ts"],"names":[],"mappings":""}