@wonderwhy-er/desktop-commander 0.2.42 → 0.2.43

package/dist/handlers/filesystem-handlers.js

@@ -135,8 +135,9 @@ export async function handleReadFile(args) {
                     fileType: 'image',
                     sourceTool: 'read_file',
                     ...await getDefaultEditorMetadata(resolvedFilePath),
+                    // Image bytes for the preview widget, carried once. Deduped from the
+                    // old `content` + `imageData` pair down to this single `content` field.
                     content: imageData,
-                    imageData,
                     mimeType: fileResult.mimeType
                 }
             };

package/dist/remote-device/remote-channel.d.ts

@@ -20,6 +20,8 @@ export declare class RemoteChannel {
     private onToolCall;
     private lastDeviceStatus;
     private lastChannelState;
+    private reconnectAttempt;
+    private isRecreatingChannel;
     private _user;
     get user(): User | null;
     initialize(url: string, key: string): void;
@@ -50,10 +52,22 @@ export declare class RemoteChannel {
      * This is used for both initial subscription and recreation after socket reconnects.
      */
     private createChannel;
+    /**
+     * Compact connection state for logs — e.g. "socket=open(1) ch=errored attempt=3".
+     * readyState 1=OPEN (a 1 while joins keep failing = a half-open socket being reused),
+     * 3=CLOSED, '-'=no socket. Reads realtime-js internals defensively; never throws.
+     */
+    private connState;
     /**
      * Check if channel is connected, recreate if not.
      */
     private checkConnectionHealth;
+    /**
+     * Run an async op but reject if it doesn't settle within `ms`, so a hung await
+     * can't leave isRecreatingChannel stuck true and disable the watchdog. Mirrors
+     * closeWithTimeout() in desktop-commander-integration.ts.
+     */
+    private withTimeout;
     /**
      * Recreate the channel by destroying old one and creating fresh instance.
      */

package/dist/remote-device/remote-channel.js

@@ -1,6 +1,9 @@
 import { createClient } from '@supabase/supabase-js';
 import { captureRemote } from '../utils/capture.js';
 const HEARTBEAT_INTERVAL = 15000;
+// Cap a single channel recreate so a hung await can't pin the re-entrancy guard
+// true (which would silently disable the connection watchdog).
+const RECREATE_TIMEOUT_MS = 30000;
 export class RemoteChannel {
     constructor() {
         this.client = null;
@@ -14,6 +17,9 @@ export class RemoteChannel {
         this.lastDeviceStatus = 'offline';
         // Track last channel state for debug logging
         this.lastChannelState = null;
+        // Reconnect diagnostics + guard (see connState() / recreateChannel())
+        this.reconnectAttempt = 0; // recreateChannel() attempts since last success
+        this.isRecreatingChannel = false; // a recreate is in flight (re-entrancy guard)
         this._user = null;
     }
     get user() { return this._user; }
@@ -128,7 +134,7 @@ export class RemoteChannel {
             console.debug('[DEBUG] Calling createChannel()');
             // ! Ignore silently in Initialization to reconnect after
             await this.createChannel().catch((error) => {
-                console.debug('[DEBUG] Failed to create channel, will retry after socket reconnect', error);
+                console.debug(`[DEBUG] Failed to create channel, will retry after socket reconnect: ${error?.message || error} — ${this.connState()}`);
             });
         }
         else {
@@ -162,9 +168,11 @@ export class RemoteChannel {
             })
                 .subscribe((status, err) => {
                 // Debug: Log all subscription status events
-                console.debug(`[DEBUG] Channel subscription status: ${status}${err ? ' (error: ' + err + ')' : ''}`);
+                console.debug(`[DEBUG] Channel subscription status: ${status}${err ? ' (error: ' + (err?.message || err) + ')' : ''} — ${this.connState()}`);
                 if (status === 'SUBSCRIBED') {
-                    console.log('✅ Channel subscribed');
+                    const recovered = this.reconnectAttempt;
+                    this.reconnectAttempt = 0;
+                    console.log(`✅ Channel subscribed${recovered > 0 ? ` (recovered after ${recovered} attempt${recovered === 1 ? '' : 's'})` : ''}`);
                     // Update device status on successful connection
                     if (this.deviceId) {
                         this.setOnlineStatus(this.deviceId, 'online').catch(e => {
@@ -174,20 +182,43 @@ export class RemoteChannel {
                     resolve();
                 }
                 else if (status === 'CHANNEL_ERROR') {
-                    // console.error('❌ Channel subscription failed:', err);
+                    // CHANNEL_ERROR is the only status carrying a real error message.
+                    console.error(`❌ Channel error: ${err?.message || 'unknown'} — ${this.connState()}`);
                     this.setOnlineStatus(this.deviceId, 'offline');
-                    captureRemote('remote_channel_subscription_error', { error: err || 'Channel error' }).catch(() => { });
+                    captureRemote('remote_channel_subscription_error', { error: err?.message || 'Channel error' }).catch(() => { });
                     reject(err || new Error('Failed to initialize tool call channel subscription'));
                 }
                 else if (status === 'TIMED_OUT') {
-                    console.error('⏱️ Channel subscription timed out, Reconnecting...');
+                    console.error(`⏱️ Channel subscription timed out, Reconnecting... — ${this.connState()}`);
                     this.setOnlineStatus(this.deviceId, 'offline');
-                    captureRemote('remote_channel_subscription_timeout', {}).catch(() => { });
+                    captureRemote('remote_channel_subscription_timeout', { attempt: this.reconnectAttempt }).catch(() => { });
                     reject(new Error('Tool call channel subscription timed out'));
                 }
+                else if (status === 'CLOSED') {
+                    // Settle the promise so an in-flight recreateChannel() can't await
+                    // forever (which would wedge the re-entrancy guard / watchdog), and
+                    // mark the device offline like the other degraded states.
+                    console.warn(`⚠️ Channel closed — ${this.connState()}`);
+                    this.setOnlineStatus(this.deviceId, 'offline');
+                    reject(new Error('Tool call channel closed during subscribe'));
+                }
             });
         });
     }
+    /**
+     * Compact connection state for logs — e.g. "socket=open(1) ch=errored attempt=3".
+     * readyState 1=OPEN (a 1 while joins keep failing = a half-open socket being reused),
+     * 3=CLOSED, '-'=no socket. Reads realtime-js internals defensively; never throws.
+     */
+    connState() {
+        let socket = '?';
+        try {
+            const rt = this.client?.realtime;
+            socket = `${rt?.connectionState?.() ?? '?'}(${rt?.conn?.readyState ?? '-'})`;
+        }
+        catch { /* best effort */ }
+        return `socket=${socket} ch=${this.channel?.state ?? '-'} attempt=${this.reconnectAttempt}`;
+    }
     /**
      * Check if channel is connected, recreate if not.
      */
@@ -198,41 +229,89 @@ export class RemoteChannel {
         const state = this.channel.state;
         // Debug: Log current channel state (only if changed)
         if (!this.lastChannelState || this.lastChannelState !== state) {
-            console.debug(`[DEBUG] channel state: ${state}`);
+            console.debug(`[DEBUG] channel state: ${state} — ${this.connState()}`);
             this.lastChannelState = state;
         }
-        // Aggressive health check: Only 'joined' is considered healthy
-        // Any other state (joining, leaving, closed, errored, etc.) triggers recreation
-        if (state !== 'joined') {
-            captureRemote('remote_channel_state_health', { state });
-            console.debug(`[DEBUG] ⚠️ Channel in unhealthy state '${state}' - recreating...`);
-            this.recreateChannel();
+        // 'joined' = healthy, 'joining' = transitional — let realtime-js's own rejoin
+        // backoff converge instead of tearing the channel down mid-join. (FIX: previously
+        // recreated on every non-joined state, which amputated that backoff.)
+        if (state === 'joined' || state === 'joining')
+            return;
+        // Unhealthy: closed, errored, leaving — recreate
+        captureRemote('remote_channel_state_health', { state, attempt: this.reconnectAttempt });
+        console.debug(`[DEBUG] ⚠️ Channel in unhealthy state '${state}' - recreating... — ${this.connState()}`);
+        this.recreateChannel();
+    }
+    /**
+     * Run an async op but reject if it doesn't settle within `ms`, so a hung await
+     * can't leave isRecreatingChannel stuck true and disable the watchdog. Mirrors
+     * closeWithTimeout() in desktop-commander-integration.ts.
+     */
+    async withTimeout(op, ms, name) {
+        let timer;
+        try {
+            return await Promise.race([
+                op(),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error(`${name} timed out after ${ms}ms`)), ms);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
         }
     }
     /**
      * Recreate the channel by destroying old one and creating fresh instance.
      */
-    recreateChannel() {
+    async recreateChannel() {
         if (!this.client || !this.user?.id || !this.onToolCall) {
             console.warn('Cannot recreate channel - missing parameters');
             console.debug('[DEBUG] recreateChannel() aborted - missing prerequisites');
             return;
         }
-        // Destroy old channel
-        if (this.channel) {
-            console.debug('[DEBUG] Destroying old channel');
-            this.client.removeChannel(this.channel);
-            this.channel = null;
+        // FIX: re-entrancy guard so a 10s health tick can't stack a second recreate
+        // on top of an in-flight one.
+        if (this.isRecreatingChannel) {
+            console.debug('[DEBUG] recreateChannel() skipped - already in progress');
+            return;
         }
+        this.isRecreatingChannel = true;
+        this.reconnectAttempt++;
         // Create fresh channel
-        console.log('🔄 Recreating channel...');
-        console.debug('[DEBUG] Calling createChannel() for recreation');
-        this.createChannel().catch(err => {
-            captureRemote('remote_channel_recreate_error', { err });
-            console.debug('[DEBUG] Channel recreation failed:', err.message);
-            // TODO: enable only for debug mode
-            // console.error('Failed to recreate channel:', err);
-        });
+        console.log(`🔄 Recreating channel... (attempt ${this.reconnectAttempt}) — ${this.connState()}`);
+        try {
+            // Cap the whole recreate: a never-settling await (e.g. a subscribe that only
+            // ever emits CLOSED) must not pin isRecreatingChannel=true and silently disable
+            // the 10s watchdog. On timeout we reject -> catch -> finally clears the guard.
+            await this.withTimeout(async () => {
+                // Destroy old channel — AWAIT it so the channel registry empties before we
+                // rebuild. (The un-awaited version raced the synchronous new-channel push, so
+                // realtime-js never tore the socket down and a half-open one got reused.)
+                if (this.channel) {
+                    console.debug('[DEBUG] Destroying old channel');
+                    await this.client.removeChannel(this.channel);
+                    this.channel = null;
+                }
+                // FIX (core): force a brand-new WebSocket. After idle / wifi-loss the socket can
+                // be HALF-OPEN (readyState OPEN but dead); reusing it made every join TIME_OUT
+                // forever. disconnect() drops it so the next subscribe() dials a fresh one.
+                try {
+                    await this.client.realtime?.disconnect?.();
+                }
+                catch { /* best effort */ }
+                console.debug('[DEBUG] Calling createChannel() for recreation');
+                await this.createChannel();
+            }, RECREATE_TIMEOUT_MS, 'recreateChannel');
+        }
+        catch (err) {
+            captureRemote('remote_channel_recreate_error', { errMsg: err?.message, attempt: this.reconnectAttempt });
+            console.debug(`[DEBUG] Channel recreation failed: ${err?.message} — ${this.connState()}`);
+        }
+        finally {
+            this.isRecreatingChannel = false;
+        }
     }
     async markCallExecuting(callId) {
         if (!this.client)

package/dist/server.d.ts

@@ -39,4 +39,8 @@ declare let currentClient: {
     version: string;
 };
 declare let currentCallIsRemote: boolean;
-export { currentClient, currentCallIsRemote };
+declare let currentRemoteClient: {
+    name?: string;
+    version?: string;
+} | null;
+export { currentClient, currentCallIsRemote, currentRemoteClient };

package/dist/server.js

@@ -8,7 +8,8 @@ const OS_GUIDANCE = getOSSpecificGuidance(SYSTEM_INFO);
 const DEV_TOOL_GUIDANCE = getDevelopmentToolGuidance(SYSTEM_INFO);
 const PATH_GUIDANCE = `IMPORTANT: ${getPathGuidance(SYSTEM_INFO)} Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.`;
 const CMD_PREFIX_DESCRIPTION = `This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.`;
-import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, GetRecentToolCallsArgsSchema, WritePdfArgsSchema, } from './tools/schemas.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, GetRecentToolCallsArgsSchema, WritePdfArgsSchema, toolArgSchemas, } from './tools/schemas.js';
+import { detectUnsupportedParams, getSupportedParams, buildUnsupportedParamsWarning, } from './utils/unsupportedParams.js';
 import { getConfig, setConfigValue } from './tools/config.js';
 import { getUsageStats } from './tools/usage.js';
 import { giveFeedbackToDesktopCommander } from './tools/feedback.js';
@@ -86,6 +87,19 @@ let currentCallIsRemote = false;
 function setCurrentCallIsRemote(isRemote) {
     currentCallIsRemote = isRemote;
 }
+// The remote caller's client for the in-flight tool call (e.g. openai-mcp,
+// claude-ai). Set per CallTool when the call is remote; null for local calls.
+// Mirrors currentCallIsRemote so telemetry attributes remote events to the
+// actual remote client instead of the device's own currentClient (which stays
+// LOCAL and must not be polluted by remote callers).
+let currentRemoteClient = null;
+/**
+ * Set the remote caller's client for the current tool call (null when local).
+ * Called once per tool call by the CallTool handler.
+ */
+function setCurrentRemoteClient(clientInfo) {
+    currentRemoteClient = clientInfo;
+}
 /**
  * Unified way to update client information
  */
@@ -147,7 +161,7 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
     }
 });
 // Export current client info for access by other modules
-export { currentClient, currentCallIsRemote };
+export { currentClient, currentCallIsRemote, currentRemoteClient };
 deferLog('info', 'Setting up request handlers...');
 /**
  * Check if a tool should be included based on current client
@@ -1121,23 +1135,41 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         // this call carries the remote marker in _meta.
         const isRemoteCall = !!(metadata && typeof metadata === 'object' && metadata.remote);
         setCurrentCallIsRemote(isRemoteCall);
-        if (metadata && typeof metadata === 'object') {
-            // add remote flag if present (convert to string for telemetry)
-            if (metadata.remote) {
-                telemetryData.remote = String(metadata.remote);
-            }
-            // Dynamically update client info if provided in _meta
-            // To use in capture later
-            if (metadata.clientInfo) {
-                await updateCurrentClient(metadata.clientInfo);
-                telemetryData.client_name = metadata.clientInfo.name;
-                telemetryData.client_version = metadata.clientInfo.version;
-            }
+        if (isRemoteCall) {
+            // add remote flag (convert to string for telemetry)
+            telemetryData.remote = String(metadata.remote);
+            // Remote calls carry the originating MCP client (e.g. openai-mcp,
+            // claude-ai) in _meta.clientInfo. Attribute this call to that remote
+            // client — NOT the device's own currentClient. Fall back to a sentinel
+            // when it's absent so the call is visibly remote-but-unattributed
+            // rather than masquerading as the local device client. We deliberately
+            // do NOT call updateCurrentClient here: currentClient tracks the LOCAL
+            // client and must not be polluted (nor its transport reconfigured) by
+            // remote callers.
+            const remoteClient = metadata.clientInfo && (metadata.clientInfo.name || metadata.clientInfo.version)
+                ? metadata.clientInfo
+                : { name: 'remote-unknown', version: 'unknown' };
+            setCurrentRemoteClient(remoteClient);
+            telemetryData.client_name = remoteClient.name;
+            telemetryData.client_version = remoteClient.version;
+        }
+        else {
+            // Local call — clear any remote attribution left by a prior call.
+            setCurrentRemoteClient(null);
         }
         if (name === 'set_config_value' && args && typeof args === 'object' && 'key' in args) {
             telemetryData.set_config_value_key_name = args.key;
             telemetryData.call_origin = args.origin === 'ui' ? 'ui' : 'llm';
         }
+        // Attribute file-surface tool calls to the file-preview UI vs the LLM.
+        // The UI passes origin:'ui' when it fires these tools to refresh/navigate
+        // (pagination, folder expansion, link resolution, in-preview edits); the
+        // first read_file that opens a file comes from the LLM and is recorded as
+        // 'llm'. Lets us separate UI-refresh churn from genuine model-driven reads.
+        if ((name === 'read_file' || name === 'write_file' || name === 'edit_block' || name === 'list_directory') &&
+            args && typeof args === 'object') {
+            telemetryData.call_origin = args.origin === 'ui' ? 'ui' : 'llm';
+        }
         if (name === 'get_prompts' && args && typeof args === 'object') {
             const promptArgs = args;
             telemetryData.action = promptArgs.action;
@@ -1435,6 +1467,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // Check if should prompt about Docker environment
             result = await processDockerPrompt(result, name);
         }
+        // If the caller sent parameters this tool does not support, Zod silently
+        // strips them. Prepend a corrective warning so the model knows they were
+        // ignored and which parameters are actually supported.
+        try {
+            const argSchema = toolArgSchemas[name];
+            if (argSchema && result && Array.isArray(result.content)) {
+                const unsupported = detectUnsupportedParams(args, argSchema);
+                if (unsupported.length > 0) {
+                    const warning = buildUnsupportedParamsWarning(name, unsupported, getSupportedParams(argSchema));
+                    result.content = [
+                        { type: "text", text: warning },
+                        ...result.content,
+                    ];
+                }
+            }
+        }
+        catch {
+            // Never let the advisory warning break an otherwise-successful call.
+        }
         return result;
     }
     catch (error) {

package/dist/terminal-manager.d.ts

@@ -5,7 +5,18 @@ interface CompletedSession {
     exitCode: number | null;
     startTime: Date;
     endTime: Date;
+    evictedLines: number;
+    evictedChars: number;
 }
+/**
+ * Output buffering caps. Without a cap, a process emitting enough output makes
+ * string concatenation throw "RangeError: Invalid string length" at V8's max
+ * string size (~536M chars) inside a stdout 'data' handler — an uncaught
+ * exception that kills the whole server (index.ts exits on uncaughtException).
+ * The cap also bounds the join() cost in snapshot reads and the periodic
+ * process-state scan, both of which are O(total output).
+ */
+export declare const MAX_BUFFERED_OUTPUT_CHARS: number;
 export interface PaginatedOutputResult {
     lines: string[];
     totalLines: number;
@@ -15,6 +26,7 @@ export interface PaginatedOutputResult {
     isComplete: boolean;
     exitCode?: number | null;
     runtimeMs?: number;
+    evictedLines?: number;
 }
 export declare class TerminalManager {
     private sessions;
@@ -72,6 +84,12 @@ export declare class TerminalManager {
         totalChars: number;
         lineCount: number;
     }): string | null;
+    /**
+     * New output since a snapshot, in absolute (since process start) offsets.
+     * If eviction dropped part of the unseen output, returns what the buffer
+     * still holds — the oldest unseen chars are lost to the cap.
+     */
+    private static outputSinceSnapshot;
     /**
    * Get a session by PID
    * @param pid Process ID

package/dist/terminal-manager.js

@@ -32,6 +32,17 @@ function getRepairedPathExt() {
     }
     return current;
 }
+/**
+ * Output buffering caps. Without a cap, a process emitting enough output makes
+ * string concatenation throw "RangeError: Invalid string length" at V8's max
+ * string size (~536M chars) inside a stdout 'data' handler — an uncaught
+ * exception that kills the whole server (index.ts exits on uncaughtException).
+ * The cap also bounds the join() cost in snapshot reads and the periodic
+ * process-state scan, both of which are O(total output).
+ */
+export const MAX_BUFFERED_OUTPUT_CHARS = 50 * 1024 * 1024; // per session; oldest lines evicted first
+const MAX_LINE_CHARS = 1024 * 1024; // force-split longer lines so eviction can work
+const MAX_WAIT_OUTPUT_CHARS = 2 * 1024 * 1024; // start_process wait buffer (prompt/state detection)
 /**
  * Get the appropriate spawn configuration for a given shell
  * This handles login shell flags for different shell types
@@ -207,7 +218,10 @@ export class TerminalManager {
             outputLines: [], // Line-based buffer
             lastReadIndex: 0, // Track where "new" output starts
             isBlocked: false,
-            startTime: new Date()
+            startTime: new Date(),
+            bufferedChars: 0,
+            evictedLines: 0,
+            evictedChars: 0
         };
         this.sessions.set(childProcess.pid, session);
         // Timing telemetry
@@ -249,7 +263,14 @@ export class TerminalManager {
                 if (!firstOutputTime)
                     firstOutputTime = now;
                 lastOutputTime = now;
-                output += text;
+                // `output` only feeds the wait-phase result and prompt/state detection,
+                // so stop growing it once resolved and keep only a bounded tail.
+                if (!resolved) {
+                    output += text;
+                    if (output.length > MAX_WAIT_OUTPUT_CHARS) {
+                        output = output.slice(-Math.floor(MAX_WAIT_OUTPUT_CHARS / 2));
+                    }
+                }
                 // Append to line-based buffer
                 this.appendToLineBuffer(session, text);
                 // Record output event if collecting timing
@@ -282,7 +303,12 @@ export class TerminalManager {
                 if (!firstOutputTime)
                     firstOutputTime = now;
                 lastOutputTime = now;
-                output += text;
+                if (!resolved) {
+                    output += text;
+                    if (output.length > MAX_WAIT_OUTPUT_CHARS) {
+                        output = output.slice(-Math.floor(MAX_WAIT_OUTPUT_CHARS / 2));
+                    }
+                }
                 // Append to line-based buffer
                 this.appendToLineBuffer(session, text);
                 // Record output event if collecting timing
@@ -329,7 +355,9 @@ export class TerminalManager {
                         outputLines: [...session.outputLines], // Copy line buffer
                         exitCode: code,
                         startTime: session.startTime,
-                        endTime: new Date()
+                        endTime: new Date(),
+                        evictedLines: session.evictedLines,
+                        evictedChars: session.evictedChars
                     });
                     // Keep only last 100 completed sessions
                     if (this.completedSessions.size > 100) {
@@ -373,6 +401,32 @@ export class TerminalManager {
                 session.outputLines.push(line);
             }
         }
+        // Appended text contributes exactly its length to the joined buffer
+        // (its newlines become the join separators).
+        session.bufferedChars += text.length;
+        // A process printing without newlines grows a single line forever, which
+        // eviction can't bound — force-split so no line exceeds MAX_LINE_CHARS.
+        // Each inserted break adds one separator to the joined length.
+        let lastIndex = session.outputLines.length - 1;
+        while (session.outputLines[lastIndex].length > MAX_LINE_CHARS) {
+            const overlong = session.outputLines[lastIndex];
+            session.outputLines[lastIndex] = overlong.slice(0, MAX_LINE_CHARS);
+            session.outputLines.push(overlong.slice(MAX_LINE_CHARS));
+            session.bufferedChars += 1;
+            lastIndex++;
+        }
+        // Enforce the per-session cap by evicting the oldest lines. Keeps the
+        // buffer far below V8's max string length so concatenation and join()
+        // can never throw "Invalid string length" and kill the server.
+        while (session.bufferedChars > MAX_BUFFERED_OUTPUT_CHARS && session.outputLines.length > 1) {
+            const dropped = session.outputLines.shift();
+            const droppedJoinedChars = dropped.length + 1; // +1 for its join separator
+            session.bufferedChars -= droppedJoinedChars;
+            session.evictedChars += droppedJoinedChars;
+            session.evictedLines++;
+            if (session.lastReadIndex > 0)
+                session.lastReadIndex--;
+        }
     }
     /**
      * Read process output with pagination (like file reading)
@@ -385,15 +439,19 @@ export class TerminalManager {
         // First check active sessions
         const session = this.sessions.get(pid);
         if (session) {
-            return this.readFromLineBuffer(session.outputLines, offset, length, session.lastReadIndex, (newIndex) => { session.lastReadIndex = newIndex; }, false, undefined);
+            const result = this.readFromLineBuffer(session.outputLines, offset, length, session.lastReadIndex, (newIndex) => { session.lastReadIndex = newIndex; }, false, undefined);
+            result.evictedLines = session.evictedLines;
+            return result;
         }
         // Then check completed sessions
         const completedSession = this.completedSessions.get(pid);
         if (completedSession) {
             const runtimeMs = completedSession.endTime.getTime() - completedSession.startTime.getTime();
-            return this.readFromLineBuffer(completedSession.outputLines, offset, length, 0, // Completed sessions don't track read position
+            const result = this.readFromLineBuffer(completedSession.outputLines, offset, length, 0, // Completed sessions don't track read position
             () => { }, // No-op for completed sessions
             true, completedSession.exitCode, runtimeMs);
+            result.evictedLines = completedSession.evictedLines;
+            return result;
         }
         return null;
     }
@@ -491,8 +549,11 @@ export class TerminalManager {
         if (session) {
             const fullOutput = session.outputLines.join('\n');
             return {
-                totalChars: fullOutput.length,
-                lineCount: session.outputLines.length
+                // Absolute since process start (includes evicted output), so the
+                // offset stays valid even if the cap evicts lines between
+                // snapshot and read.
+                totalChars: session.evictedChars + fullOutput.length,
+                lineCount: session.evictedLines + session.outputLines.length
             };
         }
         return null;
@@ -506,23 +567,28 @@ export class TerminalManager {
         // Check active session first
         const session = this.sessions.get(pid);
         if (session) {
-            const fullOutput = session.outputLines.join('\n');
-            if (fullOutput.length <= snapshot.totalChars) {
-                return ''; // No new output
-            }
-            return fullOutput.substring(snapshot.totalChars);
+            return TerminalManager.outputSinceSnapshot(session.outputLines, session.evictedChars, snapshot.totalChars);
         }
         // Fallback to completed sessions - process may have finished between snapshot and poll
         const completedSession = this.completedSessions.get(pid);
         if (completedSession) {
-            const fullOutput = completedSession.outputLines.join('\n');
-            if (fullOutput.length <= snapshot.totalChars) {
-                return ''; // No new output
-            }
-            return fullOutput.substring(snapshot.totalChars);
+            return TerminalManager.outputSinceSnapshot(completedSession.outputLines, completedSession.evictedChars, snapshot.totalChars);
         }
         return null;
     }
+    /**
+     * New output since a snapshot, in absolute (since process start) offsets.
+     * If eviction dropped part of the unseen output, returns what the buffer
+     * still holds — the oldest unseen chars are lost to the cap.
+     */
+    static outputSinceSnapshot(outputLines, evictedChars, snapshotTotalChars) {
+        const fullOutput = outputLines.join('\n');
+        const newChars = evictedChars + fullOutput.length - snapshotTotalChars;
+        if (newChars <= 0) {
+            return ''; // No new output
+        }
+        return fullOutput.substring(Math.max(0, fullOutput.length - newChars));
+    }
     /**
    * Get a session by PID
    * @param pid Process ID

package/dist/tools/edit.js

@@ -15,7 +15,7 @@
  * 3. Unify the editRange() signature to handle both text search/replace and structured edits
  */
 import { getDefaultEditorMetadata, writeFile, readFileInternal, validatePath } from './filesystem.js';
-import { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearch.js';
+import { runFuzzySearchInWorker, getSimilarityRatio } from './fuzzySearch.js';
 import { capture } from '../utils/capture.js';
 import { createErrorResponse } from '../error-handlers.js';
 import { EditBlockArgsSchema } from "./schemas.js";
@@ -202,8 +202,9 @@ RECOMMENDATION: For large search/replace operations, consider breaking them into
     if (count === 0) {
         // Track fuzzy search time
         const startTime = performance.now();
-        // Perform fuzzy search
-        const fuzzyResult = recursiveFuzzyIndexOf(content, block.search);
+        // Perform fuzzy search in a worker thread so the main event loop stays
+        // responsive to pings and parallel tool calls during the scan
+        const fuzzyResult = await runFuzzySearchInWorker(content, block.search);
         const similarity = getSimilarityRatio(block.search, fuzzyResult.value);
         // Calculate execution time in milliseconds
         const executionTime = performance.now() - startTime;

package/dist/tools/fuzzySearch.d.ts

@@ -1,22 +1,12 @@
+import type { FuzzyMatch } from './fuzzySearchCore.js';
+export { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearchCore.js';
+/** Abort fuzzy search in the worker after this many ms to avoid unbounded CPU burn. */
+export declare const FUZZY_SEARCH_TIMEOUT_MS = 30000;
 /**
- * Recursively finds the closest match to a query string within text using fuzzy matching
- * @param text The text to search within
- * @param query The query string to find
- * @param start Start index in the text (default: 0)
- * @param end End index in the text (default: text.length)
- * @param parentDistance Best distance found so far (default: Infinity)
- * @returns Object with start and end indices, matched value, and Levenshtein distance
+ * Runs the fuzzy search in a Worker thread so the main MCP event loop stays
+ * responsive to pings and other tool calls during heavy scans. Rejects if the
+ * scan exceeds timeoutMs, terminating the worker so it doesn't linger in the
+ * background. Search metrics come back with the result and are captured here,
+ * on the main thread, where the client identity is initialized.
  */
-export declare function recursiveFuzzyIndexOf(text: string, query: string, start?: number, end?: number | null, parentDistance?: number, depth?: number): {
-    start: number;
-    end: number;
-    value: string;
-    distance: number;
-};
-/**
- * Calculates the similarity ratio between two strings
- * @param a First string
- * @param b Second string
- * @returns Similarity ratio (0-1)
- */
-export declare function getSimilarityRatio(a: string, b: string): number;
+export declare function runFuzzySearchInWorker(text: string, query: string, timeoutMs?: number): Promise<FuzzyMatch>;