@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-mcp-adapter/request-headers-command.js

@@ -266,20 +266,21 @@ export function createRequestHeadersCommandFetch(config, delegate = globalThis.f
   resolvedCommand(config);
   return async (input, init) => {
     const request = new Request(input, init);
+    const signal = init?.signal === null ? request.signal : init?.signal ?? (input instanceof Request ? input.signal : request.signal);
     const body = Buffer.from(await request.clone().arrayBuffer());
     const derived = await invokeRequestHeadersCommand(config, {
       version: 1,
       method: request.method.toUpperCase(),
       url: request.url,
       bodyBase64: body.toString("base64")
-    }, request.signal);
+    }, signal);
     const headers = new Headers(request.headers);
     derived.forEach((value, name) => headers.set(name, value));
     return delegate(new URL(request.url), {
       method: request.method,
       headers,
       ...request.method === "GET" || request.method === "HEAD" ? {} : { body },
-      signal: request.signal,
+      signal,
       cache: request.cache,
       credentials: request.credentials,
       integrity: request.integrity,

package/extensions/dm-mcp-adapter/runtime-owner.js

@@ -40,7 +40,22 @@ export function combineAbortSignals(...signals) {
     return;
   if (active.length === 1)
     return active[0];
-  return AbortSignal.any(active);
+  if (typeof AbortSignal.any === "function")
+    return AbortSignal.any(active);
+  const controller = new AbortController;
+  const alreadyAborted = active.find((signal) => signal.aborted);
+  if (alreadyAborted) {
+    controller.abort(alreadyAborted.reason);
+    return controller.signal;
+  }
+  const onAbort = (event) => {
+    for (const signal of active)
+      signal.removeEventListener("abort", onAbort);
+    controller.abort(event.target.reason);
+  };
+  for (const signal of active)
+    signal.addEventListener("abort", onAbort, { once: true });
+  return controller.signal;
 }
 export function createOwnedUi(ui, owner) {
   const proxies = new WeakMap;

package/extensions/dm-mcp-adapter/sampling-handler.js

@@ -1,4 +1,4 @@
-import { complete } from "@duckmind/dm-ai/compat";
+import { completeSimple } from "@duckmind/dm-ai/compat";
 import { truncateAtWord } from "./utils.js";
 import { throwIfAborted } from "./abort.js";
 export function registerSamplingHandler(client, options) {
@@ -26,20 +26,25 @@ export async function handleSamplingRequest(options, request) {
     throw new Error("MCP sampling stop sequences are not supported");
   }
   const messages = params.messages.map(convertSamplingMessage);
-  const { model, apiKey, headers } = await resolveSamplingModel(options, params.modelPreferences);
+  const model = resolveSamplingModel(options, params.modelPreferences);
   throwIfAborted(signal);
   await confirmSampling(options, "Approve MCP sampling request", formatRequestApproval(options.serverName, `${model.provider}/${model.id}`, params.systemPrompt, messages));
   throwIfAborted(signal);
-  const result = await complete(model, {
+  const auth = await options.modelRegistry.getApiKeyAndHeaders(model);
+  if (!auth.ok)
+    throw new Error(auth.error);
+  throwIfAborted(signal);
+  const result = await completeSimple(model, {
     ...params.systemPrompt !== undefined ? { systemPrompt: params.systemPrompt } : {},
     messages
   }, {
-    ...apiKey !== undefined ? { apiKey } : {},
-    ...headers !== undefined ? { headers } : {},
     maxTokens: params.maxTokens,
     ...params.temperature !== undefined ? { temperature: params.temperature } : {},
     ...params.metadata !== undefined ? { metadata: params.metadata } : {},
-    ...signal ? { signal } : {}
+    ...signal ? { signal } : {},
+    ...auth.apiKey ? { apiKey: auth.apiKey } : {},
+    ...auth.headers ? { headers: auth.headers } : {},
+    ...auth.env ? { env: auth.env } : {}
   });
   const converted = convertAssistantResult(result);
   throwIfAborted(signal);
@@ -80,7 +85,7 @@ function messageText(message) {
   }).join(`
 `);
 }
-async function resolveSamplingModel(options, modelPreferences) {
+function resolveSamplingModel(options, modelPreferences) {
   const candidates = [];
   const availableModels = options.modelRegistry.getAvailable();
   for (const hint of modelPreferences?.hints ?? []) {
@@ -100,25 +105,11 @@ async function resolveSamplingModel(options, modelPreferences) {
   for (const model of availableModels) {
     addSamplingCandidate(candidates, model);
   }
-  const errors = [];
   const signal = options.getSignal();
-  for (const model of candidates) {
-    throwIfAborted(signal);
-    const auth = await options.modelRegistry.getApiKeyAndHeaders(model);
-    throwIfAborted(signal);
-    if (auth.ok === false) {
-      errors.push(`${model.provider}/${model.id}: ${auth.error}`);
-      continue;
-    }
-    return {
-      model,
-      ...auth.apiKey !== undefined ? { apiKey: auth.apiKey } : {},
-      ...auth.headers !== undefined ? { headers: auth.headers } : {}
-    };
-  }
-  if (errors.length > 0) {
-    throw new Error(`No configured auth for MCP sampling model. ${errors.join("; ")}`);
-  }
+  throwIfAborted(signal);
+  const model = candidates[0];
+  if (model)
+    return model;
   throw new Error("No DM model is available for MCP sampling");
 }
 function addSamplingCandidate(candidates, model) {

package/extensions/dm-mcp-adapter/sandbox-proxy-template.js

@@ -1,8 +1,11 @@
 export const SANDBOX_PROXY_SANDBOX = "allow-scripts allow-forms allow-modals allow-popups allow-downloads allow-same-origin";
 export const SANDBOX_INNER_SANDBOX = SANDBOX_PROXY_SANDBOX;
 export const SANDBOX_PROXY_PATH = "/sandbox";
+export const SANDBOX_RESOURCE_PATH_PREFIX = "/resource/";
 export function buildSandboxProxyHtml(input) {
   const parentOrigin = safeInlineJSON(input.parentOrigin);
+  const resourcePath = safeInlineJSON(input.resourcePath);
+  const allowAttribute = escapeHtmlAttribute(input.allowAttribute);
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -15,17 +18,21 @@ export function buildSandboxProxyHtml(input) {
   </style>
 </head>
 <body>
-  <iframe id="mcp-app" title="MCP App" sandbox="${SANDBOX_INNER_SANDBOX}" referrerpolicy="no-referrer"></iframe>
+  <iframe id="mcp-app" title="MCP App" sandbox="${SANDBOX_INNER_SANDBOX}" allow="${allowAttribute}" referrerpolicy="no-referrer"></iframe>
   <script>
     const EXPECTED_PARENT_ORIGIN = ${parentOrigin};
+    const RESOURCE_PATH = ${resourcePath};
     const SANDBOX_PROXY_READY_METHOD = "ui/notifications/sandbox-proxy-ready";
     const SANDBOX_RESOURCE_READY_METHOD = "ui/notifications/sandbox-resource-ready";
-    const INNER_SANDBOX = ${safeInlineJSON(SANDBOX_INNER_SANDBOX)};
     const MAX_PENDING_MESSAGES = 64;
     const innerFrame = document.getElementById("mcp-app");
     const pendingToInner = [];
     let innerReady = false;
 
+    innerFrame.addEventListener("load", () => {
+      if (innerFrame.getAttribute("src") === RESOURCE_PATH) flushPendingMessages();
+    });
+
     const isObject = (value) => value !== null && typeof value === "object";
     const isMessageFromParent = (event) =>
       event.source === window.parent && event.origin === EXPECTED_PARENT_ORIGIN;
@@ -52,99 +59,13 @@ export function buildSandboxProxyHtml(input) {
       }
     };
 
-    const sanitizeDomains = (domains) => {
-      if (!Array.isArray(domains)) return [];
-      return [...new Set(domains.filter((domain) =>
-        typeof domain === "string" &&
-        domain.length > 0 &&
-        /^[\\x21-\\x7E]+$/.test(domain) &&
-        !/[;'"]/.test(domain),
-      ))];
-    };
-
-    const toDirective = (name, trustedSources, domains) =>
-      name + " " + [...new Set([...trustedSources, ...domains])].join(" ");
-
-    const buildResourceCsp = (csp) => {
-      const resourceDomains = sanitizeDomains(csp?.resourceDomains);
-      const connectDomains = sanitizeDomains(csp?.connectDomains);
-      const frameDomains = sanitizeDomains(csp?.frameDomains);
-      const baseUriDomains = sanitizeDomains(csp?.baseUriDomains);
-      return [
-        "default-src 'none'",
-        "sandbox " + INNER_SANDBOX,
-        toDirective("script-src", ["'self'", "'unsafe-inline'"], resourceDomains),
-        toDirective("style-src", ["'self'", "'unsafe-inline'"], resourceDomains),
-        toDirective("font-src", ["'self'"], resourceDomains),
-        toDirective("img-src", ["'self'", "data:"], resourceDomains),
-        toDirective("media-src", ["'self'", "data:"], resourceDomains),
-        connectDomains.length > 0 ? "connect-src " + connectDomains.join(" ") : "connect-src 'none'",
-        frameDomains.length > 0 ? "frame-src " + frameDomains.join(" ") : "frame-src 'none'",
-        "worker-src 'none'",
-        "object-src 'none'",
-        baseUriDomains.length > 0 ? "base-uri " + baseUriDomains.join(" ") : "base-uri 'self'",
-      ].join("; ");
-    };
-
-    const escapeAttribute = (value) => value
-      .replace(/&/g, "&amp;")
-      .replace(/"/g, "&quot;")
-      .replace(/</g, "&lt;")
-      .replace(/>/g, "&gt;");
-
-    const injectCsp = (html, csp) => {
-      const meta = '<meta http-equiv="Content-Security-Policy" content="' + escapeAttribute(csp) + '">';
-      const head = html.match(/<head(?:\\s[^>]*)?>/i);
-      if (head && head.index !== undefined) {
-        const end = head.index + head[0].length;
-        return html.slice(0, end) + meta + html.slice(end);
-      }
-      return meta + html;
-    };
-
-    const safeSandbox = (requested) => {
-      const requestedTokens = typeof requested === "string" ? requested.split(/\\s+/) : [];
-      const allowedTokens = new Set(INNER_SANDBOX.split(" "));
-      const tokens = requestedTokens.filter((token) => allowedTokens.has(token));
-      // Provider HTML needs both script execution and a real proxy-origin
-      // storage context. Never accept popup escape or top-navigation tokens.
-      return [...new Set([
-        "allow-scripts",
-        "allow-same-origin",
-        ...tokens,
-      ])].filter((token) => allowedTokens.has(token)).join(" ");
-    };
-
-    const buildAllowAttribute = (permissions) => {
-      if (!isObject(permissions) || Array.isArray(permissions)) return "";
-      const allowed = [];
-      if (permissions.camera) allowed.push("camera");
-      if (permissions.microphone) allowed.push("microphone");
-      if (permissions.geolocation) allowed.push("geolocation");
-      if (permissions.clipboardWrite) allowed.push("clipboard-write");
-      return allowed.join("; ");
-    };
-
-    const loadResource = (params) => {
-      if (!isObject(params) || typeof params.html !== "string" || !innerFrame.contentDocument) return;
-      innerFrame.setAttribute("sandbox", safeSandbox(params.sandbox));
-      const allow = buildAllowAttribute(params.permissions);
-      if (allow) innerFrame.setAttribute("allow", allow);
-      else innerFrame.removeAttribute("allow");
-      innerReady = false;
-      const document = innerFrame.contentDocument;
-      document.open();
-      document.write(injectCsp(params.html, buildResourceCsp(params.csp)));
-      document.close();
-      flushPendingMessages();
-    };
-
     window.addEventListener("message", (event) => {
       if (isMessageFromParent(event)) {
         const data = event.data;
         if (!isObject(data)) return;
         if (data.method === SANDBOX_RESOURCE_READY_METHOD) {
-          loadResource(data.params);
+          innerReady = false;
+          innerFrame.setAttribute("src", RESOURCE_PATH);
           return;
         }
         if (data.method === SANDBOX_PROXY_READY_METHOD) return;
@@ -169,6 +90,9 @@ export function buildSandboxProxyHtml(input) {
 </body>
 </html>`;
 }
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 export function buildSandboxProxyCsp() {
   return [
     "default-src 'none'",

package/extensions/dm-mcp-adapter/search-ranking.js

@@ -1,6 +1,9 @@
 import { getServerPrefix, getToolNameCandidates, isServerDisabled, matchesToolPattern, resolveToolPrefix } from "./types.js";
 import { isServerInActiveFailureBackoff } from "./failure-backoff.js";
 const MIN_STEM_LENGTH = 4;
+const MAX_UNICODE_BIGRAMS_PER_RUN = 64;
+const SEARCH_RUN = /[a-z0-9]+|(?:(?![a-z0-9])[\p{L}\p{N}\p{M}])+/gu;
+const ASCII_RUN = /^[a-z0-9]+$/;
 const FIELD_WEIGHTS = {
   name: 12,
   originalName: 10,
@@ -37,7 +40,29 @@ export function normalizeSearchText(value) {
   return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_./:-]+/g, " ").toLowerCase();
 }
 export function tokenize(value) {
-  return normalizeSearchText(value).split(/[^a-z0-9]+/).filter(Boolean);
+  const tokens = [];
+  for (const run of normalizeSearchText(value).match(SEARCH_RUN) ?? []) {
+    if (ASCII_RUN.test(run)) {
+      tokens.push(run);
+      continue;
+    }
+    const characters = [...run];
+    if (characters.length === 1 || characters.length > MAX_UNICODE_BIGRAMS_PER_RUN + 1) {
+      tokens.push(run);
+      continue;
+    }
+    let previous = "";
+    for (const character of characters) {
+      if (previous) {
+        tokens.push(previous + character);
+      }
+      previous = character;
+    }
+  }
+  return tokens;
+}
+function matchesAsciiStem(fieldToken, queryToken) {
+  return ASCII_RUN.test(fieldToken) && ASCII_RUN.test(queryToken) && (fieldToken.startsWith(queryToken) || fieldToken.length >= MIN_STEM_LENGTH && queryToken.startsWith(fieldToken));
 }
 function prepareToolSearch(tool, server, keywords) {
   const fields = {
@@ -78,7 +103,7 @@ function scorePreparedToolMatch(prepared, normalizedQuery, queryTokens) {
       if (fieldTokens.includes(token)) {
         score += weight * 4;
         matchedTokens.add(token);
-      } else if (fieldTokens.some((fieldToken) => fieldToken.startsWith(token) || fieldToken.length >= MIN_STEM_LENGTH && token.startsWith(fieldToken))) {
+      } else if (fieldTokens.some((fieldToken) => matchesAsciiStem(fieldToken, token))) {
         score += weight * 2;
         matchedTokens.add(token);
       } else if (value.includes(token)) {
@@ -108,7 +133,7 @@ function scorePreparedToolMatch(prepared, normalizedQuery, queryTokens) {
       if (prepared.keywordTokens.includes(token)) {
         score += weight * 4;
         matchedTokens.add(token);
-      } else if (prepared.keywordTokens.some((keywordToken) => keywordToken.startsWith(token) || keywordToken.length >= MIN_STEM_LENGTH && token.startsWith(keywordToken))) {
+      } else if (prepared.keywordTokens.some((keywordToken) => matchesAsciiStem(keywordToken, token))) {
         score += weight * 2;
         matchedTokens.add(token);
       } else if (prepared.keywordPhrases.some((phrase) => phrase.includes(token))) {
@@ -191,8 +216,8 @@ export function paginate(items, offset, limit) {
     nextOffset: nextOffset < total ? nextOffset : null
   };
 }
-export function rankSuggestions(state, name, limit) {
-  const stripped = Object.keys(state.config.mcpServers).flatMap((server) => ["server", "short", "mcp"].map((prefix) => getServerPrefix(server, prefix))).filter((candidate) => Boolean(candidate) && name.startsWith(`${candidate}_`)).sort((a, b) => b.length - a.length).map((candidate) => name.slice(candidate.length + 1));
+export function rankSuggestions(state, name, limit, server) {
+  const stripped = Object.keys(state.config.mcpServers).flatMap((serverName) => ["server", "short", "mcp"].map((prefix) => getServerPrefix(serverName, prefix))).filter((candidate) => Boolean(candidate) && name.startsWith(`${candidate}_`)).sort((a, b) => b.length - a.length).map((candidate) => name.slice(candidate.length + 1));
   const query = stripped[0] ?? name;
-  return rankToolMatches(state, query, undefined, false).slice(0, limit).map((match) => match.tool.name);
+  return rankToolMatches(state, query, server, false).slice(0, limit).map((match) => match.tool.name);
 }

package/extensions/dm-mcp-adapter/secure-keyring.js

@@ -0,0 +1,191 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const require = createRequire(import.meta.url);
+const TEST_STORE_ENV = "DM_MCP_ADAPTER_TEST_AUTH_STORE";
+const memoryEntries = new Map;
+let memoryReadCount = 0;
+let KeyringEntryClass;
+function key(service, account) {
+  return `${service}\x00${account}`;
+}
+function nativeStore(service) {
+  const entry = (account) => {
+    try {
+      KeyringEntryClass ??= loadKeyringEntryClass();
+      return new KeyringEntryClass(service, account);
+    } catch (error) {
+      throw new Error("OS secure credential storage is unavailable. Configure or unlock the OS credential store and retry.", { cause: error });
+    }
+  };
+  const run = (operation, account, payload) => {
+    try {
+      const credential = entry(account);
+      if (operation === "read")
+        return credential.getPassword() ?? undefined;
+      if (operation === "write")
+        credential.setPassword(payload);
+      else
+        credential.deleteCredential();
+      return;
+    } catch (error) {
+      if (!shouldRecoverKeyring(error))
+        throw error;
+      return recoverKeyring(operation, service, account, payload);
+    }
+  };
+  return {
+    read: (account) => run("read", account),
+    write: (account, payload) => {
+      run("write", account, payload);
+    },
+    remove: (account) => {
+      run("remove", account);
+    }
+  };
+}
+function shouldRecoverKeyring(error) {
+  if (process.platform !== "linux" || process.env.DM_MCP_ADAPTER_DISABLE_KEYRING_RECOVERY === "1")
+    return false;
+  const seen = new Set;
+  for (let depth = 0;depth < 16 && error !== undefined && !seen.has(error); depth++) {
+    seen.add(error);
+    const candidate = typeof error === "object" && error !== null ? error : { message: error };
+    if ([candidate.name, candidate.message, candidate.code].some((value) => typeof value === "string" && /\b(?:KeyRevoked|key\s+(?:has been\s+)?revoked)\b/i.test(value)))
+      return true;
+    error = candidate.cause;
+  }
+  return false;
+}
+function recoverKeyring(operation, service, account, payload) {
+  try {
+    const adjacentHelper = new URL("./mcp-keyring-helper.cjs", import.meta.url);
+    const helper = existsSync(adjacentHelper) ? adjacentHelper : new URL("../mcp-keyring-helper.cjs", import.meta.url);
+    const result = spawnSync("keyctl", ["session", "-", process.execPath, fileURLToPath(helper)], {
+      input: `${JSON.stringify({ operation, service, account, payload })}
+`,
+      encoding: "utf8",
+      stdio: "pipe",
+      shell: false,
+      timeout: 1e4,
+      killSignal: "SIGKILL",
+      maxBuffer: 1024 * 1024,
+      windowsHide: true
+    });
+    if (result.error || result.status !== 0 || result.signal)
+      throw new Error;
+    const response = JSON.parse(result.stdout);
+    if (typeof response !== "object" || response === null || Array.isArray(response))
+      throw new Error;
+    const value = response;
+    if (value.ok !== true)
+      throw new Error;
+    const allowedKeys = operation === "read" ? ["ok", "found", "value"] : ["ok"];
+    if (Object.keys(response).some((key) => !allowedKeys.includes(key)))
+      throw new Error;
+    if (operation === "read") {
+      if (value.found === true && typeof value.value === "string")
+        return value.value;
+      if (value.found === false && value.value === undefined)
+        return;
+      throw new Error;
+    }
+    return;
+  } catch {
+    throw new Error("Linux keyring recovery failed. Configure or unlock the OS credential store and retry.");
+  }
+}
+export function createSecureKeyringStore(service) {
+  const mode = process.env[TEST_STORE_ENV];
+  if (mode === "memory" || mode === "sizelimited") {
+    return {
+      read(account) {
+        memoryReadCount++;
+        return memoryEntries.get(key(service, account));
+      },
+      write(account, payload) {
+        if (mode === "sizelimited" && payload.length > 1280)
+          throw new Error("secure credential value exceeds platform limit");
+        memoryEntries.set(key(service, account), payload);
+      },
+      remove(account) {
+        memoryEntries.delete(key(service, account));
+      }
+    };
+  }
+  if (mode === "unavailable") {
+    return {
+      read() {
+        memoryReadCount++;
+        throw new Error("simulated secure credential store unavailable");
+      },
+      write() {
+        throw new Error("simulated secure credential store unavailable");
+      },
+      remove() {
+        throw new Error("simulated secure credential store unavailable");
+      }
+    };
+  }
+  return nativeStore(service);
+}
+function loadKeyringEntryClass(keyringRequire = require, platform = process.platform, arch = process.arch) {
+  try {
+    return keyringRequire("@napi-rs/keyring").Entry;
+  } catch (loaderError) {
+    try {
+      return loadKeyringNativeBindingFallback(keyringRequire, platform, arch).Entry;
+    } catch (fallbackError) {
+      const message = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+      throw new Error(`Failed to load @napi-rs/keyring; absolute-path native binding fallback also failed: ${message}`, { cause: loaderError });
+    }
+  }
+}
+function loadKeyringNativeBindingFallback(keyringRequire, platform, arch) {
+  let lastError;
+  for (const suffix of getKeyringNativeBindingSuffixes(platform, arch)) {
+    try {
+      const packageName = `@napi-rs/keyring-${suffix}`;
+      const packageJsonPath = keyringRequire.resolve(`${packageName}/package.json`);
+      return keyringRequire(join(dirname(packageJsonPath), `keyring.${suffix}.node`));
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function getKeyringNativeBindingSuffixes(platform, arch) {
+  if (platform === "darwin")
+    return arch === "arm64" ? ["darwin-arm64"] : arch === "x64" ? ["darwin-x64"] : [];
+  if (platform === "win32")
+    return arch === "arm64" ? ["win32-arm64-msvc"] : arch === "x64" ? ["win32-x64-msvc"] : arch === "ia32" ? ["win32-ia32-msvc"] : [];
+  if (platform === "linux") {
+    if (arch === "arm64")
+      return ["linux-arm64-gnu", "linux-arm64-musl"];
+    if (arch === "arm")
+      return ["linux-arm-gnueabihf"];
+    if (arch === "riscv64")
+      return ["linux-riscv64-gnu"];
+    if (arch === "x64")
+      return ["linux-x64-gnu", "linux-x64-musl"];
+  }
+  return platform === "freebsd" && arch === "x64" ? ["freebsd-x64"] : [];
+}
+export function resetTestSecureKeyring() {
+  memoryEntries.clear();
+  memoryReadCount = 0;
+}
+export function getTestSecureKeyringReadCount() {
+  return memoryReadCount;
+}
+export function getTestSecureKeyringEntries() {
+  return [...memoryEntries.entries()];
+}
+export function setTestSecureKeyringEntry(service, account, payload) {
+  memoryEntries.set(key(service, account), payload);
+}
+export function removeTestSecureKeyringEntry(service, account) {
+  memoryEntries.delete(key(service, account));
+}