@duckmind/dm-windows-x64 0.63.4 → 0.63.9

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

@@ -0,0 +1,225 @@
+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/failure-backoff.js

@@ -0,0 +1,19 @@
+export const FAILURE_BACKOFF_MS = 60 * 1000;
+export function getFailureAgeSeconds(state, serverName) {
+  const failedAt = state.failureTracker.get(serverName);
+  if (!failedAt)
+    return null;
+  const ageMs = Date.now() - failedAt;
+  if (ageMs > FAILURE_BACKOFF_MS)
+    return null;
+  return Math.round(ageMs / 1000);
+}
+export function getFailureMessage(state, serverName) {
+  if (getFailureAgeSeconds(state, serverName) === null)
+    return null;
+  return state.failureMessages?.get(serverName) ?? null;
+}
+export function isServerInActiveFailureBackoff(state, serverName) {
+  const connection = state.manager.getConnection(serverName);
+  return connection?.status !== "connected" && connection?.status !== "needs-auth" && getFailureAgeSeconds(state, serverName) !== null;
+}

package/extensions/dm-mcp-adapter/glimpse-ui.js

@@ -0,0 +1,61 @@
+import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join, dirname } from "node:path";
+import { platform } from "node:os";
+import { createRequire } from "node:module";
+let glimpseAvailable = null;
+let resolvedBinaryPath = null;
+export function isGlimpseAvailable() {
+  if (glimpseAvailable !== null)
+    return glimpseAvailable;
+  if (platform() !== "darwin") {
+    glimpseAvailable = false;
+    return false;
+  }
+  resolvedBinaryPath = getGlimpseBinaryPath();
+  glimpseAvailable = resolvedBinaryPath !== null;
+  return glimpseAvailable;
+}
+function getGlimpseBinaryPath() {
+  if (process.env.GLIMPSE_BINARY && existsSync(process.env.GLIMPSE_BINARY)) {
+    return process.env.GLIMPSE_BINARY;
+  }
+  try {
+    const require = createRequire(import.meta.url);
+    const glimpseuiPath = require.resolve("glimpseui");
+    const binaryPath = join(dirname(glimpseuiPath), "glimpse");
+    if (existsSync(binaryPath))
+      return binaryPath;
+  } catch {}
+  try {
+    const globalRoot = execFileSync("npm", ["root", "-g"], { encoding: "utf-8" }).trim();
+    const binaryPath = join(globalRoot, "glimpseui", "src", "glimpse");
+    if (existsSync(binaryPath))
+      return binaryPath;
+  } catch {}
+  return null;
+}
+export async function openGlimpseWindow(html, options) {
+  const modulePath = resolvedBinaryPath ? join(dirname(resolvedBinaryPath), "glimpse.mjs") : "glimpseui";
+  const glimpse = await import(modulePath);
+  let active = true;
+  const win = glimpse.open(html, {
+    width: options.width ?? 900,
+    height: options.height ?? 700,
+    title: options.title
+  });
+  win.on("closed", () => {
+    if (!active)
+      return;
+    active = false;
+    options.onClosed();
+  });
+  return {
+    close: () => {
+      if (!active)
+        return;
+      active = false;
+      win.close();
+    }
+  };
+}