@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-mcp-adapter/dist/request-headers-command.js

@@ -0,0 +1,294 @@
+import { spawn, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { interpolateEnvVars } from "./utils.js";
+const DEFAULT_TIMEOUT_MS = 1e4;
+const MAX_OUTPUT_BYTES = 64 * 1024;
+const USE_PROCESS_GROUP = process.platform !== "win32";
+const CLEANUP_TOKEN_ENV = "PI_MCP_REQUEST_HEADERS_CLEANUP_TOKEN";
+const PS_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+function isNoSuchProcessError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH";
+}
+function runPosixPs(args) {
+  if (process.env.DM_MCP_ADAPTER_TEST_FAIL_PS === "1")
+    return { status: 1, signal: null, stdout: "" };
+  const result = spawnSync("ps", args, { encoding: "utf8", maxBuffer: PS_MAX_BUFFER_BYTES });
+  return { status: result.status, signal: result.signal, stdout: result.stdout };
+}
+function psFailureReason(result) {
+  return result.status === null ? `ps was killed by signal ${result.signal ?? "unknown"}` : `ps exited with code ${result.status}`;
+}
+function collectPosixProcessPids(rootPid, cleanupToken) {
+  const result = runPosixPs(["axeww", "-o", "pid=,ppid=,command="]);
+  if (result.status !== 0) {
+    throw new Error(`HTTP request headers command cleanup failed: ${psFailureReason(result)}`);
+  }
+  const childrenByParent = new Map;
+  const processPids = new Set;
+  const needle = cleanupToken ? `${CLEANUP_TOKEN_ENV}=${cleanupToken}` : undefined;
+  for (const line of result.stdout.split(`
+`)) {
+    const match = /^\s*(\d+)\s+(\d+)(?:\s+(.*))?$/.exec(line);
+    if (!match)
+      continue;
+    const pid = Number(match[1]);
+    const ppid = Number(match[2]);
+    if (!Number.isInteger(pid) || !Number.isInteger(ppid))
+      continue;
+    const children = childrenByParent.get(ppid);
+    if (children)
+      children.push(pid);
+    else
+      childrenByParent.set(ppid, [pid]);
+    if (needle && pid !== process.pid && match[3]?.includes(needle))
+      processPids.add(pid);
+  }
+  const stack = [...childrenByParent.get(rootPid) ?? []];
+  while (stack.length > 0) {
+    const pid = stack.pop();
+    processPids.add(pid);
+    stack.push(...childrenByParent.get(pid) ?? []);
+  }
+  return [...processPids];
+}
+function assertPosixProcessDiscoveryAvailable() {
+  const result = runPosixPs(["axeww", "-o", "pid=,ppid=,command="]);
+  if (result.status !== 0) {
+    throw new Error(`HTTP request headers command cleanup failed: ${psFailureReason(result)}`);
+  }
+}
+function isTaskkillNoSuchProcess(result) {
+  return `${result.stdout ?? ""}
+${result.stderr ?? ""}`.toLowerCase().includes("not found");
+}
+function signalPid(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (error) {
+    if (!isNoSuchProcessError(error))
+      throw error;
+  }
+}
+function signalProcessGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch (error) {
+    if (!isNoSuchProcessError(error))
+      throw error;
+  }
+}
+function killRequestHeadersCommand(child, trackedPosixDescendantPids = new Set, cleanupToken) {
+  if (process.platform === "win32" && child.pid !== undefined) {
+    const result = spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+      encoding: "utf8",
+      windowsHide: true
+    });
+    if (result.status === 0 || result.status === 128 || isTaskkillNoSuchProcess(result))
+      return;
+    throw new Error(`HTTP request headers command cleanup failed: taskkill exited with code ${result.status ?? "unknown"}`);
+  }
+  if (USE_PROCESS_GROUP && child.pid !== undefined) {
+    const frozenPids = new Set;
+    let cleanupError;
+    try {
+      signalProcessGroup(child.pid, "SIGSTOP");
+      for (const pid of trackedPosixDescendantPids) {
+        signalPid(pid, "SIGSTOP");
+        frozenPids.add(pid);
+      }
+      let stablePasses = 0;
+      for (let pass = 0;pass < 16; pass++) {
+        const candidates = collectPosixProcessPids(child.pid, cleanupToken);
+        const newPids = candidates.filter((pid) => !frozenPids.has(pid));
+        if (newPids.length === 0) {
+          stablePasses++;
+          if (stablePasses >= 2)
+            return;
+          continue;
+        }
+        stablePasses = 0;
+        for (const pid of newPids) {
+          signalPid(pid, "SIGSTOP");
+          frozenPids.add(pid);
+        }
+      }
+      cleanupError = new Error("HTTP request headers command cleanup failed: descendant process tree did not stabilize");
+    } catch (error) {
+      cleanupError = error instanceof Error ? error : new Error(String(error));
+    } finally {
+      signalProcessGroup(child.pid, "SIGKILL");
+      for (const pid of frozenPids)
+        signalPid(pid, "SIGKILL");
+    }
+    if (cleanupError)
+      throw cleanupError;
+    return;
+  }
+  child.kill("SIGKILL");
+}
+function resolvedCommand(config) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error("HTTP request headers command must be an object");
+  }
+  if (typeof config.command !== "string" || config.command.trim() === "") {
+    throw new Error("HTTP request headers command requires a non-empty command");
+  }
+  if (config.args !== undefined && (!Array.isArray(config.args) || config.args.some((arg) => typeof arg !== "string"))) {
+    throw new Error("HTTP request headers command args must be strings");
+  }
+  if (config.env !== undefined && (typeof config.env !== "object" || Array.isArray(config.env) || Object.values(config.env).some((value) => typeof value !== "string"))) {
+    throw new Error("HTTP request headers command env values must be strings");
+  }
+  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 60000) {
+    throw new Error("HTTP request headers command timeoutMs must be an integer between 1 and 60000");
+  }
+  return {
+    command: interpolateEnvVars(config.command),
+    args: (config.args ?? []).map(interpolateEnvVars),
+    env: {
+      ...process.env,
+      ...Object.fromEntries(Object.entries(config.env ?? {}).map(([key, value]) => [key, interpolateEnvVars(value)]))
+    },
+    timeoutMs
+  };
+}
+async function invokeRequestHeadersCommand(config, envelope, signal) {
+  const resolved = resolvedCommand(config);
+  if (USE_PROCESS_GROUP)
+    assertPosixProcessDiscoveryAvailable();
+  return new Promise((resolve, reject) => {
+    let stdout = Buffer.alloc(0);
+    let settled = false;
+    const cleanupToken = randomUUID();
+    const child = spawn(resolved.command, resolved.args, {
+      env: { ...resolved.env, [CLEANUP_TOKEN_ENV]: cleanupToken },
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true,
+      detached: USE_PROCESS_GROUP
+    });
+    const trackedPosixDescendantPids = new Set;
+    let trackingError;
+    const trackPosixDescendants = () => {
+      if (!USE_PROCESS_GROUP || child.pid === undefined || settled || trackingError)
+        return;
+      try {
+        for (const pid of collectPosixProcessPids(child.pid, cleanupToken))
+          trackedPosixDescendantPids.add(pid);
+      } catch (error) {
+        trackingError = error instanceof Error ? error : new Error(String(error));
+      }
+    };
+    const descendantTracker = USE_PROCESS_GROUP ? setInterval(trackPosixDescendants, 50) : undefined;
+    descendantTracker?.unref();
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (descendantTracker)
+        clearInterval(descendantTracker);
+      signal.removeEventListener("abort", abort);
+      if (result.status === "error")
+        reject(result.error);
+      else
+        resolve(result.headers);
+    };
+    const finishAfterKill = (result) => {
+      try {
+        killRequestHeadersCommand(child, trackedPosixDescendantPids, cleanupToken);
+        finish(result);
+      } catch (cleanupError) {
+        finish({ status: "error", error: cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError)) });
+      }
+    };
+    const failAfterKill = (message) => {
+      finishAfterKill({ status: "error", error: trackingError ?? new Error(message) });
+    };
+    const abort = () => {
+      failAfterKill("HTTP request headers command aborted");
+    };
+    const timer = setTimeout(() => {
+      failAfterKill(`HTTP request headers command timed out after ${resolved.timeoutMs}ms`);
+    }, resolved.timeoutMs);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) {
+      abort();
+      return;
+    }
+    child.on("error", () => finish({ status: "error", error: new Error("HTTP request headers command failed to start") }));
+    child.stdout.on("data", (chunk) => {
+      if (settled)
+        return;
+      stdout = Buffer.concat([stdout, Buffer.from(chunk)]);
+      if (stdout.byteLength > MAX_OUTPUT_BYTES) {
+        failAfterKill("HTTP request headers command output exceeded 64 KiB");
+      }
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      if (trackingError) {
+        failAfterKill(trackingError.message);
+        return;
+      }
+      if (code !== 0) {
+        failAfterKill(`HTTP request headers command exited with code ${code ?? "unknown"}`);
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout.toString("utf8"));
+      } catch {
+        finishAfterKill({ status: "error", error: new Error("HTTP request headers command returned invalid JSON") });
+        return;
+      }
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        finishAfterKill({ status: "error", error: new Error("HTTP request headers command must return a JSON object") });
+        return;
+      }
+      const entries = Object.entries(parsed);
+      if (entries.some(([, value]) => typeof value !== "string")) {
+        finishAfterKill({ status: "error", error: new Error("HTTP request headers command values must be strings") });
+        return;
+      }
+      try {
+        finishAfterKill({ status: "success", headers: new Headers(entries) });
+      } catch {
+        finishAfterKill({ status: "error", error: new Error("HTTP request headers command returned an invalid header") });
+      }
+    });
+    child.stdin.on("error", () => {});
+    child.stdin.end(JSON.stringify(envelope));
+  });
+}
+export function createRequestHeadersCommandFetch(config, delegate = globalThis.fetch) {
+  resolvedCommand(config);
+  return async (input, init) => {
+    const request = new Request(input, init);
+    const signal = init?.signal === null ? request.signal : init?.signal ?? (input instanceof Request ? input.signal : request.signal);
+    const body = Buffer.from(await request.clone().arrayBuffer());
+    const derived = await invokeRequestHeadersCommand(config, {
+      version: 1,
+      method: request.method.toUpperCase(),
+      url: request.url,
+      bodyBase64: body.toString("base64")
+    }, signal);
+    const headers = new Headers(request.headers);
+    derived.forEach((value, name) => headers.set(name, value));
+    return delegate(new URL(request.url), {
+      method: request.method,
+      headers,
+      ...request.method === "GET" || request.method === "HEAD" ? {} : { body },
+      signal,
+      cache: request.cache,
+      credentials: request.credentials,
+      integrity: request.integrity,
+      keepalive: request.keepalive,
+      mode: request.mode,
+      redirect: request.redirect,
+      referrer: request.referrer,
+      referrerPolicy: request.referrerPolicy
+    });
+  };
+}

