@duckmind/dm-windows-x64 0.63.4 → 0.63.9

package/extensions/dm-mcp-adapter/mcp-probe.js

@@ -0,0 +1,151 @@
+const PROBE_TIMEOUT_MS = 5000;
+const MODERN_PROTOCOL_VERSION = "2026-07-28";
+const LEGACY_PROTOCOL_VERSION = "2025-06-18";
+const JSON_ACCEPT = "application/json, text/event-stream";
+const SSE_ACCEPT = "text/event-stream";
+const MODERN_FALLBACK_STATUSES = new Set([400, 401, 404, 405, 406, 415]);
+const POST_ENDPOINT_MISMATCH_STATUSES = new Set([404, 405, 406, 415]);
+const AMBIGUOUS_STATUSES = new Set([202, 401, 503]);
+const DISCOVER_REQUEST = {
+  jsonrpc: "2.0",
+  id: 1,
+  method: "server/discover",
+  params: {}
+};
+const INITIALIZE_REQUEST = {
+  jsonrpc: "2.0",
+  id: 1,
+  method: "initialize",
+  params: {
+    protocolVersion: LEGACY_PROTOCOL_VERSION,
+    capabilities: {},
+    clientInfo: { name: "pi-mcp-probe", version: "2.1.2" }
+  }
+};
+const MODERN_STRATEGY = {
+  kind: "modern",
+  request: {
+    method: "POST",
+    headers: {
+      Accept: JSON_ACCEPT,
+      "Content-Type": "application/json",
+      "MCP-Protocol-Version": MODERN_PROTOCOL_VERSION,
+      "Mcp-Method": "server/discover"
+    },
+    body: JSON.stringify(DISCOVER_REQUEST)
+  },
+  allowJson: true
+};
+const LEGACY_POST_STRATEGY = {
+  kind: "legacy-post",
+  request: {
+    method: "POST",
+    headers: {
+      Accept: JSON_ACCEPT,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(INITIALIZE_REQUEST)
+  },
+  allowJson: true
+};
+const LEGACY_SSE_STRATEGY = {
+  kind: "legacy-sse",
+  request: { headers: { Accept: SSE_ACCEPT } },
+  allowJson: false
+};
+function jsonRpcEnvelopeInfo(value) {
+  if (typeof value !== "object" || value === null || value.jsonrpc !== "2.0") {
+    return null;
+  }
+  if ("result" in value) {
+    const result = value.result;
+    return {
+      kind: "result",
+      protocolVersion: typeof result === "object" && result !== null ? result.protocolVersion : undefined
+    };
+  }
+  if ("error" in value)
+    return { kind: "error" };
+  return null;
+}
+function isBearerChallenge(response) {
+  return /(?:^|,)\s*Bearer\b/i.test(response.headers.get("www-authenticate") ?? "");
+}
+function responseKind(response) {
+  const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+  if (contentType === "text/html")
+    return "HTML";
+  if (contentType)
+    return contentType;
+  return "an untyped response";
+}
+async function getJsonRpcEnvelopeInfo(response) {
+  try {
+    return jsonRpcEnvelopeInfo(JSON.parse(await response.text()));
+  } catch {
+    return null;
+  }
+}
+async function classifyResponse(response, strategy) {
+  const isSse = response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream");
+  if (response.ok && isSse) {
+    return { kind: "mcp", result: { isMcp: true, classification: "endpoint responded with an MCP event stream" } };
+  }
+  const envelope = strategy.allowJson || response.status === 401 ? await getJsonRpcEnvelopeInfo(response) : null;
+  if (response.ok && strategy.allowJson && envelope) {
+    if (strategy.kind === "modern" && (envelope.kind === "error" || envelope.protocolVersion !== MODERN_PROTOCOL_VERSION)) {
+      return { kind: "unsupported-modern" };
+    }
+    return {
+      kind: "mcp",
+      result: {
+        isMcp: true,
+        classification: strategy.kind === "modern" ? `endpoint supports stateless MCP ${MODERN_PROTOCOL_VERSION} server/discover` : "endpoint responded with a JSON-RPC 2.0 envelope"
+      }
+    };
+  }
+  if (response.status === 401 && isBearerChallenge(response) && envelope) {
+    return {
+      kind: "mcp",
+      result: {
+        isMcp: true,
+        classification: strategy.kind === "modern" ? `endpoint requires Bearer authentication during MCP ${MODERN_PROTOCOL_VERSION} server/discover probing` : "endpoint requires Bearer authentication and responded with a JSON-RPC 2.0 error"
+      }
+    };
+  }
+  return { kind: "unrecognized" };
+}
+async function probe(url, strategy) {
+  const response = await fetch(url, {
+    ...strategy.request,
+    signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+  });
+  return { response, outcome: await classifyResponse(response, strategy) };
+}
+function notMcp(response) {
+  const responseDescription = `endpoint returned ${responseKind(response)} (${response.status})`;
+  return {
+    isMcp: false,
+    classification: response.status === 503 ? `${responseDescription} — server is temporarily unavailable; MCP endpoint shape could not be determined` : response.status === 202 ? `${responseDescription} — MCP endpoint shape could not be determined` : response.status === 401 ? `${responseDescription} — authentication may be required; MCP endpoint shape could not be determined` : `${responseDescription} — this URL does not appear to speak MCP`
+  };
+}
+function ambiguousNotMcp(response) {
+  return AMBIGUOUS_STATUSES.has(response.status) ? notMcp(response) : undefined;
+}
+export async function probeMcpEndpoint(url) {
+  const { response: modernResponse, outcome: modernOutcome } = await probe(url, MODERN_STRATEGY);
+  if (modernOutcome.kind === "mcp")
+    return modernOutcome.result;
+  let ambiguousResult = ambiguousNotMcp(modernResponse);
+  if (modernOutcome.kind !== "unsupported-modern" && !MODERN_FALLBACK_STATUSES.has(modernResponse.status)) {
+    return ambiguousResult ?? notMcp(modernResponse);
+  }
+  const { response: postResponse, outcome: postOutcome } = await probe(url, LEGACY_POST_STRATEGY);
+  if (postOutcome.kind === "mcp")
+    return postOutcome.result;
+  ambiguousResult ??= ambiguousNotMcp(postResponse);
+  if (!POST_ENDPOINT_MISMATCH_STATUSES.has(postResponse.status))
+    return ambiguousNotMcp(postResponse) ?? ambiguousResult ?? notMcp(postResponse);
+  const { response: getResponse, outcome: getOutcome } = await probe(url, LEGACY_SSE_STRATEGY);
+  return getOutcome.kind === "mcp" ? getOutcome.result : ambiguousNotMcp(getResponse) ?? ambiguousResult ?? notMcp(getResponse);
+}

package/extensions/dm-mcp-adapter/mcp-references.js

@@ -0,0 +1,263 @@
+import { isUiToolVisibleToModel } from "./ui-tool-visibility.js";
+import { resourceNameToToolName } from "./resource-tools.js";
+import { createCachedToolSelectorCandidateIndex, isServerCacheValid, parseDirectToolSelectors } from "./metadata-cache.js";
+import {
+  formatToolName,
+  isServerDisabled,
+  isToolAllowed,
+  resolveToolPrefix
+} from "./types.js";
+const BUILTIN_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "mcp"]);
+const ENCODED_NAMESPACE_MARKER = "_mcpns_";
+function namespaceServerPart(serverName) {
+  const normalized = serverName.replace(/-/g, "_");
+  if (normalized === "" || /^[A-Za-z0-9_]+$/.test(normalized) && !normalized.startsWith(ENCODED_NAMESPACE_MARKER))
+    return normalized;
+  const codePoints = Array.from(normalized, (char) => char.codePointAt(0).toString(16)).join("_");
+  return `${ENCODED_NAMESPACE_MARKER}${codePoints}`;
+}
+export function namespaceProxyName(serverName) {
+  return `mcp__${namespaceServerPart(serverName)}`;
+}
+export function parseMcpReference(raw) {
+  if (!raw.startsWith("mcp:"))
+    return { raw };
+  const rest = raw.slice("mcp:".length).trim();
+  if (!rest)
+    return { raw };
+  const slash = rest.indexOf("/");
+  if (slash === -1)
+    return { raw, server: rest };
+  const server = rest.slice(0, slash).trim();
+  const tool = rest.slice(slash + 1).trim();
+  return {
+    raw,
+    ...server ? { server } : {},
+    ...tool ? { tool } : {}
+  };
+}
+function resolveDirectSelection(config, definition, serverName, envOverride) {
+  if (envOverride) {
+    if (envOverride.servers.has(serverName))
+      return true;
+    const selectedTools = envOverride.tools.get(serverName);
+    return selectedTools ? [...selectedTools] : false;
+  }
+  if (definition.directTools !== undefined)
+    return definition.directTools;
+  return config.settings?.directTools === true;
+}
+export function isMcpServerDirectlyRegistered(definition, settings, serverName, envOverride) {
+  if (envOverride)
+    return envOverride.servers.has(serverName);
+  if (definition?.directTools !== undefined) {
+    return definition.directTools === true || Array.isArray(definition.directTools) && definition.directTools.length > 0;
+  }
+  return settings?.directTools === true;
+}
+export function hasCallableCachedTargets(entry, definition) {
+  return entry.tools.length > 0 || definition.exposeResources !== false && (entry.resources?.length ?? 0) > 0;
+}
+function hasNamespaceProxy(config, cache, envOverride, collidingNamespaceNames, existingDirectNames, serverName) {
+  const definition = config.mcpServers[serverName];
+  if (!definition || isServerDisabled(definition))
+    return false;
+  if (isMcpServerDirectlyRegistered(definition, config.settings, serverName, envOverride))
+    return false;
+  const toolName = namespaceProxyName(serverName);
+  if (collidingNamespaceNames.has(toolName) || existingDirectNames.has(toolName))
+    return false;
+  const entry = resolveValidCache(definition, cache, serverName);
+  return !!entry && hasCallableCachedTargets(entry, definition);
+}
+function resolveValidCache(definition, cache, serverName) {
+  const entry = cache?.servers[serverName];
+  if (!definition || !entry || !isServerCacheValid(entry, definition))
+    return;
+  return entry;
+}
+function cachedServers(config, cache) {
+  const servers = [];
+  if (!cache)
+    return servers;
+  for (const [serverName, definition] of Object.entries(config.mcpServers)) {
+    if (isServerDisabled(definition))
+      continue;
+    const entry = resolveValidCache(definition, cache, serverName);
+    if (!entry)
+      continue;
+    servers.push({ serverName, definition, entry, prefix: resolveToolPrefix(definition, config.settings?.toolPrefix) });
+  }
+  return servers;
+}
+function namespaceCollisionNames(config, cache, envOverride, existingDirectNames) {
+  const names = new Map;
+  if (!cache)
+    return new Set;
+  for (const serverName of Object.keys(config.mcpServers)) {
+    if (!hasNamespaceProxy(config, cache, envOverride, new Set, existingDirectNames, serverName))
+      continue;
+    const toolName = namespaceProxyName(serverName);
+    names.set(toolName, (names.get(toolName) ?? 0) + 1);
+  }
+  return new Set([...names].filter(([, count]) => count > 1).map(([name]) => name));
+}
+function registeredDirectNames(config, cache, envOverride, selectorIndex) {
+  const owners = new Map;
+  for (const { serverName, definition, entry, prefix } of cachedServers(config, cache)) {
+    const selection = resolveDirectSelection(config, definition, serverName, envOverride);
+    for (const { name, originalName } of directNameEntries(entry, serverName, definition, prefix, selection, selectorIndex)) {
+      if (!owners.has(name))
+        owners.set(name, { serverName, originalName });
+    }
+  }
+  return owners;
+}
+function allCurrentCandidates(config, cache) {
+  if (!cache)
+    return;
+  return createCachedToolSelectorCandidateIndex(config.mcpServers, cache, config.settings?.toolPrefix ?? "server");
+}
+function directToolName(toolName, serverName, definition, prefix, selectorIndex) {
+  if (!isToolAllowed(toolName, serverName, prefix, definition.includeTools, definition.excludeTools, selectorIndex))
+    return;
+  return formatToolName(toolName, serverName, prefix);
+}
+function directNameEntries(entry, serverName, definition, prefix, selection, selectorIndex, onlyTool) {
+  if (!selection)
+    return [];
+  const names = [];
+  const addTool = (toolName) => {
+    if (selection !== true && !selection.includes(toolName))
+      return;
+    const name = directToolName(toolName, serverName, definition, prefix, selectorIndex);
+    if (!name)
+      return;
+    if (BUILTIN_NAMES.has(name))
+      return;
+    if (onlyTool !== undefined && toolName !== onlyTool && name !== onlyTool)
+      return;
+    names.push({ name, originalName: toolName });
+  };
+  for (const tool of entry.tools) {
+    if (!isUiToolVisibleToModel(tool.uiVisibility))
+      continue;
+    addTool(tool.name);
+  }
+  if (definition.exposeResources !== false) {
+    for (const resource of entry.resources ?? [])
+      addTool(`read_${resourceNameToToolName(resource.name)}`);
+  }
+  return names;
+}
+function ownedDirectToolNames(names, serverName, directNameOwners) {
+  return names.filter(({ name, originalName }) => {
+    const owner = directNameOwners.get(name);
+    return owner?.serverName === serverName && owner.originalName === originalName;
+  }).map(({ name }) => name);
+}
+function hasAllowedProxyTool(entry, serverName, definition, prefix, selectorIndex, toolName) {
+  if (toolName === undefined)
+    return true;
+  const matchesAllowedName = (baseName) => {
+    if (!isToolAllowed(baseName, serverName, prefix, definition.includeTools, definition.excludeTools, selectorIndex))
+      return false;
+    return toolName === formatToolName(baseName, serverName, prefix);
+  };
+  if (entry.tools.some((tool) => isUiToolVisibleToModel(tool.uiVisibility) && matchesAllowedName(tool.name)))
+    return true;
+  if (definition.exposeResources === false)
+    return false;
+  return (entry.resources ?? []).some((resource) => {
+    const baseName = `read_${resourceNameToToolName(resource.name)}`;
+    return matchesAllowedName(baseName);
+  });
+}
+function addName(names, seen, name) {
+  if (seen.has(name))
+    return;
+  seen.add(name);
+  names.push(name);
+}
+function resolveKnownServerReference(parsed, config, cache, envOverride, collidingNamespaceNames, existingDirectNames, directNameOwners, selectorIndex, names, seen, diagnostics) {
+  const serverName = parsed.server;
+  const definition = config.mcpServers[serverName];
+  if (!definition || isServerDisabled(definition)) {
+    diagnostics.push(`MCP reference "${parsed.raw}" refers to disabled or unknown server "${serverName}"`);
+    return;
+  }
+  const entry = resolveValidCache(definition, cache, serverName);
+  if (!entry) {
+    diagnostics.push(`MCP reference "${parsed.raw}" cannot be resolved: no valid cached metadata for server "${serverName}"`);
+    return;
+  }
+  const prefix = resolveToolPrefix(definition, config.settings?.toolPrefix);
+  const selection = resolveDirectSelection(config, definition, serverName, envOverride);
+  const directNames = ownedDirectToolNames(directNameEntries(entry, serverName, definition, prefix, selection, selectorIndex, parsed.tool), serverName, directNameOwners);
+  if (directNames.length > 0) {
+    for (const name of directNames)
+      addName(names, seen, name);
+    return;
+  }
+  if (hasNamespaceProxy(config, cache, envOverride, collidingNamespaceNames, existingDirectNames, serverName)) {
+    if (hasAllowedProxyTool(entry, serverName, definition, prefix, selectorIndex, parsed.tool)) {
+      addName(names, seen, namespaceProxyName(serverName));
+      return;
+    }
+    diagnostics.push(`MCP reference "${parsed.raw}" refers to unknown or hidden tool "${parsed.tool}" on server "${serverName}"`);
+    return;
+  }
+  diagnostics.push(`MCP reference "${parsed.raw}" resolves to no registered tool`);
+}
+function resolveBareToolReference(raw, toolName, config, cache, envOverride, collidingNamespaceNames, existingDirectNames, directNameOwners, selectorIndex, names, seen, diagnostics) {
+  let matched = false;
+  for (const { serverName, definition, entry, prefix } of cachedServers(config, cache)) {
+    const selection = resolveDirectSelection(config, definition, serverName, envOverride);
+    const directNames = ownedDirectToolNames(directNameEntries(entry, serverName, definition, prefix, selection, selectorIndex, toolName), serverName, directNameOwners);
+    for (const name of directNames) {
+      addName(names, seen, name);
+      matched = true;
+    }
+    if (hasNamespaceProxy(config, cache, envOverride, collidingNamespaceNames, existingDirectNames, serverName) && hasAllowedProxyTool(entry, serverName, definition, prefix, selectorIndex, toolName)) {
+      addName(names, seen, namespaceProxyName(serverName));
+      matched = true;
+    }
+  }
+  if (!matched)
+    diagnostics.push(`MCP reference "${raw}" does not match a configured server or cached tool`);
+}
+export function resolveMcpToolReferences(refs, config, cache, envOverride) {
+  const names = [];
+  const diagnostics = [];
+  const seen = new Set;
+  if (!config) {
+    return {
+      names: refs.filter((ref) => !ref.startsWith("mcp:")),
+      diagnostics: refs.filter((ref) => ref.startsWith("mcp:")).map((ref) => `MCP reference "${ref}" cannot be resolved: no MCP config`)
+    };
+  }
+  const parsedOverride = envOverride ? parseDirectToolSelectors(envOverride) : null;
+  const selectorIndex = allCurrentCandidates(config, cache);
+  const directNameOwners = registeredDirectNames(config, cache, parsedOverride, selectorIndex);
+  const directNames = new Set(directNameOwners.keys());
+  const collidingNamespaceNames = namespaceCollisionNames(config, cache, parsedOverride, directNames);
+  for (const ref of refs) {
+    if (!ref.startsWith("mcp:")) {
+      addName(names, seen, ref);
+      continue;
+    }
+    const parsed = parseMcpReference(ref);
+    if (!parsed.server) {
+      diagnostics.push(`MCP reference "${ref}" is empty after the "mcp:" prefix`);
+      continue;
+    }
+    if (config.mcpServers[parsed.server]) {
+      resolveKnownServerReference(parsed, config, cache, parsedOverride, collidingNamespaceNames, directNames, directNameOwners, selectorIndex, names, seen, diagnostics);
+    } else if (parsed.tool === undefined) {
+      resolveBareToolReference(ref, parsed.server, config, cache, parsedOverride, collidingNamespaceNames, directNames, directNameOwners, selectorIndex, names, seen, diagnostics);
+    } else {
+      diagnostics.push(`MCP reference "${ref}" refers to unknown server "${parsed.server}"`);
+    }
+  }
+  return { names, diagnostics };
+}

