mcp-compression-proxy 1.0.3 → 1.1.0

package/dist/cli/index.js

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 import { spawn } from 'child_process';
-import { existsSync, readFileSync, unlinkSync } from 'fs';
+import { existsSync, readFileSync, unlinkSync, statSync, openSync, readSync, closeSync, } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
 import { isDaemonRunning } from './ipc-client.js';
-import { handleTools, handleSearch, handleInfo, handleCall, handleStats, handleDaemonStatus, } from './commands.js';
+import { isManagedRouterConfigured, managedRouterUnavailableMessage } from './runtime-mode.js';
+import { handleTools, handleSearch, handleInfo, handleCall, handlePayloadRead, handlePayloadFind, handleScript, handleStats, handleDaemonStatus, handleDoctor, tailLines, } from './commands.js';
 const BASE_DIR = join(homedir(), '.mcp-compression-proxy');
 const SOCKET_PATH = join(BASE_DIR, 'daemon.sock');
 const PID_FILE = join(BASE_DIR, 'daemon.pid');
 const READY_FILE = join(BASE_DIR, 'daemon.ready');
+const LOG_FILE = join(BASE_DIR, 'daemon.log');
 const USAGE = `
 mcp-cli — Progressive MCP tool discovery for LLMs
 
@@ -18,10 +20,17 @@ Usage:
   mcp-cli search <query>               Search tools by name/description
   mcp-cli info <server>/<tool>         Get full schema for a tool
   mcp-cli call <server>/<tool> <json>  Execute a tool
+  mcp-cli output read <id> [offset] [length|all]
+                                        Read cached large output
+  mcp-cli output find <id> <query>      Find text in cached large output
+  mcp-cli script <json>                 Run a declarative MCP call chain
   mcp-cli stats                        Show compression statistics
+  mcp-cli doctor                       Check config and backend health
   mcp-cli daemon start                 Start the background daemon
   mcp-cli daemon stop                  Stop the daemon
+  mcp-cli daemon restart               Restart the daemon
   mcp-cli daemon status                Show daemon status
+  mcp-cli daemon logs [-n N] [-f]      Show daemon logs (default: last 50)
   mcp-cli help                         Show this help
 
 Options:
@@ -32,6 +41,10 @@ Options:
  * Forks the daemon.ts module with detached: true.
  */
 async function startDaemon() {
+    if (isManagedRouterConfigured(BASE_DIR)) {
+        console.error('Error: This installation uses the managed MCP router. Refusing to start a legacy daemon on the stable socket.');
+        return false;
+    }
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
     const daemonScript = join(__dirname, 'daemon.js');
@@ -61,7 +74,7 @@ async function startDaemon() {
         if (existsSync(READY_FILE)) {
             return true;
         }
-        await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
     }
     // Fallback: check if socket is reachable
     return isDaemonRunning(SOCKET_PATH);
@@ -132,6 +145,68 @@ async function stopDaemon() {
     console.error(`Daemon (PID ${pid}) did not exit within 10s; it may still be shutting down.`);
     return false;
 }
+/**
+ * Print the tail of the daemon log, optionally following it.
+ *
+ * Polls rather than shelling out to `tail`: spawning it drags in platform
+ * differences (BSD vs GNU flags) for something this file can do itself, and a
+ * dependency for it would be worse still.
+ */
+async function showLogs(args) {
+    const follow = args.includes('-f') || args.includes('--follow');
+    const countIndex = args.findIndex((arg) => arg === '-n' || arg === '--lines');
+    const requested = countIndex === -1 ? NaN : Number.parseInt(args[countIndex + 1] ?? '', 10);
+    const count = Number.isInteger(requested) && requested > 0 ? requested : 50;
+    if (!existsSync(LOG_FILE)) {
+        console.error(`No daemon log at ${LOG_FILE}.`);
+        console.error('The daemon writes it on first start: mcp-cli daemon start');
+        process.exit(1);
+    }
+    console.log(tailLines(readFileSync(LOG_FILE, 'utf-8'), count));
+    if (!follow)
+        return;
+    // Track the offset rather than re-reading the file: a long-running daemon's
+    // log is appended to constantly.
+    let offset = statSync(LOG_FILE).size;
+    await new Promise((resolve) => {
+        const timer = setInterval(() => {
+            let size;
+            try {
+                size = statSync(LOG_FILE).size;
+            }
+            catch {
+                return; // rotated out from under us; pick it up on the next tick
+            }
+            // Truncation or rotation resets the file, so start over rather than
+            // seeking past the end and printing nothing forever.
+            if (size < offset) {
+                offset = 0;
+            }
+            if (size === offset)
+                return;
+            const handle = openSync(LOG_FILE, 'r');
+            try {
+                const buffer = Buffer.alloc(size - offset);
+                readSync(handle, buffer, 0, buffer.length, offset);
+                process.stdout.write(buffer.toString('utf-8'));
+                offset = size;
+            }
+            finally {
+                closeSync(handle);
+            }
+        }, 500);
+        // Housekeeping must never be the reason this process cannot exit.
+        timer.unref?.();
+        const stop = () => {
+            clearInterval(timer);
+            process.off('SIGINT', stop);
+            process.off('SIGTERM', stop);
+            resolve();
+        };
+        process.on('SIGINT', stop);
+        process.on('SIGTERM', stop);
+    });
+}
 /**
  * Ensure daemon is running, auto-starting if needed.
  */
@@ -139,6 +214,10 @@ async function ensureDaemon(noAutoStart) {
     const running = await isDaemonRunning(SOCKET_PATH);
     if (running)
         return;
+    if (isManagedRouterConfigured(BASE_DIR)) {
+        console.error(`Error: ${managedRouterUnavailableMessage()}`);
+        process.exit(1);
+    }
     if (noAutoStart) {
         console.error('Error: Daemon is not running. Start it with: mcp-cli daemon start');
         process.exit(1);
@@ -165,7 +244,9 @@ async function readStdin() {
         // stdin has already ended.
         const timer = setTimeout(() => resolve(data.trim() || null), 1000);
         timer.unref?.();
-        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
         process.stdin.on('end', () => {
             clearTimeout(timer);
             resolve(data.trim() || null);
@@ -175,7 +256,7 @@ async function readStdin() {
 async function main() {
     const args = process.argv.slice(2);
     const noAutoStart = args.includes('--no-auto-start');
-    const filteredArgs = args.filter(a => a !== '--no-auto-start');
+    const filteredArgs = args.filter((a) => a !== '--no-auto-start');
     const command = filteredArgs[0];
     if (!command || command === 'help' || command === '--help' || command === '-h') {
         console.log(USAGE);
@@ -212,11 +293,26 @@ async function main() {
             case 'stop':
                 await stopDaemon();
                 return;
+            case 'restart': {
+                // stopDaemon() returning false just means nothing was running, which
+                // is a fine state to start from.
+                await stopDaemon();
+                const started = await startDaemon();
+                if (!started) {
+                    console.error('Failed to start daemon.');
+                    process.exit(1);
+                }
+                console.log('Daemon restarted.');
+                return;
+            }
             case 'status':
                 await handleDaemonStatus(SOCKET_PATH);
                 return;
+            case 'logs':
+                await showLogs(filteredArgs.slice(2));
+                return;
             default:
-                console.error('Usage: mcp-cli daemon <start|stop|status>');
+                console.error('Usage: mcp-cli daemon <start|stop|restart|status|logs>');
                 process.exit(1);
         }
     }
@@ -238,7 +334,7 @@ async function main() {
             break;
         case 'call': {
             if (!filteredArgs[1]) {
-                console.error('Usage: mcp-cli call <server>/<tool> \'<json_payload>\'');
+                console.error("Usage: mcp-cli call <server>/<tool> '<json_payload>'");
                 process.exit(1);
             }
             // Payload from args or stdin
@@ -253,9 +349,53 @@ async function main() {
             await handleCall(SOCKET_PATH, filteredArgs[1], payload);
             break;
         }
+        case 'output': {
+            const action = filteredArgs[1];
+            const id = filteredArgs[2];
+            if (!id || (action !== 'read' && action !== 'find')) {
+                console.error('Usage: mcp-cli output <read|find> <payload-id> ...');
+                process.exit(1);
+            }
+            if (action === 'find') {
+                const query = filteredArgs.slice(3).join(' ');
+                if (!query) {
+                    console.error('Usage: mcp-cli output find <payload-id> <query>');
+                    process.exit(1);
+                }
+                await handlePayloadFind(SOCKET_PATH, id, query);
+                break;
+            }
+            const offset = filteredArgs[3] === undefined ? undefined : Number.parseInt(filteredArgs[3], 10);
+            const lengthArg = filteredArgs[4];
+            const all = lengthArg === 'all';
+            const length = lengthArg && !all ? Number.parseInt(lengthArg, 10) : undefined;
+            await handlePayloadRead(SOCKET_PATH, id, {
+                offset: Number.isFinite(offset) ? offset : undefined,
+                length: Number.isFinite(length) ? length : undefined,
+                all,
+            });
+            break;
+        }
+        case 'script': {
+            let payload = filteredArgs[1] || '';
+            if (!payload) {
+                const stdinData = await readStdin();
+                if (stdinData)
+                    payload = stdinData;
+            }
+            if (!payload) {
+                console.error('Usage: mcp-cli script <json>');
+                process.exit(1);
+            }
+            await handleScript(SOCKET_PATH, payload);
+            break;
+        }
         case 'stats':
             await handleStats(SOCKET_PATH);
             break;
+        case 'doctor':
+            await handleDoctor(SOCKET_PATH);
+            break;
         default:
             console.error(`Unknown command: ${command}\n`);
             console.log(USAGE);

package/dist/cli/payload-interceptor.d.ts

@@ -1,6 +1,75 @@
+export declare const DEFAULT_PAYLOAD_THRESHOLD = 10000;
+export declare const DEFAULT_PAYLOAD_READ_LENGTH = 10000;
+export interface PayloadReference {
+    id: string;
+    path: string;
+    chars: number;
+    createdAt: number;
+}
+export interface CapturedPayload {
+    output: string;
+    reference?: PayloadReference;
+}
+export interface PayloadReadResult {
+    id: string;
+    content: string;
+    offset: number;
+    nextOffset: number;
+    totalChars: number;
+    eof: boolean;
+}
+export interface PayloadFindMatch {
+    offset: number;
+    line: number;
+    match: string;
+    context: string;
+}
+export interface PayloadFindResult {
+    id: string;
+    query: string;
+    totalChars: number;
+    matches: PayloadFindMatch[];
+    truncated: boolean;
+}
+export interface PayloadStoreOptions {
+    maxEntries?: number;
+    directory?: string;
+    removeDirectoryOnDestroy?: boolean;
+}
 /**
- * Intercepts large tool call outputs, saves them to a temp file,
- * and returns a reference instead of the full payload.
+ * Process-local, file-backed storage for large MCP outputs.
+ *
+ * Handles, not paths, are accepted by read/find operations so callers cannot
+ * use the daemon as an arbitrary local-file reader. Files live in a private
+ * 0700 temp directory and are written 0600.
+ */
+export declare class PayloadStore {
+    private readonly maxEntries;
+    private readonly configuredDirectory;
+    private readonly removeDirectoryOnDestroy;
+    private readonly entries;
+    private payloadDir;
+    constructor(options?: PayloadStoreOptions);
+    private getPayloadDir;
+    private getEntry;
+    private refreshEntries;
+    private evictOldest;
+    capture(output: string, threshold?: number): CapturedPayload;
+    private referenceMessage;
+    read(id: string, options?: {
+        offset?: number;
+        length?: number;
+        all?: boolean;
+    }): PayloadReadResult;
+    find(id: string, query: string, options?: {
+        caseSensitive?: boolean;
+        maxMatches?: number;
+        contextChars?: number;
+    }): PayloadFindResult;
+    destroy(): void;
+}
+/**
+ * Backward-compatible string-only wrapper used by existing callers.
  */
 export declare function interceptPayload(output: string, threshold?: number): string;
 //# sourceMappingURL=payload-interceptor.d.ts.map

package/dist/cli/payload-interceptor.js

@@ -1,49 +1,227 @@
 import { createHash } from 'crypto';
-import { mkdtempSync, writeFileSync } from 'fs';
+import { existsSync, chmodSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync, writeFileSync, } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
-const DEFAULT_THRESHOLD = 500;
+export const DEFAULT_PAYLOAD_THRESHOLD = 10_000;
+export const DEFAULT_PAYLOAD_READ_LENGTH = 10_000;
 /**
- * Private directory for intercepted payloads, created on first use.
+ * Process-local, file-backed storage for large MCP outputs.
  *
- * Writing `mcp_output_<hash>.txt` straight into the shared temp directory
- * made the path predictable from the content alone: another local user could
- * pre-plant a symlink there and turn our write into an arbitrary-file
- * overwrite, or simply read whatever a backend MCP server had just returned.
- * mkdtemp gives us a 0700 directory with an unpredictable name, so neither is
- * reachable. The name is stable for the lifetime of the process, which keeps
- * identical content mapping to a single file.
+ * Handles, not paths, are accepted by read/find operations so callers cannot
+ * use the daemon as an arbitrary local-file reader. Files live in a private
+ * 0700 temp directory and are written 0600.
  */
-let payloadDir;
-function getPayloadDir() {
-    if (payloadDir === undefined) {
-        payloadDir = mkdtempSync(join(tmpdir(), 'mcp-output-'));
+export class PayloadStore {
+    maxEntries;
+    configuredDirectory;
+    removeDirectoryOnDestroy;
+    entries = new Map();
+    payloadDir;
+    constructor(options = {}) {
+        this.maxEntries = Math.max(1, options.maxEntries ?? 100);
+        this.configuredDirectory = options.directory;
+        this.removeDirectoryOnDestroy =
+            options.removeDirectoryOnDestroy ??
+                options.directory === undefined;
     }
-    return payloadDir;
-}
-/**
- * Intercepts large tool call outputs, saves them to a temp file,
- * and returns a reference instead of the full payload.
- */
-export function interceptPayload(output, threshold) {
-    const limit = threshold ?? DEFAULT_THRESHOLD;
-    if (output.length <= limit) {
-        return output;
+    getPayloadDir() {
+        if (this.payloadDir === undefined) {
+            if (this.configuredDirectory) {
+                mkdirSync(this.configuredDirectory, {
+                    recursive: true,
+                    mode: 0o700,
+                });
+                // Tighten an existing directory created under a permissive umask.
+                const mode = statSync(this.configuredDirectory).mode & 0o777;
+                if (mode !== 0o700) {
+                    chmodSync(this.configuredDirectory, 0o700);
+                }
+                this.payloadDir = this.configuredDirectory;
+            }
+            else {
+                this.payloadDir = mkdtempSync(join(tmpdir(), 'mcp-output-'));
+            }
+        }
+        return this.payloadDir;
     }
-    const hash = createHash('sha256').update(output).digest('hex').slice(0, 12);
-    const filename = `mcp_output_${hash}.txt`;
-    const filepath = join(getPayloadDir(), filename);
-    try {
-        // 'wx' fails rather than following anything already at the path.
-        writeFileSync(filepath, output, { encoding: 'utf-8', mode: 0o600, flag: 'wx' });
+    getEntry(id) {
+        if (!/^[a-f0-9]{16,64}$/.test(id)) {
+            throw new Error(`Payload '${id}' not found or expired`);
+        }
+        let entry = this.entries.get(id);
+        if (!entry) {
+            const path = join(this.getPayloadDir(), `mcp_output_${id}.txt`);
+            if (existsSync(path)) {
+                const content = readFileSync(path, 'utf-8');
+                const stat = statSync(path);
+                entry = {
+                    id,
+                    path,
+                    chars: content.length,
+                    createdAt: stat.mtimeMs,
+                    hash: createHash('sha256').update(content).digest('hex'),
+                };
+                this.entries.set(id, entry);
+            }
+        }
+        if (!entry || !existsSync(entry.path)) {
+            this.entries.delete(id);
+            throw new Error(`Payload '${id}' not found or expired`);
+        }
+        return entry;
     }
-    catch (error) {
-        // Same content already written by this process - the existing file is the
-        // file we were about to write, so reuse it. Anything else is a real error.
-        if (error.code !== 'EEXIST') {
-            throw error;
+    refreshEntries() {
+        const directory = this.getPayloadDir();
+        for (const filename of readdirSync(directory)) {
+            const match = filename.match(/^mcp_output_([a-f0-9]{16,64})\.txt$/);
+            if (!match || this.entries.has(match[1]))
+                continue;
+            const path = join(directory, filename);
+            try {
+                const stat = statSync(path);
+                this.entries.set(match[1], {
+                    id: match[1],
+                    path,
+                    chars: stat.size,
+                    createdAt: stat.mtimeMs,
+                    hash: match[1],
+                });
+            }
+            catch {
+                /* another process removed it */
+            }
         }
     }
-    return `Output saved to ${filepath} (${output.length} chars). Read file for full content.`;
+    evictOldest() {
+        this.refreshEntries();
+        const oldest = Array.from(this.entries.values())
+            .sort((left, right) => left.createdAt - right.createdAt)[0];
+        if (!oldest)
+            return;
+        this.entries.delete(oldest.id);
+        try {
+            unlinkSync(oldest.path);
+        }
+        catch {
+            /* already gone */
+        }
+    }
+    capture(output, threshold = DEFAULT_PAYLOAD_THRESHOLD) {
+        if (output.length <= threshold) {
+            return { output };
+        }
+        const hash = createHash('sha256').update(output).digest('hex');
+        const id = hash;
+        const existing = this.entries.get(id);
+        if (existing && existing.hash === hash && existsSync(existing.path)) {
+            return {
+                output: this.referenceMessage(existing),
+                reference: existing,
+            };
+        }
+        if (existing) {
+            this.entries.delete(id);
+        }
+        this.refreshEntries();
+        while (this.entries.size >= this.maxEntries) {
+            this.evictOldest();
+        }
+        const filename = `mcp_output_${id}.txt`;
+        const path = join(this.getPayloadDir(), filename);
+        try {
+            writeFileSync(path, output, {
+                encoding: 'utf-8',
+                mode: 0o600,
+                flag: 'wx',
+            });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw error;
+            }
+        }
+        const entry = {
+            id,
+            path,
+            chars: output.length,
+            createdAt: Date.now(),
+            hash,
+        };
+        this.entries.set(id, entry);
+        return {
+            output: this.referenceMessage(entry),
+            reference: entry,
+        };
+    }
+    referenceMessage(reference) {
+        return (`Output saved to ${reference.path} (${reference.chars} chars). ` +
+            `Payload ID: ${reference.id}. Use mcp_find_output or mcp_read_output to inspect it.`);
+    }
+    read(id, options = {}) {
+        const entry = this.getEntry(id);
+        const content = readFileSync(entry.path, 'utf-8');
+        const offset = Math.min(Math.max(0, Math.trunc(options.offset ?? 0)), content.length);
+        const requestedLength = options.all
+            ? content.length - offset
+            : Math.max(1, Math.trunc(options.length ?? DEFAULT_PAYLOAD_READ_LENGTH));
+        const nextOffset = Math.min(offset + requestedLength, content.length);
+        return {
+            id,
+            content: content.slice(offset, nextOffset),
+            offset,
+            nextOffset,
+            totalChars: content.length,
+            eof: nextOffset >= content.length,
+        };
+    }
+    find(id, query, options = {}) {
+        if (query.length === 0) {
+            throw new Error('Payload search query must not be empty');
+        }
+        const entry = this.getEntry(id);
+        const content = readFileSync(entry.path, 'utf-8');
+        const caseSensitive = options.caseSensitive ?? false;
+        const maxMatches = Math.min(100, Math.max(1, Math.trunc(options.maxMatches ?? 20)));
+        const contextChars = Math.min(2000, Math.max(0, Math.trunc(options.contextChars ?? 200)));
+        const haystack = caseSensitive ? content : content.toLowerCase();
+        const needle = caseSensitive ? query : query.toLowerCase();
+        const matches = [];
+        let fromIndex = 0;
+        while (matches.length < maxMatches) {
+            const offset = haystack.indexOf(needle, fromIndex);
+            if (offset === -1)
+                break;
+            const contextStart = Math.max(0, offset - contextChars);
+            const contextEnd = Math.min(content.length, offset + query.length + contextChars);
+            matches.push({
+                offset,
+                line: content.slice(0, offset).split('\n').length,
+                match: content.slice(offset, offset + query.length),
+                context: content.slice(contextStart, contextEnd),
+            });
+            fromIndex = offset + Math.max(1, query.length);
+        }
+        return {
+            id,
+            query,
+            totalChars: content.length,
+            matches,
+            truncated: haystack.indexOf(needle, fromIndex) !== -1,
+        };
+    }
+    destroy() {
+        this.entries.clear();
+        if (this.payloadDir && this.removeDirectoryOnDestroy) {
+            rmSync(this.payloadDir, { recursive: true, force: true });
+        }
+        this.payloadDir = undefined;
+    }
+}
+const defaultPayloadStore = new PayloadStore();
+/**
+ * Backward-compatible string-only wrapper used by existing callers.
+ */
+export function interceptPayload(output, threshold) {
+    return defaultPayloadStore.capture(output, threshold).output;
 }
 //# sourceMappingURL=payload-interceptor.js.map

package/dist/cli/runtime-mode.d.ts

@@ -0,0 +1,3 @@
+export declare function isManagedRouterConfigured(baseDir: string): boolean;
+export declare function managedRouterUnavailableMessage(env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=runtime-mode.d.ts.map

package/dist/cli/runtime-mode.js

@@ -0,0 +1,12 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+export function isManagedRouterConfigured(baseDir) {
+    return existsSync(join(baseDir, 'active-release.json'));
+}
+export function managedRouterUnavailableMessage(env = process.env) {
+    if (env.CODEX_SANDBOX_NETWORK_DISABLED === '1') {
+        return 'The managed MCP router may be healthy outside this restricted Codex shell. Retry the same mcp-cli command with host/elevated execution (sandbox_permissions=require_escalated); do not run mcp-cli daemon start.';
+    }
+    return 'The managed MCP router is not reachable. Run mcp-proxy-upgrade status, then restart the router owner only if host execution also fails.';
+}
+//# sourceMappingURL=runtime-mode.js.map

package/dist/cli/runtime-paths.d.ts

@@ -0,0 +1,15 @@
+export interface DaemonRuntimePaths {
+    baseDir: string;
+    socketPath: string;
+    pidFile: string;
+    readyFile: string;
+    logFile: string;
+    payloadDir: string;
+    releaseId: string;
+}
+/**
+ * Resolve daemon paths from environment variables so multiple release
+ * generations can run beside each other while sharing durable payload files.
+ */
+export declare function getDaemonRuntimePaths(env?: NodeJS.ProcessEnv, home?: string): DaemonRuntimePaths;
+//# sourceMappingURL=runtime-paths.d.ts.map

package/dist/cli/runtime-paths.js

@@ -0,0 +1,26 @@
+import { homedir as osHomedir } from 'os';
+import { join } from 'path';
+/**
+ * Resolve daemon paths from environment variables so multiple release
+ * generations can run beside each other while sharing durable payload files.
+ */
+export function getDaemonRuntimePaths(env = process.env, home = osHomedir()) {
+    const baseDir = env.MCP_DAEMON_BASE_DIR ||
+        join(home, '.mcp-compression-proxy');
+    return {
+        baseDir,
+        socketPath: env.MCP_DAEMON_SOCKET_PATH ||
+            join(baseDir, 'daemon.sock'),
+        pidFile: env.MCP_DAEMON_PID_FILE ||
+            join(baseDir, 'daemon.pid'),
+        readyFile: env.MCP_DAEMON_READY_FILE ||
+            join(baseDir, 'daemon.ready'),
+        logFile: env.MCP_DAEMON_LOG_FILE ||
+            join(baseDir, 'daemon.log'),
+        payloadDir: env.MCP_PAYLOAD_DIR ||
+            join(baseDir, 'payloads'),
+        releaseId: env.MCP_DAEMON_RELEASE_ID?.trim() ||
+            'legacy',
+    };
+}
+//# sourceMappingURL=runtime-paths.js.map

package/dist/config/loader.d.ts

@@ -9,6 +9,10 @@ export type ConfigResult = {
     excludePatterns: string[];
     noCompressPatterns: string[];
     defaultTimeout?: number;
+    softMaxConnectionAgeSeconds?: number;
+    hardMaxConnectionAgeSeconds?: number;
+    authErrorPatterns?: string[];
+    authRetryTools?: string[];
     cli?: {
         payloadThreshold?: number;
         autoStartDaemon?: boolean;