@wonderwhy-er/desktop-commander 0.2.43 → 0.2.44

package/dist/bootstrap.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bootstrap.js

@@ -0,0 +1,22 @@
+/**
+ * Threadpool bootstrap. MUST be the first import in index.ts.
+ *
+ * Every fs operation (read_file, write_file, edit_block, config/history/log
+ * persistence) runs on libuv's threadpool, which defaults to only 4 threads.
+ * Under heavy parallel load — e.g. several agents reading/writing files on a
+ * slow or cloud-synced filesystem — 4 stalled operations exhaust the pool, and
+ * because a stalled syscall keeps its thread until the OS returns (a JS-level
+ * timeout does not cancel it), every subsequent fs op queues for minutes. That
+ * surfaced as multi-minute tool-call hangs under parallel `claude -p` load.
+ *
+ * Raising the pool size gives enough headroom that a burst of slow reads no
+ * longer starves the rest. libuv reads UV_THREADPOOL_SIZE only when the pool is
+ * first initialized (on first submitted work), so this assignment has to happen
+ * before ANY threadpool work — hence "first import". A user-provided value is
+ * always respected.
+ */
+const DEFAULT_THREADPOOL_SIZE = 16;
+if (!process.env.UV_THREADPOOL_SIZE) {
+    process.env.UV_THREADPOOL_SIZE = String(DEFAULT_THREADPOOL_SIZE);
+}
+export {};

package/dist/config-manager.d.ts

@@ -23,6 +23,8 @@ declare class ConfigManager {
     private config;
     private initialized;
     private _isFirstRun;
+    private writeChain;
+    private saveScheduled;
     constructor();
     /**
      * Initialize configuration - load from disk or create default
@@ -37,9 +39,26 @@ declare class ConfigManager {
      */
     private getDefaultConfig;
     /**
-     * Save config to disk
+     * Write the current in-memory config to disk. All writes funnel through
+     * writeChain (see saveConfig / scheduleSave) so overlapping saves can never
+     * interleave and corrupt the file. Previously every tool call could fire its
+     * own independent fs.writeFile of the same path.
+     */
+    private writeConfigToDisk;
+    /**
+     * Awaitable save, serialized on writeChain. Use for explicit, user-driven
+     * config changes where the caller wants on-disk confirmation.
      */
     private saveConfig;
+    /**
+     * Non-blocking, coalesced save. Returns immediately; the write runs in the
+     * background. A burst of calls collapses to at most one queued write behind
+     * the in-flight one, so a storm of tool calls can't storm the disk — and,
+     * critically, can't pile up behind a saturated libuv threadpool and gate the
+     * tool-call response path. Used for high-frequency, non-critical persistence
+     * such as usage stats.
+     */
+    scheduleSave(): void;
     /**
      * Get the entire config
      */
@@ -52,6 +71,16 @@ declare class ConfigManager {
      * Set a specific configuration value
      */
     setValue(key: string, value: any): Promise<void>;
+    /**
+     * Update a value in memory and persist it WITHOUT blocking the caller.
+     * The tool-call response path must never wait on a disk write: when the libuv
+     * threadpool is saturated (e.g. many parallel reads stalled on a slow/cloud
+     * filesystem) an awaited write can't get a thread and would hang the response
+     * of even pure-memory tools. The in-memory value is updated synchronously so
+     * subsequent reads see it immediately; the write is coalesced in the
+     * background. Callers needing on-disk confirmation should use setValue.
+     */
+    setValueNonBlocking(key: string, value: any): Promise<void>;
     /**
      * Update multiple configuration values at once
      */

package/dist/config-manager.js

@@ -29,6 +29,10 @@ class ConfigManager {
         this.config = {};
         this.initialized = false;
         this._isFirstRun = false; // Track if this is the first run (config was just created)
+        // Serializes all disk writes so concurrent saves can't corrupt config.json.
+        this.writeChain = Promise.resolve();
+        // True while a coalesced background write is already queued (see scheduleSave).
+        this.saveScheduled = false;
         // Get user's home directory
         // Define config directory and file paths
         this.configPath = CONFIG_FILE;
@@ -140,16 +144,45 @@ class ConfigManager {
         };
     }
     /**
-     * Save config to disk
+     * Write the current in-memory config to disk. All writes funnel through
+     * writeChain (see saveConfig / scheduleSave) so overlapping saves can never
+     * interleave and corrupt the file. Previously every tool call could fire its
+     * own independent fs.writeFile of the same path.
+     */
+    async writeConfigToDisk() {
+        await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2), 'utf8');
+    }
+    /**
+     * Awaitable save, serialized on writeChain. Use for explicit, user-driven
+     * config changes where the caller wants on-disk confirmation.
      */
     async saveConfig() {
-        try {
-            await fs.writeFile(this.configPath, JSON.stringify(this.config, null, 2), 'utf8');
-        }
-        catch (error) {
-            console.error('Failed to save config:', error);
-            throw error;
-        }
+        const write = this.writeChain.then(() => this.writeConfigToDisk());
+        // Keep the chain alive even if this write rejects, so later writes still run.
+        this.writeChain = write.catch(() => { });
+        return write;
+    }
+    /**
+     * Non-blocking, coalesced save. Returns immediately; the write runs in the
+     * background. A burst of calls collapses to at most one queued write behind
+     * the in-flight one, so a storm of tool calls can't storm the disk — and,
+     * critically, can't pile up behind a saturated libuv threadpool and gate the
+     * tool-call response path. Used for high-frequency, non-critical persistence
+     * such as usage stats.
+     */
+    scheduleSave() {
+        if (this.saveScheduled)
+            return; // a queued write will capture the latest config
+        this.saveScheduled = true;
+        this.writeChain = this.writeChain.then(async () => {
+            this.saveScheduled = false; // let the next burst queue a fresh write
+            try {
+                await this.writeConfigToDisk();
+            }
+            catch (error) {
+                console.error('Failed to save config (background):', error);
+            }
+        });
     }
     /**
      * Get the entire config
@@ -194,6 +227,20 @@ class ConfigManager {
         this.config[key] = value;
         await this.saveConfig();
     }
+    /**
+     * Update a value in memory and persist it WITHOUT blocking the caller.
+     * The tool-call response path must never wait on a disk write: when the libuv
+     * threadpool is saturated (e.g. many parallel reads stalled on a slow/cloud
+     * filesystem) an awaited write can't get a thread and would hang the response
+     * of even pure-memory tools. The in-memory value is updated synchronously so
+     * subsequent reads see it immediately; the write is coalesced in the
+     * background. Callers needing on-disk confirmation should use setValue.
+     */
+    async setValueNonBlocking(key, value) {
+        await this.init();
+        this.config[key] = value;
+        this.scheduleSave();
+    }
     /**
      * Update multiple configuration values at once
      */

