@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-mcp-adapter/dist/utils.js

@@ -0,0 +1,418 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import stripJsonComments from "strip-json-comments";
+export function stripUtf8Bom(raw) {
+  return raw.charCodeAt(0) === 65279 ? raw.slice(1) : raw;
+}
+export function parseJsonWithComments(raw) {
+  return JSON.parse(stripJsonComments(stripUtf8Bom(raw), { trailingCommas: true }));
+}
+export function resolveRealContainedPath(root, candidate, allowMissing = false) {
+  const contained = resolveContainedPath(root, candidate);
+  if (!contained)
+    return null;
+  const canonical = (path) => {
+    let existing = path;
+    while (allowMissing && !existsSync(existing)) {
+      const parent = dirname(existing);
+      if (parent === existing)
+        throw new Error("No existing path ancestor");
+      existing = parent;
+    }
+    return resolve(realpathSync(existing), relative(existing, path));
+  };
+  try {
+    return resolveContainedPath(canonical(root), canonical(contained));
+  } catch {
+    return null;
+  }
+}
+export function resolveContainedPath(root, candidate) {
+  const resolved = resolve(root, candidate);
+  const rel = relative(root, resolved);
+  return rel === "" || !rel.startsWith("..") && !rel.startsWith(sep) && !isAbsolute(rel) ? resolved : null;
+}
+export function stableStringify(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value) ?? "undefined";
+  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(",")}}`;
+}
+async function execOpen(pi, target, browser, signal) {
+  const os = platform();
+  if (os === "darwin") {
+    if (browser) {
+      return isAbsolute(browser) && extname(browser).toLowerCase() !== ".app" ? pi.exec(browser, [target], signal ? { signal } : {}) : pi.exec("open", ["-a", browser, target], signal ? { signal } : {});
+    }
+    return pi.exec("open", [target], signal ? { signal } : {});
+  }
+  if (os === "win32") {
+    return browser ? pi.exec("cmd", ["/c", "start", "", browser, target], signal ? { signal } : {}) : pi.exec("cmd", ["/c", "start", "", target], signal ? { signal } : {});
+  }
+  return browser ? pi.exec(browser, [target], signal ? { signal } : {}) : pi.exec("xdg-open", [target], signal ? { signal } : {});
+}
+export async function openUrl(pi, url, browser, signal) {
+  const result = await execOpen(pi, url, browser, signal);
+  if (result.code !== 0) {
+    throw new Error(result.stderr || `Failed to open browser (exit code ${result.code})`);
+  }
+}
+export async function openPath(pi, targetPath) {
+  const result = await execOpen(pi, targetPath);
+  if (result.code !== 0) {
+    throw new Error(result.stderr || `Failed to open path (exit code ${result.code})`);
+  }
+}
+export async function parallelLimit(items, limit, fn) {
+  const results = [];
+  const iterator = items.entries();
+  async function worker() {
+    while (true) {
+      const next = iterator.next();
+      if (next.done)
+        return;
+      const [index, item] = next.value;
+      results[index] = await fn(item);
+    }
+  }
+  const workers = Array(Math.min(limit, items.length)).fill(null).map(() => worker());
+  await Promise.all(workers);
+  return results;
+}
+export function getConfigPathFromArgv() {
+  let configPath;
+  for (let index = 2;index < process.argv.length; index++) {
+    const arg = process.argv[index];
+    if (arg === undefined)
+      continue;
+    if (arg === "--")
+      break;
+    if (arg === "--mcp-config") {
+      const value = process.argv[index + 1];
+      if (value !== undefined && !value.startsWith("-") && !value.startsWith("@")) {
+        configPath = value;
+        index++;
+      } else {
+        configPath = undefined;
+      }
+      continue;
+    }
+    if (arg.startsWith("--mcp-config=")) {
+      configPath = arg.slice("--mcp-config=".length);
+    }
+  }
+  return configPath;
+}
+export function interpolateEnvVars(value, environment = process.env) {
+  return value.replace(/\$\{(\w+)\}/g, (_, name) => environment[name] ?? "").replace(/\$env:(\w+)/g, (_, name) => environment[name] ?? "").replace(/\{env:(\w+)\}/g, (_, name) => environment[name] ?? "");
+}
+export function getMissingEnvVars(value, environment = process.env) {
+  const missing = new Set;
+  for (const match of value.matchAll(/\$\{(\w+)\}|\$env:(\w+)|\{env:(\w+)\}/g)) {
+    const name = match[1] ?? match[2] ?? match[3];
+    if (name && environment[name] === undefined) {
+      missing.add(name);
+    }
+  }
+  return [...missing];
+}
+export function toStringRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string")
+      result[key] = entry;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+function interpolateSecretExpression(value, environment) {
+  if (value.startsWith("!!"))
+    return interpolateEnvVars(value.slice(1), environment);
+  return value.startsWith("!") ? value : interpolateEnvVars(value, environment);
+}
+export function interpolateEnvRecord(values, environment = process.env) {
+  if (!values)
+    return;
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    interpolateSecretExpression(value, environment)
+  ]));
+}
+const COMMAND_SECRET_TIMEOUT_MS = 1e4;
+const COMMAND_SECRET_MAX_OUTPUT_BYTES = 1024 * 1024;
+export function resolveCommandSecret(value, context) {
+  if (value === undefined)
+    return;
+  if (value.startsWith("!!"))
+    return interpolateEnvVars(value.slice(1));
+  if (!value.startsWith("!"))
+    return interpolateEnvVars(value);
+  const result = spawnSync(value.slice(1), {
+    shell: true,
+    encoding: "utf8",
+    timeout: COMMAND_SECRET_TIMEOUT_MS,
+    maxBuffer: COMMAND_SECRET_MAX_OUTPUT_BYTES,
+    stdio: ["ignore", "pipe", "ignore"],
+    windowsHide: true
+  });
+  if (result.error) {
+    const code = result.error.code;
+    const reason = code === "ETIMEDOUT" ? "command timed out after 10 seconds" : code === "ENOBUFS" ? "command output exceeded 1 MiB" : "command failed to start";
+    throw new Error(`Failed to resolve ${context}: ${reason}`);
+  }
+  if (result.status !== 0) {
+    throw new Error(`Failed to resolve ${context}: command exited with code ${result.status ?? "unknown"}`);
+  }
+  const resolved = result.stdout.trim();
+  if (!resolved)
+    throw new Error(`Failed to resolve ${context}: command returned empty output`);
+  return resolved;
+}
+export function resolveCommandSecretsRecord(values, context) {
+  if (!values)
+    return;
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    resolveCommandSecret(value, context(key))
+  ]));
+}
+export function resolveServerUrl(definition, environment = process.env) {
+  if (definition.url == null)
+    return;
+  if (typeof definition.url !== "string") {
+    throw new Error("MCP server URL must be a string");
+  }
+  const missing = getMissingEnvVars(definition.url, environment);
+  if (missing.length > 0) {
+    throw new Error(`Missing environment variable${missing.length === 1 ? "" : "s"} in MCP server URL: ${missing.join(", ")}`);
+  }
+  const resolved = interpolateEnvVars(definition.url, environment);
+  try {
+    new URL(resolved);
+  } catch (error) {
+    throw new Error(`Invalid MCP server URL after environment interpolation: ${resolved}`, { cause: error });
+  }
+  return resolved;
+}
+export function resolveConfigPath(value, environment = process.env) {
+  if (value === undefined)
+    return;
+  return expandHomePath(interpolateEnvVars(value, environment));
+}
+export function expandHomePath(value) {
+  if (value === undefined)
+    return;
+  const resolved = value;
+  if (resolved === "~")
+    return homedir();
+  if (resolved.startsWith("~/") || platform() === "win32" && resolved.startsWith("~\\")) {
+    const suffix = platform() === "win32" ? resolved.slice(2).replace(/[\\/]/g, sep) : resolved.slice(2);
+    return join(homedir(), suffix);
+  }
+  return resolved;
+}
+export function resolveBearerToken(definition, environment = process.env) {
+  if (definition.bearerToken !== undefined) {
+    return interpolateSecretExpression(definition.bearerToken, environment);
+  }
+  return definition.bearerTokenEnv ? environment[definition.bearerTokenEnv] : undefined;
+}
+export function stripOscSequences(text) {
+  let result = "";
+  let index = 0;
+  while (index < text.length) {
+    const isEscOsc = text.charCodeAt(index) === 27 && text[index + 1] === "]";
+    const isC1Osc = text.charCodeAt(index) === 157;
+    if (!isEscOsc && !isC1Osc) {
+      result += text[index++];
+      continue;
+    }
+    index += isEscOsc ? 2 : 1;
+    while (index < text.length) {
+      const code = text.charCodeAt(index++);
+      if (code === 7 || code === 156)
+        break;
+      if (code === 27 && text[index] === "\\") {
+        index++;
+        break;
+      }
+    }
+  }
+  return result;
+}
+export function sanitizeTerminalText(text) {
+  return stripOscSequences(text).replace(/(?:\x1b\[[0-?]*[ -/]*[@-~]|\x1b[@-Z\\-_])/g, "").replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ").replace(/\s+/g, " ").trim();
+}
+export function formatTerminalError(error) {
+  const messages = [];
+  const seen = new Set;
+  const collect = (value) => {
+    if (seen.has(value))
+      return;
+    if (typeof value === "object" && value !== null || typeof value === "function")
+      seen.add(value);
+    if (value instanceof AggregateError) {
+      const countBefore = messages.length;
+      for (const nested of value.errors)
+        collect(nested);
+      if (value.cause !== undefined)
+        collect(value.cause);
+      if (messages.length === countBefore && value.message)
+        messages.push(value.message);
+      return;
+    }
+    if (value instanceof Error) {
+      if (value.message)
+        messages.push(value.message);
+      if (value.cause !== undefined)
+        collect(value.cause);
+      return;
+    }
+    messages.push(String(value));
+  };
+  collect(error);
+  return sanitizeTerminalText([...new Set(messages)].join(": "));
+}
+export function truncateAtWord(text, target) {
+  if (!text || text.length <= target)
+    return text;
+  const truncated = text.slice(0, target);
+  const lastSpace = truncated.lastIndexOf(" ");
+  if (lastSpace > target * 0.6) {
+    return truncated.slice(0, lastSpace) + "...";
+  }
+  return truncated + "...";
+}
+export const TOOL_CALL_ID_REQUEST_META_KEY = "dm-mcp-adapter/toolCallId";
+export function withToolCallIdMeta(meta, toolCallId) {
+  if (!toolCallId)
+    return meta;
+  return { ...meta, [TOOL_CALL_ID_REQUEST_META_KEY]: toolCallId };
+}
+export function normalizeDirectToolInputSchema(schema) {
+  const inputSchema = schema && typeof schema === "object" && !Array.isArray(schema) ? schema : { type: "object", properties: {} };
+  const { $schema, additionalProperties, ...normalized } = inputSchema;
+  return normalized;
+}
+export function normalizeToolArguments(value, context = "tool arguments") {
+  if (value === undefined || value === null || value === "")
+    return {};
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "")
+      return {};
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (error) {
+      throw new Error(`${context}: invalid args JSON (${error instanceof SyntaxError ? error.message : String(error)}); ` + `pass args as a JSON object, or as a valid JSON string encoding one`, { cause: error });
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`${context}: expected a JSON object, got ${Array.isArray(parsed) ? "array" : typeof parsed}`);
+    }
+    return parsed;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${context}: expected a JSON object, got ${Array.isArray(value) ? "array" : typeof value}`);
+  }
+  assertJsonSerializable(value, context);
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch (error) {
+    throw new Error(`${context}: value is not JSON-serializable: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+function assertJsonSerializable(value, context, path = "") {
+  if (value === null)
+    return;
+  if (typeof value === "string" || typeof value === "boolean")
+    return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value))
+      throw new Error(`${context}: value at ${path || "root"} is not a finite number`);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const [index, item] of value.entries())
+      assertJsonSerializable(item, context, `${path}[${index}]`);
+    return;
+  }
+  if (typeof value === "object") {
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+      throw new Error(`${context}: value at ${path || "root"} is not a plain JSON object`);
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new Error(`${context}: value at ${path || "root"} has symbol keys`);
+    }
+    for (const [key, item] of Object.entries(value)) {
+      assertJsonSerializable(item, context, path ? `${path}.${key}` : key);
+    }
+    return;
+  }
+  throw new Error(`${context}: value at ${path || "root"} is not JSON-serializable`);
+}
+export function formatAuthRequiredMessage(config, serverName, defaultMessage) {
+  const auth = config.mcpServers[serverName]?.auth;
+  if (typeof auth === "object")
+    return providerSignInMessage(serverName, auth.provider);
+  const template = config.settings?.authRequiredMessage;
+  return template ? template.replaceAll("${server}", serverName) : defaultMessage;
+}
+export function providerSignInMessage(serverName, provider) {
+  return `MCP server "${serverName}" needs sign-in. Run /login ${provider}, then /mcp-adapter reconnect ${serverName}.`;
+}
+export function providerAuthUrlError(url) {
+  const parsed = URL.canParse(url) ? new URL(url) : undefined;
+  if (parsed?.protocol === "https:")
+    return;
+  if (parsed?.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname))
+    return;
+  return "auth.provider requires an https URL, or http on localhost, 127.0.0.1, or [::1]";
+}
+export function formatMcpStatus(config, message) {
+  if (config.settings?.mcpFooterStatus === "off")
+    return;
+  return `${config.settings?.showStatusIcon === false ? "MCP: " : "\uD83D\uDD0C MCP: "}${message}`;
+}
+export function formatMcpFooterStatus(config, enabledCount, disabledCount, connectedCount) {
+  if (enabledCount + disabledCount === 0 || config.settings?.mcpFooterStatus === "off")
+    return;
+  const footerStatus = config.settings?.mcpFooterStatus ?? "full";
+  if (footerStatus === "compact")
+    return `MCP ${connectedCount}/${enabledCount}`;
+  let status = `${enabledCount} ${enabledCount === 1 ? "server" : "servers"} enabled`;
+  if (connectedCount > 0)
+    status += ` (${connectedCount} connected)`;
+  if (disabledCount > 0)
+    status += ` (${disabledCount} disabled)`;
+  return formatMcpStatus(config, status);
+}
+export function extractToolUiStreamMode(toolMeta) {
+  const uiMeta = toolMeta?.ui;
+  if (!uiMeta || typeof uiMeta !== "object")
+    return;
+  const streamMode = uiMeta["dm-mcp-adapter.streamMode"];
+  if (streamMode === "eager" || streamMode === "stream-first") {
+    return streamMode;
+  }
+  return;
+}
+export function extractToolAnnotations(annotations) {
+  if (!annotations || typeof annotations !== "object")
+    return;
+  const source = annotations;
+  const kept = {};
+  if (typeof source.title === "string")
+    kept.title = source.title;
+  for (const key of ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"]) {
+    if (typeof source[key] === "boolean")
+      kept[key] = source[key];
+  }
+  return Object.keys(kept).length > 0 ? kept : undefined;
+}

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

@@ -1,12 +1,77 @@
 import {
+  DEFAULT_REQUEST_TIMEOUT_MSEC,
   ProtocolError,
-  ProtocolErrorCode
+  ProtocolErrorCode,
+  SdkError,
+  SdkErrorCode
 } from "@modelcontextprotocol/client";
 import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
 import open from "open";
 import { abortable, throwIfAborted } from "./abort.js";
+import { combineAbortSignals } from "./runtime-owner.js";
+const promptPauses = new WeakMap;
 export function registerElicitationHandler(client, options) {
-  client.setRequestHandler("elicitation/create", (request) => handleElicitationRequest(options, request));
+  const state = { open: 0, deadlines: new Set };
+  promptPauses.set(client, state);
+  client.setRequestHandler("elicitation/create", (request) => whilePromptOpen(state, () => handleElicitationRequest(options, request)));
+}
+async function whilePromptOpen(state, run) {
+  if (state.open++ === 0)
+    for (const deadline of state.deadlines)
+      deadline.pause();
+  try {
+    return await run();
+  } finally {
+    if (--state.open === 0)
+      for (const deadline of state.deadlines)
+        deadline.resume();
+  }
+}
+const MAX_TIMER_MS = 2 ** 31 - 1;
+export async function callToolPausingForElicitation(client, params, options) {
+  const onprogress = options?.onprogress ?? (() => {});
+  const state = promptPauses.get(client);
+  if (!state)
+    return client.callTool(params, { ...options, onprogress, resetTimeoutOnProgress: true });
+  const timeout = Math.min(options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC, MAX_TIMER_MS);
+  const expired = new AbortController;
+  let remaining = timeout;
+  let startedAt = 0;
+  let timer;
+  const deadline = {
+    pause() {
+      if (timer === undefined)
+        return;
+      clearTimeout(timer);
+      timer = undefined;
+      remaining -= Date.now() - startedAt;
+    },
+    resume() {
+      startedAt = Date.now();
+      timer = setTimeout(() => expired.abort(new SdkError(SdkErrorCode.RequestTimeout, "Request timed out", { timeout })), Math.max(remaining, 0));
+    }
+  };
+  state.deadlines.add(deadline);
+  if (state.open === 0)
+    deadline.resume();
+  try {
+    return await client.callTool(params, {
+      ...options,
+      timeout: MAX_TIMER_MS,
+      signal: combineAbortSignals(options?.signal, expired.signal) ?? expired.signal,
+      onprogress: (progress) => {
+        const running = timer !== undefined;
+        deadline.pause();
+        remaining = timeout;
+        if (running)
+          deadline.resume();
+        onprogress(progress);
+      }
+    });
+  } finally {
+    state.deadlines.delete(deadline);
+    deadline.pause();
+  }
 }
 export async function handleElicitationRequest(options, request, signal) {
   throwIfAborted(signal);

package/extensions/dm-mcp-adapter/failure-backoff.js

@@ -1,4 +1,6 @@
+import { sanitizeTerminalText, truncateAtWord } from "./utils.js";
 export const FAILURE_BACKOFF_MS = 60 * 1000;
+const AGENT_FAILURE_REASON_CHARS = 300;
 export function getFailureAgeSeconds(state, serverName) {
   const failedAt = state.failureTracker.get(serverName);
   if (!failedAt)
@@ -13,6 +15,13 @@ export function getFailureMessage(state, serverName) {
     return null;
   return state.failureMessages?.get(serverName) ?? null;
 }
+export function describeFailure(state, serverName) {
+  const failedAgo = getFailureAgeSeconds(state, serverName);
+  if (failedAgo === null)
+    return null;
+  const reason = sanitizeTerminalText(state.failureMessages?.get(serverName) ?? "");
+  return reason ? `failed ${failedAgo}s ago: ${truncateAtWord(reason, AGENT_FAILURE_REASON_CHARS)}` : `failed ${failedAgo}s ago`;
+}
 export function isServerInActiveFailureBackoff(state, serverName) {
   const connection = state.manager.getConnection(serverName);
   return connection?.status !== "connected" && connection?.status !== "needs-auth" && getFailureAgeSeconds(state, serverName) !== null;