@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-mcp-adapter/dist/json-schema-validator.js

@@ -0,0 +1,70 @@
+import { Ajv } from "ajv";
+import Ajv2020Import from "ajv/dist/2020.js";
+import addFormatsImport from "ajv-formats";
+import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
+const addFormats = addFormatsImport;
+const SCHEMARS_NUMERIC_FORMATS = [
+  "int",
+  "int8",
+  "int16",
+  "int128",
+  "uint",
+  "uint8",
+  "uint16",
+  "uint32",
+  "uint64",
+  "uint128"
+];
+function addKnownFormats(ajv) {
+  addFormats(ajv);
+  for (const format of SCHEMARS_NUMERIC_FORMATS)
+    ajv.addFormat(format, true);
+}
+const DRAFT_07_SCHEMA_URIS = new Set([
+  "http://json-schema.org/draft-07/schema",
+  "https://json-schema.org/draft-07/schema"
+]);
+const DRAFT_2020_12_SCHEMA_URIS = new Set([
+  "https://json-schema.org/draft/2020-12/schema"
+]);
+function schemaDialect(schema) {
+  if (!("$schema" in schema) || typeof schema.$schema !== "string") {
+    return { status: "unstamped" };
+  }
+  return {
+    status: "stamped",
+    uri: schema.$schema.endsWith("#") ? schema.$schema.slice(0, -1) : schema.$schema
+  };
+}
+export function createJsonSchemaValidator() {
+  let draft07Validator;
+  let draft2020Validator;
+  return {
+    getValidator(schema) {
+      const dialect = schemaDialect(schema);
+      if (dialect.status === "unstamped" || DRAFT_2020_12_SCHEMA_URIS.has(dialect.uri)) {
+        draft2020Validator ??= (() => {
+          const Ajv2020 = Ajv2020Import;
+          const ajv = new Ajv2020({ strict: false, allErrors: true });
+          addKnownFormats(ajv);
+          return new AjvJsonSchemaValidator(ajv);
+        })();
+        return draft2020Validator.getValidator(schema);
+      }
+      if (!DRAFT_07_SCHEMA_URIS.has(dialect.uri)) {
+        throw new Error(`Unsupported JSON Schema dialect: ${dialect.uri}`);
+      }
+      draft07Validator ??= (() => {
+        const ajv = new Ajv({
+          strict: false,
+          validateFormats: true,
+          validateSchema: false,
+          allErrors: true
+        });
+        addKnownFormats(ajv);
+        return new AjvJsonSchemaValidator(ajv);
+      })();
+      return draft07Validator.getValidator(schema);
+    }
+  };
+}

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

