@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-mcp-adapter/dist/consent-manager.js

@@ -1,84 +0,0 @@
-import { ConsentError } from "./errors.js";
-import { logger } from "./logger.js";
-
-export class ConsentManager {
-  mode;
-  persistDecision;
-  approvedServers = new Set;
-  deniedServers = new Set;
-  log = logger.child({ component: "ConsentManager" });
-  constructor(mode = "once-per-server", persistDecision) {
-    this.mode = mode;
-    this.persistDecision = persistDecision;
-    this.log.debug("Initialized", { mode });
-  }
-  requiresPrompt(serverName) {
-    if (this.mode === "never")
-      return false;
-    if (this.deniedServers.has(serverName))
-      return true;
-    if (this.mode === "always")
-      return true;
-    return !this.approvedServers.has(serverName);
-  }
-  shouldCacheConsent() {
-    return this.mode !== "always";
-  }
-  registerDecision(serverName, approved) {
-    this.applyDecision(serverName, approved);
-    try {
-      this.persistDecision?.({
-        version: 1,
-        kind: "iframe",
-        decision: approved ? "allow" : "deny",
-        serverName
-      });
-    } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error);
-      this.log.debug("Failed to persist consent decision", { server: serverName, error: detail });
-    }
-  }
-  restoreDecision(serverName, approved) {
-    if (this.mode === "always" && approved) {
-      this.approvedServers.delete(serverName);
-      this.deniedServers.delete(serverName);
-      return;
-    }
-    this.applyDecision(serverName, approved);
-  }
-  ensureApproved(serverName) {
-    if (this.mode === "never")
-      return;
-    if (this.deniedServers.has(serverName)) {
-      throw new ConsentError(serverName, { denied: true });
-    }
-    if (!this.approvedServers.has(serverName)) {
-      throw new ConsentError(serverName, { requiresApproval: true });
-    }
-    if (this.mode === "always") {
-      this.approvedServers.delete(serverName);
-    }
-  }
-  clear(serverName) {
-    if (serverName) {
-      this.approvedServers.delete(serverName);
-      this.deniedServers.delete(serverName);
-      this.log.debug("Cleared consent for server", { server: serverName });
-      return;
-    }
-    this.approvedServers.clear();
-    this.deniedServers.clear();
-    this.log.debug("Cleared all consent records");
-  }
-  applyDecision(serverName, approved) {
-    this.deniedServers.delete(serverName);
-    this.approvedServers.delete(serverName);
-    if (approved) {
-      this.approvedServers.add(serverName);
-      this.log.debug("Consent granted", { server: serverName });
-      return;
-    }
-    this.deniedServers.add(serverName);
-    this.log.debug("Consent denied", { server: serverName });
-  }
-}

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

