@wonderwhy-er/desktop-commander 0.2.41 → 0.2.43

package/dist/utils/mcp-ui-ab-test.d.ts

@@ -0,0 +1,13 @@
+export declare const MCP_UI_EXPERIMENT_NAME = "McpUiPreviews";
+export declare const MCP_UI_SHOW_VARIANT = "showMCPUi";
+export declare const MCP_UI_HIDE_VARIANT = "notShowMCPUi";
+export interface McpUiPreviewDecisionDeps {
+    getExistingAssignment: () => Promise<unknown>;
+    isFirstRun: () => boolean;
+    wasLoadedFromCache: () => boolean;
+    waitForFreshFlags: () => Promise<void>;
+    getABTestVariant: (experimentName: string) => Promise<string | null>;
+    capture: (event: string, properties?: Record<string, unknown>) => Promise<unknown> | unknown;
+}
+export declare function resolveMcpUiPreviewDecision(deps: McpUiPreviewDecisionDeps): Promise<boolean>;
+export declare function shouldShowMcpUiPreviews(): Promise<boolean>;

package/dist/utils/mcp-ui-ab-test.js

@@ -0,0 +1,62 @@
+import { configManager } from '../config-manager.js';
+import { getABTestVariant } from './ab-test.js';
+import { capture } from './capture.js';
+import { featureFlagManager } from './feature-flags.js';
+export const MCP_UI_EXPERIMENT_NAME = 'McpUiPreviews';
+export const MCP_UI_SHOW_VARIANT = 'showMCPUi';
+export const MCP_UI_HIDE_VARIANT = 'notShowMCPUi';
+function variantEnablesMcpUi(variant) {
+    if (variant === MCP_UI_HIDE_VARIANT)
+        return false;
+    if (variant === MCP_UI_SHOW_VARIANT)
+        return true;
+    return null;
+}
+export async function resolveMcpUiPreviewDecision(deps) {
+    try {
+        const existingAssignment = await deps.getExistingAssignment();
+        const existingDecision = variantEnablesMcpUi(existingAssignment);
+        if (existingDecision !== null) {
+            if (!deps.wasLoadedFromCache()) {
+                await deps.waitForFreshFlags();
+            }
+            const currentVariant = await deps.getABTestVariant(MCP_UI_EXPERIMENT_NAME);
+            return variantEnablesMcpUi(currentVariant) ?? existingDecision;
+        }
+        if (!deps.isFirstRun()) {
+            return true;
+        }
+        if (!deps.wasLoadedFromCache()) {
+            await deps.waitForFreshFlags();
+        }
+        const variant = await deps.getABTestVariant(MCP_UI_EXPERIMENT_NAME);
+        const decision = variantEnablesMcpUi(variant);
+        if (decision === null) {
+            return true;
+        }
+        try {
+            await deps.capture('server_mcp_ui_ab_decision', {
+                experiment: MCP_UI_EXPERIMENT_NAME,
+                variant,
+                mcp_ui_enabled: decision,
+            });
+        }
+        catch {
+            // Telemetry must not change the assigned product experience.
+        }
+        return decision;
+    }
+    catch {
+        return true;
+    }
+}
+export async function shouldShowMcpUiPreviews() {
+    return resolveMcpUiPreviewDecision({
+        getExistingAssignment: () => configManager.getValue(`abTest_${MCP_UI_EXPERIMENT_NAME}`),
+        isFirstRun: () => configManager.isFirstRun(),
+        wasLoadedFromCache: () => featureFlagManager.wasLoadedFromCache(),
+        waitForFreshFlags: () => featureFlagManager.waitForFreshFlags(),
+        getABTestVariant,
+        capture,
+    });
+}

package/dist/utils/unsupportedParams.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Utility for detecting parameters a caller sent that a tool's Zod schema does
+ * not accept.
+ *
+ * Zod's default `z.object()` silently strips unknown keys, so a model that
+ * invents a parameter (e.g. `view_range`) gets a normal-looking response with no
+ * signal that its input was ignored. These helpers let the dispatcher surface a
+ * corrective warning instead.
+ *
+ * Detection is top-level only. That is sufficient here because none of the tool
+ * arg schemas use a top-level `.passthrough()`/catchall — free-form fields
+ * (`options`, `params`, `pdfOptions`) are named keys whose contents are
+ * intentionally unvalidated.
+ */
+/** List the parameter names a tool schema accepts (empty array if it takes none). */
+export declare function getSupportedParams(schema: unknown): string[];
+/**
+ * Return the names of top-level keys in `args` that the schema does not accept.
+ * Returns [] when args is not a plain object or the schema's params can't be
+ * determined (so we never warn on something we can't reason about).
+ */
+export declare function detectUnsupportedParams(args: unknown, schema: unknown): string[];
+/** Build the corrective warning string shown to the model. */
+export declare function buildUnsupportedParamsWarning(toolName: string, unsupported: string[], supported: string[]): string;

