@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,294 +0,0 @@
-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/resource-tools.js

@@ -1,7 +0,0 @@
-export function resourceNameToToolName(name) {
-  let result = name.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_+/, "").replace(/_+$/, "").toLowerCase();
-  if (!result || /^\d/.test(result)) {
-    result = "resource" + (result ? "_" + result : "");
-  }
-  return result;
-}

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

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

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