@pasko70/pibo 1.9.8 → 1.9.9

package/dist/mcp/agent-context.js

@@ -1,127 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import { ensureConfigExists, isHttpServer, loadConfig, } from './config.js';
-import { ErrorCode, formatCliError } from './errors.js';
-export const MCP_SERVER_DESCRIPTION_MAX_LENGTH = 480;
-export const ENABLED_MCP_SERVERS_CONTEXT_PATH = '.pibo/context/enabled-mcp-servers.md';
-export function normalizeMcpServerDescription(value) {
-    const description = value.replace(/\s+/g, ' ').trim();
-    if (!description) {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'MCP_DESCRIPTION_REQUIRED',
-            message: 'MCP server description is required',
-        }));
-    }
-    if (description.length > MCP_SERVER_DESCRIPTION_MAX_LENGTH) {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'MCP_DESCRIPTION_TOO_LONG',
-            message: `MCP server description must be ${MCP_SERVER_DESCRIPTION_MAX_LENGTH} characters or fewer`,
-        }));
-    }
-    return description;
-}
-export async function listMcpServerInfos(configPath) {
-    try {
-        const config = await loadConfig(configPath);
-        return Object.entries(config.mcpServers).map(([name, server]) => mcpServerInfoFromConfig(name, server));
-    }
-    catch (error) {
-        if (error.message.includes('CONFIG_NOT_FOUND'))
-            return [];
-        throw error;
-    }
-}
-export async function setMcpServerDescription(serverName, descriptionInput, configPath) {
-    const description = normalizeMcpServerDescription(descriptionInput);
-    const path = await ensureConfigExists(configPath);
-    const config = await readMcpConfig(path);
-    const server = config.mcpServers[serverName];
-    if (!server) {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'SERVER_NOT_FOUND',
-            message: `Server "${serverName}" not found in config`,
-            details: `Available servers: ${Object.keys(config.mcpServers).join(', ') || '(none)'}`,
-        }));
-    }
-    server.pibo = {
-        ...(server.pibo ?? {}),
-        description,
-        descriptionSource: 'user',
-    };
-    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`);
-    return mcpServerInfoFromConfig(serverName, server);
-}
-export async function getMcpAgentContextFile(selectedServerNames, configPath) {
-    if (selectedServerNames.length === 0)
-        return undefined;
-    const infos = await listMcpServerInfos(configPath);
-    const infosByName = new Map(infos.map((info) => [info.name, info]));
-    const selected = selectedServerNames
-        .map((name) => infosByName.get(name))
-        .filter((info) => Boolean(info?.description));
-    if (selected.length === 0)
-        return undefined;
-    const sections = selected.flatMap((server) => [
-        `## ${server.name}`,
-        server.description ?? '',
-        '',
-        `Discover: \`npm run dev -- mcp info ${server.name}\``,
-        `Call: \`npm run dev -- mcp call ${server.name} <tool> '<json>'\``,
-        '',
-    ]);
-    return {
-        path: ENABLED_MCP_SERVERS_CONTEXT_PATH,
-        content: [
-            '# Enabled MCP Servers',
-            '',
-            'These MCP servers are enabled for this agent. Use the MCP CLI for discovery and calls.',
-            '',
-            ...sections,
-        ].join('\n').trimEnd(),
-    };
-}
-async function readMcpConfig(path) {
-    const content = await readFile(path, 'utf-8');
-    const parsed = JSON.parse(content);
-    if (!parsed ||
-        typeof parsed !== 'object' ||
-        !('mcpServers' in parsed) ||
-        typeof parsed.mcpServers !== 'object' ||
-        parsed.mcpServers === null) {
-        throw new Error(formatCliError({
-            code: ErrorCode.CLIENT_ERROR,
-            type: 'CONFIG_MISSING_FIELD',
-            message: 'Config file missing required "mcpServers" object',
-            details: `File: ${path}`,
-        }));
-    }
-    return parsed;
-}
-function mcpServerInfoFromConfig(name, server) {
-    const metadata = normalizeMetadata(server.pibo);
-    const description = metadata.description;
-    return {
-        name,
-        transport: isHttpServer(server) ? 'http' : 'stdio',
-        ...(description ? { description } : {}),
-        ...(metadata.descriptionSource ? { descriptionSource: metadata.descriptionSource } : {}),
-        hasDescription: Boolean(description),
-        editable: metadata.descriptionSource !== 'registry',
-    };
-}
-function normalizeMetadata(metadata) {
-    if (!metadata || typeof metadata !== 'object')
-        return {};
-    const description = typeof metadata.description === 'string' && metadata.description.trim()
-        ? metadata.description.trim()
-        : undefined;
-    const descriptionSource = metadata.descriptionSource === 'registry' || metadata.descriptionSource === 'user'
-        ? metadata.descriptionSource
-        : undefined;
-    return {
-        ...(description ? { description } : {}),
-        ...(descriptionSource ? { descriptionSource } : {}),
-    };
-}

package/dist/mcp/client.js

@@ -1,332 +0,0 @@
-/**
- * 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

@@ -1,146 +0,0 @@
-/**
- * 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);
-    }
-}