package/dist/handlers/filesystem-handlers.js

@@ -41,7 +41,12 @@ function getErrorFromPath(path) {
  * Handle read_file command
  */
 export async function handleReadFile(args) {
-    const HANDLER_TIMEOUT = 60000; // 60 seconds total operation timeout
+    // Backstop for the whole handler operation. The real control is the
+    // 3-minute cancellable read timeout inside readFileFromDisk; this sits just
+    // above it (so that one fires first, with cleanup + a useful error) but
+    // still below the MCP client's ~4-minute hard cap, so we never leave the
+    // client hanging on an opaque timeout.
+    const HANDLER_TIMEOUT = 3.5 * 60 * 1000; // 3m30s
     // Add input validation
     if (args === null || args === undefined) {
         return createErrorResponse('No arguments provided for read_file command');
@@ -95,28 +100,47 @@ export async function handleReadFile(args) {
                     },
                     ...pdfContent
                 ],
-                structuredContent: {
-                    fileName: path.basename(resolvedFilePath),
-                    filePath: resolvedFilePath,
-                    fileType: 'unsupported',
-                    sourceTool: 'read_file',
-                    ...await getDefaultEditorMetadata(resolvedFilePath),
-                    content: pdfContent
-                        .filter((item) => item.type === "text")
-                        .map((item) => item.text)
-                        .join("\n"),
-                },
+                ...(parsed.origin === 'ui' ? {
+                    structuredContent: {
+                        fileName: path.basename(resolvedFilePath),
+                        filePath: resolvedFilePath,
+                        fileType: 'unsupported',
+                        ...await getDefaultEditorMetadata(resolvedFilePath),
+                    },
+                } : {}),
             };
         }
         // Handle image files
         if (fileResult.metadata?.isImage) {
             // Return the image bytes in the MCP content array so the host model can
-            // actually see the image. structuredContent additionally carries the bytes
-            // for the preview widget to render.
+            // actually see the image. The preview widget gets its copy from its own
+            // origin:'ui' read — structuredContent stays metadata-only.
             const imageData = typeof fileResult.content === 'string'
                 ? fileResult.content
                 : fileResult.content.toString('base64');
             const imageSummary = `Image file: ${parsed.path} (${fileResult.mimeType})\n`;
+            const imageStructuredContent = {
+                fileName: path.basename(resolvedFilePath),
+                filePath: resolvedFilePath,
+                fileType: 'image',
+                ...await getDefaultEditorMetadata(resolvedFilePath),
+                mimeType: fileResult.mimeType,
+            };
+            // Widget pull (origin: 'ui'): return the base64 in a TEXT block, never
+            // an image block. An image content block makes the host inline-vision-
+            // render the result, which preempts delivery of this RPC response to
+            // the widget — leaving the preview stuck on "Preparing preview…" for
+            // exactly the host-rendered types (png/jpeg/gif/webp). Text-only lets
+            // the RPC response through so the widget can draw the <img>.
+            if (parsed.origin === 'ui') {
+                return {
+                    content: [{ type: "text", text: imageData }],
+                    structuredContent: imageStructuredContent,
+                };
+            }
+            // Model-facing read: keep the image block so the host/model sees it.
+            // No structuredContent — the widget renders from its own origin:'ui'
+            // read, and nothing else consumes it.
             return {
                 content: [
                     {
@@ -129,37 +153,32 @@ export async function handleReadFile(args) {
                         mimeType: fileResult.mimeType
                     }
                 ],
-                structuredContent: {
-                    fileName: path.basename(resolvedFilePath),
-                    filePath: resolvedFilePath,
-                    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,
-                    mimeType: fileResult.mimeType
-                }
             };
         }
         else {
             // For all other files, return as text.
             // structuredContent carries only file metadata (no content duplication);
-            // the widget reads text from the MCP content array.
-            const textContent = typeof fileResult.content === 'string'
+            // the widget reads text from the MCP content array (over the RPC read).
+            let textContent = typeof fileResult.content === 'string'
                 ? fileResult.content
                 : fileResult.content.toString('utf8');
             const fileType = fileResult.metadata?.isDirectory ? 'directory' : resolvePreviewFileType(resolvedFilePath);
+            // The directory fallback prefixes a "use list_directory instead" hint
+            // for the LLM. The widget's own read (a list_directory preview pulls
+            // read_file on the dir path) would render that hint as a notice — strip it.
+            if (parsed.origin === 'ui' && fileType === 'directory') {
+                textContent = textContent.replace(/^This is a directory, not a file\.[^\n]*\n+/, '');
+            }
             return {
                 content: [{ type: "text", text: textContent }],
-                structuredContent: {
-                    fileName: path.basename(resolvedFilePath),
-                    filePath: resolvedFilePath,
-                    fileType,
-                    sourceTool: 'read_file',
-                    ...await getDefaultEditorMetadata(resolvedFilePath),
-                    content: textContent,
-                },
+                ...(parsed.origin === 'ui' ? {
+                    structuredContent: {
+                        fileName: path.basename(resolvedFilePath),
+                        filePath: resolvedFilePath,
+                        fileType,
+                        ...await getDefaultEditorMetadata(resolvedFilePath),
+                    },
+                } : {}),
             };
         }
     };
