@duckmind/dm-windows-x64 0.63.4 → 0.63.9

package/extensions/dm-mcp-adapter/session-recovery.js

@@ -0,0 +1,82 @@
+import { ProtocolError, SdkHttpError, UnauthorizedError } from "@modelcontextprotocol/client";
+import { logger } from "./logger.js";
+import { throwIfAborted } from "./abort.js";
+import { isServerDisabled } from "./types.js";
+import { supportsOAuth } from "./mcp-auth-flow.js";
+import { invalidateAuthEntryCache } from "./mcp-auth.js";
+const CONNECTION_CLOSED_PROTOCOL_CODE = -32000;
+const SERVER_NOT_INITIALIZED_MCP_MESSAGES = new Set([
+  "Server not initialized",
+  "Bad Request: Server not initialized"
+]);
+export function isTerminatedSession(err, hadSessionId) {
+  if (!hadSessionId)
+    return false;
+  if (err instanceof SdkHttpError) {
+    return err.status === 404 || err.status === 400 && /"code"\s*:\s*-32000/.test(err.message) && /"message"\s*:\s*"Bad Request: Server not initialized"/.test(err.message);
+  }
+  return err instanceof ProtocolError && err.code === CONNECTION_CLOSED_PROTOCOL_CODE && SERVER_NOT_INITIALIZED_MCP_MESSAGES.has(err.message);
+}
+function hasSessionId(connection) {
+  const transport = connection.transport;
+  return transport?.sessionId != null;
+}
+
+export class SessionRecoveryAuthRequiredError extends Error {
+  serverName;
+  authMessage;
+  constructor(serverName, authMessage) {
+    super(authMessage ?? `MCP server "${serverName}" requires OAuth authentication after reconnect.`);
+    this.serverName = serverName;
+    this.authMessage = authMessage;
+    this.name = "SessionRecoveryAuthRequiredError";
+  }
+}
+export async function withSessionRecovery(deps, serverName, fn) {
+  if (isServerDisabled(deps.config.mcpServers[serverName])) {
+    throw new Error(`MCP server "${serverName}" is disabled`);
+  }
+  const connection = deps.manager.getConnection(serverName);
+  if (!connection) {
+    throw new Error(`Server "${serverName}" is not connected`);
+  }
+  const hadSessionId = hasSessionId(connection);
+  try {
+    return await fn(connection);
+  } catch (err) {
+    const definition = deps.config.mcpServers[serverName];
+    if (definition && supportsOAuth(definition) && (err instanceof UnauthorizedError || err instanceof SdkHttpError && err.status === 401)) {
+      invalidateAuthEntryCache(serverName);
+    }
+    if (!isTerminatedSession(err, hadSessionId)) {
+      throw err;
+    }
+    if (!definition) {
+      throw err;
+    }
+    throwIfAborted(deps.signal);
+    logger.debug(`MCP session for "${serverName}" expired; reconnecting`, {
+      server: serverName
+    });
+    let freshConnection = deps.signal ? await deps.manager.reconnect(serverName, definition, connection, deps.signal) : await deps.manager.reconnect(serverName, definition, connection);
+    throwIfAborted(deps.signal);
+    if (freshConnection.status === "needs-auth") {
+      freshConnection = await deps.onNeedsAuth?.(serverName) ?? freshConnection;
+      throwIfAborted(deps.signal);
+    }
+    if (freshConnection.status === "needs-auth") {
+      throw new SessionRecoveryAuthRequiredError(serverName);
+    }
+    if (freshConnection.status !== "connected") {
+      throw err;
+    }
+    try {
+      deps.manager.publishMetadataChanged(serverName, freshConnection, "session-reconnect");
+    } catch (publicationError) {
+      const message = publicationError instanceof Error ? publicationError.message : String(publicationError);
+      logger.debug(`MCP metadata publication after reconnect failed for "${serverName}": ${message}`);
+    }
+    throwIfAborted(deps.signal);
+    return fn(freshConnection);
+  }
+}

