@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

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

@@ -3,6 +3,7 @@ import {
   MCP_STATUS_SNAPSHOT_VERSION
 } from "./types.js";
 import { getFailureAgeSeconds, isServerInActiveFailureBackoff } from "./failure-backoff.js";
+import { describeProjectServerBlock } from "./project-server-trust.js";
 export function createMcpStatusSnapshot(state) {
   const servers = [];
   let totalTools = 0;
@@ -20,7 +21,12 @@ export function createMcpStatusSnapshot(state) {
     const directToolCount = disabled ? 0 : state.directToolCounts?.get(name) ?? 0;
     const resourceCount = disabled || activeFailure ? undefined : state.resourceCounts?.get(name) ?? (connection?.status === "connected" ? connection.resources.length : undefined);
     let status = "not-connected";
-    if (disabled) {
+    const block = state.blockedProjectServers?.get(name);
+    const blockedReason = block ? describeProjectServerBlock(block.reason) : undefined;
+    if (block) {
+      status = "blocked";
+      disabledCount++;
+    } else if (disabled) {
       status = "disabled";
       disabledCount++;
     } else if (connection?.status === "connected") {
@@ -45,7 +51,8 @@ export function createMcpStatusSnapshot(state) {
       ...connection?.status === "connected" && connection.listenCatalogStale ? { catalogStale: true } : {},
       ...resourceCount !== undefined ? { resourceCount } : {},
       ...status === "failed" && failedAgoSeconds !== null ? { failedAgoSeconds } : {},
-      disabled
+      disabled,
+      ...blockedReason ? { blockedReason } : {}
     });
   }
   return {

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

@@ -154,6 +154,10 @@ export function createMcpTraceWriter(sessionCwd, settings = {}, randomSuffix = M
 export function isMcpTraceEnabled(definition, settings) {
   return definition.trace ?? settings?.enabled === true;
 }
+const untracedMessageHandlers = new WeakMap;
+export function untracedMessageHandler(transport) {
+  return untracedMessageHandlers.get(transport)?.() ?? transport.onmessage;
+}
 export function wrapTransportWithMcpTrace(transport, server, transportKind, observer) {
   let messageHandler = transport.onmessage;
   let tracedMessageHandler;
@@ -179,6 +183,7 @@ export function wrapTransportWithMcpTrace(transport, server, transportKind, obse
       }
     });
     transport.onmessage = messageHandler;
+    untracedMessageHandlers.set(transport, () => messageHandler);
   } catch {}
   transport.send = async (message, options) => {
     const started = performance.now();

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

@@ -7,6 +7,7 @@ import { getToolUiResourceUri } from "./ui-app-bridge-helpers.js";
 import { createToolSelectorCandidateIndex, formatPromptCommandName, formatToolName, getToolNameCandidates, isServerDisabled, isToolAllowed, resolveToolPrefix, resolveUniqueNameOwnership } from "./types.js";
 import { resourceNameToToolName } from "./resource-tools.js";
 import {
+  extractToolAnnotations,
   extractToolUiStreamMode,
   interpolateEnvRecord,
   interpolateEnvVars,
@@ -17,7 +18,6 @@ import {
 } from "./utils.js";
 import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.js";
 const CACHE_VERSION = 1;
-const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 export function getMetadataCachePath() {
   return getAgentPath("mcp-cache.json");
 }
@@ -38,31 +38,57 @@ export function loadMetadataCache() {
     return null;
   }
 }
-export function saveMetadataCache(cache) {
+export function saveMetadataCache(cache, options = {}) {
+  updateMetadataCacheFile((servers) => {
+    const next = { ...servers };
+    for (const [name, entry] of Object.entries(cache.servers)) {
+      const disk = servers[name];
+      if (!options.startupSnapshot) {
+        next[name] = entry;
+      } else if (entry.discoveryFailed) {
+        if (JSON.stringify(disk) === JSON.stringify(options.startupSnapshot[name]))
+          next[name] = entry;
+      } else if (disk && !disk.discoveryFailed && disk.configHash === entry.configHash) {
+        if ((disk.cachedAt ?? 0) > entry.cachedAt)
+          continue;
+        const outputShapes = { ...entry.outputShapes, ...keepOutputShapes(disk, entry.configHash, entry.tools) };
+        next[name] = Object.keys(outputShapes).length > 0 ? { ...entry, outputShapes } : entry;
+      } else {
+        next[name] = entry;
+      }
+    }
+    return next;
+  });
+}
+function updateMetadataCacheFile(update) {
   const cachePath = getMetadataCachePath();
   const dir = dirname(cachePath);
   mkdirSync(dir, { recursive: true });
-  let merged = { version: CACHE_VERSION, servers: {} };
+  let servers = {};
   try {
     if (existsSync(cachePath)) {
       const existing = JSON.parse(readFileSync(cachePath, "utf-8"));
       if (existing && existing.version === CACHE_VERSION && existing.servers) {
-        merged.servers = { ...existing.servers };
+        servers = { ...existing.servers };
       }
     }
   } catch {}
-  merged.version = CACHE_VERSION;
-  merged.servers = { ...merged.servers, ...cache.servers };
+  const next = update(servers);
+  if (!next)
+    return;
   const tmpPath = `${cachePath}.${process.pid}.tmp`;
-  writeFileSync(tmpPath, JSON.stringify(merged), "utf-8");
+  writeFileSync(tmpPath, JSON.stringify({ version: CACHE_VERSION, servers: next }), "utf-8");
   renameSync(tmpPath, cachePath);
 }
 export function computeServerHash(definition, environment = process.env) {
+  const isStdio = !!definition.command;
+  const literalEnv = isBuiltInAgentPlugin(definition, "env") || isStdio && definition.literalEnv === true;
   const identity = {
     command: resolveConfigPath(definition.command, environment),
     args: definition.args,
     socket: resolveConfigPath(definition.socket, environment),
-    env: isBuiltInAgentPlugin(definition, "env") ? definition.env : interpolateEnvRecord(definition.env, environment),
+    env: literalEnv ? definition.env : interpolateEnvRecord(definition.env, environment),
+    ...isStdio ? { inheritEnv: definition.inheritEnv !== false, literalEnv } : {},
     cwd: isBuiltInAgentPlugin(definition, "cwd") ? definition.cwd : resolveConfigPath(definition.cwd, environment),
     url: resolveServerUrl(definition, environment),
     headers: isBuiltInAgentPlugin(definition, "headers") ? definition.headers : interpolateEnvRecord(definition.headers, environment),
@@ -83,7 +109,30 @@ export function computeServerHash(definition, environment = process.env) {
   const normalized = stableStringify(identity);
   return createHash("sha256").update(normalized).digest("hex");
 }
-export function isServerCacheValid(entry, definition, maxAgeMs = CACHE_MAX_AGE_MS, environment = process.env) {
+export function outputShapeKey(tool) {
+  return stableStringify({ description: tool.description ?? "", inputSchema: tool.inputSchema ?? null });
+}
+export function saveObservedOutput(serverName, definition, toolName, toolKey, output) {
+  const configHash = computeServerHash(definition);
+  updateMetadataCacheFile((servers) => {
+    const entry = servers[serverName];
+    const cachedTool = entry?.tools?.find((tool) => tool.name === toolName);
+    if (!entry || !cachedTool || entry.configHash !== configHash || outputShapeKey(cachedTool) !== toolKey)
+      return;
+    return { ...servers, [serverName]: { ...entry, outputShapes: { ...entry.outputShapes, [toolName]: output } } };
+  });
+}
+export function keepOutputShapes(previous, configHash, tools) {
+  if (!previous?.outputShapes || previous.configHash !== configHash || previous.cacheScope === "private")
+    return;
+  const kept = Object.entries(previous.outputShapes).filter(([toolName]) => {
+    const before = previous.tools?.find((tool) => tool.name === toolName);
+    const after = tools.find((tool) => tool.name === toolName);
+    return before !== undefined && after !== undefined && outputShapeKey(before) === outputShapeKey(after);
+  });
+  return kept.length > 0 ? Object.fromEntries(kept) : undefined;
+}
+export function isServerCacheValid(entry, definition, maxAgeMs = 0, environment = process.env) {
   let configHash;
   try {
     configHash = computeServerHash(definition, environment);
@@ -94,6 +143,10 @@ export function isServerCacheValid(entry, definition, maxAgeMs = CACHE_MAX_AGE_M
     return false;
   if (!entry.cachedAt || typeof entry.cachedAt !== "number")
     return false;
+  if (entry.cacheScope === "private")
+    return false;
+  if (entry.discoveryFailed)
+    return false;
   const declaredTtlMs = entry.ttlMs;
   if (typeof declaredTtlMs === "number" && Number.isSafeInteger(declaredTtlMs) && declaredTtlMs >= 0) {
     if (declaredTtlMs === 0)
@@ -158,6 +211,7 @@ export function reconstructToolMetadata(serverName, entry, prefix, definition, c
       continue;
     }
     const name = formatToolName(tool.name, serverName, effectivePrefix);
+    const annotations = extractToolAnnotations(tool.annotations);
     metadata.push({
       name,
       originalName: tool.name,
@@ -166,7 +220,8 @@ export function reconstructToolMetadata(serverName, entry, prefix, definition, c
       ...tool.outputSchema !== undefined ? { outputSchema: tool.outputSchema } : {},
       ...tool.uiResourceUri !== undefined ? { uiResourceUri: tool.uiResourceUri } : {},
       ...tool.uiVisibility !== undefined ? { uiVisibility: tool.uiVisibility } : {},
-      ...tool.uiStreamMode !== undefined ? { uiStreamMode: tool.uiStreamMode } : {}
+      ...tool.uiStreamMode !== undefined ? { uiStreamMode: tool.uiStreamMode } : {},
+      ...annotations !== undefined ? { annotations } : {}
     });
   }
   if (definition.exposeResources !== false) {
@@ -216,6 +271,7 @@ export function serializeTools(tools) {
     const uiResourceUri = tryGetToolUiResourceUri(t);
     const uiVisibility = extractUiToolVisibility(t._meta);
     const uiStreamMode = extractToolUiStreamMode(t._meta);
+    const annotations = extractToolAnnotations(t.annotations);
     return {
       name: t.name,
       ...t.description !== undefined ? { description: t.description } : {},
@@ -223,7 +279,8 @@ export function serializeTools(tools) {
       ...t.outputSchema !== undefined ? { outputSchema: t.outputSchema } : {},
       ...uiResourceUri !== undefined ? { uiResourceUri } : {},
       ...uiVisibility !== undefined ? { uiVisibility } : {},
-      ...uiStreamMode !== undefined ? { uiStreamMode } : {}
+      ...uiStreamMode !== undefined ? { uiStreamMode } : {},
+      ...annotations !== undefined ? { annotations } : {}
     };
   });
 }

package/extensions/dm-mcp-adapter/namespace-tools.js

@@ -45,7 +45,7 @@ function resolveNamespaceProxyTools(config, cache, envOverride, existingDirectNa
   return filterCollidingNamespaceProxyTools(Object.keys(config.mcpServers).map((serverName) => namespaceProxyCandidate(config, cache, envOverride, existingDirectNames, serverName)).filter((spec) => spec !== null)).filter((spec) => !unavailableServers.has(spec.serverName));
 }
 function namespaceExecute(getState, getInitPromise, ensureRuntime, executeCall, serverName, getPiTools) {
-  return async (_toolCallId, params, signal, _onUpdate, ctx) => {
+  return async (toolCallId, params, signal, _onUpdate, ctx) => {
     if (typeof params.tool !== "string" || params.tool.length === 0) {
       return {
         content: [{ type: "text", text: `mcp__${serverName} requires a \`tool\` parameter naming the underlying MCP tool.` }],
@@ -84,7 +84,7 @@ function namespaceExecute(getState, getInitPromise, ensureRuntime, executeCall,
         details: { error: "not_initialized", server: serverName }
       };
     }
-    return executeCall(state, params.tool, params.args ?? {}, serverName, getPiTools, signal, "proxy");
+    return executeCall(state, params.tool, params.args ?? {}, serverName, getPiTools, signal, "proxy", undefined, toolCallId);
   };
 }
 const parameters = Type.Object({
@@ -133,10 +133,17 @@ function registerNamespaceProxyTool(input, spec, renderOptions, renderShell, ren
     execute: namespaceExecute(input.getState, input.getInitPromise, input.ensureRuntime, executeCall, spec.serverName, input.getPiTools)
   });
   input.guardReentrant?.();
+  if (input.fallbackDeactivatedNames?.delete(spec.toolName)) {
+    input.guardReentrant?.();
+    const activeTools = getActiveToolsIfReady(input.pi);
+    input.guardReentrant?.();
+    if (activeTools && !activeTools.includes(spec.toolName)) {
+      input.pi.setActiveTools([...activeTools, spec.toolName]);
+      input.guardReentrant?.();
+    }
+  }
 }
-function getActiveToolsForStaleCleanup(pi, staleNames) {
-  if (staleNames.length === 0)
-    return;
+function getActiveToolsIfReady(pi) {
   try {
     return pi.getActiveTools?.();
   } catch (error) {
@@ -145,6 +152,11 @@ function getActiveToolsForStaleCleanup(pi, staleNames) {
     throw error;
   }
 }
+function getActiveToolsForStaleCleanup(pi, staleNames) {
+  if (staleNames.length === 0)
+    return;
+  return getActiveToolsIfReady(pi);
+}
 function deactivateStaleNamespaceTools(input, nextNames) {
   const activeDirectNames = input.activeDirectNames ?? new Set;
   const staleNames = [...input.existingNamespaceNames].filter((name) => !nextNames.has(name) && !activeDirectNames.has(name));
@@ -163,12 +175,15 @@ function deactivateStaleNamespaceTools(input, nextNames) {
   if (!activeTools)
     return deactivated;
   const stale = new Set(staleNames);
+  const fallbackRemoved = staleNames.filter((name) => !deactivated.includes(name) && activeTools.includes(name));
   const nextActiveTools = activeTools.filter((name) => !stale.has(name));
   if (nextActiveTools.length === activeTools.length)
     return deactivated;
   input.guardReentrant?.();
   input.pi.setActiveTools(nextActiveTools);
   input.guardReentrant?.();
+  for (const name of fallbackRemoved)
+    input.fallbackDeactivatedNames?.add(name);
   for (const name of staleNames) {
     if (!deactivated.includes(name))
       deactivated.push(name);

package/extensions/dm-mcp-adapter/onboarding-state.js

@@ -21,7 +21,11 @@ export function loadOnboardingState() {
       version: 1,
       sharedConfigHintShown: raw.sharedConfigHintShown === true,
       setupCompleted: raw.setupCompleted === true,
-      ...typeof raw.lastDiscoveryFingerprint === "string" ? { lastDiscoveryFingerprint: raw.lastDiscoveryFingerprint } : {}
+      ...typeof raw.lastDiscoveryFingerprint === "string" ? { lastDiscoveryFingerprint: raw.lastDiscoveryFingerprint } : {},
+      ...Array.isArray(raw.piSignInImportsAsked) ? {
+        piSignInImportsAsked: raw.piSignInImportsAsked.filter((entry) => typeof entry?.server === "string" && typeof entry.url === "string")
+      } : {},
+      ...typeof raw.piBuiltinMcpHandledVersion === "string" ? { piBuiltinMcpHandledVersion: raw.piBuiltinMcpHandledVersion } : {}
     };
   } catch {
     return { ...DEFAULT_STATE };
@@ -60,3 +64,9 @@ export function markSetupCompleted(fingerprint) {
     };
   });
 }
+export function markPiSignInImportAsked(server, url) {
+  return updateOnboardingState((state) => ({
+    ...state,
+    piSignInImportsAsked: [...state.piSignInImportsAsked ?? [], { server, url }]
+  }));
+}

package/extensions/dm-mcp-adapter/output-shape.js

@@ -0,0 +1,312 @@
+import { logger } from "./logger.js";
+import { outputShapeKey, saveObservedOutput } from "./metadata-cache.js";
+import { formatPropertyName } from "./ts-shape.js";
+const MAX_DEPTH = 6;
+const MAX_ARRAY_SAMPLE = 5;
+const MAX_OBJECT_KEYS = 40;
+const FIELD_NAME = /^[A-Za-z_$][A-Za-z0-9_$]{0,39}$/;
+const MAX_UNION = 4;
+const MAX_NODES_PER_CALL = 1000;
+const MAX_SHAPE_CHARS = 4 * 1024;
+const MAX_JSON_TEXT_CHARS = 256 * 1024;
+const MIN_ALIAS_CHARS = 80;
+const SHAPE_TYPES = new Set(["null", "boolean", "number", "string", "object", "array"]);
+export function observedOutputRecorder(state, serverName, toolName) {
+  const tool = findTool(state, serverName, toolName);
+  const listingIsPrivate = () => state.manager.getConnection(serverName)?.toolListHints?.cacheScope === "private";
+  const privateAtStart = listingIsPrivate();
+  return (result) => recordObservedOutput(state, serverName, tool, privateAtStart || listingIsPrivate(), result);
+}
+function recordObservedOutput(state, serverName, tool, observedPrivately, result) {
+  if (!tool || tool.outputSchema !== undefined)
+    return;
+  const toolName = tool.originalName;
+  const observed = readResultValue(result);
+  if (!observed)
+    return;
+  const definition = state.config.mcpServers[serverName];
+  if (!definition)
+    return;
+  const shape = inferShape(observed.value, 0, { nodes: MAX_NODES_PER_CALL });
+  const byTool = observedOutputsFor(state, definition);
+  const toolKey = outputShapeKey(tool);
+  const previous = byTool.get(toolName);
+  const mergeable = previous?.source === observed.source && previous.toolKey === toolKey;
+  const next = {
+    source: observed.source,
+    shape: fitShape(mergeable ? mergeShapes(previous.shape, shape) : shape),
+    toolKey,
+    private: observedPrivately || mergeable && previous.private
+  };
+  byTool.set(toolName, next);
+  if (state.scriptTool === true && !next.private && JSON.stringify(next) !== JSON.stringify(previous)) {
+    try {
+      saveObservedOutput(serverName, definition, toolName, toolKey, { source: next.source, shape: next.shape });
+    } catch (error) {
+      logger.debug(`MCP: failed to save output shape for ${serverName}/${toolName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+export function seedObservedOutputs(state, serverName, entry) {
+  const definition = state.config.mcpServers[serverName];
+  const saved = entry.outputShapes;
+  if (!definition || typeof saved !== "object" || saved === null)
+    return;
+  const byTool = observedOutputsFor(state, definition);
+  for (const [toolName, value] of Object.entries(saved)) {
+    const cachedTool = Array.isArray(entry.tools) ? entry.tools.find((tool) => tool?.name === toolName) : undefined;
+    if (!cachedTool || typeof value !== "object" || value === null)
+      continue;
+    const toolKey = outputShapeKey(cachedTool);
+    if (byTool.get(toolName)?.toolKey === toolKey)
+      continue;
+    const { source, shape } = value;
+    if (source !== "structuredContent" && source !== "jsonText")
+      continue;
+    const parsed = readSavedShape(shape, 0);
+    if (parsed && !isUnknown(parsed))
+      byTool.set(toolName, { source, shape: fitShape(parsed), toolKey, private: false });
+  }
+}
+export function getObservedOutput(state, serverName, tool) {
+  if (tool.outputSchema !== undefined)
+    return;
+  const definition = state.config.mcpServers[serverName];
+  const observed = definition && state.observedOutputs?.get(definition)?.get(tool.originalName);
+  return observed && observed.toolKey === outputShapeKey(tool) && !isUnknown(observed.shape) ? observed : undefined;
+}
+export function renderOutputShape(shape) {
+  const plain = new Map;
+  const uses = new Map;
+  const once = renderShape(shape, "item", (node, field, text) => {
+    plain.set(node, text);
+    const use = uses.get(text);
+    if (use)
+      use.count++;
+    else
+      uses.set(text, { count: 1, field });
+    return text;
+  });
+  const names = new Map;
+  const taken = new Set(["Record"]);
+  for (const [text, use] of uses) {
+    if (use.count < 2 || text.length < MIN_ALIAS_CHARS)
+      continue;
+    const words = use.field.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+    const base = /^[A-Za-z]/.test(words) ? words : `T${words}`;
+    let name = base;
+    for (let suffix = 2;taken.has(name); suffix++)
+      name = `${base}${suffix}`;
+    taken.add(name);
+    names.set(text, name);
+  }
+  if (names.size === 0)
+    return once;
+  const definitions = new Map;
+  const main = renderShape(shape, "item", (node, _field, text) => {
+    const name = names.get(plain.get(node));
+    if (!name)
+      return text;
+    if (!definitions.has(name))
+      definitions.set(name, text);
+    return name;
+  });
+  return [...[...definitions].map(([name, body]) => `type ${name} = ${body};`), main].join(`
+`);
+}
+function renderShape(shape, field, onObject) {
+  if (shape.anyOf)
+    return shape.anyOf.map((variant) => renderShape(variant, field, onObject)).join(" | ");
+  switch (shape.type) {
+    case undefined:
+      return "unknown";
+    case "object": {
+      if (shape.additionalProperties)
+        return `Record<string, ${renderShape(shape.additionalProperties, field, onObject)}>`;
+      const required = new Set(shape.required);
+      const properties = Object.entries(shape.properties ?? {}).map(([name, property]) => `${formatPropertyName(name)}${required.has(name) ? "" : "?"}: ${renderShape(property, name, onObject)};`);
+      return onObject(shape, field, properties.length === 0 ? "{}" : `{ ${properties.join(" ")} }`);
+    }
+    case "array": {
+      if (!shape.items)
+        return "unknown[]";
+      const item = renderShape(shape.items, field, onObject);
+      return shape.items.anyOf ? `(${item})[]` : `${item}[]`;
+    }
+    default:
+      return shape.type;
+  }
+}
+function observedOutputsFor(state, definition) {
+  const observedOutputs = state.observedOutputs ??= new WeakMap;
+  let byTool = observedOutputs.get(definition);
+  if (!byTool)
+    observedOutputs.set(definition, byTool = new Map);
+  return byTool;
+}
+function readSavedShape(value, depth) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || depth > MAX_DEPTH)
+    return;
+  const raw = value;
+  if (raw.anyOf !== undefined) {
+    if (!Array.isArray(raw.anyOf) || raw.anyOf.length < 2 || raw.anyOf.length > MAX_UNION || raw.anyOf.some((variant) => typeof variant !== "object" || variant === null || ("anyOf" in variant)))
+      return;
+    const variants = raw.anyOf.map((variant) => readSavedShape(variant, depth));
+    return variants.every((variant) => variant?.type !== undefined) ? { anyOf: variants } : undefined;
+  }
+  if (raw.type === undefined)
+    return {};
+  if (typeof raw.type !== "string" || !SHAPE_TYPES.has(raw.type))
+    return;
+  const shape = { type: raw.type };
+  for (const key of ["items", "additionalProperties"]) {
+    if (raw[key] === undefined)
+      continue;
+    const child = readSavedShape(raw[key], depth + 1);
+    if (!child)
+      return;
+    shape[key] = child;
+  }
+  if (raw.properties !== undefined) {
+    if (typeof raw.properties !== "object" || raw.properties === null || Array.isArray(raw.properties))
+      return;
+    const entries = Object.entries(raw.properties);
+    if (entries.length > MAX_OBJECT_KEYS)
+      return;
+    const properties = {};
+    for (const [key, child] of entries) {
+      const property = key !== "__proto__" && FIELD_NAME.test(key) ? readSavedShape(child, depth + 1) : undefined;
+      if (!property)
+        return;
+      properties[key] = property;
+    }
+    shape.properties = properties;
+    shape.required = Array.isArray(raw.required) ? raw.required.filter((key) => typeof key === "string" && Object.hasOwn(properties, key)) : [];
+  }
+  return shape;
+}
+function findTool(state, serverName, toolName) {
+  return state.toolMetadata.get(serverName)?.find((tool) => tool.originalName === toolName && !tool.resourceUri);
+}
+function readResultValue(result) {
+  const structured = result.structuredContent;
+  if (typeof structured === "object" && structured !== null)
+    return { source: "structuredContent", value: structured };
+  const content = result.content;
+  if (!Array.isArray(content) || content.length !== 1)
+    return;
+  const block = content[0];
+  if (block.type !== "text" || typeof block.text !== "string" || block.text.length > MAX_JSON_TEXT_CHARS)
+    return;
+  const text = block.text.trim();
+  if (!text.startsWith("{") && !text.startsWith("["))
+    return;
+  try {
+    return { source: "jsonText", value: JSON.parse(text) };
+  } catch {
+    return;
+  }
+}
+function inferShape(value, depth, budget) {
+  if (--budget.nodes < 0)
+    return {};
+  if (value === null)
+    return { type: "null" };
+  if (typeof value === "boolean" || typeof value === "number" || typeof value === "string")
+    return { type: typeof value };
+  if (typeof value !== "object" || depth >= MAX_DEPTH)
+    return {};
+  if (Array.isArray(value)) {
+    const items = value.slice(0, MAX_ARRAY_SAMPLE).map((item) => inferShape(item, depth + 1, budget));
+    return items.length === 0 ? { type: "array" } : { type: "array", items: items.reduce(mergeShapes) };
+  }
+  const record = value;
+  const keys = [];
+  let isMap = false;
+  for (const key in record) {
+    if (!Object.hasOwn(record, key))
+      continue;
+    keys.push(key);
+    if (keys.length > MAX_OBJECT_KEYS || !FIELD_NAME.test(key) || /\d{4}/.test(key) || key === "__proto__") {
+      isMap = true;
+      break;
+    }
+  }
+  if (isMap) {
+    const values = keys.slice(0, MAX_ARRAY_SAMPLE).map((key) => inferShape(record[key], depth + 1, budget));
+    return { type: "object", additionalProperties: values.reduce(mergeShapes) };
+  }
+  const properties = {};
+  for (const key of keys)
+    properties[key] = inferShape(record[key], depth + 1, budget);
+  return { type: "object", properties, required: keys };
+}
+function isUnknown(shape) {
+  return shape.type === undefined && shape.anyOf === undefined;
+}
+function mergeShapes(left, right) {
+  if (isUnknown(left) || isUnknown(right))
+    return {};
+  const variants = [...left.anyOf ?? [left]];
+  for (const variant of right.anyOf ?? [right]) {
+    const index = variants.findIndex((existing) => existing.type === variant.type);
+    if (index === -1)
+      variants.push(variant);
+    else
+      variants[index] = mergeSameType(variants[index], variant);
+  }
+  if (variants.length > MAX_UNION)
+    return {};
+  return variants.length === 1 ? variants[0] : { anyOf: variants };
+}
+function mergeSameType(left, right) {
+  if (left.type === "array") {
+    const items = left.items && right.items ? mergeShapes(left.items, right.items) : left.items ?? right.items;
+    return items ? { type: "array", items } : { type: "array" };
+  }
+  if (left.type !== "object")
+    return left;
+  const keys = new Set([...Object.keys(left.properties ?? {}), ...Object.keys(right.properties ?? {})]);
+  if (left.additionalProperties || right.additionalProperties || keys.size > MAX_OBJECT_KEYS) {
+    const values = [
+      left.additionalProperties,
+      right.additionalProperties,
+      ...Object.values(left.properties ?? {}),
+      ...Object.values(right.properties ?? {})
+    ].filter((shape) => shape !== undefined);
+    return { type: "object", additionalProperties: values.reduce(mergeShapes) };
+  }
+  const properties = {};
+  for (const key of keys) {
+    const leftProperty = left.properties?.[key];
+    const rightProperty = right.properties?.[key];
+    properties[key] = leftProperty && rightProperty ? mergeShapes(leftProperty, rightProperty) : leftProperty ?? rightProperty;
+  }
+  const rightRequired = new Set(right.required);
+  return { type: "object", properties, required: (left.required ?? []).filter((key) => rightRequired.has(key)) };
+}
+function fitShape(shape) {
+  for (let depth = MAX_DEPTH;depth > 0; depth--) {
+    const pruned = pruneShape(shape, depth);
+    if (renderOutputShape(pruned).length <= MAX_SHAPE_CHARS)
+      return pruned;
+  }
+  return {};
+}
+function pruneShape(shape, depth) {
+  if (shape.anyOf) {
+    const variants = shape.anyOf.map((variant) => pruneShape(variant, depth));
+    return variants.some(isUnknown) ? {} : { anyOf: variants };
+  }
+  if (shape.type !== "object" && shape.type !== "array")
+    return shape;
+  if (depth === 0)
+    return {};
+  const prune = (child) => pruneShape(child, depth - 1);
+  return {
+    ...shape,
+    ...shape.properties ? { properties: Object.fromEntries(Object.entries(shape.properties).map(([key, child]) => [key, prune(child)])) } : {},
+    ...shape.items ? { items: prune(shape.items) } : {},
+    ...shape.additionalProperties ? { additionalProperties: prune(shape.additionalProperties) } : {}
+  };
+}

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

@@ -4,8 +4,10 @@ import { getAgentDir, getConfigDirName } from "./agent-dir.js";
 import { parseJsonWithComments, resolveContainedPath, resolveRealContainedPath } from "./utils.js";
 export function loadPackageMcpConfigs(cwd = process.cwd()) {
   const mcpServers = {};
+  const serverSources = new Map;
   const seen = new Set;
-  for (const packageRoot of getConfiguredPackageRoots(cwd)) {
+  for (const packageSource of getConfiguredPackageRoots(cwd)) {
+    const { packageRoot } = packageSource;
     const manifest = readPackageManifest(packageRoot);
     if (!manifest || typeof manifest.name !== "string" || !manifest.name)
       continue;
@@ -34,10 +36,11 @@ export function loadPackageMcpConfigs(cwd = process.cwd()) {
         packageServers.add(normalizedName);
         seen.add(normalizedName);
         mcpServers[normalizedName] = server;
+        serverSources.set(normalizedName, packageSource);
       }
     }
   }
-  return { mcpServers };
+  return { mcpServers, serverSources };
 }
 function getConfiguredPackageRoots(cwd) {
   const roots = [];
@@ -61,8 +64,9 @@ function getConfiguredPackageRoots(cwd) {
       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);
+      if (root && !roots.some((entry) => entry.packageRoot === root)) {
+        roots.push({ packageRoot: root, scope, settingsPath });
+      }
     }
   }
   return roots;
@@ -75,8 +79,13 @@ function resolvePackageRoot(source, scope, cwd) {
   }
   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$/, "");
+    const isUrl = /^[a-z]+:\/\//i.test(gitSource);
+    if (isUrl && !URL.canParse(gitSource))
+      return null;
+    const url = isUrl ? new URL(gitSource) : null;
+    const value = url ? url.hostname + url.pathname : gitSource.replace(/^git@([^:]+):/, "$1/");
+    const refStart = value.indexOf("@", value.indexOf("/"));
+    const path = (refStart < 0 || refStart === value.length - 1 ? value : value.slice(0, refStart)).replace(/\.git$/, "");
     return path && !path.startsWith("/") ? resolveContainedPath(join(baseDir, "git"), path) : null;
   }
   return isAbsolute(source) ? resolve(source) : resolve(baseDir, source);