@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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