package/extensions/dm-mcp-adapter/dist/runtime-owner.js

@@ -0,0 +1,94 @@
+import { formatTerminalError } from "./utils.js";
+export function createMcpRuntimeOwner() {
+  const controller = new AbortController;
+  const cleanups = [];
+  let stopPromise;
+  const reportCleanupFailure = (error, late) => {
+    console.error(`MCP: ${late ? "late " : ""}runtime cleanup failed: ${formatTerminalError(error)}`);
+  };
+  return {
+    signal: controller.signal,
+    isActive: () => !controller.signal.aborted,
+    addCleanup: (cleanup) => {
+      if (controller.signal.aborted) {
+        Promise.resolve().then(cleanup).catch((error) => reportCleanupFailure(error, true));
+        return;
+      }
+      cleanups.push(cleanup);
+    },
+    stop: (reason = "MCP extension runtime stopped") => {
+      if (stopPromise)
+        return stopPromise;
+      controller.abort(new Error(reason));
+      const pendingCleanups = cleanups.splice(0).reverse().map((cleanup) => Promise.resolve().then(cleanup));
+      stopPromise = Promise.allSettled(pendingCleanups).then((results) => {
+        const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (failures.length > 0) {
+          const aggregate = new AggregateError(failures, "MCP runtime cleanup failed");
+          console.error(`MCP: runtime cleanup failed: ${formatTerminalError(aggregate)}`);
+          throw aggregate;
+        }
+      });
+      return stopPromise;
+    },
+    throwIfInactive: () => controller.signal.throwIfAborted()
+  };
+}
+export function combineAbortSignals(...signals) {
+  const active = signals.filter((signal) => signal !== undefined);
+  if (active.length === 0)
+    return;
+  if (active.length === 1)
+    return active[0];
+  if (typeof AbortSignal.any === "function")
+    return AbortSignal.any(active);
+  const controller = new AbortController;
+  const alreadyAborted = active.find((signal) => signal.aborted);
+  if (alreadyAborted) {
+    controller.abort(alreadyAborted.reason);
+    return controller.signal;
+  }
+  const onAbort = (event) => {
+    for (const signal of active)
+      signal.removeEventListener("abort", onAbort);
+    controller.abort(event.target.reason);
+  };
+  for (const signal of active)
+    signal.addEventListener("abort", onAbort, { once: true });
+  return controller.signal;
+}
+export function createOwnedUi(ui, owner) {
+  const proxies = new WeakMap;
+  const wrap = (value) => {
+    if ((typeof value !== "object" || value === null) && typeof value !== "function") {
+      return value;
+    }
+    const object = value;
+    const existing = proxies.get(object);
+    if (existing)
+      return existing;
+    const proxy = new Proxy(object, {
+      get(target, property, receiver) {
+        if (!owner.isActive())
+          return;
+        const member = Reflect.get(target, property, receiver);
+        if (typeof member === "function") {
+          return (...args) => {
+            if (!owner.isActive())
+              return;
+            return Reflect.apply(member, target, args);
+          };
+        }
+        return owner.isActive() ? wrap(member) : undefined;
+      }
+    });
+    proxies.set(object, proxy);
+    return proxy;
+  };
+  return wrap(ui);
+}
+export function isAbortError(error, signal) {
+  if (signal?.aborted)
+    return true;
+  return error instanceof Error && (error.name === "AbortError" || error.message === "MCP extension runtime stopped");
+}

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

