@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,387 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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;
-  };
-}