@pasko70/pibo 1.0.0

package/dist/mcp/client.js

@@ -0,0 +1,332 @@
+/**
+ * MCP Client - Connection management for MCP servers
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { debug, filterTools, getConcurrencyLimit, getMaxRetries, getRetryDelayMs, getTimeoutMs, isDaemonEnabled, isHttpServer, isToolAllowed, } from './config.js';
+import { cleanupOrphanedDaemons, getDaemonConnection, } from './daemon-client.js';
+import { VERSION } from './version.js';
+// Re-export config utilities for convenience
+export { debug, getTimeoutMs, getConcurrencyLimit };
+/**
+ * Get retry config respecting MCP_TIMEOUT budget
+ */
+function getRetryConfig() {
+    const totalBudgetMs = getTimeoutMs();
+    const maxRetries = getMaxRetries();
+    const baseDelayMs = getRetryDelayMs();
+    // Reserve at least 5s for the final attempt
+    const retryBudgetMs = Math.max(0, totalBudgetMs - 5000);
+    return {
+        maxRetries,
+        baseDelayMs,
+        maxDelayMs: Math.min(10000, retryBudgetMs / 2),
+        totalBudgetMs,
+    };
+}
+/**
+ * Check if an error is transient and worth retrying
+ * Uses error codes when available, falls back to message matching
+ */
+export function isTransientError(error) {
+    // Check error code first (more reliable than message matching)
+    const nodeError = error;
+    if (nodeError.code) {
+        const transientCodes = [
+            'ECONNREFUSED',
+            'ECONNRESET',
+            'ETIMEDOUT',
+            'ENOTFOUND',
+            'EPIPE',
+            'ENETUNREACH',
+            'EHOSTUNREACH',
+            'EAI_AGAIN',
+        ];
+        if (transientCodes.includes(nodeError.code)) {
+            return true;
+        }
+    }
+    // Fallback to message matching for errors without codes
+    const message = error.message;
+    // HTTP transient errors - require status code at start or with HTTP context
+    // Pattern: "502", "502 Bad Gateway", "HTTP 502", "status 502", "status code 502"
+    if (/^(502|503|504|429)\b/.test(message))
+        return true;
+    if (/\b(http|status(\s+code)?)\s*(502|503|504|429)\b/i.test(message))
+        return true;
+    if (/\b(502|503|504|429)\s+(bad gateway|service unavailable|gateway timeout|too many requests)/i.test(message))
+        return true;
+    // Generic network terms - more specific patterns
+    if (/network\s*(error|fail|unavailable|timeout)/i.test(message))
+        return true;
+    if (/connection\s*(reset|refused|timeout)/i.test(message))
+        return true;
+    if (/\btimeout\b/i.test(message))
+        return true;
+    return false;
+}
+/**
+ * Calculate delay with exponential backoff and jitter
+ */
+function calculateDelay(attempt, config) {
+    const exponentialDelay = config.baseDelayMs * 2 ** attempt;
+    const cappedDelay = Math.min(exponentialDelay, config.maxDelayMs);
+    // Add jitter (±25%)
+    const jitter = cappedDelay * 0.25 * (Math.random() * 2 - 1);
+    return Math.round(cappedDelay + jitter);
+}
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Execute a function with retry logic for transient failures
+ * Respects overall timeout budget from MCP_TIMEOUT
+ */
+async function withRetry(fn, operationName, config = getRetryConfig()) {
+    let lastError;
+    const startTime = Date.now();
+    for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+        // Check if we've exceeded the total timeout budget
+        const elapsed = Date.now() - startTime;
+        if (elapsed >= config.totalBudgetMs) {
+            debug(`${operationName}: timeout budget exhausted after ${elapsed}ms`);
+            break;
+        }
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            const remainingBudget = config.totalBudgetMs - (Date.now() - startTime);
+            const shouldRetry = attempt < config.maxRetries &&
+                isTransientError(lastError) &&
+                remainingBudget > 1000; // At least 1s remaining
+            if (shouldRetry) {
+                const delay = Math.min(calculateDelay(attempt, config), remainingBudget - 1000);
+                debug(`${operationName} failed (attempt ${attempt + 1}/${config.maxRetries + 1}): ${lastError.message}. Retrying in ${delay}ms...`);
+                await sleep(delay);
+            }
+            else {
+                throw lastError;
+            }
+        }
+    }
+    throw lastError;
+}
+/**
+ * Safely close a connection, logging but not throwing on error
+ */
+export async function safeClose(close) {
+    try {
+        await close();
+    }
+    catch (err) {
+        debug(`Failed to close connection: ${err.message}`);
+    }
+}
+/**
+ * Connect to an MCP server with retry logic
+ * Captures stderr from stdio servers to include in error messages
+ */
+export async function connectToServer(serverName, config) {
+    // Collect stderr for better error messages
+    const stderrChunks = [];
+    return withRetry(async () => {
+        const client = new Client({
+            name: 'mcp-cli',
+            version: VERSION,
+        }, {
+            capabilities: {},
+        });
+        let transport;
+        if (isHttpServer(config)) {
+            transport = createHttpTransport(config);
+        }
+        else {
+            transport = createStdioTransport(config);
+            // Capture stderr for debugging - attach BEFORE connect
+            // Always stream stderr immediately so auth prompts are visible
+            const stderrStream = transport.stderr;
+            if (stderrStream) {
+                stderrStream.on('data', (chunk) => {
+                    const text = chunk.toString();
+                    stderrChunks.push(text);
+                    // Always stream stderr immediately so users can see auth prompts
+                    process.stderr.write(`[${serverName}] ${text}`);
+                });
+            }
+        }
+        try {
+            await client.connect(transport);
+        }
+        catch (error) {
+            // Enhance error with captured stderr
+            const stderrOutput = stderrChunks.join('').trim();
+            if (stderrOutput) {
+                const err = error;
+                err.message = `${err.message}\n\nServer stderr:\n${stderrOutput}`;
+            }
+            throw error;
+        }
+        // For successful connections, forward stderr to console
+        if (!isHttpServer(config)) {
+            const stderrStream = transport.stderr;
+            if (stderrStream) {
+                stderrStream.on('data', (chunk) => {
+                    process.stderr.write(chunk);
+                });
+            }
+        }
+        return {
+            client,
+            close: async () => {
+                await client.close();
+            },
+        };
+    }, `connect to ${serverName}`);
+}
+/**
+ * Create HTTP transport for remote servers
+ */
+function createHttpTransport(config) {
+    const url = new URL(config.url);
+    return new StreamableHTTPClientTransport(url, {
+        requestInit: {
+            headers: config.headers,
+        },
+    });
+}
+/**
+ * Create stdio transport for local servers
+ * Uses stderr: 'pipe' to capture server output for debugging
+ */
+function createStdioTransport(config) {
+    // Merge process.env with config.env, filtering out undefined values
+    const mergedEnv = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value !== undefined) {
+            mergedEnv[key] = value;
+        }
+    }
+    if (config.env) {
+        Object.assign(mergedEnv, config.env);
+    }
+    return new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: mergedEnv,
+        cwd: config.cwd,
+        stderr: 'pipe', // Capture stderr for better error messages
+    });
+}
+/**
+ * List all tools from a connected client with retry logic
+ */
+export async function listTools(client) {
+    return withRetry(async () => {
+        const result = await client.listTools();
+        return result.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        }));
+    }, 'list tools');
+}
+/**
+ * Get a specific tool by name
+ */
+export async function getTool(client, toolName) {
+    const tools = await listTools(client);
+    return tools.find((t) => t.name === toolName);
+}
+/**
+ * Call a tool with arguments and retry logic
+ */
+export async function callTool(client, toolName, args) {
+    return withRetry(async () => {
+        const result = await client.callTool({
+            name: toolName,
+            arguments: args,
+        }, undefined, { timeout: getTimeoutMs() });
+        return result;
+    }, `call tool ${toolName}`);
+}
+// ============================================================================
+// Unified Connection Interface (Daemon + Direct)
+// ============================================================================
+/**
+ * Get a unified connection to an MCP server
+ *
+ * If daemon mode is enabled (default), tries to use a cached daemon connection.
+ * Falls back to direct connection if daemon fails or is disabled.
+ *
+ * @param serverName - Name of the server from config
+ * @param config - Server configuration
+ * @returns McpConnection with listTools, callTool, and close methods
+ */
+export async function getConnection(serverName, config) {
+    // Clean up any orphaned daemons on first call
+    await cleanupOrphanedDaemons();
+    // Try daemon connection if enabled
+    if (isDaemonEnabled()) {
+        try {
+            const daemonConn = await getDaemonConnection(serverName, config);
+            if (daemonConn) {
+                debug(`Using daemon connection for ${serverName}`);
+                return {
+                    async listTools() {
+                        const data = await daemonConn.listTools();
+                        const tools = data;
+                        // Apply tool filtering from config
+                        return filterTools(tools, config);
+                    },
+                    async callTool(toolName, args) {
+                        // Check if tool is allowed before calling
+                        if (!isToolAllowed(toolName, config)) {
+                            throw new Error(`Tool "${toolName}" is disabled by configuration`);
+                        }
+                        return daemonConn.callTool(toolName, args);
+                    },
+                    async getInstructions() {
+                        return daemonConn.getInstructions();
+                    },
+                    async close() {
+                        await daemonConn.close();
+                    },
+                    isDaemon: true,
+                };
+            }
+        }
+        catch (err) {
+            debug(`Daemon connection failed for ${serverName}: ${err.message}, falling back to direct`);
+        }
+    }
+    // Fall back to direct connection
+    debug(`Using direct connection for ${serverName}`);
+    const { client, close } = await connectToServer(serverName, config);
+    return {
+        async listTools() {
+            const tools = await listTools(client);
+            // Apply tool filtering from config
+            return filterTools(tools, config);
+        },
+        async callTool(toolName, args) {
+            // Check if tool is allowed before calling
+            if (!isToolAllowed(toolName, config)) {
+                throw new Error(`Tool "${toolName}" is disabled by configuration`);
+            }
+            return callTool(client, toolName, args);
+        },
+        async getInstructions() {
+            return client.getInstructions();
+        },
+        async close() {
+            await close();
+        },
+        isDaemon: false,
+    };
+}

