mcp-compression-proxy 1.0.2 → 1.1.0

package/dist/cli/commands.d.ts

@@ -14,10 +14,28 @@ export declare function handleInfo(socketPath: string, serverTool: string): Prom
  * mcp-cli call <server>/<tool> '<json>' — execute a tool
  */
 export declare function handleCall(socketPath: string, serverTool: string, jsonPayload: string): Promise<void>;
+export declare function handlePayloadRead(socketPath: string, id: string, options?: {
+    offset?: number;
+    length?: number;
+    all?: boolean;
+}): Promise<void>;
+export declare function handlePayloadFind(socketPath: string, id: string, query: string): Promise<void>;
+export declare function handleScript(socketPath: string, jsonPayload: string): Promise<void>;
 /**
  * mcp-cli stats — get compression/server statistics
  */
 export declare function handleStats(socketPath: string): Promise<void>;
+/**
+ * Last `count` lines of a log file's contents.
+ *
+ * Kept as a pure function so it is testable without a real log on disk - the
+ * CLI entry point is excluded from coverage collection, this file is not.
+ */
+export declare function tailLines(content: string, count: number): string;
+/**
+ * mcp-cli doctor — validate config and report live backend health
+ */
+export declare function handleDoctor(socketPath: string): Promise<void>;
 /**
  * mcp-cli daemon status — show daemon status
  */

package/dist/cli/commands.js

@@ -1,4 +1,5 @@
 import { sendRequest, isDaemonRunning } from './ipc-client.js';
+import { loadJSONServers } from '../config/loader.js';
 /**
  * Format tool entries as aligned plain text:
  *   server/tool_name        Short description
@@ -7,9 +8,9 @@ function formatToolList(tools) {
     if (tools.length === 0)
         return 'No tools found.';
     // Calculate column width for alignment
-    const names = tools.map(t => `${t.server}/${t.tool}`);
-    const maxLen = Math.min(Math.max(...names.map(n => n.length)), 40);
-    const lines = tools.map(t => {
+    const names = tools.map((t) => `${t.server}/${t.tool}`);
+    const maxLen = Math.min(Math.max(...names.map((n) => n.length)), 40);
+    const lines = tools.map((t) => {
         const name = `${t.server}/${t.tool}`;
         const padded = name.padEnd(maxLen + 4);
         return `${padded}${t.description}`;
@@ -28,7 +29,7 @@ export async function handleTools(socketPath) {
     const result = response.result;
     console.log(formatToolList(result.tools));
     // Summary line
-    const serverCount = new Set(result.tools.map(t => t.server)).size;
+    const serverCount = new Set(result.tools.map((t) => t.server)).size;
     console.log(`\n(${result.count} tools across ${serverCount} servers)`);
 }
 /**
@@ -76,7 +77,7 @@ export async function handleInfo(socketPath, serverTool) {
 export async function handleCall(socketPath, serverTool, jsonPayload) {
     const slashIndex = serverTool.indexOf('/');
     if (slashIndex === -1) {
-        console.error('Usage: mcp-cli call <server>/<tool> \'<json_payload>\'');
+        console.error("Usage: mcp-cli call <server>/<tool> '<json_payload>'");
         process.exit(1);
     }
     const server = serverTool.slice(0, slashIndex);
@@ -107,6 +108,49 @@ export async function handleCall(socketPath, serverTool, jsonPayload) {
     }
     console.log(result.output);
 }
+export async function handlePayloadRead(socketPath, id, options = {}) {
+    const response = await sendRequest(socketPath, 'payload-read', {
+        id,
+        ...options,
+    });
+    if (response.error) {
+        console.error(`Error: ${response.error.message}`);
+        process.exit(1);
+    }
+    console.log(JSON.stringify(response.result, null, 2));
+}
+export async function handlePayloadFind(socketPath, id, query) {
+    const response = await sendRequest(socketPath, 'payload-find', {
+        id,
+        query,
+    });
+    if (response.error) {
+        console.error(`Error: ${response.error.message}`);
+        process.exit(1);
+    }
+    console.log(JSON.stringify(response.result, null, 2));
+}
+export async function handleScript(socketPath, jsonPayload) {
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonPayload);
+    }
+    catch {
+        console.error('Error: Invalid JSON script');
+        process.exit(1);
+    }
+    const steps = Array.isArray(parsed) ? parsed : parsed?.steps;
+    if (!Array.isArray(steps)) {
+        console.error('Error: Script must be an array of steps or an object with a steps array');
+        process.exit(1);
+    }
+    const response = await sendRequest(socketPath, 'script', { steps });
+    if (response.error) {
+        console.error(`Error: ${response.error.message}`);
+        process.exit(1);
+    }
+    console.log(JSON.stringify(response.result, null, 2));
+}
 /**
  * mcp-cli stats — get compression/server statistics
  */
