@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

@@ -0,0 +1,342 @@
+import { randomUUID } from "node:crypto";
+import { untracedMessageHandler } from "./mcp-trace.js";
+export const MCP_PROTOCOL_EVENT = "dm-mcp-adapter:protocol:v1";
+const reserved = new Set([
+  "tools",
+  "resources",
+  "prompts",
+  "sampling",
+  "elicitation",
+  "logging",
+  "roots",
+  "completion",
+  "completions",
+  "tasks",
+  "subscriptions",
+  "server",
+  "client",
+  "notifications",
+  "rpc",
+  "initialize",
+  "ping"
+]);
+const record = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function validate(raw) {
+  if (!record(raw) || typeof raw.namespace !== "string" || !/^[a-z][a-z0-9_-]*$/.test(raw.namespace) || reserved.has(raw.namespace))
+    throw new Error("Invalid or reserved MCP protocol namespace");
+  const names = new Set;
+  for (const field of ["requests", "streams", "notifications"]) {
+    if (!Array.isArray(raw[field]) || raw[field].length > 64)
+      throw new Error("Invalid MCP protocol methods");
+    const prefix = field === "notifications" ? `notifications/${raw.namespace}/` : `${raw.namespace}/`;
+    for (const name of raw[field]) {
+      if (typeof name !== "string" || !name.startsWith(prefix) || !/^[a-zA-Z0-9_/-]+$/.test(name) || name.length <= prefix.length || names.has(name))
+        throw new Error("Invalid or duplicate MCP protocol method");
+      names.add(name);
+    }
+  }
+  return {
+    namespace: raw.namespace,
+    requests: [...raw.requests],
+    streams: [...raw.streams],
+    notifications: [...raw.notifications]
+  };
+}
+function paramsCopy(params) {
+  if (!record(params) || Object.hasOwn(params, "_meta"))
+    throw new Error("Protocol parameters must be an object without reserved _meta");
+  return structuredClone(params);
+}
+const message = (error) => error instanceof Error ? error.message : String(error);
+const routers = new WeakMap;
+function routerFor(connection) {
+  const transport = connection.transport;
+  const existing = routers.get(transport);
+  if (existing)
+    return existing;
+  const router = {
+    prefix: `mcp-extension-${randomUUID()}-`,
+    next: 0,
+    entries: new Map,
+    disconnect: new Set,
+    closed: false,
+    watchers: new Set
+  };
+  routers.set(transport, router);
+  const previousMessage = untracedMessageHandler(transport);
+  const previousClose = transport.onclose;
+  transport.onmessage = (frame, extra) => {
+    const raw = frame;
+    const id = typeof raw.id === "string" ? raw.id : raw.params?._meta?.["io.modelcontextprotocol/subscriptionId"];
+    const entry = typeof id === "string" ? router.entries.get(id) : undefined;
+    if (entry && !raw.method && (("result" in raw) || ("error" in raw))) {
+      entry.finish("error" in raw ? {
+        reason: "error",
+        error: typeof raw.error?.message === "string" ? raw.error.message : "MCP stream error",
+        ...typeof raw.error?.code === "number" ? { protocolError: structuredClone(raw.error) } : {}
+      } : { reason: "ended" });
+      return;
+    }
+    const cancelled = raw.method === "notifications/cancelled" && typeof raw.params?.requestId === "string" ? router.entries.get(raw.params.requestId) : undefined;
+    if (cancelled) {
+      cancelled.finish({
+        reason: "ended",
+        error: "MCP server cancelled the stream"
+      });
+      return;
+    }
+    if (entry && !("id" in raw) && entry.methods.has(raw.method) && record(raw.params)) {
+      try {
+        Promise.resolve(entry.notify(raw.method, raw.params)).catch((error) => entry.finish({
+          reason: "error",
+          error: `Protocol handler failed: ${message(error)}`
+        }));
+      } catch (error) {
+        entry.finish({
+          reason: "error",
+          error: `Protocol handler failed: ${message(error)}`
+        });
+      }
+      return;
+    }
+    if (!entry && typeof id === "string" && id.startsWith(router.prefix))
+      return;
+    if (!entry && !("id" in raw) && typeof raw.method === "string" && (raw.params === undefined || record(raw.params))) {
+      for (const watcher of [...router.watchers]) {
+        if (!router.watchers.has(watcher) || !watcher.methods.has(raw.method))
+          continue;
+        try {
+          Promise.resolve(watcher.notify(raw.method, structuredClone(raw.params ?? {}))).catch((error) => watcher.finish({
+            reason: "error",
+            error: `Protocol handler failed: ${message(error)}`
+          }));
+        } catch (error) {
+          watcher.finish({
+            reason: "error",
+            error: `Protocol handler failed: ${message(error)}`
+          });
+        }
+      }
+    }
+    previousMessage?.(frame, extra);
+  };
+  transport.onclose = () => {
+    router.closed = true;
+    try {
+      previousClose?.();
+    } finally {
+      for (const close of [...router.disconnect])
+        close();
+    }
+  };
+  return router;
+}
+function pin(connection) {
+  connection.activeProtocolOperations = (connection.activeProtocolOperations ?? 0) + 1;
+  let done = false;
+  return () => {
+    if (done)
+      return;
+    done = true;
+    connection.activeProtocolOperations--;
+    connection.lastUsedAt = Date.now();
+  };
+}
+export function createProtocolSession(connection, owner, definition) {
+  const spec = validate(definition);
+  if (owner.aborted || connection.status !== "connected")
+    throw new Error("MCP connection is unavailable");
+  const router = routerFor(connection);
+  if (router.closed)
+    throw new Error("MCP connection is unavailable");
+  const controller = new AbortController;
+  const active = new Set;
+  const ensure = (method, allowed) => {
+    if (controller.signal.aborted)
+      throw new Error("MCP protocol session ended");
+    if (!allowed.includes(method))
+      throw new Error(`Undeclared MCP protocol method: ${method}`);
+  };
+  const close = (reason) => {
+    if (controller.signal.aborted)
+      return;
+    for (const finish of [...active])
+      finish(reason);
+    controller.abort(new Error(reason.error ?? "MCP protocol session ended"));
+    owner.removeEventListener("abort", disconnected);
+    router.disconnect.delete(disconnected);
+  };
+  const disconnected = () => close({ reason: "disconnected", error: "MCP connection or session ended" });
+  owner.addEventListener("abort", disconnected, { once: true });
+  router.disconnect.add(disconnected);
+  return {
+    signal: controller.signal,
+    watchNotifications(methods, onNotification) {
+      if (!Array.isArray(methods) || methods.length === 0 || methods.length > 64)
+        throw new Error("Declared notification methods are required");
+      for (const method of methods)
+        ensure(method, spec.notifications);
+      if (typeof onNotification !== "function")
+        throw new Error("A protocol notification handler is required");
+      const release = pin(connection);
+      let settle;
+      const closed = new Promise((resolve) => {
+        settle = resolve;
+      });
+      let finished = false;
+      const finish = (end) => {
+        if (finished)
+          return;
+        finished = true;
+        router.watchers.delete(entry);
+        active.delete(finish);
+        release();
+        settle(end);
+      };
+      const entry = {
+        methods: new Set(methods),
+        notify: onNotification,
+        finish
+      };
+      router.watchers.add(entry);
+      active.add(finish);
+      return { closed, close: () => finish({ reason: "cancelled" }) };
+    },
+    async request(method, params = {}, signal) {
+      ensure(method, spec.requests);
+      const copy = paramsCopy(params);
+      const release = pin(connection);
+      try {
+        const z = await import("zod/v4");
+        return await connection.client.request({ method, params: copy }, z.record(z.string(), z.unknown()), {
+          signal: signal ? AbortSignal.any([signal, controller.signal]) : controller.signal
+        });
+      } finally {
+        release();
+      }
+    },
+    openStream(method, params, onNotification) {
+      ensure(method, spec.streams);
+      const copy = paramsCopy(params);
+      if (typeof onNotification !== "function")
+        throw new Error("A protocol notification handler is required");
+      const id = `${router.prefix}${router.next++}`;
+      const release = pin(connection);
+      let settle;
+      const closed = new Promise((resolve) => {
+        settle = resolve;
+      });
+      let finished = false;
+      let dispatched = false;
+      const requestController = new AbortController;
+      let cancellation;
+      const cancelWire = () => cancellation ??= router.closed || !dispatched || connection.transport.hasPerRequestStream ? Promise.resolve() : connection.client.notification({
+        method: "notifications/cancelled",
+        params: { requestId: id }
+      }).catch(() => {});
+      const finish = (end) => {
+        if (finished)
+          return;
+        finished = true;
+        router.entries.delete(id);
+        active.delete(finish);
+        release();
+        settle(end);
+        requestController.abort();
+        if (end.reason !== "ended")
+          cancelWire();
+      };
+      router.entries.set(id, {
+        methods: new Set(spec.notifications),
+        notify: onNotification,
+        finish
+      });
+      active.add(finish);
+      const sent = Promise.resolve().then(async () => {
+        if (finished)
+          return;
+        const envelope = connection.requestMetadata?.();
+        if (connection.client.getProtocolEra() === "modern" && !envelope)
+          throw new Error("MCP client request metadata is unavailable");
+        const meta = envelope ? { _meta: envelope } : {};
+        dispatched = true;
+        await connection.transport.send({
+          jsonrpc: "2.0",
+          id,
+          method,
+          params: { ...copy, ...meta }
+        }, {
+          requestSignal: requestController.signal,
+          onRequestStreamEnd: () => finish({
+            reason: "disconnected",
+            error: "MCP request stream ended without a final response"
+          })
+        });
+      });
+      sent.catch((error) => finish({ reason: "error", error: message(error) }));
+      return {
+        id,
+        sent,
+        closed,
+        async cancel() {
+          finish({ reason: "cancelled" });
+          await cancelWire();
+        }
+      };
+    },
+    close: () => close({ reason: "cancelled" })
+  };
+}
+export function registerProtocolBridge(pi, resolve) {
+  const registrations = new Set;
+  pi.events.on(MCP_PROTOCOL_EVENT, (raw) => {
+    if (!record(raw) || raw.result !== undefined || raw.error !== undefined)
+      return;
+    const request = raw;
+    try {
+      if (request.version !== 1)
+        throw new Error("Invalid MCP protocol registration version");
+      const definition = validate(request.definition);
+      if (registrations.has(definition.namespace))
+        throw new Error(`MCP protocol already registered: ${definition.namespace}`);
+      registrations.add(definition.namespace);
+      let disposed = false;
+      const sessions = new Set;
+      request.result = {
+        async connect(name) {
+          if (disposed)
+            throw new Error("MCP protocol registration disposed");
+          if (typeof name !== "string" || !name.trim())
+            throw new Error("MCP server name is required");
+          const target = await resolve(name);
+          if (disposed)
+            throw new Error("MCP protocol registration disposed");
+          const session = createProtocolSession(target.connection, target.signal, definition);
+          sessions.add(session);
+          session.signal.addEventListener("abort", () => sessions.delete(session), { once: true });
+          return session;
+        },
+        dispose() {
+          if (disposed)
+            return;
+          disposed = true;
+          registrations.delete(definition.namespace);
+          for (const session of sessions)
+            session.close();
+          sessions.clear();
+        }
+      };
+    } catch (error) {
+      request.error = error instanceof Error ? error : new Error(String(error));
+    }
+  });
+}
+export function registerMcpProtocol(pi, definition) {
+  const request = { version: 1, definition };
+  pi.events.emit(MCP_PROTOCOL_EVENT, request);
+  if (request.error)
+    throw request.error;
+  if (!request.result)
+    throw new Error("dm-mcp-adapter does not expose protocol extensions");
+  return request.result;
+}

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