package/dist/utils/unsupportedParams.js

@@ -0,0 +1,66 @@
+/**
+ * Utility for detecting parameters a caller sent that a tool's Zod schema does
+ * not accept.
+ *
+ * Zod's default `z.object()` silently strips unknown keys, so a model that
+ * invents a parameter (e.g. `view_range`) gets a normal-looking response with no
+ * signal that its input was ignored. These helpers let the dispatcher surface a
+ * corrective warning instead.
+ *
+ * Detection is top-level only. That is sufficient here because none of the tool
+ * arg schemas use a top-level `.passthrough()`/catchall — free-form fields
+ * (`options`, `params`, `pdfOptions`) are named keys whose contents are
+ * intentionally unvalidated.
+ */
+/**
+ * Resolve a Zod schema down to the field map of its underlying object schema,
+ * unwrapping wrappers (effects/optional/default/nullable/branded) defensively.
+ * Returns null when the schema is not (and does not wrap) a plain object schema,
+ * in which case we cannot determine the supported parameters and must not warn.
+ */
+function getObjectShape(schema) {
+    let current = schema;
+    for (let i = 0; current && current._def && i < 10; i++) {
+        const typeName = current._def.typeName;
+        if (typeName === 'ZodObject') {
+            const shape = typeof current.shape === 'function' ? current.shape() : current.shape;
+            return shape ?? null;
+        }
+        if (typeName === 'ZodEffects')
+            current = current._def.schema;
+        else if (typeName === 'ZodOptional' || typeName === 'ZodNullable' || typeName === 'ZodDefault') {
+            current = typeof current._def.innerType === 'function' ? current._def.innerType() : current._def.innerType;
+        }
+        else if (typeName === 'ZodBranded')
+            current = current._def.type;
+        else
+            return null;
+    }
+    return null;
+}
+/** List the parameter names a tool schema accepts (empty array if it takes none). */
+export function getSupportedParams(schema) {
+    const shape = getObjectShape(schema);
+    return shape ? Object.keys(shape) : [];
+}
+/**
+ * Return the names of top-level keys in `args` that the schema does not accept.
+ * Returns [] when args is not a plain object or the schema's params can't be
+ * determined (so we never warn on something we can't reason about).
+ */
+export function detectUnsupportedParams(args, schema) {
+    if (!args || typeof args !== 'object' || Array.isArray(args))
+        return [];
+    const shape = getObjectShape(schema);
+    if (shape === null)
+        return [];
+    const supported = new Set(Object.keys(shape));
+    return Object.keys(args).filter((k) => !supported.has(k));
+}
+/** Build the corrective warning string shown to the model. */
+export function buildUnsupportedParamsWarning(toolName, unsupported, supported) {
+    const ignored = unsupported.join(', ');
+    const supportedList = supported.length > 0 ? supported.join(', ') : '(none)';
+    return `You sent parameters not supported by this tool, which were ignored: ${ignored}. `
+        + `Supported parameters for ${toolName}: ${supportedList}.`;
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.41";
+export declare const VERSION = "0.2.43";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.41';
+export const VERSION = '0.2.43';

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.41",
+  "version": "0.2.43",
   "description": "MCP server for terminal operations and file editing",
   "mcpName": "io.github.wonderwhy-er/desktop-commander",
   "license": "MIT",
   "author": "Eduards Ruzga",
   "homepage": "https://github.com/wonderwhy-er/DesktopCommanderMCP",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wonderwhy-er/DesktopCommanderMCP.git"
+  },
   "bugs": "https://github.com/wonderwhy-er/DesktopCommanderMCP/issues",
   "type": "module",
   "engines": {
@@ -41,6 +45,7 @@
     "prepare": "npm run build",
     "clean": "shx rm -rf dist",
     "test": "npm run build && node test/run-all-tests.js",
+    "test:integration": "npm run build && node test/integration/run-all-integration-tests.js",
     "test:debug": "node --inspect test/run-all-tests.js",
     "validate:tools": "npm run build && node scripts/validate-tools-sync.js",
     "link:local": "npm run build && npm link",