@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

@@ -0,0 +1,300 @@
+import { ProtocolError } from "@modelcontextprotocol/client";
+import { createApplicationInputHandler, createTaskSessionEndpointId, createTaskSessionFromClient, DispatchError, JsonRpcResponseError, resultFromTaskOutcome, TaskCancelledError, TaskFailedError } from "@modelcontextprotocol/ext-tasks/client";
+import { logger } from "./logger.js";
+export const TASKS_EXTENSION_ID = "io.modelcontextprotocol/tasks";
+const RAW_REQUEST_ID_PREFIX = "pi-mcp-tasks-";
+const DEFAULT_RAW_REQUEST_TIMEOUT_MS = 60000;
+const LATE_TASK_HANDLE_GRACE_MS = 60000;
+function abortError(signal) {
+  return signal.reason instanceof Error ? signal.reason : new DOMException("This operation was aborted", "AbortError");
+}
+function isJsonRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export class RawRequestChannel {
+  transport;
+  pending = new Map;
+  requestCounter = 0;
+  defaultTimeoutMs;
+  attached = false;
+  constructor(transport, defaultTimeoutMs) {
+    this.transport = transport;
+    this.defaultTimeoutMs = defaultTimeoutMs ?? DEFAULT_RAW_REQUEST_TIMEOUT_MS;
+  }
+  attach() {
+    if (this.attached)
+      return;
+    this.attached = true;
+    const previousOnMessage = this.transport.onmessage;
+    this.transport.onmessage = (message, extra) => {
+      if (this.consumeRawResponse(message))
+        return;
+      previousOnMessage?.(message, extra);
+    };
+    const previousOnClose = this.transport.onclose;
+    this.transport.onclose = () => {
+      this.rejectAll("MCP connection closed");
+      previousOnClose?.();
+    };
+  }
+  rawDispatch = (request, options) => {
+    if (!isJsonRecord(request) || typeof request.method !== "string") {
+      return Promise.reject(new Error("Raw MCP request must be a JSON object with a string method"));
+    }
+    const params = request.params;
+    if (params !== undefined && !isJsonRecord(params)) {
+      return Promise.reject(new Error("Raw MCP request params must be a JSON object"));
+    }
+    const signal = options?.signal;
+    if (signal?.aborted)
+      return Promise.reject(abortError(signal));
+    const id = `${RAW_REQUEST_ID_PREFIX}${++this.requestCounter}`;
+    const message = {
+      jsonrpc: "2.0",
+      id,
+      method: request.method,
+      ...params === undefined ? {} : { params }
+    };
+    const timeoutMs = options?.context?.requestTimeoutMs ?? this.defaultTimeoutMs;
+    return new Promise((resolve, reject) => {
+      const entry = {
+        id,
+        resolve,
+        reject,
+        state: "pending",
+        ...signal === undefined ? {} : { signal },
+        ...message.method === "tools/call" ? { observationController: new AbortController } : {}
+      };
+      entry.requestTimer = setTimeout(() => {
+        this.terminateLocalWait(entry, new Error(`MCP task request "${message.method}" timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pending.set(id, entry);
+      if (signal) {
+        entry.onAbort = () => {
+          this.terminateLocalWait(entry, abortError(signal));
+        };
+        signal.addEventListener("abort", entry.onAbort, { once: true });
+      }
+      const fail = (error) => {
+        if (this.pending.get(id) !== entry)
+          return;
+        const wasPending = entry.state === "pending";
+        this.finishRequest(entry, true);
+        if (wasPending)
+          reject(error instanceof Error ? error : new Error(String(error)));
+      };
+      try {
+        Promise.resolve(this.transport.send(message, {
+          ...options?.context?.headers === undefined ? {} : { headers: options.context.headers },
+          ...entry.observationController !== undefined ? { requestSignal: entry.observationController.signal } : signal === undefined ? {} : { requestSignal: signal }
+        })).catch(fail);
+      } catch (error) {
+        fail(error);
+      }
+    });
+  };
+  consumeRawResponse(message) {
+    if (!("id" in message) || typeof message.id !== "string")
+      return false;
+    if (!message.id.startsWith(RAW_REQUEST_ID_PREFIX))
+      return false;
+    if ("method" in message)
+      return false;
+    const entry = this.pending.get(message.id);
+    if (!entry)
+      return true;
+    const wasObserving = entry.state === "observing";
+    this.finishRequest(entry, true);
+    if (wasObserving) {
+      this.cancelLateTask(message);
+      return true;
+    }
+    if ("error" in message) {
+      const { code, message: errorMessage, data } = message.error;
+      entry.resolve({ kind: "error", error: { code, message: errorMessage, ...data === undefined ? {} : { data } } });
+    } else if ("result" in message) {
+      entry.resolve({ kind: "result", result: message.result });
+    } else {
+      entry.reject(new Error("MCP task response frame carried neither result nor error"));
+    }
+    return true;
+  }
+  terminateLocalWait(entry, error) {
+    if (this.pending.get(entry.id) !== entry || entry.state !== "pending")
+      return;
+    if (entry.observationController === undefined) {
+      this.finishRequest(entry, false);
+    } else {
+      entry.state = "observing";
+      this.clearLocalWait(entry);
+      entry.observationTimer = setTimeout(() => {
+        this.finishRequest(entry, true);
+      }, LATE_TASK_HANDLE_GRACE_MS);
+    }
+    entry.reject(error);
+  }
+  clearLocalWait(entry) {
+    if (entry.requestTimer !== undefined)
+      clearTimeout(entry.requestTimer);
+    delete entry.requestTimer;
+    if (entry.signal !== undefined && entry.onAbort !== undefined) {
+      entry.signal.removeEventListener("abort", entry.onAbort);
+    }
+    delete entry.onAbort;
+  }
+  finishRequest(entry, abortObservation) {
+    if (this.pending.get(entry.id) !== entry)
+      return;
+    this.clearLocalWait(entry);
+    if (entry.observationTimer !== undefined)
+      clearTimeout(entry.observationTimer);
+    delete entry.observationTimer;
+    this.pending.delete(entry.id);
+    if (abortObservation)
+      entry.observationController?.abort();
+  }
+  cancelLateTask(message) {
+    if (!("result" in message) || !isJsonRecord(message.result))
+      return;
+    if (message.result.resultType !== "task" || typeof message.result.taskId !== "string")
+      return;
+    const taskId = message.result.taskId;
+    this.rawDispatch({ method: "tasks/cancel", params: { taskId } }, { context: { headers: { "Mcp-Name": taskId } } }).catch(() => {});
+  }
+  rejectAll(reason) {
+    const entries = [...this.pending.values()];
+    for (const entry of entries) {
+      const wasPending = entry.state === "pending";
+      this.finishRequest(entry, true);
+      if (wasPending)
+        entry.reject(new Error(reason));
+    }
+  }
+}
+export function serverAdvertisesTasks(client) {
+  if (client.getProtocolEra?.() !== "modern")
+    return false;
+  const capabilities = client.getServerCapabilities();
+  const extension = capabilities?.extensions?.[TASKS_EXTENSION_ID];
+  return isJsonRecord(extension) && Object.keys(extension).length === 0;
+}
+function capabilityNotSupportedError(serverName, method, inputKey) {
+  const error = new Error(`MCP server ${serverName} requested ${method} during a task, but this session has no handler for it`);
+  Object.assign(error, {
+    code: "CAPABILITY_NOT_SUPPORTED",
+    data: { key: inputKey ?? "unknown", method }
+  });
+  return error;
+}
+export async function attachTaskSession(options) {
+  const { client, serverName, definition } = options;
+  if (!serverAdvertisesTasks(client))
+    return;
+  const protocolVersion = client.getNegotiatedProtocolVersion?.();
+  if (protocolVersion === undefined)
+    return;
+  const endpointId = await createTaskSessionEndpointId("dm-mcp-adapter", {
+    server: serverName,
+    ...definition.command !== undefined ? { transport: { type: "stdio", command: definition.command, args: definition.args ?? [] } } : definition.url !== undefined ? { transport: { type: "http", url: definition.url } } : { transport: { type: "unix-socket", socket: definition.socket ?? null } }
+  });
+  const onInputRequest = createApplicationInputHandler({
+    elicitation: async (request, context) => {
+      if (options.onElicitation === undefined) {
+        throw capabilityNotSupportedError(serverName, "elicitation/create", context.inputId);
+      }
+      const result = await options.onElicitation({ method: "elicitation/create", params: request.params }, context.signal);
+      return {
+        action: result.action,
+        ...result.content === undefined ? {} : { content: result.content }
+      };
+    },
+    sampling: async (request, context) => {
+      if (options.onSampling === undefined) {
+        throw capabilityNotSupportedError(serverName, "sampling/createMessage", context.inputId);
+      }
+      const result = await options.onSampling({ method: "sampling/createMessage", params: request.params }, context.signal);
+      return {
+        model: result.model,
+        role: result.role,
+        content: result.content
+      };
+    },
+    roots: async () => ({ roots: [] })
+  });
+  const channel = new RawRequestChannel(options.transport, options.requestTimeoutMs);
+  channel.attach();
+  const session = createTaskSessionFromClient(client, {
+    endpointId,
+    rawDispatch: channel.rawDispatch,
+    v2RequestFraming: {
+      protocolVersion,
+      clientInfo: options.clientInfo,
+      clientCapabilities: options.clientCapabilities
+    },
+    tools: { currentTool: () => {
+      return;
+    } },
+    onInputRequest,
+    onError: (error) => logger.warn(`ext-tasks background error for ${serverName}: ${String(error)}`)
+  });
+  if (!session.capabilities.execution) {
+    await session.close().catch(() => {});
+    channel.rejectAll("Task session downgraded");
+    return;
+  }
+  return { session, channel };
+}
+function toCallToolError(error, signal) {
+  if (error instanceof TaskCancelledError && signal?.aborted === true) {
+    return abortError(signal);
+  }
+  if (error instanceof JsonRpcResponseError) {
+    return ProtocolError.fromError(error.code, error.message, error.data);
+  }
+  if (error instanceof TaskFailedError && error.code !== undefined) {
+    return ProtocolError.fromError(error.code, error.message, error.data);
+  }
+  if (error instanceof DispatchError) {
+    return error.cause ?? error;
+  }
+  return error;
+}
+export async function callToolViaTaskSession(session, options) {
+  const { signal } = options;
+  let execution;
+  try {
+    execution = await session.callTool(options.name, options.args, {
+      ...options.meta === undefined ? {} : { metadata: options.meta },
+      ...signal === undefined ? {} : { signal },
+      ...options.requestTimeoutMs === undefined ? {} : { requestTimeoutMs: options.requestTimeoutMs }
+    });
+  } catch (error) {
+    throw toCallToolError(error, signal);
+  }
+  let onAbort;
+  if (signal !== undefined && execution.kind === "task") {
+    onAbort = () => {
+      execution.cancel().catch(() => {});
+    };
+    if (signal.aborted)
+      onAbort();
+    else
+      signal.addEventListener("abort", onAbort, { once: true });
+  }
+  try {
+    const settlement = await execution.settle(signal === undefined ? {} : { signal });
+    const result = resultFromTaskOutcome(settlement.outcome);
+    if (!isJsonRecord(result)) {
+      throw new Error(`Task-backed tool ${options.name} settled with a non-object result`);
+    }
+    const { resultType: _resultType, ...lifted } = result;
+    return lifted;
+  } catch (error) {
+    throw toCallToolError(error, signal);
+  } finally {
+    if (signal !== undefined && onAbort !== undefined)
+      signal.removeEventListener("abort", onAbort);
+    await execution.close().catch(() => {});
+  }
+}

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

@@ -0,0 +1,220 @@
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { Buffer } from "node:buffer";
+import { dirname, isAbsolute, resolve } from "node:path";
+export const MCP_TRACE_SCHEMA_VERSION = 1;
+export const DEFAULT_MCP_TRACE_MAX_BYTES = 256 * 1024;
+export const DEFAULT_MCP_TRACE_MAX_EVENTS = 1e4;
+function boundedPositiveInteger(value, fallback) {
+  if (!Number.isFinite(value) || value === undefined || value <= 0)
+    return fallback;
+  return Math.floor(value);
+}
+export function redactTraceText(value, maxLength = 160) {
+  if (/\b(?:token|secret|password|passwd|api[_-]?key|authorization|cookie)\b/i.test(value)) {
+    return "[REDACTED]";
+  }
+  let redacted = value.replace(/\b[a-z][a-z\d+.-]*:\/\/[^\s"'<>]+/gi, "[REDACTED_URL]").replace(/\b(?:bearer|basic)\s+[A-Za-z0-9._~+/=-]+/gi, "[REDACTED_AUTH]").replace(/\b(?:token|secret|password|passwd|api[_-]?key|authorization|cookie)\s*[:=]\s*[^\s,;]+/gi, "$1=[REDACTED]");
+  if (redacted.length > maxLength)
+    redacted = `${redacted.slice(0, maxLength - 1)}…`;
+  return redacted;
+}
+function messageKind(message) {
+  if ("method" in message)
+    return "id" in message ? "request" : "notification";
+  return "response";
+}
+function traceId(value) {
+  if (value === null)
+    return null;
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string")
+    return "[REDACTED_ID]";
+  return;
+}
+function messageBytes(message) {
+  try {
+    return Buffer.byteLength(JSON.stringify(message), "utf8");
+  } catch {
+    return;
+  }
+}
+export function createMcpTraceEvent(direction, server, transport, message, status, options) {
+  const kind = messageKind(message);
+  const bytes = messageBytes(message);
+  const event = {
+    version: MCP_TRACE_SCHEMA_VERSION,
+    timestamp: new Date().toISOString(),
+    direction,
+    server: redactTraceText(server, 120),
+    transport,
+    kind,
+    status,
+    ...bytes !== undefined ? { bytes } : {}
+  };
+  if ("method" in message)
+    event.method = redactTraceText(message.method, 120);
+  if ("id" in message)
+    event.id = traceId(message.id) ?? null;
+  const relatedRequestId = traceId(options?.relatedRequestId);
+  if (relatedRequestId !== undefined && relatedRequestId !== null)
+    event.relatedRequestId = relatedRequestId;
+  if ("error" in message && message.error && typeof message.error.code === "number") {
+    event.errorCode = message.error.code;
+  }
+  if (options?.durationMs !== undefined && Number.isFinite(options.durationMs)) {
+    event.durationMs = Math.max(0, Math.round(options.durationMs * 100) / 100);
+  }
+  return event;
+}
+
+export class McpTraceWriter {
+  options;
+  maxBytes;
+  maxEvents;
+  append;
+  resetFile;
+  makeDirectory;
+  bytesWritten = 0;
+  eventsWritten = 0;
+  queue = Promise.resolve();
+  disabled = false;
+  initializationFailed = false;
+  fileReady;
+  constructor(options) {
+    this.options = options;
+    this.maxBytes = boundedPositiveInteger(options.maxBytes, DEFAULT_MCP_TRACE_MAX_BYTES);
+    this.maxEvents = boundedPositiveInteger(options.maxEvents, DEFAULT_MCP_TRACE_MAX_EVENTS);
+    this.append = options.appendFile ?? (async (path, data, appendOptions) => {
+      await appendFile(path, data, appendOptions);
+    });
+    this.resetFile = options.writeFile ?? (async (path, data, writeOptions) => {
+      await writeFile(path, data, writeOptions);
+    });
+    this.makeDirectory = options.mkdir ?? (async (path) => {
+      await mkdir(path, { recursive: true });
+      return;
+    });
+    this.fileReady = this.makeDirectory(dirname(this.options.filePath), { recursive: true }).then(() => this.resetFile(this.options.filePath, "", { encoding: "utf8" })).catch(() => {
+      this.initializationFailed = true;
+      this.disabled = true;
+    });
+  }
+  get filePath() {
+    return this.options.filePath;
+  }
+  get isDisabled() {
+    return this.disabled;
+  }
+  get stats() {
+    return { bytes: this.bytesWritten, events: this.eventsWritten };
+  }
+  write(event) {
+    if (this.disabled || this.eventsWritten >= this.maxEvents)
+      return;
+    let line;
+    try {
+      line = `${JSON.stringify(event)}
+`;
+    } catch {
+      this.disabled = true;
+      return;
+    }
+    const bytes = Buffer.byteLength(line, "utf8");
+    if (bytes > this.maxBytes - this.bytesWritten) {
+      this.disabled = true;
+      return;
+    }
+    this.bytesWritten += bytes;
+    this.eventsWritten += 1;
+    this.queue = this.queue.then(async () => {
+      await this.fileReady;
+      if (this.initializationFailed)
+        return;
+      await this.append(this.options.filePath, line, { encoding: "utf8" });
+    }).catch(() => {
+      this.disabled = true;
+    });
+  }
+  async flush() {
+    await this.fileReady;
+    await this.queue;
+  }
+}
+export function createMcpTraceWriter(sessionCwd, settings = {}, randomSuffix = Math.random().toString(36).slice(2, 10)) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const configuredPath = settings.file;
+  const filePath = configuredPath ? isAbsolute(configuredPath) ? configuredPath : resolve(sessionCwd ?? process.cwd(), configuredPath) : resolve(sessionCwd ?? process.cwd(), ".dm", "mcp-traces", `mcp-${timestamp}-${randomSuffix}.jsonl`);
+  return new McpTraceWriter({
+    filePath,
+    ...settings.maxBytes !== undefined ? { maxBytes: settings.maxBytes } : {},
+    ...settings.maxEvents !== undefined ? { maxEvents: settings.maxEvents } : {}
+  });
+}
+export function isMcpTraceEnabled(definition, settings) {
+  return definition.trace ?? settings?.enabled === true;
+}
+const untracedMessageHandlers = new WeakMap;
+export function untracedMessageHandler(transport) {
+  return untracedMessageHandlers.get(transport)?.() ?? transport.onmessage;
+}
+export function wrapTransportWithMcpTrace(transport, server, transportKind, observer) {
+  let messageHandler = transport.onmessage;
+  let tracedMessageHandler;
+  const originalSend = transport.send;
+  const record = (event) => {
+    try {
+      observer.record(event);
+    } catch {}
+  };
+  try {
+    Object.defineProperty(transport, "onmessage", {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return tracedMessageHandler;
+      },
+      set(handler) {
+        messageHandler = handler;
+        tracedMessageHandler = handler ? (message, extra) => {
+          record(createMcpTraceEvent("inbound", server, transportKind, message, "received"));
+          handler(message, extra);
+        } : undefined;
+      }
+    });
+    transport.onmessage = messageHandler;
+    untracedMessageHandlers.set(transport, () => messageHandler);
+  } catch {}
+  transport.send = async (message, options) => {
+    const started = performance.now();
+    const messages = Array.isArray(message) ? message : [message];
+    try {
+      await originalSend.call(transport, message, options);
+      for (const item of messages) {
+        record(createMcpTraceEvent("outbound", server, transportKind, item, "sent", {
+          durationMs: performance.now() - started
+        }));
+      }
+    } catch (error) {
+      for (const item of messages) {
+        record(createMcpTraceEvent("outbound", server, transportKind, item, "error", {
+          durationMs: performance.now() - started
+        }));
+      }
+      throw error;
+    }
+  };
+  return transport;
+}
+export function traceTransportKind(definition, transport) {
+  if (definition.command)
+    return "stdio";
+  if (definition.socket)
+    return "unix-socket";
+  const constructorName = transport.constructor?.name.toLowerCase() ?? "";
+  if (constructorName.includes("sse"))
+    return "sse";
+  if (constructorName.includes("streamable"))
+    return "streamable-http";
+  return definition.url ? "streamable-http" : "unknown";
+}