@@ -0,0 +1,213 @@
+import { completeSimple } from "@duckmind/dm-ai/compat";
+import { truncateAtWord } from "./utils.js";
+import { throwIfAborted } from "./abort.js";
+export function registerSamplingHandler(client, options) {
+  client.setRequestHandler("sampling/createMessage", (request) => {
+    return handleSamplingRequest(options, request);
+  });
+}
+export async function handleSamplingRequest(options, request) {
+  const params = request.params;
+  const signal = options.getSignal();
+  throwIfAborted(signal);
+  if ("task" in params && params.task) {
+    throw new Error("MCP sampling tasks are not supported");
+  }
+  if (params.includeContext && params.includeContext !== "none") {
+    throw new Error("MCP sampling context inclusion is not supported");
+  }
+  if (params.tools?.length) {
+    throw new Error("MCP sampling tool use is not supported");
+  }
+  if (params.toolChoice) {
+    throw new Error("MCP sampling tool choice is not supported");
+  }
+  if (params.stopSequences?.length) {
+    throw new Error("MCP sampling stop sequences are not supported");
+  }
+  const messages = params.messages.map(convertSamplingMessage);
+  const model = resolveSamplingModel(options, params.modelPreferences);
+  throwIfAborted(signal);
+  await confirmSampling(options, "Approve MCP sampling request", formatRequestApproval(options.serverName, `${model.provider}/${model.id}`, params.systemPrompt, messages));
+  throwIfAborted(signal);
+  const auth = await options.modelRegistry.getApiKeyAndHeaders(model);
+  if (!auth.ok)
+    throw new Error(auth.error);
+  throwIfAborted(signal);
+  const result = await completeSimple(model, {
+    ...params.systemPrompt !== undefined ? { systemPrompt: params.systemPrompt } : {},
+    messages
+  }, {
+    maxTokens: params.maxTokens,
+    ...params.temperature !== undefined ? { temperature: params.temperature } : {},
+    ...params.metadata !== undefined ? { metadata: params.metadata } : {},
+    ...signal ? { signal } : {},
+    ...auth.apiKey ? { apiKey: auth.apiKey } : {},
+    ...auth.headers ? { headers: auth.headers } : {},
+    ...auth.env ? { env: auth.env } : {}
+  });
+  const converted = convertAssistantResult(result);
+  throwIfAborted(signal);
+  await confirmSampling(options, "Return MCP sampling response", formatResponseApproval(options.serverName, converted));
+  return converted;
+}
+function formatRequestApproval(serverName, modelName, systemPrompt, messages) {
+  const lines = [`${serverName} wants to sample ${messages.length} message${messages.length === 1 ? "" : "s"} with ${modelName}.`];
+  if (systemPrompt) {
+    lines.push(`System: ${truncateAtWord(systemPrompt, 400)}`);
+  }
+  for (const [index, message] of messages.entries()) {
+    lines.push(`${index + 1}. ${message.role}: ${truncateAtWord(messageText(message), 400)}`);
+  }
+  return lines.join(`
+
+`);
+}
+function formatResponseApproval(serverName, response) {
+  const text = response.content.type === "text" ? response.content.text : `[${response.content.type} content]`;
+  return `${serverName} will receive this response from ${response.model}:
+
+${truncateAtWord(text, 1000)}`;
+}
+function messageText(message) {
+  if (typeof message.content === "string")
+    return message.content;
+  return message.content.map((block) => {
+    if (block.type === "text")
+      return block.text;
+    if (block.type === "image")
+      return `[image: ${block.mimeType}]`;
+    if (block.type === "thinking")
+      return "[thinking]";
+    if (block.type === "toolCall")
+      return `[tool call: ${block.name}]`;
+    return "[content]";
+  }).join(`
+`);
+}
+function resolveSamplingModel(options, modelPreferences) {
+  const candidates = [];
+  const availableModels = options.modelRegistry.getAvailable();
+  for (const hint of modelPreferences?.hints ?? []) {
+    const normalizedHint = hint.name?.trim().toLowerCase();
+    if (!normalizedHint)
+      continue;
+    for (const model of availableModels) {
+      const searchableNames = [`${model.provider}/${model.id}`, model.id, model.name];
+      if (searchableNames.some((name) => name.toLowerCase().includes(normalizedHint))) {
+        addSamplingCandidate(candidates, model);
+      }
+    }
+  }
+  const currentModel = options.getCurrentModel();
+  if (currentModel)
+    addSamplingCandidate(candidates, currentModel);
+  for (const model of availableModels) {
+    addSamplingCandidate(candidates, model);
+  }
+  const signal = options.getSignal();
+  throwIfAborted(signal);
+  const model = candidates[0];
+  if (model)
+    return model;
+  throw new Error("No DM model is available for MCP sampling");
+}
+function addSamplingCandidate(candidates, model) {
+  if (!candidates.some((candidate) => candidate.provider === model.provider && candidate.id === model.id)) {
+    candidates.push(model);
+  }
+}
+async function confirmSampling(options, title, message) {
+  if (options.autoApprove)
+    return;
+  if (!options.ui) {
+    throw new Error("MCP sampling requires interactive approval. Set settings.samplingAutoApprove to true to allow it without UI.");
+  }
+  const approved = await options.ui.confirm(title, message);
+  if (!approved) {
+    throw new Error("MCP sampling request was declined");
+  }
+}
+function convertSamplingMessage(message) {
+  const blocks = Array.isArray(message.content) ? message.content : [message.content];
+  if (message.role === "user") {
+    return {
+      role: "user",
+      content: blocks.map(convertUserContent),
+      timestamp: Date.now()
+    };
+  }
+  return {
+    role: "assistant",
+    content: blocks.map(convertAssistantContent),
+    api: "mcp-sampling",
+    provider: "mcp",
+    model: "sampling-request",
+    usage: zeroUsage(),
+    stopReason: "stop",
+    timestamp: Date.now()
+  };
+}
+function convertUserContent(block) {
+  if (block.type === "text") {
+    return { type: "text", text: block.text };
+  }
+  throw new Error(`MCP sampling ${block.type} content is not supported`);
+}
+function convertAssistantContent(block) {
+  if (block.type === "text") {
+    return { type: "text", text: block.text };
+  }
+  throw new Error(`MCP sampling assistant ${block.type} content is not supported`);
+}
+function convertAssistantResult(message) {
+  if (message.stopReason === "error") {
+    throw new Error(message.errorMessage ?? "MCP sampling model call failed");
+  }
+  if (message.stopReason === "aborted") {
+    throw new Error(message.errorMessage ?? "MCP sampling model call was aborted");
+  }
+  const text = message.content.map((block) => {
+    if (block.type === "text")
+      return block.text;
+    if (block.type === "thinking")
+      return;
+    throw new Error(`MCP sampling result ${block.type} content is not supported`);
+  }).filter((value) => value !== undefined).join(`
+
+`).trim();
+  if (!text) {
+    throw new Error("MCP sampling result did not contain text content");
+  }
+  return {
+    role: "assistant",
+    content: { type: "text", text },
+    model: `${message.provider}/${message.model}`,
+    stopReason: mapStopReason(message.stopReason)
+  };
+}
+function mapStopReason(reason) {
+  if (reason === "stop")
+    return "endTurn";
+  if (reason === "length")
+    return "maxTokens";
+  if (reason === "toolUse")
+    return "toolUse";
+  return reason;
+}
+function zeroUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      total: 0
+    }
+  };
+}