@@ -238,7 +257,30 @@ export async function handleReadMultipleFiles(args) {
  */
 export async function handleWriteFile(args) {
     try {
+        const modeProvided = !!(args && typeof args === 'object' && 'mode' in args);
         const parsed = WriteFileArgsSchema.parse(args);
+        // An omitted `mode` falls back to 'rewrite', which silently destroys
+        // the target's existing content. The common failure is an LLM caller
+        // intending to append but dropping the optional param (issue #541), so
+        // require explicit intent when the target already has content;
+        // new/empty files keep the zero-friction default.
+        if (!modeProvided) {
+            let existing = null;
+            try {
+                existing = await getFileInfo(parsed.path);
+            }
+            catch {
+                // Missing file or invalid path — nothing to protect; the write
+                // itself will surface any real path error.
+            }
+            if (existing?.isFile && existing.size > 0) {
+                return createErrorResponse(`Write rejected to prevent accidental data loss: ${parsed.path} already exists ` +
+                    `with content (${existing.size} bytes), and no 'mode' was specified — the default ` +
+                    `mode 'rewrite' would REPLACE the entire file. Retry with an explicit mode: ` +
+                    `'append' to add your content to the end of the existing file, or 'rewrite' ` +
+                    `to replace all existing content.`);
+            }
+        }
         // Get the line limit from configuration
         const config = await configManager.getConfig();
         const MAX_LINES = config.fileWriteLineLimit ?? 50; // Default to 50 if not set
@@ -255,19 +297,13 @@ export async function handleWriteFile(args) {
         await writeFile(parsed.path, parsed.content, parsed.mode);
         // Provide more informative message based on mode
         const modeMessage = parsed.mode === 'append' ? 'appended to' : 'wrote to';
-        const resolvedWritePath = resolveAbsolutePath(parsed.path);
+        // No structuredContent: nothing in the UI calls write_file (the widget
+        // previews the write via its own read_file pull at tool-result time).
         return {
             content: [{
                     type: "text",
                     text: `Successfully ${modeMessage} ${parsed.path} (${lineCount} lines) ${errorMessage}`
                 }],
-            structuredContent: {
-                fileName: path.basename(resolvedWritePath),
-                filePath: resolvedWritePath,
-                fileType: resolvePreviewFileType(resolvedWritePath),
-                sourceTool: 'write_file',
-                ...await getDefaultEditorMetadata(resolvedWritePath),
-            },
         };
     }
     catch (error) {
@@ -304,16 +340,13 @@ export async function handleListDirectory(args) {
         const resolvedPath = resolveAbsolutePath(parsed.path);
         return {
             content: [{ type: "text", text: resultText }],
-            structuredContent: {
-                fileName: path.basename(resolvedPath),
-                filePath: resolvedPath,
-                fileType: 'directory',
-                sourceTool: 'list_directory',
-                // Carry the listing in structuredContent too. Chat reads the text
-                // content array, but structuredContent-only consumers (e.g. Cowork)
-                // render from here and would otherwise show an empty directory.
-                content: resultText,
-            },
+            ...(parsed.origin === 'ui' ? {
+                structuredContent: {
+                    fileName: path.basename(resolvedPath),
+                    filePath: resolvedPath,
+                    fileType: 'directory',
+                },
+            } : {}),
         };
     }
     catch (error) {

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import './bootstrap.js';

package/dist/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+// MUST be first: raises the libuv threadpool size before any fs work is
+// submitted. See src/bootstrap.ts for why import order matters.
+import './bootstrap.js';
 import { FilteredStdioServerTransport } from './custom-stdio.js';
 import { server, flushDeferredMessages } from './server.js';
 import { configManager } from './config-manager.js';

package/dist/remote-device/desktop-commander-integration.js

@@ -2,7 +2,7 @@ import { spawn } from 'child_process';
 import path from 'path';
 import fs from 'fs/promises';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { fileURLToPath } from 'url';
 import { captureRemote } from '../utils/capture.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -24,7 +24,13 @@ export class DesktopCommanderIntegration {
         console.debug('[DEBUG] MCP config:', JSON.stringify(config, null, 2));
         try {
             console.debug('[DEBUG] Creating StdioClientTransport');
-            this.mcpTransport = new StdioClientTransport(config);
+            // DC_REMOTE_DEVICE tells the spawned server it is serving remote
+            // services, so it suppresses local-only behavior like opening the
+            // welcome page in a browser the remote user would never see.
+            this.mcpTransport = new StdioClientTransport({
+                ...config,
+                env: { ...getDefaultEnvironment(), ...config.env, DC_REMOTE_DEVICE: 'true' }
+            });
             // Create MCP client
             console.debug('[DEBUG] Creating MCP Client');
             this.mcpClient = new Client({

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

@@ -22,6 +22,7 @@ export declare class RemoteChannel {
     private lastChannelState;
     private reconnectAttempt;
     private isRecreatingChannel;
+    private joiningSince;
     private _user;
     get user(): User | null;
     initialize(url: string, key: string): void;

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

@@ -4,6 +4,14 @@ 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;
@@ -20,6 +28,7 @@ export class RemoteChannel {
         // 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; }
@@ -232,12 +241,33 @@ export class RemoteChannel {
             console.debug(`[DEBUG] channel state: ${state} — ${this.connState()}`);
             this.lastChannelState = state;
         }
-        // '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')
+        // '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();

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";
@@ -20,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';
@@ -100,6 +101,15 @@ let currentRemoteClient = null;
 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
  */
@@ -128,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))
@@ -1120,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
@@ -1159,16 +1203,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         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;
@@ -1505,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/tools/edit.d.ts

@@ -19,7 +19,7 @@ interface SearchReplace {
     search: string;
     replace: string;
 }
-export declare function performSearchReplace(filePath: string, block: SearchReplace, expectedReplacements?: number): Promise<ServerResult>;
+export declare function performSearchReplace(filePath: string, block: SearchReplace, expectedReplacements?: number, origin?: 'ui' | 'llm'): Promise<ServerResult>;
 /**
  * Handle edit_block command
  *