@wonderwhy-er/desktop-commander 0.2.42 → 0.2.44

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

@@ -1,6 +1,17 @@
 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;
+// Max time the channel may sit CONTINUOUSLY in 'joining' before we force a recreate.
+// 'joining' is normally healthy (we let realtime-js's rejoin backoff converge), but on a
+// HALF-OPEN socket (readyState OPEN yet dead) realtime-js parks the channel in 'joining'
+// forever and never reconnects the socket — the device then wedges offline silently with
+// no recreate firing. realtime-js's join push times out in ~10s, so a genuine join
+// resolves/errors well within this window; 3 health ticks of unbroken 'joining' means the
+// state machine has stalled and only a fresh socket (via recreate) recovers it.
+const JOINING_WEDGE_TIMEOUT_MS = 30000;
 export class RemoteChannel {
     constructor() {
         this.client = null;
@@ -14,6 +25,10 @@ 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.joiningSince = null; // ts the channel entered an unbroken 'joining' run; null when not joining
         this._user = null;
     }
     get user() { return this._user; }
@@ -128,7 +143,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 +177,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 +191,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 +238,110 @@ 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...`);
+        // 'joined' = healthy. Clear the joining-overstay timer.
+        if (state === 'joined') {
+            this.joiningSince = null;
+            return;
+        }
+        // 'joining' = transitional — normally let realtime-js's own rejoin backoff converge
+        // instead of tearing the channel down mid-join (recreating on every non-joined state
+        // amputates that backoff). BUT bound it: on a half-open socket realtime-js can park
+        // the channel in 'joining' indefinitely without ever reconnecting the socket, so the
+        // recreate below would never fire and the device wedges offline silently. If 'joining'
+        // overstays JOINING_WEDGE_TIMEOUT_MS unbroken, force a recreate — the only path that
+        // disconnect()s the dead socket. (connState() in the log shows the half-open socket.)
+        if (state === 'joining') {
+            const now = Date.now();
+            if (this.joiningSince === null)
+                this.joiningSince = now;
+            const stuckMs = now - this.joiningSince;
+            if (stuckMs < JOINING_WEDGE_TIMEOUT_MS)
+                return;
+            console.debug(`[DEBUG] ⚠️ Channel stuck 'joining' ${Math.round(stuckMs / 1000)}s - forcing recreate — ${this.connState()}`);
+            captureRemote('remote_channel_joining_wedge', { stuckMs, attempt: this.reconnectAttempt });
+            this.joiningSince = null;
             this.recreateChannel();
+            return;
+        }
+        // Unhealthy: closed, errored, leaving — recreate
+        this.joiningSince = null;
+        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

@@ -1,3 +1,4 @@
+import path from 'path';
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, InitializeRequestSchema, LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, } from "@modelcontextprotocol/sdk/types.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
@@ -8,7 +9,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';
@@ -19,7 +21,7 @@ import { processDockerPrompt } from './utils/dockerPrompt.js';
 import { toolHistory } from './utils/toolHistory.js';
 import { handleWelcomePageOnboarding } from './utils/welcome-onboarding.js';
 import { VERSION } from './version.js';
-import { capture, capture_call_tool } from "./utils/capture.js";
+import { capture, capture_call_tool, runInUiOriginCallContext } from "./utils/capture.js";
 import { logToStderr, logger } from './utils/logger.js';
 import { buildUiToolMeta, CONFIG_EDITOR_RESOURCE_URI, FILE_PREVIEW_RESOURCE_URI, } from './ui/contracts.js';
 import { listUiResources, readUiResource } from './ui/resources.js';
@@ -86,6 +88,28 @@ 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;
+}
+/**
+ * True when this server instance is serving remote services rather than a
+ * local MCP client. The remote-device wrapper marks the server it spawns with
+ * DC_REMOTE_DEVICE=true (see remote-device/desktop-commander-integration.ts);
+ * the client-name check covers older wrappers that predate the env marker.
+ */
+function isRemoteClientContext(clientName) {
+    return process.env.DC_REMOTE_DEVICE === 'true' || clientName === 'desktop-commander-client';
+}
 /**
  * Unified way to update client information
  */
@@ -114,13 +138,33 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
         const clientInfo = request.params?.clientInfo;
         if (clientInfo) {
             await updateCurrentClient(clientInfo);
-            // Welcome page for new claude-ai users (A/B test controlled)
-            // Also matches 'local-agent-mode-*' which is how Claude.ai connectors report themselves
-            if ((currentClient.name === 'claude-ai' || currentClient.name?.startsWith('local-agent-mode')) && !global.disableOnboarding) {
-                await handleWelcomePageOnboarding();
+            // Welcome page for new users (A/B test controlled) — all clients except
+            // the Desktop Commander app and remote contexts, where the server is
+            // spawned by the remote-device wrapper and a locally opened browser
+            // would never reach the remote user.
+            if (currentClient.name !== 'desktop-commander-app'
+                && currentClient.name !== 'desktop-commander'
+                && !isRemoteClientContext(currentClient.name)
+                && !global.disableOnboarding) {
+                await handleWelcomePageOnboarding(currentClient.name);
             }
         }
-        capture('run_server_mcp_initialized');
+        // Raw host environment signals (no PII, undefined when absent). Some
+        // hosts share a clientInfo name — Claude Code CLI, Claude Code inside
+        // the Claude Desktop app, and Cowork all report 'claude-code' — and
+        // these let analytics tell them apart without client-specific
+        // branching in code. Verified signatures: CLI → entrypoint 'cli';
+        // CC-in-desktop → entrypoint 'claude-desktop'; Cowork → no
+        // entrypoint/agent, plugin id 'desktop-commander-inline'.
+        // Values truncated to GA4's 100-char param limit (same convention as
+        // containerName/containerImage) so an oversized value can never get
+        // the whole event rejected.
+        capture('run_server_mcp_initialized', {
+            host_entrypoint: process.env.CLAUDE_CODE_ENTRYPOINT?.substring(0, 100),
+            host_agent: process.env.AI_AGENT?.substring(0, 100),
+            host_plugin_id: process.env.CLAUDE_PLUGIN_DATA
+                ? path.basename(process.env.CLAUDE_PLUGIN_DATA).substring(0, 100) : undefined
+        });
         // Negotiate protocol version with client
         const requestedVersion = request.params?.protocolVersion;
         const protocolVersion = (requestedVersion && SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion))
@@ -147,7 +191,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
@@ -1106,6 +1150,20 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 });
 import * as handlers from './handlers/index.js';
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const args = request.params.arguments;
+    // Calls fired programmatically by the widget UIs (file preview, config
+    // editor) carry origin:'ui'. They are real tool executions but not agent
+    // actions, so they must produce zero telemetry: running them inside the
+    // UI-origin capture context makes capture() drop every event they raise
+    // (server_call_tool, server_read_file, server_edit_block, ...). Deliberate
+    // UI interactions are tracked separately via mcp_ui_event.
+    const isUiOriginCall = !!(args && typeof args === 'object' && args.origin === 'ui');
+    if (isUiOriginCall) {
+        return runInUiOriginCallContext(() => handleCallToolRequest(request));
+    }
+    return handleCallToolRequest(request);
+});
+async function handleCallToolRequest(request) {
     const { name, arguments: args } = request.params;
     const startTime = Date.now();
     // Hoisted above the try so the finally block can read them when emitting the
@@ -1121,22 +1179,30 @@ 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';
         }
         if (name === 'get_prompts' && args && typeof args === 'object') {
             const promptArgs = args;
@@ -1435,6 +1501,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) {
@@ -1454,12 +1539,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         // Single tool-call telemetry event, fired AFTER execution so it can carry
         // timing. In a finally so it still fires on the hard-crash path (the catch
         // above). Only missed if a tool never returns or throws (a true hang).
-        capture_call_tool('server_call_tool', {
-            ...telemetryData,
-            duration_ms: Date.now() - startTime,
-            is_error: String(isError),
-        });
+        // Not emitted for track_ui_event (it is just the transport for
+        // mcp_ui_event) — and UI-origin calls are dropped wholesale by the
+        // capture layer, so server_call_tool reflects only genuine
+        // agent-driven tool calls.
+        if (name !== 'track_ui_event') {
+            capture_call_tool('server_call_tool', {
+                ...telemetryData,
+                duration_ms: Date.now() - startTime,
+                is_error: String(isError),
+            });
+        }
     }
-});
+}
 // Add no-op handlers so Visual Studio initialization succeeds
 server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({ resourceTemplates: [] }));

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