@pasko70/pibo 1.9.8 → 1.9.9

package/dist/mcp/daemon-client.js

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

package/dist/mcp/daemon.js

@@ -1,327 +0,0 @@
-/**
- * MCP-CLI Daemon - Background worker that maintains persistent MCP connections
- *
- * This is spawned as a detached process and manages a Unix socket for IPC.
- * It maintains the MCP server connection and forwards requests from CLI invocations.
- */
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'node:fs';
-import { createServer } from 'node:net';
-import { dirname } from 'node:path';
-import { callTool, connectToServer, listTools, } from './client.js';
-import { debug, getConfigHash, getDaemonTimeoutMs, getPidPath, getSocketDir, getSocketPath, } from './config.js';
-// ============================================================================
-// PID File Management
-// ============================================================================
-/**
- * Write PID file with config hash for stale detection
- */
-export function writePidFile(serverName, configHash) {
-    const pidPath = getPidPath(serverName);
-    const dir = dirname(pidPath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true, mode: 0o700 });
-    }
-    const content = {
-        pid: process.pid,
-        configHash,
-        startedAt: new Date().toISOString(),
-    };
-    writeFileSync(pidPath, JSON.stringify(content), { mode: 0o600 });
-}
-/**
- * Read PID file content
- */
-export function readPidFile(serverName) {
-    const pidPath = getPidPath(serverName);
-    if (!existsSync(pidPath)) {
-        return null;
-    }
-    try {
-        const content = readFileSync(pidPath, 'utf-8');
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Remove PID file
- */
-export function removePidFile(serverName) {
-    const pidPath = getPidPath(serverName);
-    try {
-        if (existsSync(pidPath)) {
-            unlinkSync(pidPath);
-        }
-    }
-    catch {
-        // Ignore errors during cleanup
-    }
-}
-/**
- * Remove socket file
- */
-export function removeSocketFile(serverName) {
-    const socketPath = getSocketPath(serverName);
-    try {
-        if (existsSync(socketPath)) {
-            unlinkSync(socketPath);
-        }
-    }
-    catch {
-        // Ignore errors during cleanup
-    }
-}
-/**
- * Check if a process is running
- */
-export function isProcessRunning(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Kill a process by PID
- */
-export function killProcess(pid) {
-    try {
-        process.kill(pid, 'SIGTERM');
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// ============================================================================
-// Daemon Worker
-// ============================================================================
-/**
- * Main daemon entry point - run as detached background process
- */
-export async function runDaemon(serverName, config) {
-    const socketPath = getSocketPath(serverName);
-    const configHash = getConfigHash(config);
-    const timeoutMs = getDaemonTimeoutMs();
-    let idleTimer = null;
-    let mcpClient = null;
-    let server = null;
-    const activeConnections = new Set();
-    // Cleanup function
-    const cleanup = async () => {
-        debug(`[daemon:${serverName}] Shutting down...`);
-        if (idleTimer) {
-            clearTimeout(idleTimer);
-            idleTimer = null;
-        }
-        // Close all active socket connections
-        for (const conn of activeConnections) {
-            try {
-                conn.end();
-            }
-            catch {
-                // Ignore
-            }
-        }
-        activeConnections.clear();
-        // Close MCP connection
-        if (mcpClient) {
-            try {
-                await mcpClient.close();
-            }
-            catch {
-                // Ignore
-            }
-            mcpClient = null;
-        }
-        // Close socket server
-        if (server) {
-            try {
-                server.close();
-            }
-            catch {
-                // Ignore
-            }
-            server = null;
-        }
-        // Clean up files
-        removeSocketFile(serverName);
-        removePidFile(serverName);
-        debug(`[daemon:${serverName}] Cleanup complete`);
-    };
-    // Reset idle timer
-    const resetIdleTimer = () => {
-        if (idleTimer) {
-            clearTimeout(idleTimer);
-        }
-        idleTimer = setTimeout(async () => {
-            debug(`[daemon:${serverName}] Idle timeout reached, shutting down`);
-            await cleanup();
-            process.exit(0);
-        }, timeoutMs);
-    };
-    // Handle signals
-    process.on('SIGTERM', async () => {
-        await cleanup();
-        process.exit(0);
-    });
-    process.on('SIGINT', async () => {
-        await cleanup();
-        process.exit(0);
-    });
-    // Ensure socket dir exists
-    const socketDir = getSocketDir();
-    if (!existsSync(socketDir)) {
-        mkdirSync(socketDir, { recursive: true, mode: 0o700 });
-    }
-    // Remove stale socket if exists
-    removeSocketFile(serverName);
-    // Write PID file
-    writePidFile(serverName, configHash);
-    // Connect to MCP server
-    try {
-        debug(`[daemon:${serverName}] Connecting to MCP server...`);
-        mcpClient = await connectToServer(serverName, config);
-        debug(`[daemon:${serverName}] Connected to MCP server`);
-    }
-    catch (error) {
-        console.error(`[daemon:${serverName}] Failed to connect:`, error.message);
-        await cleanup();
-        process.exit(1);
-    }
-    // Handle incoming request
-    const handleRequest = async (data) => {
-        resetIdleTimer();
-        let request;
-        try {
-            request = JSON.parse(data.toString());
-        }
-        catch {
-            return {
-                id: 'unknown',
-                success: false,
-                error: { code: 'INVALID_REQUEST', message: 'Invalid JSON' },
-            };
-        }
-        debug(`[daemon:${serverName}] Request: ${request.type} (${request.id})`);
-        if (!mcpClient) {
-            return {
-                id: request.id,
-                success: false,
-                error: { code: 'NOT_CONNECTED', message: 'MCP client not connected' },
-            };
-        }
-        try {
-            switch (request.type) {
-                case 'ping':
-                    return { id: request.id, success: true, data: 'pong' };
-                case 'listTools': {
-                    const tools = await listTools(mcpClient.client);
-                    return { id: request.id, success: true, data: tools };
-                }
-                case 'callTool': {
-                    if (!request.toolName) {
-                        return {
-                            id: request.id,
-                            success: false,
-                            error: { code: 'MISSING_TOOL', message: 'toolName required' },
-                        };
-                    }
-                    const result = await callTool(mcpClient.client, request.toolName, request.args ?? {});
-                    return { id: request.id, success: true, data: result };
-                }
-                case 'getInstructions': {
-                    const instructions = mcpClient.client.getInstructions();
-                    return { id: request.id, success: true, data: instructions };
-                }
-                case 'close':
-                    // Graceful shutdown requested
-                    setTimeout(async () => {
-                        await cleanup();
-                        process.exit(0);
-                    }, 100);
-                    return { id: request.id, success: true, data: 'closing' };
-                default:
-                    return {
-                        id: request.id,
-                        success: false,
-                        error: {
-                            code: 'UNKNOWN_TYPE',
-                            message: `Unknown request type: ${request.type}`,
-                        },
-                    };
-            }
-        }
-        catch (error) {
-            const err = error;
-            return {
-                id: request.id,
-                success: false,
-                error: { code: 'EXECUTION_ERROR', message: err.message },
-            };
-        }
-    };
-    // Start Unix socket server
-    try {
-        server = createServer((socket) => {
-            activeConnections.add(socket);
-            debug(`[daemon:${serverName}] Client connected`);
-            socket.on('data', async (data) => {
-                const response = await handleRequest(Buffer.isBuffer(data) ? data : Buffer.from(data));
-                socket.write(`${JSON.stringify(response)}\n`);
-            });
-            socket.on('close', () => {
-                activeConnections.delete(socket);
-                debug(`[daemon:${serverName}] Client disconnected`);
-            });
-            socket.on('error', (error) => {
-                debug(`[daemon:${serverName}] Socket error: ${error.message}`);
-                activeConnections.delete(socket);
-            });
-        });
-        await new Promise((resolve, reject) => {
-            server?.once('error', reject);
-            server?.listen(socketPath, () => {
-                server?.off('error', reject);
-                resolve();
-            });
-        });
-        debug(`[daemon:${serverName}] Listening on ${socketPath}`);
-        // Start idle timer
-        resetIdleTimer();
-        // Signal readiness by writing to stdout (parent will read this)
-        console.log('DAEMON_READY');
-    }
-    catch (error) {
-        console.error(`[daemon:${serverName}] Failed to start socket server:`, error.message);
-        await cleanup();
-        process.exit(1);
-    }
-}
-// ============================================================================
-// Entry point when run directly
-// ============================================================================
-// Check if running as daemon process
-if (process.argv[2] === '--daemon') {
-    const serverName = process.argv[3];
-    const configJson = process.argv[4];
-    if (!serverName || !configJson) {
-        console.error('Usage: daemon.ts --daemon <serverName> <configJson>');
-        process.exit(1);
-    }
-    let config;
-    try {
-        config = JSON.parse(configJson);
-    }
-    catch {
-        console.error('Invalid config JSON');
-        process.exit(1);
-    }
-    runDaemon(serverName, config).catch((error) => {
-        console.error('Daemon failed:', error);
-        process.exit(1);
-    });
-}