@@ -1,308 +0,0 @@
-import { ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/client";
-import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
-import open from "open";
-import { abortable, throwIfAborted } from "./abort.js";
-export function registerElicitationHandler(client, options) {
-  client.setRequestHandler("elicitation/create", (request) => handleElicitationRequest(options, request));
-}
-export async function handleElicitationRequest(options, request, signal) {
-  throwIfAborted(signal);
-  return request.params.mode === "url" ? handleUrlElicitation(options, request.params, signal) : handleFormElicitation(options, request.params, signal);
-}
-export async function handleFormElicitation(options, params, signal) {
-  const properties = Object.entries(params.requestedSchema.properties);
-  const decision = await abortable(options.ui.select(`MCP Input Request
-Server: ${options.serverName}
-
-${params.message}`, ["Continue", "Decline"]), signal);
-  if (decision === undefined)
-    return { action: "cancel" };
-  if (decision === "Decline")
-    return { action: "decline" };
-  if (properties.length === 0)
-    return { action: "accept", content: {} };
-  const values = {};
-  for (const [name, schema] of properties) {
-    const value = await collectValidField(options.ui, params, name, schema, undefined, signal);
-    if (value.status === "cancelled")
-      return { action: "cancel" };
-    values[name] = value.value;
-  }
-  while (true) {
-    const content = coerceAndValidateFormValues(params, values);
-    const action = await abortable(options.ui.select(formatReview(options.serverName, properties, content), ["Submit", "Edit", "Decline"]), signal);
-    if (action === undefined)
-      return { action: "cancel" };
-    if (action === "Decline")
-      return { action: "decline" };
-    if (action === "Submit")
-      return { action: "accept", content };
-    const labels = properties.map(([name, schema]) => `${schema.title ?? humanizeName(name)} (${name})`);
-    const selected = await abortable(options.ui.select("Choose a field to edit", labels), signal);
-    if (selected === undefined)
-      return { action: "cancel" };
-    const property = properties[labels.indexOf(selected)];
-    if (!property)
-      continue;
-    const [name, schema] = property;
-    const value = await collectValidField(options.ui, params, name, schema, values[name], signal);
-    if (value.status === "cancelled")
-      return { action: "cancel" };
-    values[name] = value.value;
-  }
-}
-async function collectValidField(ui, params, name, schema, current, signal) {
-  const required = params.requestedSchema.required?.includes(name) === true;
-  while (true) {
-    const result = await collectField(ui, params, name, schema, current, signal);
-    if (result.status === "cancelled")
-      return result;
-    try {
-      coerceAndValidateFormValues({
-        ...params,
-        requestedSchema: {
-          type: "object",
-          properties: { [name]: schema },
-          ...required ? { required: [name] } : {}
-        }
-      }, { [name]: result.value });
-      return result;
-    } catch (error) {
-      ui.notify(error instanceof Error ? error.message : String(error), "error");
-      current = result.value;
-    }
-  }
-}
-async function collectField(ui, params, name, schema, current, signal) {
-  const required = params.requestedSchema.required?.includes(name) === true;
-  const title = [schema.title ?? humanizeName(name), required ? "(required)" : "", schema.description].filter(Boolean).join(" ");
-  if (schema.type === "string" && (("enum" in schema) || ("oneOf" in schema))) {
-    const choices = "oneOf" in schema ? schema.oneOf.map((option) => ({ value: option.const, display: formatChoice(option.const, option.title) })) : schema.enum.map((value, index) => ({
-      value,
-      display: formatChoice(value, "enumNames" in schema ? schema.enumNames?.[index] : undefined)
-    }));
-    const displays = uniqueLabels(choices.map((choice) => choice.display));
-    const actions = [...displays];
-    const useDefault = schema.default === undefined ? undefined : uniqueAction("Use default", actions);
-    if (useDefault)
-      actions.push(useDefault);
-    const omit = required ? undefined : uniqueAction("Omit", actions);
-    if (omit)
-      actions.push(omit);
-    const action = await abortable(ui.select(title, actions), signal);
-    if (action === undefined)
-      return { status: "cancelled" };
-    if (action === useDefault)
-      return { status: "collected", value: schema.default };
-    if (action === omit)
-      return { status: "collected", value: undefined };
-    return { status: "collected", value: choices[displays.indexOf(action)]?.value };
-  }
-  if (schema.type === "boolean") {
-    const actions = ["Yes", "No"];
-    if (schema.default !== undefined)
-      actions.push("Use default");
-    if (!required)
-      actions.push("Omit");
-    const action = await abortable(ui.select(title, actions), signal);
-    if (action === undefined)
-      return { status: "cancelled" };
-    if (action === "Use default")
-      return { status: "collected", value: schema.default };
-    if (action === "Omit")
-      return { status: "collected", value: undefined };
-    return { status: "collected", value: action === "Yes" };
-  }
-  if (schema.type === "array") {
-    const actions = ["Choose values"];
-    if (schema.default !== undefined)
-      actions.push("Use default");
-    if (!required)
-      actions.push("Omit");
-    const action = await abortable(ui.select(title, actions), signal);
-    if (action === undefined)
-      return { status: "cancelled" };
-    if (action === "Use default")
-      return { status: "collected", value: schema.default };
-    if (action === "Omit")
-      return { status: "collected", value: undefined };
-    const choices = extractMultiSelectOptions(schema);
-    const selected = new Set(Array.isArray(current) ? current : []);
-    while (true) {
-      const displays = uniqueLabels(choices.map((choice) => selected.has(choice.value) ? `✓ ${choice.display}` : choice.display));
-      const done = uniqueAction("Done", displays);
-      const picked = await abortable(ui.select(title, [...displays, done]), signal);
-      if (picked === undefined)
-        return { status: "cancelled" };
-      if (picked === done)
-        return { status: "collected", value: [...selected] };
-      const choice = choices[displays.indexOf(picked)];
-      if (!choice)
-        continue;
-      if (selected.has(choice.value))
-        selected.delete(choice.value);
-      else
-        selected.add(choice.value);
-    }
-  }
-  const actions = ["Enter value"];
-  if (schema.default !== undefined)
-    actions.push("Use default");
-  if (!required)
-    actions.push("Omit");
-  const action = await abortable(ui.select(title, actions), signal);
-  if (action === undefined)
-    return { status: "cancelled" };
-  if (action === "Use default")
-    return { status: "collected", value: schema.default };
-  if (action === "Omit")
-    return { status: "collected", value: undefined };
-  const entered = await abortable(ui.input(title, current === undefined ? undefined : String(current)), signal);
-  return entered === undefined ? { status: "cancelled" } : { status: "collected", value: entered };
-}
-export function coerceAndValidateFormValues(params, values) {
-  const output = {};
-  const required = new Set(params.requestedSchema.required ?? []);
-  for (const [name, schema] of Object.entries(params.requestedSchema.properties)) {
-    const value = values[name];
-    if (value === undefined) {
-      if (required.has(name))
-        throw new Error(`Missing required elicitation field: ${name}`);
-      continue;
-    }
-    if (schema.type === "string") {
-      const stringValue = String(value);
-      const limits = schema;
-      if (limits.minLength !== undefined && stringValue.length < limits.minLength) {
-        throw new Error(`Elicitation field ${name} is shorter than minimum length ${limits.minLength}`);
-      }
-      if (limits.maxLength !== undefined && stringValue.length > limits.maxLength) {
-        throw new Error(`Elicitation field ${name} is longer than maximum length ${limits.maxLength}`);
-      }
-      if ("enum" in schema && !schema.enum.includes(stringValue)) {
-        throw new Error(`Elicitation field ${name} is not an allowed value`);
-      }
-      if ("oneOf" in schema && !schema.oneOf.some((option) => option.const === stringValue)) {
-        throw new Error(`Elicitation field ${name} is not an allowed value`);
-      }
-      output[name] = stringValue;
-      continue;
-    }
-    if (schema.type === "number" || schema.type === "integer") {
-      if (typeof value === "string" && value.trim() === "") {
-        throw new Error(`Elicitation field ${name} must be a number`);
-      }
-      const numberValue = typeof value === "number" ? value : Number(value);
-      if (!Number.isFinite(numberValue))
-        throw new Error(`Elicitation field ${name} must be a number`);
-      if (schema.type === "integer" && !Number.isInteger(numberValue)) {
-        throw new Error(`Elicitation field ${name} must be an integer`);
-      }
-      if (schema.minimum !== undefined && numberValue < schema.minimum) {
-        throw new Error(`Elicitation field ${name} is below minimum ${schema.minimum}`);
-      }
-      if (schema.maximum !== undefined && numberValue > schema.maximum) {
-        throw new Error(`Elicitation field ${name} is above maximum ${schema.maximum}`);
-      }
-      output[name] = numberValue;
-      continue;
-    }
-    if (schema.type === "boolean") {
-      output[name] = typeof value === "boolean" ? value : value === "true";
-      continue;
-    }
-    if (schema.type === "array") {
-      if (!Array.isArray(value))
-        throw new Error(`Elicitation field ${name} must be a list`);
-      const allowed = new Set(extractMultiSelectOptions(schema).map((option) => option.value));
-      const arrayValue = value.map(String);
-      if (schema.minItems !== undefined && arrayValue.length < schema.minItems) {
-        throw new Error(`Elicitation field ${name} has fewer than ${schema.minItems} selections`);
-      }
-      if (schema.maxItems !== undefined && arrayValue.length > schema.maxItems) {
-        throw new Error(`Elicitation field ${name} has more than ${schema.maxItems} selections`);
-      }
-      if (arrayValue.some((item) => !allowed.has(item))) {
-        throw new Error(`Elicitation field ${name} contains an invalid selection`);
-      }
-      output[name] = arrayValue;
-    }
-  }
-  const validation = new AjvJsonSchemaValidator().getValidator(params.requestedSchema)(output);
-  if (!validation.valid) {
-    throw new Error(`Invalid elicitation response: ${validation.errorMessage}`);
-  }
-  return output;
-}
-function formatChoice(value, title) {
-  return title && title !== value ? `${title} (${value})` : value;
-}
-function uniqueLabels(labels) {
-  const used = new Set;
-  return labels.map((label) => {
-    let unique = label;
-    while (used.has(unique))
-      unique += "…";
-    used.add(unique);
-    return unique;
-  });
-}
-function uniqueAction(label, choices) {
-  let unique = label;
-  while (choices.includes(unique))
-    unique += "…";
-  return unique;
-}
-function extractMultiSelectOptions(schema) {
-  const items = schema.items;
-  return items.anyOf ? items.anyOf.map((option) => ({ value: option.const, display: formatChoice(option.const, option.title) })) : (items.enum ?? []).map((value) => ({ value, display: value }));
-}
-function formatReview(serverName, properties, content) {
-  const rows = properties.map(([name, schema]) => `${schema.title ?? humanizeName(name)}: ${content[name] === undefined ? "(omitted)" : String(content[name])}`);
-  return [`Review input for ${serverName}`, "", ...rows].join(`
-`);
-}
-export async function handleUrlElicitation(options, params, signal) {
-  throwIfAborted(signal);
-  if (!options.allowUrl)
-    throw new ProtocolError(ProtocolErrorCode.InvalidParams, "URL elicitation is not supported");
-  let parsed;
-  try {
-    parsed = new URL(params.url);
-  } catch {
-    throw new ProtocolError(ProtocolErrorCode.InvalidParams, "URL elicitation supplied an invalid URL");
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new ProtocolError(ProtocolErrorCode.InvalidParams, "URL elicitation only supports HTTP and HTTPS URLs");
-  }
-  const decision = await abortable(options.ui.select([
-    "MCP Browser Request",
-    `Server: ${options.serverName}`,
-    "",
-    params.message,
-    "",
-    `Host: ${parsed.host}`,
-    `Full URL: ${params.url}`,
-    "",
-    "Open this URL in your browser?"
-  ].join(`
-`), ["Open", "Decline"]), signal);
-  if (decision === undefined)
-    return { action: "cancel" };
-  if (decision === "Decline")
-    return { action: "decline" };
-  try {
-    await abortable(open(params.url), signal);
-  } catch (error) {
-    throwIfAborted(signal);
-    options.ui.notify(`Could not open MCP elicitation URL: ${error instanceof Error ? error.message : String(error)}`, "error");
-    return { action: "cancel" };
-  }
-  throwIfAborted(signal);
-  options.onUrlAccepted?.(params.elicitationId);
-  options.ui.notify("Opened browser for MCP elicitation.", "info");
-  return { action: "accept" };
-}
-function humanizeName(name) {
-  return name.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^./, (char) => char.toUpperCase());
-}

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

