@pasko70/pibo 1.0.0

package/dist/mcp/config.js

@@ -0,0 +1,440 @@
+/**
+ * MCP-CLI Configuration Types and Loader
+ */
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { ErrorCode, configInvalidJsonError, configMissingFieldError, configNotFoundError, configSearchError, formatCliError, serverNotFoundError, } from './errors.js';
+export const DEFAULT_MCP_CONFIG_FILE = 'mcp_servers.json';
+// ============================================================================
+// Tool Filtering
+// ============================================================================
+/**
+ * Simple glob pattern matcher for tool names
+ * Supports * (any characters) and ? (single character)
+ */
+function matchesPattern(name, pattern) {
+    // Convert glob pattern to regex
+    const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special regex chars
+        .replace(/\*/g, '.*') // * matches any characters
+        .replace(/\?/g, '.'); // ? matches single character
+    return new RegExp(`^${regexPattern}$`, 'i').test(name);
+}
+/**
+ * Check if a tool name matches any of the given patterns
+ */
+function matchesAnyPattern(name, patterns) {
+    return patterns.some((pattern) => matchesPattern(name, pattern));
+}
+/**
+ * Filter tools based on allowedTools and disabledTools configuration
+ *
+ * Rules:
+ * - If allowedTools is specified, only tools matching those patterns are available
+ * - If disabledTools is specified, tools matching those patterns are excluded
+ * - disabledTools takes precedence over allowedTools
+ *
+ * @param tools - Array of tools with name property
+ * @param config - Server config with optional allowedTools/disabledTools
+ * @returns Filtered array of tools
+ */
+export function filterTools(tools, config) {
+    const { allowedTools, disabledTools } = config;
+    return tools.filter((tool) => {
+        // First check if tool is in disabledTools (takes precedence)
+        if (disabledTools && disabledTools.length > 0) {
+            if (matchesAnyPattern(tool.name, disabledTools)) {
+                return false;
+            }
+        }
+        // Then check if allowedTools is specified
+        if (allowedTools && allowedTools.length > 0) {
+            return matchesAnyPattern(tool.name, allowedTools);
+        }
+        // No filtering specified, allow all
+        return true;
+    });
+}
+/**
+ * Check if a specific tool is allowed by the config
+ *
+ * @param toolName - Name of the tool to check
+ * @param config - Server config with optional allowedTools/disabledTools
+ * @returns true if tool is allowed, false otherwise
+ */
+export function isToolAllowed(toolName, config) {
+    const { allowedTools, disabledTools } = config;
+    // First check if tool is in disabledTools (takes precedence)
+    if (disabledTools && disabledTools.length > 0) {
+        if (matchesAnyPattern(toolName, disabledTools)) {
+            return false;
+        }
+    }
+    // Then check if allowedTools is specified
+    if (allowedTools && allowedTools.length > 0) {
+        return matchesAnyPattern(toolName, allowedTools);
+    }
+    // No filtering specified, allow all
+    return true;
+}
+/**
+ * Check if a server config is HTTP-based
+ */
+export function isHttpServer(config) {
+    return 'url' in config;
+}
+/**
+ * Check if a server config is stdio-based
+ */
+export function isStdioServer(config) {
+    return 'command' in config;
+}
+// ============================================================================
+// Environment Variables & Runtime Configuration
+// ============================================================================
+/**
+ * Default configuration values - centralized to avoid inline magic numbers
+ */
+export const DEFAULT_TIMEOUT_SECONDS = 1800; // 30 minutes
+export const DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_SECONDS * 1000;
+export const DEFAULT_CONCURRENCY = 5;
+export const DEFAULT_MAX_RETRIES = 3;
+export const DEFAULT_RETRY_DELAY_MS = 1000; // 1 second base delay
+export const DEFAULT_DAEMON_TIMEOUT_SECONDS = 60; // 60 seconds idle timeout
+export const DEFAULT_DAEMON_REQUEST_TIMEOUT_SECONDS = 60;
+/**
+ * Debug logging utility - only logs when MCP_DEBUG is set
+ */
+export function debug(message) {
+    if (process.env.MCP_DEBUG) {
+        console.error(`[pibo mcp] ${message}`);
+    }
+}
+/**
+ * Get configured timeout in milliseconds
+ * @env MCP_TIMEOUT - timeout in seconds (default: 1800 = 30 minutes)
+ */
+export function getTimeoutMs() {
+    const envTimeout = process.env.MCP_TIMEOUT;
+    if (envTimeout) {
+        const seconds = Number.parseInt(envTimeout, 10);
+        if (!Number.isNaN(seconds) && seconds > 0) {
+            return seconds * 1000;
+        }
+    }
+    return DEFAULT_TIMEOUT_MS;
+}
+/**
+ * Get concurrency limit for parallel server connections
+ * @env MCP_CONCURRENCY - max parallel connections (default: 5)
+ */
+export function getConcurrencyLimit() {
+    const envConcurrency = process.env.MCP_CONCURRENCY;
+    if (envConcurrency) {
+        const limit = Number.parseInt(envConcurrency, 10);
+        if (!Number.isNaN(limit) && limit > 0) {
+            return limit;
+        }
+    }
+    return DEFAULT_CONCURRENCY;
+}
+/**
+ * Get max retry attempts for transient failures
+ * @env MCP_MAX_RETRIES - max retry attempts (default: 3, use 0 to disable retries)
+ */
+export function getMaxRetries() {
+    const envRetries = process.env.MCP_MAX_RETRIES;
+    if (envRetries) {
+        const retries = Number.parseInt(envRetries, 10);
+        if (!Number.isNaN(retries) && retries >= 0) {
+            return retries;
+        }
+    }
+    return DEFAULT_MAX_RETRIES;
+}
+/**
+ * Get base delay for retry backoff in milliseconds
+ * @env MCP_RETRY_DELAY - base delay in milliseconds (default: 1000)
+ */
+export function getRetryDelayMs() {
+    const envDelay = process.env.MCP_RETRY_DELAY;
+    if (envDelay) {
+        const delay = Number.parseInt(envDelay, 10);
+        if (!Number.isNaN(delay) && delay > 0) {
+            return delay;
+        }
+    }
+    return DEFAULT_RETRY_DELAY_MS;
+}
+// ============================================================================
+// Daemon Configuration
+// ============================================================================
+/**
+ * Check if daemon mode is enabled
+ * @env MCP_NO_DAEMON - set to "1" to disable daemon, force fresh connections
+ */
+export function isDaemonEnabled() {
+    return process.env.MCP_NO_DAEMON !== '1';
+}
+/**
+ * Get daemon idle timeout in milliseconds
+ * @env MCP_DAEMON_TIMEOUT - timeout in seconds (default: 60)
+ */
+export function getDaemonTimeoutMs() {
+    const envTimeout = process.env.MCP_DAEMON_TIMEOUT;
+    if (envTimeout) {
+        const seconds = Number.parseInt(envTimeout, 10);
+        if (!Number.isNaN(seconds) && seconds > 0) {
+            return seconds * 1000;
+        }
+    }
+    return DEFAULT_DAEMON_TIMEOUT_SECONDS * 1000;
+}
+/**
+ * Get daemon request timeout in milliseconds
+ * @env MCP_DAEMON_REQUEST_TIMEOUT - timeout in seconds (default: 60)
+ */
+export function getDaemonRequestTimeoutMs() {
+    const envTimeout = process.env.MCP_DAEMON_REQUEST_TIMEOUT;
+    if (envTimeout) {
+        const seconds = Number.parseInt(envTimeout, 10);
+        if (!Number.isNaN(seconds) && seconds > 0) {
+            return seconds * 1000;
+        }
+    }
+    return DEFAULT_DAEMON_REQUEST_TIMEOUT_SECONDS * 1000;
+}
+/**
+ * Get the socket directory for daemon connections
+ * Uses platform-appropriate temp directory
+ */
+export function getSocketDir() {
+    const uid = process.getuid?.() ?? 'unknown';
+    // macOS uses /var/folders which is auto-cleaned, Linux uses /tmp
+    const base = process.platform === 'darwin' ? '/tmp' : '/tmp';
+    return join(base, `mcp-cli-${uid}`);
+}
+/**
+ * Get socket path for a specific server
+ */
+export function getSocketPath(serverName) {
+    return join(getSocketDir(), `${serverName}.sock`);
+}
+/**
+ * Get PID file path for a specific server daemon
+ */
+export function getPidPath(serverName) {
+    return join(getSocketDir(), `${serverName}.pid`);
+}
+/**
+ * Generate a hash of server config for stale detection
+ * Returns consistent hash for identical configs
+ */
+export function getConfigHash(config) {
+    const str = JSON.stringify(config, Object.keys(config).sort());
+    return createHash('sha256').update(str).digest('hex').slice(0, 16);
+}
+/**
+ * Check if strict environment variable mode is enabled
+ * @env MCP_STRICT_ENV - set to "false" to warn instead of error (default: true)
+ */
+function isStrictEnvMode() {
+    const value = process.env.MCP_STRICT_ENV?.toLowerCase();
+    return value !== 'false' && value !== '0';
+}
+/**
+ * Substitute environment variables in a string
+ * Supports ${VAR_NAME} syntax
+ *
+ * By default (strict mode), throws an error when referenced env var is not set.
+ * Set MCP_STRICT_ENV=false to warn instead of error.
+ */
+function substituteEnvVars(value) {
+    const missingVars = [];
+    const result = value.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+        const envValue = process.env[varName];
+        if (envValue === undefined) {
+            missingVars.push(varName);
+            return '';
+        }
+        return envValue;
+    });
+    if (missingVars.length > 0) {
+        const varList = missingVars.map((v) => `\${${v}}`).join(', ');
+        const message = `Missing environment variable${missingVars.length > 1 ? 's' : ''}: ${varList}`;
+        if (isStrictEnvMode()) {
+            throw new Error(formatCliError({
+                code: ErrorCode.CLIENT_ERROR,
+                type: 'MISSING_ENV_VAR',
+                message: message,
+                details: 'Referenced in config but not set in environment',
+                suggestion: `Set the variable(s) before running: export ${missingVars[0]}="value" or set MCP_STRICT_ENV=false to use empty values`,
+            }));
+        }
+        // Non-strict mode: warn but continue
+        console.error(`[pibo mcp] Warning: ${message}`);
+    }
+    return result;
+}
+/**
+ * Recursively substitute environment variables in an object
+ */
+function substituteEnvVarsInObject(obj) {
+    if (typeof obj === 'string') {
+        return substituteEnvVars(obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(substituteEnvVarsInObject);
+    }
+    if (obj && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = substituteEnvVarsInObject(value);
+        }
+        return result;
+    }
+    return obj;
+}
+/**
+ * Get default config search paths
+ */
+export function getDefaultConfigPaths() {
+    const paths = [];
+    const home = homedir();
+    // Current directory
+    paths.push(resolve(DEFAULT_MCP_CONFIG_FILE));
+    // Home directory variants
+    paths.push(join(home, '.mcp_servers.json'));
+    paths.push(join(home, '.config', 'mcp', 'mcp_servers.json'));
+    return paths;
+}
+export function getPreferredConfigPath(explicitPath) {
+    if (explicitPath) {
+        return resolve(explicitPath);
+    }
+    if (process.env.MCP_CONFIG_PATH) {
+        return resolve(process.env.MCP_CONFIG_PATH);
+    }
+    return resolve(DEFAULT_MCP_CONFIG_FILE);
+}
+export function findConfigPath(explicitPath) {
+    if (explicitPath) {
+        const resolvedPath = resolve(explicitPath);
+        return existsSync(resolvedPath) ? resolvedPath : undefined;
+    }
+    if (process.env.MCP_CONFIG_PATH) {
+        const resolvedPath = resolve(process.env.MCP_CONFIG_PATH);
+        return existsSync(resolvedPath) ? resolvedPath : undefined;
+    }
+    return getDefaultConfigPaths().find((path) => existsSync(path));
+}
+export async function ensureConfigExists(explicitPath) {
+    const existingPath = findConfigPath(explicitPath);
+    if (existingPath) {
+        return existingPath;
+    }
+    const configPath = getPreferredConfigPath(explicitPath);
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify({ mcpServers: {} }, null, 2)}\n`);
+    return configPath;
+}
+/**
+ * Load and parse MCP servers configuration
+ */
+export async function loadConfig(explicitPath) {
+    let configPath;
+    // Check explicit path from argument or environment
+    if (explicitPath) {
+        configPath = resolve(explicitPath);
+    }
+    else if (process.env.MCP_CONFIG_PATH) {
+        configPath = resolve(process.env.MCP_CONFIG_PATH);
+    }
+    // If explicit path provided, it must exist
+    if (configPath) {
+        if (!existsSync(configPath)) {
+            throw new Error(formatCliError(configNotFoundError(configPath)));
+        }
+    }
+    else {
+        // Search default paths
+        const searchPaths = getDefaultConfigPaths();
+        for (const path of searchPaths) {
+            if (existsSync(path)) {
+                configPath = path;
+                break;
+            }
+        }
+        if (!configPath) {
+            throw new Error(formatCliError(configSearchError()));
+        }
+    }
+    // Read and parse config
+    const content = await readFile(configPath, 'utf-8');
+    let config;
+    try {
+        config = JSON.parse(content);
+    }
+    catch (e) {
+        throw new Error(formatCliError(configInvalidJsonError(configPath, e.message)));
+    }
+    // Validate structure
+    if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+        throw new Error(formatCliError(configMissingFieldError(configPath)));
+    }
+    // Validate individual server configs
+    for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+        if (!serverConfig || typeof serverConfig !== 'object') {
+            throw new Error(formatCliError({
+                code: ErrorCode.CLIENT_ERROR,
+                type: 'CONFIG_INVALID_SERVER',
+                message: `Invalid server configuration for "${serverName}"`,
+                details: 'Server config must be an object',
+                suggestion: `Use { "command": "..." } for stdio or { "url": "..." } for HTTP`,
+            }));
+        }
+        const hasCommand = 'command' in serverConfig;
+        const hasUrl = 'url' in serverConfig;
+        if (!hasCommand && !hasUrl) {
+            throw new Error(formatCliError({
+                code: ErrorCode.CLIENT_ERROR,
+                type: 'CONFIG_INVALID_SERVER',
+                message: `Server "${serverName}" missing required field`,
+                details: `Must have either "command" (for stdio) or "url" (for HTTP)`,
+                suggestion: `Add "command": "npx ..." for local servers or "url": "https://..." for remote servers`,
+            }));
+        }
+        if (hasCommand && hasUrl) {
+            throw new Error(formatCliError({
+                code: ErrorCode.CLIENT_ERROR,
+                type: 'CONFIG_INVALID_SERVER',
+                message: `Server "${serverName}" has both "command" and "url"`,
+                details: 'A server must be either stdio (command) or HTTP (url), not both',
+                suggestion: `Remove one of "command" or "url"`,
+            }));
+        }
+    }
+    // Substitute environment variables
+    config = substituteEnvVarsInObject(config);
+    return config;
+}
+/**
+ * Get a specific server config by name
+ */
+export function getServerConfig(config, serverName) {
+    const server = config.mcpServers[serverName];
+    if (!server) {
+        const available = Object.keys(config.mcpServers);
+        throw new Error(formatCliError(serverNotFoundError(serverName, available)));
+    }
+    return server;
+}
+/**
+ * List all server names
+ */
+export function listServerNames(config) {
+    return Object.keys(config.mcpServers);
+}

package/dist/mcp/daemon-client.js

@@ -0,0 +1,266 @@
+/**
+ * MCP-CLI Daemon Client - IPC client for communicating with daemon workers
+ *
+ * Handles spawning daemons, detecting stale connections, and forwarding requests.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { createConnection } from 'node:net';
+import { dirname, extname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { debug, getConfigHash, getDaemonRequestTimeoutMs, getSocketDir, getSocketPath, } from './config.js';
+import { isProcessRunning, killProcess, readPidFile, removePidFile, removeSocketFile, } from './daemon.js';
+/**
+ * Generate a unique request ID
+ */
+function generateRequestId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+ * Send a request to the daemon and wait for response
+ */
+async function sendRequest(socketPath, request) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let responseText = '';
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutId);
+            fn();
+        };
+        const socket = createConnection(socketPath, () => {
+            socket.write(JSON.stringify(request));
+        });
+        socket.on('data', (data) => {
+            responseText += data.toString();
+            if (responseText.includes('\n')) {
+                settle(() => {
+                    try {
+                        resolve(JSON.parse(responseText.trim()));
+                    }
+                    catch {
+                        reject(new Error('Invalid response from daemon'));
+                    }
+                    finally {
+                        socket.end();
+                    }
+                });
+            }
+        });
+        socket.on('end', () => {
+            if (settled)
+                return;
+            settle(() => {
+                try {
+                    resolve(JSON.parse(responseText.trim()));
+                }
+                catch {
+                    reject(new Error('Invalid response from daemon'));
+                }
+            });
+        });
+        socket.on('error', (error) => {
+            settle(() => reject(error));
+        });
+        const timeoutId = setTimeout(() => {
+            socket.destroy();
+            settle(() => reject(new Error('Daemon request timeout')));
+        }, getDaemonRequestTimeoutMs());
+    });
+}
+/**
+ * Check if daemon is running and has matching config
+ */
+function isDaemonValid(serverName, config) {
+    const socketPath = getSocketPath(serverName);
+    const pidInfo = readPidFile(serverName);
+    // No PID file = no daemon
+    if (!pidInfo) {
+        debug(`[daemon-client] No PID file for ${serverName}`);
+        return false;
+    }
+    // Check if process is actually running
+    if (!isProcessRunning(pidInfo.pid)) {
+        debug(`[daemon-client] Process ${pidInfo.pid} not running, cleaning up`);
+        removePidFile(serverName);
+        removeSocketFile(serverName);
+        return false;
+    }
+    // Check if config matches
+    const currentHash = getConfigHash(config);
+    if (pidInfo.configHash !== currentHash) {
+        debug(`[daemon-client] Config hash mismatch for ${serverName}, killing old daemon`);
+        killProcess(pidInfo.pid);
+        removePidFile(serverName);
+        removeSocketFile(serverName);
+        return false;
+    }
+    // Check if socket exists
+    if (!existsSync(socketPath)) {
+        debug(`[daemon-client] Socket missing for ${serverName}, cleaning up`);
+        killProcess(pidInfo.pid);
+        removePidFile(serverName);
+        return false;
+    }
+    return true;
+}
+/**
+ * Spawn a new daemon process for a server
+ */
+async function spawnDaemon(serverName, config) {
+    debug(`[daemon-client] Spawning daemon for ${serverName}`);
+    // Find the daemon script next to this module. This is .ts under tsx and .js after build.
+    const modulePath = fileURLToPath(import.meta.url);
+    const daemonScript = join(dirname(modulePath), `daemon${extname(modulePath)}`);
+    const configJson = JSON.stringify(config);
+    // Spawn detached process
+    const proc = spawn(process.execPath, [
+        ...process.execArgv,
+        daemonScript,
+        '--daemon',
+        serverName,
+        configJson,
+    ], {
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env },
+    });
+    // Wait for daemon to signal readiness or fail
+    return new Promise((resolve) => {
+        let resolved = false;
+        proc.stdout?.on('data', (data) => {
+            const text = data.toString();
+            if (text.includes('DAEMON_READY') && !resolved) {
+                resolved = true;
+                // Don't await the process, let it run in the background.
+                proc.stdout?.unref?.();
+                proc.stderr?.unref?.();
+                proc.unref();
+                resolve(true);
+            }
+        });
+        // Timeout after 5 seconds (fast fallback to direct connection)
+        setTimeout(() => {
+            if (!resolved) {
+                resolved = true;
+                debug(`[daemon-client] Daemon spawn timeout for ${serverName}`);
+                resolve(false);
+            }
+        }, 5000);
+        // Check for early exit
+        proc.on('exit', (code) => {
+            if (!resolved && code !== 0) {
+                resolved = true;
+                debug(`[daemon-client] Daemon exited with code ${code}`);
+                resolve(false);
+            }
+        });
+    });
+}
+/**
+ * Get or create a daemon connection for a server
+ * Returns null if daemon mode fails (caller should fallback to direct connection)
+ */
+export async function getDaemonConnection(serverName, config) {
+    const socketPath = getSocketPath(serverName);
+    // Check if valid daemon exists
+    if (!isDaemonValid(serverName, config)) {
+        // Spawn new daemon
+        const spawned = await spawnDaemon(serverName, config);
+        if (!spawned) {
+            debug(`[daemon-client] Failed to spawn daemon for ${serverName}`);
+            return null;
+        }
+        // Wait a bit for socket to be ready
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    // Verify socket exists
+    if (!existsSync(socketPath)) {
+        debug(`[daemon-client] Socket not found after spawn for ${serverName}`);
+        return null;
+    }
+    // Test connection with ping
+    try {
+        const pingResponse = await sendRequest(socketPath, {
+            id: generateRequestId(),
+            type: 'ping',
+        });
+        if (!pingResponse.success) {
+            debug(`[daemon-client] Ping failed for ${serverName}`);
+            return null;
+        }
+    }
+    catch (error) {
+        debug(`[daemon-client] Connection test failed for ${serverName}: ${error.message}`);
+        return null;
+    }
+    debug(`[daemon-client] Connected to daemon for ${serverName}`);
+    // Return connection interface
+    return {
+        serverName,
+        async listTools() {
+            const response = await sendRequest(socketPath, {
+                id: generateRequestId(),
+                type: 'listTools',
+            });
+            if (!response.success) {
+                throw new Error(response.error?.message ?? 'listTools failed');
+            }
+            return response.data;
+        },
+        async callTool(toolName, args) {
+            const response = await sendRequest(socketPath, {
+                id: generateRequestId(),
+                type: 'callTool',
+                toolName,
+                args,
+            });
+            if (!response.success) {
+                throw new Error(response.error?.message ?? 'callTool failed');
+            }
+            return response.data;
+        },
+        async getInstructions() {
+            const response = await sendRequest(socketPath, {
+                id: generateRequestId(),
+                type: 'getInstructions',
+            });
+            if (!response.success) {
+                throw new Error(response.error?.message ?? 'getInstructions failed');
+            }
+            return response.data;
+        },
+        async close() {
+            // Just disconnect, don't tell daemon to close (let it idle timeout)
+            debug(`[daemon-client] Disconnecting from ${serverName} daemon`);
+        },
+    };
+}
+/**
+ * Clean up any orphaned daemon processes and sockets
+ * Call this on CLI startup
+ */
+export async function cleanupOrphanedDaemons() {
+    const socketDir = getSocketDir();
+    if (!existsSync(socketDir)) {
+        return;
+    }
+    try {
+        const files = (await readdir(socketDir)).filter((file) => file.endsWith('.pid'));
+        for (const file of files) {
+            const serverName = file.replace('.pid', '');
+            const pidInfo = readPidFile(serverName);
+            if (pidInfo && !isProcessRunning(pidInfo.pid)) {
+                debug(`[daemon-client] Cleaning up orphaned daemon: ${serverName}`);
+                removePidFile(serverName);
+                removeSocketFile(serverName);
+            }
+        }
+    }
+    catch {
+        // Ignore errors during cleanup scan
+    }
+}