@@ -9,6 +9,7 @@ const FIELD_WEIGHTS = {
   originalName: 10,
   server: 8,
   description: 5,
+  serverDescription: 5,
   keywords: 5
 };
 const searchCache = new WeakMap;
@@ -59,17 +60,18 @@ export function tokenize(value) {
       previous = character;
     }
   }
-  return tokens;
+  return [...new Set(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) {
+function prepareToolSearch(tool, server, keywords, serverDescription) {
   const fields = {
     name: normalizeSearchText(tool.name),
     originalName: normalizeSearchText(tool.originalName),
     server: normalizeSearchText(server),
-    description: normalizeSearchText(tool.description)
+    description: normalizeSearchText(tool.description),
+    serverDescription: normalizeSearchText(serverDescription ?? "")
   };
   const preparedFields = Object.entries(fields).map(([field, value]) => [field, value, tokenize(value)]);
   const keywordPhrases = keywords?.map((keyword) => normalizeSearchText(keyword).trim()).filter(Boolean) ?? [];
@@ -168,14 +170,14 @@ function getPreparedTools(state, serverName, metadata, definition, globalPrefix,
   }
   const toolPrefix = resolveToolPrefix(definition, globalPrefix);
   let cached = stateCache.get(serverName);
-  if (cached?.metadata !== metadata || cached.searchKeywords !== definition?.searchKeywords || cached.toolPrefix !== toolPrefix) {
-    cached = { metadata, searchKeywords: definition?.searchKeywords, toolPrefix };
+  if (cached?.metadata !== metadata || cached.searchKeywords !== definition?.searchKeywords || cached.serverDescription !== definition?.description || cached.toolPrefix !== toolPrefix) {
+    cached = { metadata, searchKeywords: definition?.searchKeywords, serverDescription: definition?.description, toolPrefix };
     stateCache.set(serverName, cached);
   }
   const cacheKey = includeKeywords ? "withKeywords" : "withoutKeywords";
   let prepared = cached[cacheKey];
   if (!prepared) {
-    prepared = metadata.map((tool) => prepareToolSearch(tool, serverName, includeKeywords && definition?.searchKeywords !== undefined ? resolveSearchKeywords(definition, tool.originalName, serverName, globalPrefix) : undefined));
+    prepared = metadata.map((tool) => prepareToolSearch(tool, serverName, includeKeywords && definition?.searchKeywords !== undefined ? resolveSearchKeywords(definition, tool.originalName, serverName, globalPrefix) : undefined, definition?.description));
     cached[cacheKey] = prepared;
   }
   return prepared;

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

@@ -58,7 +58,7 @@ function roundRobinNonLexical(query, matches) {
   return result;
 }
 function selectSemanticCandidates(state, query, server, allowedServers, limit) {
-  const eligible = eligibleMatches(state, server, new Set(allowedServers));
+  const eligible = eligibleMatches(state, server, allowedServers);
   let selected = eligible;
   if (eligible.length > limit) {
     const eligiblePaths = new Set(eligible.map((match) => `${match.server}\x00${match.tool.name}`));
@@ -87,7 +87,7 @@ export async function semanticSearch(state, query, server, signal, evaluator = e
     return { ok: false, error: { code: "disabled", message: "Jev semantic search is disabled." } };
   }
   if (settings.allowedServers.length === 0) {
-    return { ok: false, error: { code: "data_policy_denied", message: "Semantic search is enabled, but settings.jev.allowedServers is empty. Run /mcp jev setup or allow specific MCP servers." } };
+    return { ok: false, error: { code: "data_policy_denied", message: "Semantic search is enabled, but settings.jev.allowedServers is empty. Run /mcp-adapter jev setup or allow specific MCP servers." } };
   }
   if (server && !settings.allowedServers.includes(server)) {
     return { ok: false, error: { code: "data_policy_denied", message: `Server "${server}" is not allowed by settings.jev.allowedServers.` } };
@@ -98,7 +98,8 @@ export async function semanticSearch(state, query, server, signal, evaluator = e
   if (query.trim().length === 0) {
     return { ok: false, error: { code: "empty_query", message: "Semantic search query cannot be empty." } };
   }
-  const candidates = selectSemanticCandidates(state, query, server, settings.allowedServers, settings.semanticCandidateLimit);
+  const allowedServers = new Set(settings.allowedServers);
+  const candidates = selectSemanticCandidates(state, query, server, allowedServers, settings.semanticCandidateLimit);
   if (candidates.length === 0) {
     return { ok: false, error: { code: "no_eligible_tools", message: "Semantic search has no eligible cached tools from the allowed servers. Connect an allowed server or update settings.jev.allowedServers." } };
   }
@@ -130,7 +131,7 @@ export async function semanticSearch(state, query, server, signal, evaluator = e
     if (envelope.error.code === "timeout" || envelope.error.code === "rate_limited" || envelope.error.code === "service_unavailable") {
       return {
         ok: true,
-        matches: rankToolMatches(state, query, server),
+        matches: rankToolMatches(state, query, server).filter((match) => allowedServers.has(match.server)),
         backend: { requested: "semantic", used: "lexical", degraded: true, reason: envelope.error.code }
       };
     }