@@ -1,225 +0,0 @@
-export class McpUiError extends Error {
-  code;
-  context;
-  recoveryHint;
-  cause;
-  constructor(message, options) {
-    super(message);
-    this.name = "McpUiError";
-    this.code = options.code;
-    this.context = options.context ?? {};
-    this.recoveryHint = options.recoveryHint;
-    this.cause = options.cause;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      context: this.context,
-      recoveryHint: this.recoveryHint,
-      stack: this.stack
-    };
-  }
-}
-
-export class ResourceFetchError extends McpUiError {
-  constructor(uri, reason, options) {
-    super(`Failed to fetch UI resource "${uri}": ${reason}`, {
-      code: "RESOURCE_FETCH_ERROR",
-      context: { uri, ...options?.server !== undefined ? { server: options.server } : {} },
-      recoveryHint: "Check that the MCP server is connected and the resource URI is valid.",
-      ...options?.cause !== undefined ? { cause: options.cause } : {}
-    });
-    this.name = "ResourceFetchError";
-  }
-}
-
-export class ResourceParseError extends McpUiError {
-  constructor(uri, reason, options) {
-    super(`Invalid UI resource "${uri}": ${reason}`, {
-      code: "RESOURCE_PARSE_ERROR",
-      context: {
-        uri,
-        ...options?.server !== undefined ? { server: options.server } : {},
-        ...options?.mimeType !== undefined ? { mimeType: options.mimeType } : {}
-      },
-      recoveryHint: "Ensure the resource returns valid HTML with the correct MIME type."
-    });
-    this.name = "ResourceParseError";
-  }
-}
-
-export class BridgeConnectionError extends McpUiError {
-  constructor(reason, options) {
-    super(`AppBridge connection failed: ${reason}`, {
-      code: "BRIDGE_CONNECTION_ERROR",
-      context: options?.session !== undefined ? { session: options.session } : {},
-      recoveryHint: "Check browser console for detailed errors. The iframe may have failed to load.",
-      ...options?.cause !== undefined ? { cause: options.cause } : {}
-    });
-    this.name = "BridgeConnectionError";
-  }
-}
-
-export class ConsentError extends McpUiError {
-  denied;
-  constructor(server, options) {
-    const message = options.denied ? `Tool calls for "${server}" were denied for this session` : `Tool call approval required for "${server}"`;
-    super(message, {
-      code: options.denied ? "CONSENT_DENIED" : "CONSENT_REQUIRED",
-      context: { server },
-      recoveryHint: options.denied ? "The user denied tool access. Start a new session to try again." : "Prompt the user for consent before calling tools."
-    });
-    this.name = "ConsentError";
-    this.denied = options.denied ?? false;
-  }
-}
-
-export class SessionError extends McpUiError {
-  constructor(reason, options) {
-    super(`Session error: ${reason}`, {
-      code: "SESSION_ERROR",
-      context: options?.session !== undefined ? { session: options.session } : {},
-      recoveryHint: "The session may have expired or been closed. Try opening the UI again.",
-      ...options?.cause !== undefined ? { cause: options.cause } : {}
-    });
-    this.name = "SessionError";
-  }
-}
-
-export class ServerError extends McpUiError {
-  constructor(reason, options) {
-    super(`UI server error: ${reason}`, {
-      code: "SERVER_ERROR",
-      context: options?.port !== undefined ? { port: options.port } : {},
-      recoveryHint: "Check if the port is available. Another process may be using it.",
-      ...options?.cause !== undefined ? { cause: options.cause } : {}
-    });
-    this.name = "ServerError";
-  }
-}
-
-export class McpServerError extends McpUiError {
-  constructor(server, reason, options) {
-    super(`MCP server "${server}" error: ${reason}`, {
-      code: "MCP_SERVER_ERROR",
-      context: { server, ...options?.tool !== undefined ? { tool: options.tool } : {} },
-      recoveryHint: "Check that the MCP server is running and responsive.",
-      ...options?.cause !== undefined ? { cause: options.cause } : {}
-    });
-    this.name = "McpServerError";
-  }
-}
-export function wrapError(error, context) {
-  if (error instanceof McpUiError) {
-    return new McpUiError(error.message, {
-      code: error.code,
-      context: { ...error.context, ...context },
-      ...error.recoveryHint !== undefined ? { recoveryHint: error.recoveryHint } : {},
-      ...error.cause !== undefined ? { cause: error.cause } : {}
-    });
-  }
-  const cause = error instanceof Error ? error : undefined;
-  const message = error instanceof Error ? error.message : String(error);
-  return new McpUiError(message, {
-    code: "UNKNOWN_ERROR",
-    ...context !== undefined ? { context } : {},
-    ...cause !== undefined ? { cause } : {}
-  });
-}
-export function isErrorCode(error, code) {
-  return error instanceof McpUiError && error.code === code;
-}
-export const INPUT_REQUIRED_NEEDS_UI = "input_required_needs_ui";
-const INPUT_REQUIRED_METHODS = new Set([
-  "elicitation/create",
-  "sampling/createMessage"
-]);
-const MAX_INPUT_REQUIRED_SERVER_LENGTH = 96;
-const MAX_INPUT_REQUIRED_TARGET_LENGTH = 160;
-const MAX_INPUT_REQUIRED_DETAIL_LENGTH = 128;
-function asRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
-}
-function boundedText(value, maxLength) {
-  if (typeof value !== "string" || value.length === 0)
-    return;
-  return value.length <= maxLength ? value : `${value.slice(0, maxLength - 1)}…`;
-}
-function findEmbeddedInputRequest(error) {
-  let current = error;
-  const seen = new Set;
-  for (let depth = 0;depth < 8 && current !== undefined && current !== null; depth++) {
-    if (seen.has(current))
-      return;
-    seen.add(current);
-    const record = asRecord(current);
-    if (!record)
-      return;
-    if (record.code === INPUT_REQUIRED_NEEDS_UI) {
-      const details = asRecord(record.details);
-      const inputKey = boundedText(details?.inputKey, MAX_INPUT_REQUIRED_DETAIL_LENGTH);
-      const inputMethod = boundedText(details?.inputMethod, MAX_INPUT_REQUIRED_DETAIL_LENGTH);
-      if (inputKey && inputMethod && INPUT_REQUIRED_METHODS.has(inputMethod)) {
-        const server = boundedText(details?.server, MAX_INPUT_REQUIRED_SERVER_LENGTH);
-        const tool = boundedText(details?.tool, MAX_INPUT_REQUIRED_TARGET_LENGTH);
-        const resourceUri = boundedText(details?.resourceUri, MAX_INPUT_REQUIRED_TARGET_LENGTH);
-        return {
-          inputKey,
-          inputMethod,
-          ...server ? { server } : {},
-          ...tool ? { tool } : {},
-          ...resourceUri ? { resourceUri } : {}
-        };
-      }
-    }
-    if (record.code === "CAPABILITY_NOT_SUPPORTED") {
-      const data = asRecord(record.data);
-      const inputKey = boundedText(data?.key, MAX_INPUT_REQUIRED_DETAIL_LENGTH);
-      const inputMethod = boundedText(data?.method, MAX_INPUT_REQUIRED_DETAIL_LENGTH);
-      if (inputKey && inputMethod && INPUT_REQUIRED_METHODS.has(inputMethod)) {
-        return { inputKey, inputMethod };
-      }
-    }
-    current = record.cause;
-  }
-  return;
-}
-export function getInputRequiredNeedsUiDetails(error, identity) {
-  const request = findEmbeddedInputRequest(error);
-  if (!request)
-    return;
-  const server = boundedText(request.server ?? identity.server, MAX_INPUT_REQUIRED_SERVER_LENGTH) ?? "unknown";
-  const tool = boundedText(request.tool ?? identity.tool, MAX_INPUT_REQUIRED_TARGET_LENGTH);
-  const resourceUri = boundedText(request.resourceUri ?? identity.resourceUri, MAX_INPUT_REQUIRED_TARGET_LENGTH);
-  const target = resourceUri ? `read resource "${resourceUri}"` : tool ? `call tool "${tool}"` : "complete the MCP request";
-  const guidance = request.inputMethod === "elicitation/create" ? "Run this call in an interactive DM session with elicitation enabled, then retry." : "Run this call in an interactive DM session with the required MCP capability enabled, then retry.";
-  const message = `MCP server "${server}" requested input to ${target}, but this session has no handler for "${request.inputMethod}" (input "${request.inputKey}"). ${guidance}`;
-  return {
-    error: INPUT_REQUIRED_NEEDS_UI,
-    server,
-    ...tool ? { tool } : {},
-    ...resourceUri ? { resourceUri } : {},
-    inputKey: request.inputKey,
-    inputMethod: request.inputMethod,
-    message
-  };
-}
-
-export class InputRequiredNeedsUiError extends McpUiError {
-  details;
-  constructor(details, cause) {
-    super(details.message, {
-      code: INPUT_REQUIRED_NEEDS_UI,
-      context: { ...details },
-      recoveryHint: "Run this call in an interactive DM session with the required MCP input handler enabled, then retry.",
-      ...cause ? { cause } : {}
-    });
-    this.details = details;
-    this.name = "InputRequiredNeedsUiError";
-  }
-}