@@ -0,0 +1,387 @@
+import { SdkError, SdkErrorCode } from "@modelcontextprotocol/client";
+import { isServerDisabled } from "./types.js";
+import { isTransientHttpConnectError, isUnauthorizedHttpError } from "./server-manager.js";
+import { hasPendingAuth } from "./mcp-auth-flow.js";
+import { logger } from "./logger.js";
+import { formatTerminalError, parallelLimit, sanitizeTerminalText } from "./utils.js";
+import { isTerminatedSession } from "./session-recovery.js";
+const KEEP_ALIVE_RETRY_BASE_MS = 30000;
+const KEEP_ALIVE_RETRY_MAX_MS = 5 * 60000;
+const KEEP_ALIVE_CHECK_CONCURRENCY = 10;
+
+export class McpLifecycleManager {
+  manager;
+  hasPendingAuthForServer;
+  keepAliveServers = new Map;
+  allServers = new Map;
+  serverSettings = new Map;
+  globalIdleTimeout = 10 * 60 * 1000;
+  healthCheckInterval;
+  onReconnect;
+  onReconnectFailure;
+  onHealthRestored;
+  onAuthRequired;
+  onIdleShutdown;
+  activeHealthCheck;
+  activeConvergence;
+  shutdownPromise;
+  retryStates = new Map;
+  pendingMetadataPublications = new Set;
+  stopped = false;
+  removeHealthAbortListener;
+  constructor(manager, hasPendingAuthForServer = hasPendingAuth) {
+    this.manager = manager;
+    this.hasPendingAuthForServer = hasPendingAuthForServer;
+  }
+  setReconnectCallback(callback) {
+    this.onReconnect = callback;
+  }
+  setReconnectFailureCallback(callback) {
+    this.onReconnectFailure = callback;
+  }
+  setHealthRestoredCallback(callback) {
+    this.onHealthRestored = callback;
+  }
+  setAuthRequiredCallback(callback) {
+    this.onAuthRequired = callback;
+  }
+  markKeepAlive(name, definition) {
+    if (isServerDisabled(definition))
+      return;
+    this.keepAliveServers.set(name, definition);
+  }
+  registerServer(name, definition, settings) {
+    if (isServerDisabled(definition))
+      return;
+    this.allServers.set(name, definition);
+    if (settings?.idleTimeout !== undefined)
+      this.serverSettings.set(name, settings);
+  }
+  unregisterServer(name) {
+    this.allServers.delete(name);
+    this.keepAliveServers.delete(name);
+    this.serverSettings.delete(name);
+    this.retryStates.delete(name);
+    this.pendingMetadataPublications.delete(name);
+  }
+  setGlobalIdleTimeout(minutes) {
+    this.globalIdleTimeout = minutes * 60 * 1000;
+  }
+  setIdleShutdownCallback(callback) {
+    this.onIdleShutdown = callback;
+  }
+  startHealthChecks(signalOrInterval, maybeIntervalMs = 30000) {
+    const signal = typeof signalOrInterval === "number" ? undefined : signalOrInterval;
+    const intervalMs = typeof signalOrInterval === "number" ? signalOrInterval : maybeIntervalMs;
+    this.stopped = false;
+    if (signal?.aborted) {
+      this.stopped = true;
+      return;
+    }
+    const stop = () => {
+      this.stopped = true;
+      if (this.healthCheckInterval)
+        clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = undefined;
+    };
+    signal?.addEventListener("abort", stop, { once: true });
+    this.removeHealthAbortListener = () => signal?.removeEventListener("abort", stop);
+    this.healthCheckInterval = setInterval(() => {
+      if (this.stopped || signal?.aborted || this.activeHealthCheck)
+        return;
+      const check = this.checkConnections(signal).catch((error) => {
+        console.error(`MCP: Health check failed: ${formatTerminalError(error)}`);
+      }).finally(() => {
+        if (this.activeHealthCheck === check)
+          this.activeHealthCheck = undefined;
+      });
+      this.activeHealthCheck = check;
+    }, intervalMs);
+    this.healthCheckInterval.unref();
+  }
+  async ensureConverged(signal) {
+    if (this.stopped || signal?.aborted)
+      return;
+    if (this.activeConvergence)
+      return this.activeConvergence;
+    const check = this.checkKeepAliveConnections(signal);
+    this.activeConvergence = check;
+    try {
+      await check;
+    } finally {
+      if (this.activeConvergence === check)
+        this.activeConvergence = undefined;
+    }
+  }
+  async checkConnections(signal) {
+    if (this.stopped || signal?.aborted)
+      return;
+    await this.ensureConverged(signal);
+    if (this.stopped || signal?.aborted)
+      return;
+    for (const [name] of this.allServers) {
+      if (this.keepAliveServers.has(name))
+        continue;
+      const timeout = this.getIdleTimeout(name);
+      if (timeout > 0 && this.manager.isIdle(name, timeout)) {
+        await this.manager.close(name);
+        if (this.stopped || signal?.aborted)
+          return;
+        this.onIdleShutdown?.(name);
+      }
+    }
+  }
+  async checkKeepAliveConnections(signal) {
+    if (this.stopped || signal?.aborted)
+      return;
+    await parallelLimit([...this.keepAliveServers], KEEP_ALIVE_CHECK_CONCURRENCY, ([name, definition]) => this.checkKeepAliveConnection(name, definition, signal));
+  }
+  async checkKeepAliveConnection(name, definition, signal, retrySuperseded = true) {
+    if (isServerDisabled(definition) || this.stopped || signal?.aborted)
+      return;
+    if (this.keepAliveServers.get(name) !== definition)
+      return;
+    const connection = this.manager.getConnection(name);
+    if (connection?.status === "needs-auth") {
+      this.pendingMetadataPublications.delete(name);
+      return;
+    }
+    if (!this.shouldAttemptConnection(name, connection))
+      return;
+    if (!connection || connection.status !== "connected") {
+      if (this.hasPendingAuthForServer(name)) {
+        logger.debug(`Skipping reconnect for ${name} while OAuth authorization is pending`);
+        return;
+      }
+      let freshConnection;
+      try {
+        freshConnection = await this.manager.connect(name, definition, signal);
+      } catch (error) {
+        if (this.stopped || signal?.aborted)
+          return;
+        this.reportConnectionFailure(name, definition, error, "reconnect", this.manager.getConnection(name));
+        return;
+      }
+      if (this.stopped || signal?.aborted)
+        return;
+      if (freshConnection.status === "needs-auth") {
+        await this.notifyAuthRequired(name, definition, freshConnection);
+        return;
+      }
+      if (freshConnection.status !== "connected") {
+        this.reportConnectionFailure(name, definition, new Error(`MCP server ${name} did not return a connected session`), "reconnect", freshConnection);
+        return;
+      }
+      logger.debug(`Reconnected to ${name}`);
+      await this.publishConnectedMetadata(name, definition, freshConnection);
+      return;
+    }
+    if (this.pendingMetadataPublications.has(name)) {
+      await this.publishConnectedMetadata(name, definition, connection);
+      return;
+    }
+    if (!definition.url)
+      return;
+    const hadSessionId = connection.transport?.sessionId != null;
+    let refreshResult;
+    try {
+      refreshResult = await this.manager.refreshTools(name, connection, signal);
+    } catch (error) {
+      if (this.stopped || signal?.aborted)
+        return;
+      const current = this.manager.getConnection(name);
+      if (current !== connection || connection.status !== "connected") {
+        await this.handleSupersededConnection(name, definition, connection, signal, retrySuperseded);
+        return;
+      }
+      if (!shouldReconnectAfterRefresh(error, hadSessionId, definition)) {
+        this.reportConnectionFailure(name, definition, error, "refresh", connection);
+        return;
+      }
+      if (this.hasPendingAuthForServer(name)) {
+        logger.debug(`Skipping reconnect for ${name} while OAuth authorization is pending`);
+        return;
+      }
+      let freshConnection;
+      try {
+        freshConnection = await this.manager.reconnect(name, definition, connection, signal);
+      } catch (reconnectError) {
+        if (this.stopped || signal?.aborted)
+          return;
+        this.reportConnectionFailure(name, definition, reconnectError, "reconnect", this.manager.getConnection(name));
+        return;
+      }
+      if (this.stopped || signal?.aborted)
+        return;
+      if (freshConnection.status === "needs-auth") {
+        await this.notifyAuthRequired(name, definition, freshConnection);
+        return;
+      }
+      if (freshConnection.status !== "connected") {
+        this.reportConnectionFailure(name, definition, new Error(`MCP server ${name} did not return a connected session`), "reconnect", freshConnection);
+        return;
+      }
+      logger.debug(`Reconnected stale MCP session for ${name}`);
+      await this.publishConnectedMetadata(name, definition, freshConnection);
+      return;
+    }
+    if (refreshResult === "superseded") {
+      await this.handleSupersededConnection(name, definition, connection, signal, retrySuperseded);
+      return;
+    }
+    if (refreshResult === "refresh-timeout") {
+      this.deferRefreshTimeout(name, definition, connection);
+      return;
+    }
+    if (this.keepAliveServers.get(name) !== definition)
+      return;
+    if (this.retryStates.delete(name)) {
+      await this.onHealthRestored?.(name);
+    }
+  }
+  async handleSupersededConnection(name, definition, staleConnection, signal, retrySuperseded) {
+    const current = this.manager.getConnection(name);
+    if (this.keepAliveServers.get(name) !== definition)
+      return;
+    if (current === staleConnection && current.status === "connected") {
+      if (this.retryStates.delete(name))
+        await this.onHealthRestored?.(name);
+      return;
+    }
+    if (current?.status === "connected") {
+      await this.publishConnectedMetadata(name, definition, current);
+      return;
+    }
+    if (current?.status === "needs-auth") {
+      await this.notifyAuthRequired(name, definition, current);
+      return;
+    }
+    if (retrySuperseded) {
+      await this.checkKeepAliveConnection(name, definition, signal, false);
+    }
+  }
+  async publishConnectedMetadata(name, definition, connection) {
+    if (this.keepAliveServers.get(name) !== definition) {
+      if (this.manager.getConnection(name) === connection)
+        await this.manager.close(name);
+      return;
+    }
+    this.pendingMetadataPublications.add(name);
+    try {
+      await this.onReconnect?.(name);
+      this.pendingMetadataPublications.delete(name);
+      this.retryStates.delete(name);
+    } catch (error) {
+      if (this.stopped)
+        return;
+      this.reportConnectionFailure(name, definition, error, "publish", connection);
+    }
+  }
+  async notifyAuthRequired(name, definition, connection) {
+    if (this.keepAliveServers.get(name) !== definition) {
+      if (this.manager.getConnection(name) === connection)
+        await this.manager.close(name);
+      return;
+    }
+    this.pendingMetadataPublications.delete(name);
+    this.retryStates.delete(name);
+    try {
+      await this.onAuthRequired?.(name);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.debug(`MCP: auth-required callback failed for ${name}: ${sanitizeTerminalText(message)}`);
+    }
+  }
+  shouldAttemptConnection(name, connection) {
+    const retry = this.retryStates.get(name);
+    if (!retry)
+      return true;
+    if (retry.connection !== connection || retry.status !== connection?.status) {
+      this.retryStates.delete(name);
+      return true;
+    }
+    return Date.now() >= retry.nextAttemptAt;
+  }
+  connectionFailureTarget(action, name) {
+    if (action === "reconnect")
+      return `reconnect to ${name}`;
+    if (action === "publish")
+      return `publish metadata for ${name}`;
+    return `refresh ${name}`;
+  }
+  reportConnectionFailure(name, definition, error, action, connection) {
+    if (!this.recordRetry(name, definition, connection))
+      return;
+    this.onReconnectFailure?.(name, error);
+    if (isTransientHttpConnectError(error))
+      return;
+    const retry = this.retryStates.get(name);
+    if (retry?.warningReported)
+      return;
+    if (retry)
+      retry.warningReported = true;
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`MCP: Failed to ${this.connectionFailureTarget(action, name)}: ${sanitizeTerminalText(message)}`);
+  }
+  deferRefreshTimeout(name, definition, connection) {
+    if (!this.recordRetry(name, definition, connection))
+      return;
+    logger.debug(`MCP: keep-alive tools/list refresh timed out for ${name}; retrying after backoff`);
+  }
+  recordRetry(name, definition, connection) {
+    if (this.keepAliveServers.get(name) !== definition)
+      return false;
+    const previous = this.retryStates.get(name);
+    const attempts = (previous?.attempts ?? 0) + 1;
+    const delay = Math.min(KEEP_ALIVE_RETRY_BASE_MS * 2 ** Math.min(attempts - 1, 10), KEEP_ALIVE_RETRY_MAX_MS);
+    this.retryStates.set(name, {
+      attempts,
+      nextAttemptAt: Date.now() + delay,
+      connection,
+      status: connection?.status,
+      warningReported: previous?.warningReported ?? false
+    });
+    return true;
+  }
+  getIdleTimeout(name) {
+    const perServer = this.serverSettings.get(name)?.idleTimeout;
+    if (perServer !== undefined)
+      return perServer * 60 * 1000;
+    return this.globalIdleTimeout;
+  }
+  async gracefulShutdown() {
+    if (this.shutdownPromise)
+      return this.shutdownPromise;
+    this.shutdownPromise = this.shutdownOnce();
+    return this.shutdownPromise;
+  }
+  async shutdownOnce() {
+    this.stopped = true;
+    if (this.healthCheckInterval)
+      clearInterval(this.healthCheckInterval);
+    this.healthCheckInterval = undefined;
+    this.removeHealthAbortListener?.();
+    this.removeHealthAbortListener = undefined;
+    await this.activeHealthCheck;
+    this.activeHealthCheck = undefined;
+    await this.activeConvergence;
+    this.activeConvergence = undefined;
+    this.onReconnect = undefined;
+    this.onReconnectFailure = undefined;
+    this.onHealthRestored = undefined;
+    this.onAuthRequired = undefined;
+    this.onIdleShutdown = undefined;
+    this.retryStates.clear();
+    this.pendingMetadataPublications.clear();
+    if (typeof this.manager.closeAll === "function") {
+      await this.manager.closeAll();
+    }
+  }
+}
+function shouldReconnectAfterRefresh(error, hadSessionId, definition) {
+  if (isTerminatedSession(error, hadSessionId))
+    return true;
+  if (definition.auth === "bearer" && isUnauthorizedHttpError(error))
+    return true;
+  return error instanceof SdkError && (error.code === SdkErrorCode.NotConnected || error.code === SdkErrorCode.ConnectionClosed);
+}

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