@@ -118,6 +162,87 @@ export async function handleStats(socketPath) {
     }
     console.log(JSON.stringify(response.result, null, 2));
 }
+/**
+ * Last `count` lines of a log file's contents.
+ *
+ * Kept as a pure function so it is testable without a real log on disk - the
+ * CLI entry point is excluded from coverage collection, this file is not.
+ */
+export function tailLines(content, count) {
+    if (!content)
+        return '';
+    // A trailing newline is a terminator, not an empty final line; without this
+    // `-n 1` would return a blank.
+    const lines = content.replace(/\n$/, '').split('\n');
+    return lines.slice(Math.max(0, lines.length - count)).join('\n');
+}
+/**
+ * mcp-cli doctor — validate config and report live backend health
+ */
+export async function handleDoctor(socketPath) {
+    let healthy = true;
+    console.log('Configuration');
+    // Uncached on purpose: a doctor reports what is on disk right now.
+    // A schema error throws, and an unformatted stack trace here would bury the
+    // one thing the user came for.
+    let configuredServers = [];
+    try {
+        const config = loadJSONServers();
+        if (!config) {
+            console.log('  ! No servers.json found (user or project level)');
+            console.log('    The proxy will start with management tools only.');
+            healthy = false;
+        }
+        else {
+            configuredServers = config.servers.map((server) => server.name);
+            const disabled = config.servers.filter((server) => server.enabled === false).length;
+            console.log(`  ✓ Loaded ${config.servers.length} server(s)${disabled ? `, ${disabled} disabled` : ''}`);
+            if (config.excludePatterns.length > 0) {
+                console.log(`    excludeTools: ${config.excludePatterns.join(', ')}`);
+            }
+            if (config.noCompressPatterns.length > 0) {
+                console.log(`    noCompressTools: ${config.noCompressPatterns.join(', ')}`);
+            }
+        }
+    }
+    catch (error) {
+        console.log('  ✗ Invalid configuration');
+        for (const line of String(error instanceof Error ? error.message : error).split('\n')) {
+            console.log(`    ${line}`);
+        }
+        console.log('\nFix the configuration before checking backend health.');
+        process.exit(1);
+    }
+    console.log('\nBackends');
+    const response = await sendRequest(socketPath, 'daemon-status');
+    if (response.error) {
+        console.log(`  ✗ Daemon did not respond: ${response.error.message}`);
+        process.exit(1);
+    }
+    const status = response.result;
+    for (const server of status.servers) {
+        if (server.connected) {
+            console.log(`  ✓ ${server.name}`);
+        }
+        else {
+            console.log(`  ✗ ${server.name}: ${server.lastError || 'not connected'}`);
+            healthy = false;
+        }
+    }
+    // A server in the config that the daemon has no record of predates the
+    // daemon's own startup, so its warm connections are stale.
+    const known = new Set(status.servers.map((server) => server.name));
+    const missing = configuredServers.filter((name) => !known.has(name));
+    if (missing.length > 0) {
+        console.log(`  ! Not known to the running daemon: ${missing.join(', ')}`);
+        console.log('    Restart it to pick them up: mcp-cli daemon restart');
+        healthy = false;
+    }
+    console.log(`\n${healthy ? 'All checks passed.' : 'Some checks failed (see above).'}`);
+    if (!healthy) {
+        process.exit(1);
+    }
+}
 /**
  * mcp-cli daemon status — show daemon status
  */