package/extensions/dm-mcp-adapter/dist/http-ca.js

@@ -1,71 +0,0 @@
-import { readFileSync } from "node:fs";
-import { X509Certificate } from "node:crypto";
-import { Agent, Request as UndiciRequest, fetch as undiciFetch } from "undici";
-import { getMissingEnvVars, resolveConfigPath, resolveServerUrl } from "./utils.js";
-export function validateCaFile(definition) {
-  if (definition.caFile === undefined)
-    return;
-  if (typeof definition.caFile !== "string" || !definition.caFile.trim()) {
-    throw new Error("MCP caFile must be a non-empty path string");
-  }
-  if (definition.command !== undefined || definition.socket !== undefined || !definition.url || new URL(resolveServerUrl(definition)).protocol !== "https:") {
-    throw new Error("MCP caFile is only supported for HTTPS HTTP servers");
-  }
-}
-export function createCaFetch(definition) {
-  validateCaFile(definition);
-  if (definition.caFile === undefined)
-    return;
-  const origin = new URL(resolveServerUrl(definition)).origin;
-  if (getMissingEnvVars(definition.caFile).length)
-    throw new Error("Missing environment variable in MCP caFile");
-  let ca;
-  try {
-    ca = readFileSync(resolveConfigPath(definition.caFile), "utf8");
-    const certificates = ca.match(/-----BEGIN CERTIFICATE-----[\s\S]*?-----END CERTIFICATE-----/g);
-    if (!certificates?.length || ca.replace(/-----BEGIN CERTIFICATE-----[\s\S]*?-----END CERTIFICATE-----/g, "").trim()) {
-      throw new Error("expected a PEM certificate bundle");
-    }
-    for (const certificate of certificates)
-      new X509Certificate(certificate);
-  } catch (cause) {
-    throw new Error("Failed to load MCP caFile PEM certificate bundle", { cause });
-  }
-  const dispatcher = new Agent({ connect: { ca } });
-  let closed;
-  return {
-    fetch: (input, init) => {
-      const url = new URL(input instanceof Request ? input.url : input.toString());
-      if (url.origin !== origin)
-        return globalThis.fetch(input, init);
-      try {
-        const bundledInput = input instanceof Request ? new UndiciRequest(input.url, {
-          method: input.method,
-          headers: [...input.headers],
-          ...init?.body == null && input.body ? { body: async function* () {
-            yield* input.body;
-          }(), duplex: "half" } : {},
-          cache: input.cache,
-          credentials: input.credentials,
-          integrity: input.integrity,
-          keepalive: input.keepalive,
-          mode: input.mode,
-          redirect: input.redirect,
-          referrer: input.referrer,
-          referrerPolicy: input.referrerPolicy,
-          signal: input.signal
-        }) : input;
-        const options = {
-          ...init,
-          ...init?.headers !== undefined ? { headers: [...new Headers(init.headers)] } : {},
-          dispatcher,
-          redirect: "error"
-        };
-        return undiciFetch(bundledInput, options);
-      } catch (error) {
-        return Promise.reject(error);
-      }
-    },
-    close: () => closed ??= dispatcher.destroy()
-  };
-}