@@ -0,0 +1,115 @@
+const LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+const LEVEL_PREFIX = {
+  debug: "[MCP-UI:DEBUG]",
+  info: "[MCP-UI]",
+  warn: "[MCP-UI:WARN]",
+  error: "[MCP-UI:ERROR]"
+};
+
+class Logger {
+  minLevel = "info";
+  handlers = [];
+  defaultContext = {};
+  setLevel(level) {
+    this.minLevel = level;
+  }
+  setDefaultContext(context) {
+    this.defaultContext = context;
+  }
+  addHandler(handler) {
+    this.handlers.push(handler);
+  }
+  clearHandlers() {
+    this.handlers = [];
+  }
+  shouldLog(level) {
+    return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[this.minLevel];
+  }
+  emit(level, message, context, error) {
+    if (!this.shouldLog(level))
+      return;
+    const entry = {
+      level,
+      message,
+      context: { ...this.defaultContext, ...context },
+      ...error !== undefined ? { error } : {},
+      timestamp: new Date
+    };
+    const prefix = LEVEL_PREFIX[level];
+    const contextStr = formatContext(entry.context);
+    const fullMessage = contextStr ? `${prefix} ${message} ${contextStr}` : `${prefix} ${message}`;
+    if (level === "error") {
+      console.error(fullMessage, error ?? "");
+    } else if (level === "warn") {
+      console.warn(fullMessage);
+    } else if (level === "debug") {
+      console.debug(fullMessage);
+    } else {
+      console.log(fullMessage);
+    }
+    for (const handler of this.handlers) {
+      try {
+        handler(entry);
+      } catch {}
+    }
+  }
+  debug(message, context) {
+    this.emit("debug", message, context);
+  }
+  info(message, context) {
+    this.emit("info", message, context);
+  }
+  warn(message, context) {
+    this.emit("warn", message, context);
+  }
+  error(message, error, context) {
+    this.emit("error", message, context, error);
+  }
+  child(context) {
+    return new ChildLogger(this, context);
+  }
+}
+
+class ChildLogger {
+  parent;
+  context;
+  constructor(parent, context) {
+    this.parent = parent;
+    this.context = context;
+  }
+  debug(message, context) {
+    this.parent.debug(message, { ...this.context, ...context });
+  }
+  info(message, context) {
+    this.parent.info(message, { ...this.context, ...context });
+  }
+  warn(message, context) {
+    this.parent.warn(message, { ...this.context, ...context });
+  }
+  error(message, error, context) {
+    this.parent.error(message, error, { ...this.context, ...context });
+  }
+  child(context) {
+    return new ChildLogger(this.parent, { ...this.context, ...context });
+  }
+}
+function formatContext(context) {
+  if (!context || Object.keys(context).length === 0)
+    return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(context)) {
+    if (value !== undefined && value !== null) {
+      parts.push(`${key}=${typeof value === "string" ? value : JSON.stringify(value)}`);
+    }
+  }
+  return parts.length > 0 ? `(${parts.join(", ")})` : "";
+}
+export const logger = new Logger;
+if (process.env.MCP_UI_DEBUG === "1" || process.env.MCP_UI_DEBUG === "true") {
+  logger.setLevel("debug");
+}