package/extensions/dm-mcp-adapter/skills/mcp-scripting/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: mcp-scripting
+description: Write mcpScript JavaScript for discovering, inspecting, and calling MCP tools.
+disable-model-invocation: true
+---
+
+# MCP scripting
+
+For multi-call MCP work, write ordinary JavaScript with loops, filtering, chaining, fan-out, or other logic between calls. Run that source with `mcpScript`; it is the primary MCP orchestration surface. For a single MCP search, describe, status check, auth action, or tool call, use `mcp` instead.
+
+Write the source naturally, then pass it as `mcpScript`'s `code` argument:
+
+```js
+const { items } = await tools.search({ query: "search issues", server: "github" });
+const candidate = items[0];
+if (!candidate) return { error: "No matching tool" };
+
+const details = await tools.describe({ path: candidate.path });
+if (details.error) return details;
+
+const result = await tools.call(details.path, { query: "is:open label:bug" });
+if (!result.ok) return result;
+emit({ tool: details.path, completed: true });
+return result.data;
+```
+
+## Workflow
+
+1. Find candidate tools with `await tools.search({ query, server?, limit?, offset? })`.
+2. Inspect the exact returned path with `await tools.describe({ path })`.
+3. Call it with `tools.call(path, args)`.
+
+Calls resolve to `{ ok: true, data }` or `{ ok: false, error }`; handle failed calls instead of expecting them to stop the script. `emit(value)` adds user-visible output before the final `return` value. `console` output is captured too.
+
+`tools` is a non-enumerable proxy: `Object.keys(tools)` throws. Always use `tools.search` for discovery. When a known flat path is a valid identifier, direct calls such as `tools.github_search_issues(args)` are supported; use bracket syntax for hyphenated names: `tools["server_tool-name"](args)`. `search`, `call`, `describe`, and promise/serialization names (`then`, `catch`, `finally`, `toJSON`, `toString`, `valueOf`) are reserved on the proxy; if a flat path collides with one, call it via `tools.call("exact-path", args)`.
+
+`tools.search` and `tools.describe` are asynchronous and must be awaited. The default script timeout is 30 seconds; the worker is terminated at the deadline, including for infinite loops. Every invocation still uses normal lazy connection, authentication, output guarding, and approval gates. Result details contain a concise `calls` trace with every search, describe, and call operation; each entry includes its query or path, outcome, and duration.
+
+Use plain JavaScript loops and Promise utilities for composition. Fluent helpers such as `tools.find(...).one()`, `tools.parallel(...)`, and `tools.retry(...)` are not provided.

package/extensions/dm-mcp-adapter/test-runner.mjs

@@ -0,0 +1,18 @@
+import { spawnSync } from "node:child_process";
+const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+const args = process.argv.slice(2);
+function run(script, scriptArgs = []) {
+  const commandArgs = ["run", script];
+  if (scriptArgs.length > 0)
+    commandArgs.push("--", ...scriptArgs);
+  const result = spawnSync(npm, commandArgs, { stdio: "inherit" });
+  if (result.error)
+    throw result.error;
+  process.exitCode = result.status ?? 1;
+  return process.exitCode === 0;
+}
+if (args.length > 0) {
+  run("test:vitest", args);
+} else if (run("test:vitest")) {
+  run("test:public-exports");
+}

package/extensions/dm-mcp-adapter/tool-approval.js