package/extensions/dm-mcp-adapter/mcp-script-worker.mjs

@@ -0,0 +1,126 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { formatWithOptions } from "node:util";
+import vm from "node:vm";
+const TOOLS_ENUMERATION_ERROR = "tools is not enumerable — use tools.search({ query })";
+const RESERVED_TOOL_PROPS = new Set(["then", "catch", "finally", "toJSON", "toString", "valueOf"]);
+function needsInspectableFormatting(value, stack = new WeakSet) {
+  if (value === undefined || typeof value === "bigint" || typeof value === "function" || typeof value === "symbol")
+    return true;
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (stack.has(value))
+    return true;
+  if (value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet)
+    return true;
+  stack.add(value);
+  try {
+    return Object.values(value).some((entry) => needsInspectableFormatting(entry, stack));
+  } finally {
+    stack.delete(value);
+  }
+}
+function formatValue(value) {
+  if (typeof value === "string")
+    return value;
+  try {
+    if (!needsInspectableFormatting(value)) {
+      const json = JSON.stringify(value, null, 2);
+      if (json !== undefined)
+        return json;
+    }
+    return formatWithOptions({ colors: false, depth: 6 }, value);
+  } catch {
+    return "[unserializable value]";
+  }
+}
+function toContentBlock(value) {
+  if (typeof value === "object" && value !== null) {
+    if (value.type === "text" && typeof value.text === "string") {
+      return { type: "text", text: value.text };
+    }
+    if (value.type === "image" && typeof value.data === "string" && typeof value.mimeType === "string") {
+      return { type: "image", data: value.data, mimeType: value.mimeType };
+    }
+  }
+  return { type: "text", text: formatValue(value) };
+}
+let nextRequestId = 0;
+const pending = new Map;
+parentPort.on("message", (message) => {
+  if (message?.type !== "result" || typeof message.id !== "number")
+    return;
+  const resolve = pending.get(message.id);
+  if (!resolve)
+    return;
+  pending.delete(message.id);
+  resolve(message.envelope);
+});
+function request(type, payload) {
+  return new Promise((resolve) => {
+    const id = ++nextRequestId;
+    pending.set(id, resolve);
+    parentPort.postMessage({ type, id, ...payload });
+  });
+}
+const tools = new Proxy(Object.create(null), {
+  get(_target, property) {
+    if (property === "search") {
+      return async (input) => request("search", { input });
+    }
+    if (property === "call") {
+      return async (path, args) => {
+        if (typeof path !== "string" || path.trim() === "") {
+          return {
+            ok: false,
+            error: {
+              code: "invalid_tool_path",
+              message: "tools.call(path, args) requires a non-empty tool path."
+            }
+          };
+        }
+        return request("call", { path, args });
+      };
+    }
+    if (property === "describe") {
+      return async (input) => request("describe", { input });
+    }
+    if (typeof property !== "string" || RESERVED_TOOL_PROPS.has(property))
+      return;
+    return (args) => request("call", { path: property, args });
+  },
+  ownKeys() {
+    throw new Error(TOOLS_ENUMERATION_ERROR);
+  }
+});
+const emit = (value) => {
+  parentPort.postMessage({ type: "emit", block: toContentBlock(value) });
+};
+const capturedConsole = Object.freeze({
+  log: (...args) => emit(`[console.log] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  info: (...args) => emit(`[console.info] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  warn: (...args) => emit(`[console.warn] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  error: (...args) => emit(`[console.error] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`),
+  debug: (...args) => emit(`[console.debug] ${formatWithOptions({ colors: false, depth: 4 }, ...args)}`)
+});
+(async () => {
+  try {
+    const context = vm.createContext(Object.assign(Object.create(null), {
+      tools,
+      emit,
+      console: capturedConsole
+    }), {
+      codeGeneration: { strings: false, wasm: false },
+      name: "mcpScript"
+    });
+    const script = new vm.Script(`(async () => {
+${workerData.code}
+})()`, { filename: "mcpScript.js" });
+    const returnValue = await Promise.resolve(script.runInContext(context));
+    parentPort.postMessage(returnValue === undefined ? { type: "done" } : { type: "done", returnBlock: toContentBlock(returnValue) });
+  } catch (error) {
+    parentPort.postMessage({
+      type: "error",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+})();