package/extensions/dm-mcp-adapter/dist/mcp-auth-fetch.js

@@ -0,0 +1,86 @@
+import { combineAbortSignals } from "./runtime-owner.js";
+import { interpolateEnvRecord, resolveCommandSecretsRecord } from "./utils.js";
+export function resolveOAuthHeaders(values, options = {}) {
+  const { commands = true, literal = false } = options;
+  if (literal)
+    return new Headers(values);
+  const selected = Object.fromEntries(Object.entries(values ?? {}).filter(([, value]) => commands || !value.startsWith("!") || value.startsWith("!!")));
+  for (const value of Object.values(selected)) {
+    if (value.startsWith("!") && !value.startsWith("!!"))
+      continue;
+    for (const match of value.matchAll(/\$\{(\w+)\}|\$env:(\w+)|\{env:(\w+)\}/g)) {
+      const name = match[1] ?? match[2] ?? match[3];
+      if (!process.env[name])
+        throw new TypeError("Missing environment credential in OAuth HTTP headers");
+    }
+  }
+  try {
+    const resolved = commands ? resolveCommandSecretsRecord(selected, () => "OAuth HTTP header") : interpolateEnvRecord(selected);
+    if (Object.values(resolved ?? {}).some((value) => !value.trim())) {
+      throw new Error("empty header");
+    }
+    return new Headers(resolved);
+  } catch {
+    throw new TypeError("Failed to resolve OAuth HTTP headers");
+  }
+}
+const DEFAULT_OAUTH_REQUEST_TIMEOUT_MS = 30000;
+function resolveOAuthRequestTimeoutMs() {
+  const parsed = Number(process.env.PI_MCP_OAUTH_REQUEST_TIMEOUT_MS);
+  return Number.isSafeInteger(parsed) && parsed > 0 && parsed <= 2147483647 ? parsed : DEFAULT_OAUTH_REQUEST_TIMEOUT_MS;
+}
+export function createOAuthFetch(serverUrl, getHeaders = () => new Headers, signal, options = {}) {
+  const origin = new URL(serverUrl).origin;
+  let headerResolutionError;
+  const throwIfHeaderResolutionFailed = () => {
+    if (headerResolutionError)
+      throw headerResolutionError;
+  };
+  const fetchFn = async (input, init) => {
+    const request = input instanceof Request ? input : undefined;
+    const url = new URL(request ? request.url : String(input));
+    const combined = combineAbortSignals(signal, init?.signal ?? request?.signal, options.timeout === false ? undefined : AbortSignal.timeout(resolveOAuthRequestTimeoutMs()));
+    combined?.throwIfAborted();
+    throwIfHeaderResolutionFailed();
+    let serviceHeaders;
+    try {
+      serviceHeaders = url.origin === origin ? getHeaders() : new Headers;
+    } catch {
+      headerResolutionError = new TypeError("Failed to resolve OAuth HTTP headers");
+      throw headerResolutionError;
+    }
+    const headers = new Headers(serviceHeaders);
+    new Headers(init?.headers ?? request?.headers).forEach((value, key) => headers.set(key, value));
+    const protectedRequest = [...serviceHeaders].length > 0;
+    try {
+      return await (options.delegate ?? globalThis.fetch)(input, {
+        ...init,
+        headers,
+        ...combined ? { signal: combined } : {},
+        ...protectedRequest ? { redirect: "error" } : {}
+      });
+    } catch (error) {
+      combined?.throwIfAborted();
+      if (protectedRequest)
+        throw new TypeError("OAuth HTTP request failed");
+      throw error;
+    }
+  };
+  return Object.assign(fetchFn, { throwIfHeaderResolutionFailed });
+}
+export function oauthHeaderResolver(values, options = {}) {
+  const snapshot = values ? { ...values } : undefined;
+  let result;
+  return () => {
+    if (!result) {
+      try {
+        result = { headers: resolveOAuthHeaders(snapshot, options) };
+      } catch (error) {
+        result = { error };
+      }
+    }
+    if ("error" in result)
+      throw result.error;
+    return result.headers;
+  };
+}