@duckmind/dm-windows-x64 0.63.6 → 0.63.9

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

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import stripJsonComments from "strip-json-comments";
+import { getAgentDir, getConfigDirName } from "./agent-dir.js";
+export function loadPackageMcpConfigs(cwd = process.cwd()) {
+  const mcpServers = {};
+  const seen = new Set;
+  for (const packageRoot of getConfiguredPackageRoots(cwd)) {
+    const manifest = readPackageManifest(packageRoot);
+    if (!manifest || typeof manifest.name !== "string" || !manifest.name)
+      continue;
+    const paths = getManifestMcpPaths(manifest.pi?.mcp, manifest.name);
+    if (!paths)
+      continue;
+    const packagePrefix = formatPackageName(manifest.name);
+    const packageServers = new Set;
+    for (const path of paths) {
+      const configPath = resolvePackageConfigPath(packageRoot, path);
+      if (!configPath) {
+        console.warn(`DM package ${manifest.name} skips MCP config ${path}: file must stay inside the package`);
+        continue;
+      }
+      const config = readMcpConfig(configPath, manifest.name);
+      if (!config)
+        continue;
+      for (const [serverName, server] of Object.entries(config.mcpServers)) {
+        const normalizedName = `${packagePrefix}__${formatServerName(serverName)}`;
+        if (packageServers.has(normalizedName) || seen.has(normalizedName)) {
+          console.warn(`DM package ${manifest.name} skips duplicate normalized MCP server ${normalizedName}`);
+          continue;
+        }
+        packageServers.add(normalizedName);
+        seen.add(normalizedName);
+        mcpServers[normalizedName] = server;
+      }
+    }
+  }
+  return { mcpServers };
+}
+function getConfiguredPackageRoots(cwd) {
+  const roots = [];
+  for (const [settingsPath, scope] of [
+    [join(cwd, getConfigDirName(), "settings.json"), "project"],
+    [join(getAgentDir(), "settings.json"), "user"]
+  ]) {
+    const settings = readOptionalJson(settingsPath, `${scope} DM settings`);
+    if (settings === undefined)
+      continue;
+    if (typeof settings !== "object" || settings === null || Array.isArray(settings)) {
+      throw new Error(`${scope} DM settings ${settingsPath} must be a JSON object`);
+    }
+    const packages = settings.packages;
+    if (packages === undefined)
+      continue;
+    if (!Array.isArray(packages))
+      throw new Error(`${scope} DM settings ${settingsPath} packages must be an array`);
+    for (const entry of packages) {
+      const source = typeof entry === "string" ? entry : entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.source === "string" ? entry.source : undefined;
+      if (!source)
+        throw new Error(`${scope} DM settings ${settingsPath} package entries must be strings or objects with a string source`);
+      const root = resolvePackageRoot(source, scope, cwd);
+      if (root && !roots.includes(root))
+        roots.push(root);
+    }
+  }
+  return roots;
+}
+function resolvePackageRoot(source, scope, cwd) {
+  const baseDir = scope === "user" ? getAgentDir() : join(cwd, getConfigDirName());
+  if (source.startsWith("npm:")) {
+    const name = source.slice(4).trim().match(/^(@?[^@]+(?:\/[^@]+)?)/)?.[1];
+    return name ? resolveContainedPath(join(baseDir, "npm", "node_modules"), name) : null;
+  }
+  const gitSource = source.startsWith("git:") ? source.slice(4).trim() : /^(?:(?:https?|ssh):\/\/|git@[^:]+:)/.test(source) ? source : null;
+  if (gitSource) {
+    const value = gitSource.replace(/^ssh:\/\/git@/, "").replace(/^git@([^:]+):/, "$1/").replace(/^[a-z]+:\/\//i, "");
+    const path = value.replace(/@[^/]+$/, "").replace(/\.git$/, "");
+    return path && !path.startsWith("/") ? resolveContainedPath(join(baseDir, "git"), path) : null;
+  }
+  return isAbsolute(source) ? resolve(source) : resolve(baseDir, source);
+}
+function readPackageManifest(packageRoot) {
+  const manifest = readOptionalJson(join(packageRoot, "package.json"), `DM package manifest ${packageRoot}`);
+  return manifest && typeof manifest === "object" && !Array.isArray(manifest) ? manifest : null;
+}
+function getManifestMcpPaths(value, packageName) {
+  const paths = typeof value === "string" ? [value] : Array.isArray(value) && value.every((path) => typeof path === "string") ? value : null;
+  if (value !== undefined && !paths)
+    console.warn(`DM package ${packageName} ignores invalid pi.mcp manifest entry`);
+  return paths;
+}
+function readMcpConfig(path, packageName) {
+  const config = readRequiredJson(path, `DM package ${packageName} MCP config`);
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error(`DM package ${packageName} MCP config ${path} must be a JSON object`);
+  }
+  const servers = config.mcpServers;
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    throw new Error(`DM package ${packageName} MCP config ${path} must contain a JSON object mcpServers field`);
+  }
+  const mcpServers = {};
+  for (const [name, server] of Object.entries(servers)) {
+    if (!server || typeof server !== "object" || Array.isArray(server)) {
+      throw new Error(`DM package ${packageName} MCP config ${path} server ${name} must be a JSON object`);
+    }
+    mcpServers[name] = server;
+  }
+  return { mcpServers };
+}
+function readRequiredJson(path, description) {
+  try {
+    return JSON.parse(stripJsonComments(readFileSync(path, "utf8"), { trailingCommas: true }));
+  } catch (error) {
+    throw new Error(`${description} ${path} contains invalid JSON: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+function readOptionalJson(path, description) {
+  if (!existsSync(path))
+    return;
+  return readRequiredJson(path, description);
+}
+function resolveContainedPath(root, path) {
+  const resolved = resolve(root, path);
+  const rel = relative(root, resolved);
+  return rel === "" || !rel.startsWith("..") && !rel.startsWith(sep) && !isAbsolute(rel) ? resolved : null;
+}
+function resolvePackageConfigPath(packageRoot, path) {
+  const lexicalPath = resolveContainedPath(packageRoot, path);
+  if (!lexicalPath || !existsSync(lexicalPath) || !statSync(lexicalPath).isFile())
+    return null;
+  try {
+    const realPackageRoot = realpathSync(packageRoot);
+    const realConfigPath = realpathSync(lexicalPath);
+    return resolveContainedPath(realPackageRoot, realConfigPath);
+  } catch {
+    return null;
+  }
+}
+function formatPackageName(name) {
+  return name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "package";
+}
+function formatServerName(name) {
+  return name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "server";
+}

package/extensions/dm-mcp-adapter/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "dm-mcp-adapter",
+  "version": "2.32.1",
+  "description": "MCP (Model Context Protocol) adapter extension for DM.",
+  "type": "module",
+  "bin": {
+    "dm-mcp-adapter": "cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.js",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./oauth": {
+      "types": "./oauth.js",
+      "import": "./oauth.js",
+      "default": "./oauth.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js",
+      "default": "./dist/config.js"
+    },
+    "./metadata-cache": {
+      "types": "./dist/metadata-cache.d.ts",
+      "import": "./dist/metadata-cache.js",
+      "default": "./dist/metadata-cache.js"
+    }
+  },
+  "license": "MIT",
+  "author": "Nico Bailon",
+  "keywords": [
+    "duckmind",
+    "dm",
+    "dm-package",
+    "dm-extension",
+    "mcp",
+    "model-context-protocol"
+  ],
+  "dm": {
+    "extensions": [
+      "./index.js"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "peerDependenciesMeta": {
+    "@duckmind/dm-ai": {
+      "optional": true
+    },
+    "@duckmind/dm-coding-agent": {
+      "optional": true
+    },
+    "@duckmind/dm-tui": {
+      "optional": true
+    },
+    "typebox": {
+      "optional": true
+    }
+  }
+}

package/extensions/dm-mcp-adapter/panel-keys.js

@@ -0,0 +1,26 @@
+import { matchesKey } from "@duckmind/dm-tui";
+function configuredSaveKeys(keybindings) {
+  const explicit = keybindings?.getUserBindings?.()["mcp.panel.save"];
+  if (explicit !== undefined)
+    return { keys: Array.isArray(explicit) ? explicit : [explicit], configured: true };
+  return { keys: [], configured: false };
+}
+export function createPanelKeys(keybindings) {
+  const saveBinding = configuredSaveKeys(keybindings);
+  if (keybindings) {
+    return {
+      selectUp: (data) => keybindings.matches(data, "tui.select.up"),
+      selectDown: (data) => keybindings.matches(data, "tui.select.down"),
+      selectConfirm: (data) => keybindings.matches(data, "tui.select.confirm"),
+      save: (data) => saveBinding.keys.length > 0 ? saveBinding.keys.some((key) => matchesKey(data, key)) : !saveBinding.configured && matchesKey(data, "ctrl+s"),
+      saveLabel: () => saveBinding.keys[0] ?? (saveBinding.configured ? null : "ctrl+s")
+    };
+  }
+  return {
+    selectUp: (data) => matchesKey(data, "up"),
+    selectDown: (data) => matchesKey(data, "down"),
+    selectConfirm: (data) => matchesKey(data, "return"),
+    save: (data) => matchesKey(data, "ctrl+s"),
+    saveLabel: () => "ctrl+s"
+  };
+}

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

@@ -0,0 +1,258 @@
+import { isServerDisabled } from "./types.js";
+import { formatPromptCommandName } from "./types.js";
+import { lazyConnect } from "./init.js";
+import { isServerCacheValid, loadMetadataCache, reconstructPromptMetadata } from "./metadata-cache.js";
+import { logger } from "./logger.js";
+import { truncateAtWord } from "./utils.js";
+export function resolveCachedPrompts(config) {
+  const cache = loadMetadataCache();
+  if (!cache?.servers)
+    return [];
+  const prefix = config.settings?.toolPrefix ?? "server";
+  const specs = [];
+  for (const [serverName, entry] of Object.entries(cache.servers)) {
+    const definition = config.mcpServers[serverName];
+    if (!definition || isServerDisabled(definition))
+      continue;
+    if (!entry?.prompts?.length || !isServerCacheValid(entry, definition))
+      continue;
+    specs.push(...reconstructPromptMetadata(serverName, entry.prompts, prefix, definition));
+  }
+  return specs;
+}
+export function parsePromptArgs(input) {
+  const positional = [];
+  const named = {};
+  const tokens = tokenizeArgs(input);
+  for (const token of tokens) {
+    const eq = findUnquotedEquals(token);
+    if (eq > 0) {
+      const key = token.slice(0, eq).trim();
+      const value = stripQuotes(token.slice(eq + 1).trim());
+      if (key) {
+        named[key] = value;
+        continue;
+      }
+    }
+    positional.push(stripQuotes(token));
+  }
+  return { positional, named };
+}
+function tokenizeArgs(input) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let escaped = false;
+  for (const char of input) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      current += char;
+      if (char === quote)
+        quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current.length > 0)
+    tokens.push(current);
+  return tokens;
+}
+function findUnquotedEquals(token) {
+  let quote = null;
+  for (let i = 0;i < token.length; i++) {
+    const ch = token[i];
+    if (quote) {
+      if (ch === quote)
+        quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'")
+      quote = ch;
+    else if (ch === "=")
+      return i;
+  }
+  return -1;
+}
+function stripQuotes(value) {
+  if (value.length >= 2 && (value.startsWith('"') || value.startsWith("'")) && value.endsWith(value.charAt(0))) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+export function resolvePromptArgs(metadata, parsed) {
+  const args = {};
+  const declared = metadata.arguments;
+  let positionalIndex = 0;
+  for (const argDef of declared) {
+    const value = parsed.named[argDef.name] ?? parsed.positional[positionalIndex++];
+    if (value !== undefined && value !== "") {
+      args[argDef.name] = value;
+    }
+  }
+  for (const [key, value] of Object.entries(parsed.named)) {
+    if (!(key in args))
+      args[key] = value;
+  }
+  const missing = declared.filter((a) => a.required && (args[a.name] === undefined || args[a.name] === ""));
+  if (missing.length > 0) {
+    return { ok: false, error: buildUsageMessage(metadata, missing) };
+  }
+  return { ok: true, args };
+}
+function buildUsageMessage(metadata, missing) {
+  const usage = metadata.arguments.map((a) => a.required ? `<${a.name}>` : `[${a.name}]`).join(" ");
+  const missingList = missing.map((a) => a.name).join(", ");
+  return `Missing required argument${missing.length > 1 ? "s" : ""}: ${missingList}.
+Usage: /${metadata.commandName} ${usage}`.trim();
+}
+export function formatPromptResult(result) {
+  const lines = [];
+  for (const message of result.messages) {
+    const text = extractMessageText(message);
+    if (!text)
+      continue;
+    if (message.role === "user" && result.messages.length === 1) {
+      lines.push(text);
+    } else {
+      lines.push(`[${message.role}] ${text}`);
+    }
+  }
+  return lines.join(`
+
+`).trim();
+}
+function extractMessageText(message) {
+  const content = message.content;
+  if (!content || typeof content !== "object")
+    return "";
+  switch (content.type) {
+    case "text":
+      return content.text ?? "";
+    case "resource": {
+      const resource = content.resource;
+      if (!resource)
+        return "";
+      if ("text" in resource && typeof resource.text === "string") {
+        return `[resource ${resource.uri}]
+${resource.text}`;
+      }
+      return `[resource ${resource.uri}]`;
+    }
+    case "resource_link":
+      return `[resource_link ${content.uri ?? ""}${content.name ? ` — ${content.name}` : ""}]`;
+    case "image":
+      return `[image ${content.mimeType ?? "unknown"}${content.data ? " (embedded)" : ""}]`;
+    case "audio":
+      return `[audio ${content.mimeType ?? "unknown"}]`;
+    default:
+      return "";
+  }
+}
+export function createPromptCommand(pi, getState, metadata) {
+  const description = buildCommandDescription(metadata);
+  return {
+    description,
+    handler: async (args, ctx) => {
+      const state = getState();
+      if (!state) {
+        if (ctx.hasUI)
+          ctx.ui.notify("MCP not initialized", "error");
+        return;
+      }
+      const liveMetadata = findLivePromptMetadata(state, metadata.serverName, metadata.originalName);
+      if (state.promptMetadataLive?.has(metadata.serverName) && !liveMetadata) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(`MCP prompt "${metadata.originalName}" is no longer advertised by server "${metadata.serverName}". Run /mcp reconnect to refresh.`, "error");
+        }
+        return;
+      }
+      const live = liveMetadata ?? metadata;
+      const parsed = parsePromptArgs(args ?? "");
+      const resolved = resolvePromptArgs(live, parsed);
+      if (!resolved.ok) {
+        if (ctx.hasUI)
+          ctx.ui.notify(resolved.error ?? "Invalid prompt arguments", "error");
+        return;
+      }
+      const promptArgs = resolved.args ?? {};
+      if (!state.config.mcpServers[metadata.serverName]) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(`MCP prompt "${live.originalName}" is no longer configured. Run /mcp reconnect to refresh.`, "error");
+        }
+        return;
+      }
+      const connected = await lazyConnect(state, metadata.serverName, ctx.signal);
+      if (!connected) {
+        if (ctx.hasUI) {
+          const conn = state.manager.getConnection(metadata.serverName);
+          const message = conn?.status === "needs-auth" ? `MCP server "${metadata.serverName}" needs authentication. Run /mcp-auth ${metadata.serverName}.` : `MCP server "${metadata.serverName}" is not available. Run /mcp reconnect ${metadata.serverName}.`;
+          ctx.ui.notify(message, "error");
+        }
+        return;
+      }
+      const refreshed = findLivePromptMetadata(state, metadata.serverName, metadata.originalName);
+      if (state.promptMetadataLive?.has(metadata.serverName) && !refreshed) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(`MCP prompt "${metadata.originalName}" is no longer advertised by server "${metadata.serverName}". Run /mcp reconnect to refresh.`, "error");
+        }
+        return;
+      }
+      const dispatchMetadata = refreshed ?? live;
+      let result;
+      try {
+        result = await state.manager.getPrompt(metadata.serverName, dispatchMetadata.originalName, Object.keys(promptArgs).length > 0 ? promptArgs : undefined, ctx.signal);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.debug(`MCP prompt "${live.originalName}" on ${metadata.serverName} failed: ${message}`);
+        if (ctx.hasUI) {
+          ctx.ui.notify(`MCP prompt "${live.originalName}" failed: ${message}`, "error");
+        }
+        return;
+      }
+      const text = formatPromptResult(result);
+      if (!text) {
+        if (ctx.hasUI) {
+          ctx.ui.notify(`MCP prompt "${live.originalName}" returned no text content.`, "warning");
+        }
+        return;
+      }
+      pi.sendUserMessage(text);
+    }
+  };
+}
+function findLivePromptMetadata(state, serverName, originalName) {
+  return state.promptMetadata?.get(serverName)?.find((p) => p.originalName === originalName);
+}
+function buildCommandDescription(metadata) {
+  const base = metadata.description || metadata.title || `MCP prompt from ${metadata.serverName}`;
+  return truncateAtWord(`MCP: ${base}`, 120) || `MCP prompt from ${metadata.serverName}`;
+}
+export function listAllPromptMetadata(state) {
+  const flat = [];
+  for (const list of state.promptMetadata?.values() ?? [])
+    flat.push(...list);
+  flat.sort((a, b) => a.commandName.localeCompare(b.commandName));
+  return flat;
+}
+
+export { formatPromptCommandName };