@@ -136,16 +261,30 @@ export async function handleDaemonStatus(socketPath) {
     const hours = Math.floor(status.uptime / 3600);
     const minutes = Math.floor((status.uptime % 3600) / 60);
     const uptimeStr = hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
-    console.log(`Daemon running (PID ${status.pid}, uptime ${uptimeStr})`);
-    console.log(`Servers: ${status.connectedServers} connected, ${status.totalServers - status.connectedServers} failed`);
+    console.log(`Daemon running (PID ${status.pid}, release ${status.releaseId ?? 'legacy'}, uptime ${uptimeStr})`);
+    const failed = status.servers.filter((server) => server.state === 'failed');
+    const inactive = status.servers.filter((server) => !server.connected && server.state !== 'failed');
+    console.log(`Servers: ${status.connectedServers} connected, ${inactive.length} inactive, ${failed.length} failed`);
     console.log(`Tools: ${status.cachedToolCount} cached`);
     console.log(`Socket: ${status.socketPath}`);
-    // Show failed servers
-    const failed = status.servers.filter(s => !s.connected);
-    if (failed.length > 0) {
-        console.log('\nFailed servers:');
-        for (const s of failed) {
-            console.log(`  - ${s.name}: ${s.lastError || 'unknown error'}`);
+    if (status.servers.length > 0) {
+        console.log('\nConnection lifecycle:');
+        for (const server of status.servers) {
+            const details = [
+                `state=${server.state ?? (server.connected ? 'ready' : 'failed')}`,
+                server.generation ? `generation=${server.generation}` : undefined,
+                server.connectionAgeSeconds !== undefined
+                    ? `age=${server.connectionAgeSeconds}s`
+                    : undefined,
+                `active=${server.activeCalls ?? 0}`,
+                `recycles=${server.recycleCount ?? 0}`,
+                `auth-resets=${server.authInvalidations ?? 0}`,
+                `failures=${server.consecutiveFailures ?? 0}`,
+            ].filter((value) => value !== undefined);
+            console.log(`  - ${server.name}: ${details.join(', ')}`);
+            if (server.lastError) {
+                console.log(`    last error: ${server.lastError}`);
+            }
         }
     }
 }

package/dist/cli/daemon.js

@@ -2,18 +2,18 @@
 import net from 'net';
 import fs from 'fs';
 import path from 'path';
-import { homedir } from 'os';
 import pino from 'pino';
 import { MCPClientManager } from '../mcp/client-manager.js';
+import { callToolWithAuthRecovery } from '../mcp/tool-call-executor.js';
 import { CompressionCache } from '../services/compression-cache.js';
 import { SessionManager } from '../services/session-manager.js';
 import { StatsService } from '../services/stats-service.js';
-import { loadJSONServers, matchesIgnorePattern } from '../config/loader.js';
-import { interceptPayload } from './payload-interceptor.js';
-const BASE_DIR = path.join(homedir(), '.mcp-compression-proxy');
-const SOCKET_PATH = path.join(BASE_DIR, 'daemon.sock');
-const PID_FILE = path.join(BASE_DIR, 'daemon.pid');
-const LOG_FILE = path.join(BASE_DIR, 'daemon.log');
+import { loadJSONServers, loadJSONServersCached, matchesIgnorePattern } from '../config/loader.js';
+import { DEFAULT_PAYLOAD_THRESHOLD, PayloadStore } from './payload-interceptor.js';
+import { runCallScript } from '../mcp/call-script.js';
+import { getDaemonRuntimePaths } from './runtime-paths.js';
+const RUNTIME_PATHS = getDaemonRuntimePaths();
+const { baseDir: BASE_DIR, socketPath: SOCKET_PATH, pidFile: PID_FILE, readyFile: READY_FILE, logFile: LOG_FILE, payloadDir: PAYLOAD_DIR, releaseId: RELEASE_ID, } = RUNTIME_PATHS;
 export function getSocketPath() {
     return SOCKET_PATH;
 }
@@ -33,6 +33,12 @@ async function startDaemon() {
     // mkdirSync ignores `mode` when the directory already exists, so an
     // upgrade from a previous version still gets tightened.
     fs.chmodSync(BASE_DIR, 0o700);
+    for (const runtimePath of [SOCKET_PATH, PID_FILE, READY_FILE, LOG_FILE]) {
+        fs.mkdirSync(path.dirname(runtimePath), {
+            recursive: true,
+            mode: 0o700,
+        });
+    }
     const logger = pino({
         name: 'mcp-cli-daemon',
         level: process.env.LOG_LEVEL || 'info',
@@ -48,11 +54,15 @@ async function startDaemon() {
         },
     });
     const startTime = Date.now();
-    logger.info({ pid: process.pid }, 'Daemon starting');
+    logger.info({ pid: process.pid, releaseId: RELEASE_ID }, 'Daemon starting');
     // Write PID file
     fs.writeFileSync(PID_FILE, String(process.pid), 'utf-8');
     // Initialize services (reusing existing components)
     const clientManager = new MCPClientManager(logger);
+    const payloadStore = new PayloadStore({
+        directory: PAYLOAD_DIR,
+        removeDirectoryOnDestroy: false,
+    });
     const compressionCache = new CompressionCache(logger);
     const sessionManager = new SessionManager(logger);
     const statsService = new StatsService(logger, clientManager, compressionCache, sessionManager);
@@ -73,10 +83,19 @@ async function startDaemon() {
         if (rawConfig.cli && typeof rawConfig.cli === 'object') {
             cliConfig = rawConfig.cli;
         }
-        const enabledServers = config.servers.filter(s => s.enabled !== false);
+        const enabledServers = config.servers.filter((s) => s.enabled !== false);
         logger.info({ total: config.servers.length, enabled: enabledServers.length }, 'Initializing backend MCP servers');
         try {
-            await clientManager.initializeServers(enabledServers, config.defaultTimeout);
+            // inheritEnv must be passed here too: the config watch below reconciles
+            // with it, so omitting it makes every connection's stored config differ
+            // from the reconciled one on the first tick - bouncing every healthy
+            // backend ~5s after startup.
+            await clientManager.initializeServers(enabledServers, config.defaultTimeout, config.inheritEnv, {
+                softMaxConnectionAgeSeconds: config.softMaxConnectionAgeSeconds,
+                hardMaxConnectionAgeSeconds: config.hardMaxConnectionAgeSeconds,
+                authErrorPatterns: config.authErrorPatterns,
+                authRetryTools: config.authRetryTools,
+            });
             logger.info('Backend MCP servers initialization complete');
         }
         catch (error) {
@@ -86,6 +105,13 @@ async function startDaemon() {
     else {
         logger.warn('No configuration found. Daemon started with no backend servers.');
     }
+    // The daemon outlives any single CLI invocation, so it is the entry point
+    // that most needs this: editing servers.json would otherwise mean stopping a
+    // daemon that is holding warm connections. Cached loader rather than the
+    // uncached one used above - the poll is what its mtime fingerprint is for.
+    clientManager.startConfigWatch(loadJSONServersCached, undefined, (reloaded) => {
+        compressionCache.setNoCompressPatterns(reloaded.noCompressPatterns);
+    });
     // Clean up stale socket file if it exists
     if (fs.existsSync(SOCKET_PATH)) {
         fs.unlinkSync(SOCKET_PATH);
@@ -97,18 +123,18 @@ async function startDaemon() {
         try {
             switch (method) {
                 case 'tools': {
-                    const clients = clientManager.getConnectedClients();
+                    const serverNames = clientManager.getConfiguredServerNames();
                     const toolEntries = [];
-                    for (const { name, client } of clients) {
+                    for (const name of serverNames) {
                         try {
-                            const result = await client.listTools();
+                            const result = await clientManager.withClient(name, async ({ client }) => client.listTools());
                             for (const tool of result.tools) {
                                 const fullName = `${name}__${tool.name}`;
                                 if (matchesIgnorePattern(fullName, excludePatterns))
                                     continue;
-                                const desc = compressionCache.getCompressedDescription(name, tool.name)
-                                    || tool.description
-                                    || '';
+                                const desc = compressionCache.getCompressedDescription(name, tool.name) ||
+                                    tool.description ||
+                                    '';
                                 // Truncate to ~60 chars for compact listing
                                 const shortDesc = desc.length > 60 ? desc.slice(0, 57) + '...' : desc;
                                 toolEntries.push({ server: name, tool: tool.name, description: shortDesc });
@@ -122,18 +148,18 @@ async function startDaemon() {
                 }
                 case 'search': {
                     const query = String(params?.query || '').toLowerCase();
-                    const clients = clientManager.getConnectedClients();
+                    const serverNames = clientManager.getConfiguredServerNames();
                     const matches = [];
-                    for (const { name, client } of clients) {
+                    for (const name of serverNames) {
                         try {
-                            const result = await client.listTools();
+                            const result = await clientManager.withClient(name, async ({ client }) => client.listTools());
                             for (const tool of result.tools) {
                                 const fullName = `${name}__${tool.name}`;
                                 if (matchesIgnorePattern(fullName, excludePatterns))
                                     continue;
-                                const desc = compressionCache.getCompressedDescription(name, tool.name)
-                                    || tool.description
-                                    || '';
+                                const desc = compressionCache.getCompressedDescription(name, tool.name) ||
+                                    tool.description ||
+                                    '';
                                 const searchText = `${name}/${tool.name} ${desc}`.toLowerCase();
                                 if (searchText.includes(query)) {
                                     const shortDesc = desc.length > 60 ? desc.slice(0, 57) + '...' : desc;
@@ -150,15 +176,17 @@ async function startDaemon() {
                 case 'info': {
                     const serverName = String(params?.server || '');
                     const toolName = String(params?.tool || '');
-                    const client = clientManager.getClient(serverName);
-                    if (!client) {
-                        return { id, error: { code: -1, message: `Server '${serverName}' not found or not connected` } };
-                    }
                     try {
-                        const result = await client.listTools();
-                        const tool = result.tools.find(t => t.name === toolName);
+                        const result = await clientManager.withClient(serverName, async ({ client }) => client.listTools());
+                        const tool = result.tools.find((t) => t.name === toolName);
                         if (!tool) {
-                            return { id, error: { code: -1, message: `Tool '${toolName}' not found on server '${serverName}'` } };
+                            return {
+                                id,
+                                error: {
+                                    code: -1,
+                                    message: `Tool '${toolName}' not found on server '${serverName}'`,
+                                },
+                            };
                         }
                         return {
                             id,
@@ -179,28 +207,69 @@ async function startDaemon() {
                     const serverName = String(params?.server || '');
                     const toolName = String(params?.tool || '');
                     const args = (params?.arguments || {});
-                    const threshold = cliConfig.payloadThreshold ?? 500;
-                    const client = clientManager.getClient(serverName);
-                    if (!client) {
-                        return { id, error: { code: -1, message: `Server '${serverName}' not found or not connected` } };
-                    }
+                    const threshold = cliConfig.payloadThreshold ?? DEFAULT_PAYLOAD_THRESHOLD;
                     try {
-                        const result = await client.callTool({ name: toolName, arguments: args });
+                        const result = await callToolWithAuthRecovery(clientManager, logger, serverName, toolName, args);
                         const content = result.content;
                         // Extract text content
                         // flatMap rather than filter+map: filter does not narrow the
                         // element type, which is why this needed a non-null assertion.
-                        const textParts = content.flatMap((c) => c.type === 'text' && c.text ? [c.text] : []);
+                        const textParts = content.flatMap((c) => (c.type === 'text' && c.text ? [c.text] : []));
                         const fullOutput = textParts.join('\n');
                         // Apply payload interception
-                        const output = interceptPayload(fullOutput, threshold);
-                        return { id, result: { output, isError: result.isError } };
+                        const captured = payloadStore.capture(fullOutput, threshold);
+                        return {
+                            id,
+                            result: {
+                                output: captured.output,
+                                isError: result.isError,
+                                payload: captured.reference,
+                            },
+                        };
                     }
                     catch (error) {
                         const msg = error instanceof Error ? error.message : 'Unknown error';
                         return { id, error: { code: -1, message: msg } };
                     }
                 }
+                case 'payload-read': {
+                    const payloadId = String(params?.id || '');
+                    const result = payloadStore.read(payloadId, {
+                        offset: params?.offset,
+                        length: params?.length,
+                        all: params?.all,
+                    });
+                    return { id, result };
+                }
+                case 'payload-find': {
+                    const payloadId = String(params?.id || '');
+                    const query = String(params?.query || '');
+                    const result = payloadStore.find(payloadId, query, {
+                        caseSensitive: params?.caseSensitive,
+                        maxMatches: params?.maxMatches,
+                        contextChars: params?.contextChars,
+                    });
+                    return { id, result };
+                }
+                case 'script': {
+                    const steps = params?.steps;
+                    if (!Array.isArray(steps)) {
+                        return {
+                            id,
+                            error: { code: -1, message: 'Script steps must be an array' },
+                        };
+                    }
+                    const threshold = cliConfig.payloadThreshold ?? DEFAULT_PAYLOAD_THRESHOLD;
+                    const result = await runCallScript(steps, async (serverName, toolName, args) => {
+                        const callResult = await callToolWithAuthRecovery(clientManager, logger, serverName, toolName, args);
+                        const content = callResult.content;
+                        const output = content
+                            .flatMap((item) => (item.type === 'text' && item.text ? [item.text] : []))
+                            .join('\n');
+                        return { output, isError: callResult.isError };
+                    }, payloadStore, threshold);
+                    return { id, result };
+                }
                 case 'stats': {
                     const stats = await statsService.getStats({
                         serverName: params?.serverName,
@@ -210,13 +279,14 @@ async function startDaemon() {
                 }
                 case 'daemon-status': {
                     const statuses = clientManager.getServerStatuses();
-                    const connectedCount = statuses.filter(s => s.connected).length;
+                    const connectedCount = statuses.filter((s) => s.connected).length;
                     const cacheMetrics = compressionCache.getCacheMetrics();
                     return {
                         id,
                         result: {
                             running: true,
                             pid: process.pid,
+                            releaseId: RELEASE_ID,
                             uptime: Math.floor((Date.now() - startTime) / 1000),
                             servers: statuses,
                             cachedToolCount: cacheMetrics.totalCached,
@@ -257,7 +327,10 @@ async function startDaemon() {
                         .catch((error) => {
                         const errResponse = {
                             id: request.id,
-                            error: { code: -1, message: error instanceof Error ? error.message : 'Unknown error' },
+                            error: {
+                                code: -1,
+                                message: error instanceof Error ? error.message : 'Unknown error',
+                            },
                         };
                         socket.write(JSON.stringify(errResponse) + '\n');
                     });
@@ -291,37 +364,48 @@ async function startDaemon() {
         try {
             fs.unlinkSync(PID_FILE);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         process.exit(1);
     });
     server.listen(SOCKET_PATH, () => {
         logger.info({ socketPath: SOCKET_PATH, pid: process.pid }, 'Daemon listening');
         // Signal readiness by writing a ready marker
-        const readyFile = path.join(BASE_DIR, 'daemon.ready');
-        fs.writeFileSync(readyFile, String(Date.now()), 'utf-8');
+        fs.writeFileSync(READY_FILE, String(Date.now()), 'utf-8');
     });
     // Graceful shutdown
     function shutdown() {
         logger.info('Daemon shutting down');
         server.close();
-        clientManager.disconnectAll().then(() => {
+        clientManager
+            .disconnectAll()
+            .then(() => {
             sessionManager.destroy();
+            payloadStore.destroy();
             // Clean up files
             try {
                 fs.unlinkSync(SOCKET_PATH);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
             try {
                 fs.unlinkSync(PID_FILE);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
             try {
-                fs.unlinkSync(path.join(BASE_DIR, 'daemon.ready'));
+                fs.unlinkSync(READY_FILE);
+            }
+            catch {
+                /* ignore */
             }
-            catch { /* ignore */ }
             logger.info('Daemon stopped');
             process.exit(0);
-        }).catch(() => {
+        })
+            .catch(() => {
             process.exit(1);
         });
     }