package/dist/mcp/commands/call.js

@@ -0,0 +1,146 @@
+/**
+ * Call command - Execute a tool with arguments
+ *
+ * Output behavior:
+ * - Default: Raw text content to stdout (CLI-friendly)
+ * - With --json: Full JSON response to stdout
+ * - Errors always go to stderr
+ */
+import { getConnection, getTimeoutMs, safeClose, } from '../client.js';
+import { getServerConfig, loadConfig, } from '../config.js';
+import { ErrorCode, formatCliError, invalidJsonArgsError, invalidTargetError, serverConnectionError, toolExecutionError, toolNotFoundError, } from '../errors.js';
+import { formatToolResult } from '../output.js';
+/**
+ * Parse target into server and tool name
+ */
+function parseTarget(target) {
+    const slashIndex = target.indexOf('/');
+    if (slashIndex === -1) {
+        throw new Error(formatCliError(invalidTargetError(target)));
+    }
+    return {
+        server: target.substring(0, slashIndex),
+        tool: target.substring(slashIndex + 1),
+    };
+}
+/**
+ * Parse JSON arguments from string or stdin
+ */
+async function parseArgs(argsString) {
+    let jsonString;
+    if (argsString) {
+        jsonString = argsString;
+    }
+    else if (!process.stdin.isTTY) {
+        // Read from stdin with timeout - use timer cleanup to prevent memory leak
+        const timeoutMs = getTimeoutMs();
+        const chunks = [];
+        let timeoutId;
+        const readPromise = (async () => {
+            for await (const chunk of process.stdin) {
+                chunks.push(chunk);
+            }
+            return Buffer.concat(chunks).toString('utf-8').trim();
+        })();
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => reject(new Error(`stdin read timed out after ${timeoutMs}ms`)), timeoutMs);
+        });
+        try {
+            jsonString = await Promise.race([readPromise, timeoutPromise]);
+        }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+        }
+    }
+    else {
+        // No arguments provided
+        return {};
+    }
+    if (!jsonString) {
+        return {};
+    }
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (e) {
+        throw new Error(formatCliError(invalidJsonArgsError(jsonString, e.message)));
+    }
+}
+/**
+ * Execute the call command
+ */
+export async function callCommand(options) {
+    let config;
+    try {
+        config = await loadConfig(options.configPath);
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(ErrorCode.CLIENT_ERROR);
+    }
+    let serverName;
+    let toolName;
+    try {
+        const parsed = parseTarget(options.target);
+        serverName = parsed.server;
+        toolName = parsed.tool;
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(ErrorCode.CLIENT_ERROR);
+    }
+    let serverConfig;
+    try {
+        serverConfig = getServerConfig(config, serverName);
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(ErrorCode.CLIENT_ERROR);
+    }
+    let args;
+    try {
+        args = await parseArgs(options.args);
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(ErrorCode.CLIENT_ERROR);
+    }
+    let connection;
+    try {
+        connection = await getConnection(serverName, serverConfig);
+    }
+    catch (error) {
+        console.error(formatCliError(serverConnectionError(serverName, error.message)));
+        process.exit(ErrorCode.NETWORK_ERROR);
+    }
+    try {
+        const result = await connection.callTool(toolName, args);
+        // Extract text content from MCP response for CLI-friendly output
+        // Uses formatToolResult which extracts text from MCP content array
+        console.log(formatToolResult(result));
+    }
+    catch (error) {
+        // Try to get available tools for better error message
+        let availableTools;
+        try {
+            const tools = await connection.listTools();
+            availableTools = tools.map((t) => t.name);
+        }
+        catch {
+            // Ignore - we'll show error without tool list
+        }
+        const errMsg = error.message;
+        // Check if it's a "tool not found" type error
+        if (errMsg.includes('not found') || errMsg.includes('unknown tool')) {
+            console.error(formatCliError(toolNotFoundError(toolName, serverName, availableTools)));
+        }
+        else {
+            console.error(formatCliError(toolExecutionError(toolName, serverName, errMsg)));
+        }
+        process.exit(ErrorCode.SERVER_ERROR);
+    }
+    finally {
+        await safeClose(connection.close);
+    }
+}