@@ -0,0 +1,151 @@
+import { createHash, randomUUID } from "node:crypto";
+import { abortable } from "./abort.js";
+import { combineAbortSignals } from "./runtime-owner.js";
+import {
+  getToolNameCandidates,
+  matchesToolPattern,
+  resolveToolPrefix,
+  MCP_TOOL_APPROVAL_REQUEST_EVENT
+} from "./types.js";
+import { sanitizeTerminalText } from "./utils.js";
+function stableStringify(value) {
+  if (value === null || value === undefined || typeof value !== "object") {
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? "undefined" : serialized;
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(",")}}`;
+}
+export function isToolCallApprovalRequired(config, serverName, toolMeta, toolMetadata) {
+  const definition = config.mcpServers[serverName];
+  const serverApproval = definition?.approveTools;
+  const approval = serverApproval !== undefined ? serverApproval : config.settings?.approveTools;
+  if (approval === true)
+    return true;
+  if (!Array.isArray(approval) || approval.length === 0)
+    return false;
+  const prefix = resolveToolPrefix(definition, config.settings?.toolPrefix);
+  const currentCandidates = getToolNameCandidates(toolMeta.originalName, serverName, prefix, false);
+  if (serverApproval !== undefined) {
+    if (matchesToolPattern(currentCandidates, approval))
+      return true;
+    if (!toolMetadata)
+      return matchesToolPattern(getToolNameCandidates(toolMeta.originalName, serverName, prefix), approval);
+    const legacyCandidates = getToolNameCandidates(toolMeta.originalName, serverName, prefix);
+    const legacyEmittedName = [...currentCandidates].find((candidate) => candidate !== toolMeta.originalName)?.replace(/-/g, "_");
+    if (legacyEmittedName)
+      legacyCandidates.add(legacyEmittedName);
+    for (const candidate of currentCandidates)
+      legacyCandidates.delete(candidate);
+    const otherCurrentCandidates = new Set;
+    for (const tool of toolMetadata.get(serverName) ?? []) {
+      for (const candidate of getToolNameCandidates(tool.originalName, serverName, prefix, false)) {
+        otherCurrentCandidates.add(candidate);
+      }
+    }
+    for (const candidate of currentCandidates)
+      otherCurrentCandidates.delete(candidate);
+    return approval.some((pattern) => matchesToolPattern(legacyCandidates, [pattern]) && !matchesToolPattern(otherCurrentCandidates, [pattern]));
+  }
+  if (matchesToolPattern(currentCandidates, approval))
+    return true;
+  if (!toolMetadata)
+    return false;
+  const legacyCandidates = getToolNameCandidates(toolMeta.originalName, serverName, prefix);
+  const legacyEmittedName = [...currentCandidates].find((candidate) => candidate !== toolMeta.originalName)?.replace(/-/g, "_");
+  if (legacyEmittedName)
+    legacyCandidates.add(legacyEmittedName);
+  for (const candidate of currentCandidates)
+    legacyCandidates.delete(candidate);
+  const otherCurrentCandidates = new Set;
+  for (const [name, metadata] of toolMetadata) {
+    const otherPrefix = resolveToolPrefix(config.mcpServers[name], config.settings?.toolPrefix);
+    for (const tool of metadata) {
+      for (const candidate of getToolNameCandidates(tool.originalName, name, otherPrefix, false)) {
+        otherCurrentCandidates.add(candidate);
+      }
+    }
+  }
+  for (const candidate of currentCandidates)
+    otherCurrentCandidates.delete(candidate);
+  return approval.some((pattern) => matchesToolPattern(legacyCandidates, [pattern]) && !matchesToolPattern(otherCurrentCandidates, [pattern]));
+}
+function isMcpToolApprovalDecision(value) {
+  return value === "allow_once" || value === "allow_for_session" || value === "deny" || value === "abstain";
+}
+async function requestBrokerApproval(state, serverName, toolMeta, args, origin, signal) {
+  if (!state.approvalEvents)
+    return "abstain";
+  let acceptingClaim = true;
+  let handler;
+  const request = {
+    requestId: randomUUID(),
+    serverName,
+    originalToolName: toolMeta.originalName,
+    prefixedToolName: toolMeta.name,
+    args: args ?? {},
+    origin,
+    ...signal !== undefined ? { signal } : {},
+    claim(candidate) {
+      if (!acceptingClaim || handler)
+        return false;
+      handler = candidate;
+      return true;
+    }
+  };
+  state.approvalEvents.emit(MCP_TOOL_APPROVAL_REQUEST_EVENT, request);
+  acceptingClaim = false;
+  if (!handler)
+    return "abstain";
+  try {
+    const decision = await abortable(Promise.resolve().then(handler), signal);
+    return isMcpToolApprovalDecision(decision) ? decision : "deny";
+  } catch (error) {
+    if (signal?.aborted)
+      throw error;
+    return "deny";
+  }
+}
+export async function ensureToolCallApproved(state, serverName, toolMeta, args, signal, origin = toolMeta.resourceUri ? "resource" : "proxy", approvalMetadata) {
+  const argsHash = createHash("sha256").update(stableStringify(args ?? {})).digest("hex");
+  const cacheKey = `${serverName}\x00${toolMeta.originalName}\x00${argsHash}`;
+  const approvedToolCalls = state.approvedToolCalls ??= new Map;
+  if (approvedToolCalls.has(cacheKey)) {
+    return { ok: true };
+  }
+  const brokerDecision = await requestBrokerApproval(state, serverName, toolMeta, args, origin, signal);
+  if (brokerDecision === "allow_once")
+    return { ok: true };
+  if (brokerDecision === "allow_for_session") {
+    approvedToolCalls.set(cacheKey, true);
+    return { ok: true };
+  }
+  if (brokerDecision === "deny")
+    return { ok: false, reason: "denied" };
+  if (!isToolCallApprovalRequired(state.config, serverName, toolMeta, approvalMetadata ?? state.toolMetadata)) {
+    return { ok: true };
+  }
+  if (!state.ui) {
+    return { ok: false, reason: "approval_required_headless" };
+  }
+  const json = JSON.stringify(args ?? {}, null, 2);
+  const sanitized = sanitizeTerminalText(json);
+  const preview = sanitized.length > 500 ? `${sanitized.slice(0, 500)}...` : sanitized;
+  const title = `MCP: ${sanitizeTerminalText(serverName)} wants to run ${sanitizeTerminalText(toolMeta.originalName)}`;
+  const ownedSignal = combineAbortSignals(state.owner?.signal, signal);
+  const decision = await abortable(state.ui.select(`${title}
+
+Arguments:
+${preview}`, ["Allow once", "Allow for session", "Deny"]), ownedSignal);
+  if (decision === "Allow once") {
+    return { ok: true };
+  }
+  if (decision === "Allow for session") {
+    approvedToolCalls.set(cacheKey, true);
+    return { ok: true };
+  }
+  return { ok: false, reason: "denied" };
+}

package/extensions/dm-mcp-adapter/tool-metadata.js

@@ -0,0 +1,247 @@
+import { getToolUiResourceUri } from "./ui-app-bridge-helpers.js";
+import { createToolSelectorCandidateIndex, formatToolName, getToolNameCandidates, isToolAllowed, resolveToolPrefix } from "./types.js";
+import { resourceNameToToolName } from "./resource-tools.js";
+import { extractToolUiStreamMode } from "./utils.js";
+import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.js";
+export function buildToolMetadata(tools, resources, definition, serverName, prefix, configuredServers, knownMetadata, includeMissingConfiguredCandidates = false) {
+  const metadata = [];
+  const failedTools = [];
+  const seenNames = new Set;
+  const effectivePrefix = resolveToolPrefix(definition, prefix);
+  const hasToolFilters = Array.isArray(definition.includeTools) && definition.includeTools.length > 0 || Array.isArray(definition.excludeTools) && definition.excludeTools.length > 0;
+  const selectorCandidateIndex = hasToolFilters && configuredServers ? (() => {
+    const candidates = new Set;
+    const additionalCandidatesByToolName = new Map;
+    const evaluatedToolNames = new Set;
+    const addCandidates = (target, originalName, candidateServerName, candidatePrefix) => {
+      for (const candidate of getToolNameCandidates(originalName, candidateServerName, candidatePrefix, false))
+        target.add(candidate);
+    };
+    for (const tool of tools) {
+      if (!tool?.name)
+        continue;
+      evaluatedToolNames.add(tool.name);
+      addCandidates(candidates, tool.name, serverName, effectivePrefix);
+    }
+    if (definition.exposeResources !== false) {
+      for (const resource of resources) {
+        const baseName = `read_${resourceNameToToolName(resource.name)}`;
+        evaluatedToolNames.add(baseName);
+        if (resource?.name && resource?.uri)
+          addCandidates(candidates, baseName, serverName, effectivePrefix);
+      }
+    }
+    for (const [otherServerName, otherDefinition] of Object.entries(configuredServers)) {
+      if (otherServerName === serverName)
+        continue;
+      const otherPrefix = resolveToolPrefix(otherDefinition, prefix);
+      const knownTools = knownMetadata?.get(otherServerName);
+      if (knownTools) {
+        for (const tool of knownTools) {
+          candidates.add(tool.name);
+          addCandidates(candidates, tool.originalName, otherServerName, otherPrefix);
+        }
+      } else if (!knownMetadata || includeMissingConfiguredCandidates) {
+        for (const toolName of evaluatedToolNames) {
+          let additionalCandidates = additionalCandidatesByToolName.get(toolName);
+          if (!additionalCandidates) {
+            additionalCandidates = new Set;
+            additionalCandidatesByToolName.set(toolName, additionalCandidates);
+          }
+          addCandidates(additionalCandidates, toolName, otherServerName, otherPrefix);
+          if (includeMissingConfiguredCandidates) {
+            for (const candidate of getToolNameCandidates(toolName, otherServerName, otherPrefix, false)) {
+              additionalCandidates.add(candidate.replace(/-/g, "_"));
+            }
+          }
+        }
+      }
+    }
+    return createToolSelectorCandidateIndex(candidates, additionalCandidatesByToolName);
+  })() : undefined;
+  for (const tool of tools) {
+    if (!tool?.name) {
+      failedTools.push("(unnamed)");
+      continue;
+    }
+    if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) {
+      continue;
+    }
+    const name = formatToolName(tool.name, serverName, effectivePrefix);
+    if (seenNames.has(name)) {
+      continue;
+    }
+    const uiVisibility = extractUiToolVisibility(tool._meta);
+    if (!isUiToolVisibleToModel(uiVisibility)) {
+      continue;
+    }
+    seenNames.add(name);
+    let uiResourceUri;
+    try {
+      uiResourceUri = getToolUiResourceUri({ _meta: tool._meta });
+    } catch {
+      failedTools.push(tool.name);
+    }
+    const uiStreamMode = extractToolUiStreamMode(tool._meta);
+    metadata.push({
+      name,
+      originalName: tool.name,
+      description: tool.description ?? "",
+      ...tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {},
+      ...uiResourceUri !== undefined ? { uiResourceUri } : {},
+      ...uiVisibility !== undefined ? { uiVisibility } : {},
+      ...uiStreamMode !== undefined ? { uiStreamMode } : {}
+    });
+  }
+  if (definition.exposeResources !== false) {
+    for (const resource of resources) {
+      const baseName = `read_${resourceNameToToolName(resource.name)}`;
+      if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools, selectorCandidateIndex)) {
+        continue;
+      }
+      const name = formatToolName(baseName, serverName, effectivePrefix);
+      if (seenNames.has(name)) {
+        continue;
+      }
+      seenNames.add(name);
+      metadata.push({
+        name,
+        originalName: baseName,
+        description: resource.description ?? `Read resource: ${resource.uri}`,
+        resourceUri: resource.uri
+      });
+    }
+  }
+  return { metadata, failedTools };
+}
+export function getToolNames(state, serverName) {
+  return state.toolMetadata.get(serverName)?.map((m) => m.name) ?? [];
+}
+export function totalToolCount(state) {
+  let count = 0;
+  for (const metadata of state.toolMetadata.values()) {
+    count += metadata.length;
+  }
+  return count;
+}
+export function findToolByName(metadata, toolName) {
+  if (!metadata)
+    return;
+  const exact = metadata.find((m) => m.name === toolName);
+  if (exact)
+    return exact;
+  const normalized = toolName.replace(/-/g, "_");
+  return metadata.find((m) => m.name.replace(/-/g, "_") === normalized);
+}
+export function formatSchema(schema, indent = "  ") {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return `${indent}(no schema)`;
+  }
+  const s = schema;
+  if (s.type === "object" && s.properties && typeof s.properties === "object" && !Array.isArray(s.properties)) {
+    const props = s.properties;
+    const required = Array.isArray(s.required) ? s.required.filter((name) => typeof name === "string") : [];
+    if (Object.keys(props).length === 0) {
+      return `${indent}(no parameters)`;
+    }
+    const lines = [];
+    for (const [name, propSchema] of Object.entries(props)) {
+      lines.push(...formatProperty(name, propSchema, required.includes(name), indent));
+    }
+    return lines.join(`
+`);
+  }
+  const lines = formatNestedSchema(s, indent);
+  if (lines.length > 0) {
+    return lines.join(`
+`);
+  }
+  const typeStr = formatType(s);
+  if (typeStr) {
+    return `${indent}(${typeStr})`;
+  }
+  return `${indent}(complex schema)`;
+}
+function formatProperty(name, schema, required, indent) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return [`${indent}${name}${required ? " *required*" : ""}`];
+  }
+  const s = schema;
+  const parts = [`${indent}${name}`];
+  const typeStr = formatType(s);
+  if (typeStr)
+    parts.push(`(${typeStr})`);
+  if (required)
+    parts.push("*required*");
+  appendSchemaAnnotations(parts, s);
+  return [parts.join(" "), ...formatNestedSchema(s, `${indent}  `)];
+}
+function formatNestedSchema(schema, indent) {
+  const lines = [];
+  if (Array.isArray(schema.anyOf)) {
+    lines.push(...formatVariants("anyOf", schema.anyOf, indent));
+  }
+  if (Array.isArray(schema.oneOf)) {
+    lines.push(...formatVariants("oneOf", schema.oneOf, indent));
+  }
+  if (schema.items !== undefined) {
+    lines.push(...formatProperty("items", schema.items, false, indent));
+  }
+  if (schema.properties && typeof schema.properties === "object" && !Array.isArray(schema.properties)) {
+    const required = Array.isArray(schema.required) ? schema.required.filter((name) => typeof name === "string") : [];
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      lines.push(...formatProperty(name, propSchema, required.includes(name), indent));
+    }
+  }
+  return lines;
+}
+function formatVariants(keyword, variants, indent) {
+  const lines = [`${indent}${keyword}:`];
+  for (const variant of variants) {
+    if (!variant || typeof variant !== "object" || Array.isArray(variant)) {
+      lines.push(`${indent}  - ${JSON.stringify(variant)}`);
+      continue;
+    }
+    const s = variant;
+    const typeStr = formatType(s) || "schema";
+    const parts = [`${indent}  - ${typeStr}`];
+    appendSchemaAnnotations(parts, s);
+    lines.push(parts.join(" "));
+    lines.push(...formatNestedSchema(s, `${indent}    `));
+  }
+  return lines;
+}
+function formatType(schema) {
+  if (Object.hasOwn(schema, "const")) {
+    return `const ${JSON.stringify(schema.const)}`;
+  }
+  if (Array.isArray(schema.enum)) {
+    return `enum: ${schema.enum.map((v) => JSON.stringify(v)).join(", ")}`;
+  }
+  if (Array.isArray(schema.type)) {
+    return schema.type.map((type) => String(type)).join(" | ");
+  }
+  if (schema.type) {
+    return String(schema.type);
+  }
+  if (schema.properties && typeof schema.properties === "object" && !Array.isArray(schema.properties)) {
+    return "object";
+  }
+  if (schema.items !== undefined) {
+    return "array";
+  }
+  return "";
+}
+function appendSchemaAnnotations(parts, schema) {
+  if (schema.description && typeof schema.description === "string") {
+    parts.push(`- ${schema.description}`);
+  }
+  for (const key of ["minLength", "maxLength", "minimum", "maximum", "minItems", "maxItems", "format", "pattern"]) {
+    if (schema[key] !== undefined) {
+      parts.push(`[${key}: ${JSON.stringify(schema[key])}]`);
+    }
+  }
+  if (schema.default !== undefined) {
+    parts.push(`[default: ${JSON.stringify(schema.default)}]`);
+  }
+}