package/dist/mcp/commands/grep.js

@@ -0,0 +1,145 @@
+/**
+ * Grep command - Search tools by pattern
+ */
+import { debug, getConcurrencyLimit, getConnection, safeClose, } from '../client.js';
+import { getServerConfig, listServerNames, loadConfig, } from '../config.js';
+import { ErrorCode } from '../errors.js';
+import { formatSearchResults } from '../output.js';
+/**
+ * Convert glob pattern to regex
+ * Handles: * (any chars), ? (single char), ** (globstar)
+ *
+ * Examples:
+ * - "*file*" matches "read_file", "file_utils"
+ * - "**test**" matches "test", "my_test_tool", "testing"
+ * - "server/*" matches "server/tool" but not "server/sub/tool"
+ * - "server/**" matches "server/tool" and "server/sub/tool"
+ */
+export function globToRegex(pattern) {
+    let escaped = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const char = pattern[i];
+        if (char === '*' && pattern[i + 1] === '*') {
+            // ** (globstar) - match anything including slashes (zero or more chars)
+            escaped += '.*';
+            i += 2;
+            // Skip any immediately following * (e.g., *** becomes .*)
+            while (pattern[i] === '*') {
+                i++;
+            }
+        }
+        else if (char === '*') {
+            // * - match any chars except slash (zero or more)
+            escaped += '[^/]*';
+            i += 1;
+        }
+        else if (char === '?') {
+            // ? - match single char (not slash)
+            escaped += '[^/]';
+            i += 1;
+        }
+        else if ('[.+^${}()|\\]'.includes(char)) {
+            // Escape special regex chars
+            escaped += `\\${char}`;
+            i += 1;
+        }
+        else {
+            escaped += char;
+            i += 1;
+        }
+    }
+    return new RegExp(`^${escaped}$`, 'i');
+}
+/**
+ * Process items with limited concurrency, preserving order
+ */
+async function processWithConcurrency(items, processor, maxConcurrency) {
+    const results = new Array(items.length);
+    let currentIndex = 0;
+    async function worker() {
+        while (currentIndex < items.length) {
+            const index = currentIndex++;
+            results[index] = await processor(items[index], index);
+        }
+    }
+    // Start workers up to concurrency limit
+    const workers = Array.from({ length: Math.min(maxConcurrency, items.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}
+/**
+ * Search tools in a single server (uses daemon if enabled)
+ */
+async function searchServerTools(serverName, config, pattern) {
+    let connection = null;
+    try {
+        const serverConfig = getServerConfig(config, serverName);
+        connection = await getConnection(serverName, serverConfig);
+        const tools = await connection.listTools();
+        const results = [];
+        for (const tool of tools) {
+            // Match against tool name only (not server name or description)
+            if (pattern.test(tool.name)) {
+                results.push({ server: serverName, tool });
+            }
+        }
+        debug(`${serverName}: found ${results.length} matches`);
+        return { serverName, results };
+    }
+    catch (error) {
+        const errorMsg = error.message;
+        debug(`${serverName}: connection failed - ${errorMsg}`);
+        return { serverName, results: [], error: errorMsg };
+    }
+    finally {
+        if (connection) {
+            await safeClose(connection.close);
+        }
+    }
+}
+/**
+ * Execute the grep command
+ */
+export async function grepCommand(options) {
+    let config;
+    try {
+        config = await loadConfig(options.configPath);
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(ErrorCode.CLIENT_ERROR);
+    }
+    const pattern = globToRegex(options.pattern);
+    const serverNames = listServerNames(config);
+    if (serverNames.length === 0) {
+        console.log('No MCP servers configured.');
+        console.log('Next: pibo mcp config help');
+        return;
+    }
+    const concurrencyLimit = getConcurrencyLimit();
+    debug(`Searching ${serverNames.length} servers for pattern "${options.pattern}" (concurrency: ${concurrencyLimit})`);
+    // Process servers in parallel with concurrency limit
+    const serverResults = await processWithConcurrency(serverNames, (serverName) => searchServerTools(serverName, config, pattern), concurrencyLimit);
+    const allResults = [];
+    const failedServers = [];
+    for (const result of serverResults) {
+        allResults.push(...result.results);
+        if (result.error) {
+            failedServers.push(result.serverName);
+        }
+    }
+    // Show failed servers warning
+    if (failedServers.length > 0) {
+        console.error(`Warning: ${failedServers.length} server(s) failed to connect: ${failedServers.join(', ')}`);
+    }
+    if (allResults.length === 0) {
+        console.log(`No tools found matching "${options.pattern}"`);
+        console.log('  Tip: Pattern matches tool names only (not server names)');
+        console.log(`  Tip: Use '*' for wildcards, e.g. '*file*' or 'read_*'`);
+        console.log(`  Tip: Run 'pibo mcp' to list all available tools`);
+        return;
+    }
+    // Human-readable output
+    console.log(formatSearchResults(allResults, options.withDescriptions));
+}

package/dist/mcp/commands/info.js

@@ -0,0 +1,71 @@
+/**
+ * Info command - Show server or tool details
+ */
+import { getConnection, safeClose } from '../client.js';
+import { getServerConfig, loadConfig, } from '../config.js';
+import { ErrorCode, formatCliError, serverConnectionError, toolNotFoundError, } from '../errors.js';
+import { formatServerDetails, formatToolSchema } from '../output.js';
+/**
+ * Parse target into server and optional tool name
+ */
+function parseTarget(target) {
+    const parts = target.split('/');
+    if (parts.length === 1) {
+        return { server: parts[0] };
+    }
+    return { server: parts[0], tool: parts.slice(1).join('/') };
+}
+/**
+ * Execute the info command
+ */
+export async function infoCommand(options) {
+    let config;
+    try {
+        config = await loadConfig(options.configPath);
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(ErrorCode.CLIENT_ERROR);
+    }
+    const { server: serverName, tool: toolName } = parseTarget(options.target);
+    let serverConfig;
+    try {
+        serverConfig = getServerConfig(config, serverName);
+    }
+    catch (error) {
+        console.error(error.message);
+        process.exit(ErrorCode.CLIENT_ERROR);
+    }
+    let connection;
+    try {
+        connection = await getConnection(serverName, serverConfig);
+    }
+    catch (error) {
+        console.error(formatCliError(serverConnectionError(serverName, error.message)));
+        process.exit(ErrorCode.NETWORK_ERROR);
+    }
+    try {
+        if (toolName) {
+            // Show specific tool schema
+            const tools = await connection.listTools();
+            const tool = tools.find((t) => t.name === toolName);
+            if (!tool) {
+                const availableTools = tools.map((t) => t.name);
+                console.error(formatCliError(toolNotFoundError(toolName, serverName, availableTools)));
+                process.exit(ErrorCode.CLIENT_ERROR);
+            }
+            // Human-readable output
+            console.log(formatToolSchema(serverName, tool));
+        }
+        else {
+            // Show server details
+            const tools = await connection.listTools();
+            const instructions = await connection.getInstructions();
+            // Human-readable output
+            console.log(formatServerDetails(serverName, serverConfig, tools, options.withDescriptions, instructions));
+        }
+    }
+    finally {
+        await safeClose(connection.close);
+    }
+}