@duckmind/dm-windows-x64 0.63.4 → 0.63.9

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

@@ -0,0 +1,291 @@
+import { formatWithOptions } from "node:util";
+import { Worker } from "node:worker_threads";
+import { guardMcpOutput, guardedMcpDetails, resolveMcpOutputGuardOptions } from "./mcp-output-guard.js";
+import { executeCall } from "./proxy-modes.js";
+import { combineAbortSignals } from "./runtime-owner.js";
+import { paginate, rankSuggestions, rankToolMatches } from "./search-ranking.js";
+import { isServerInActiveFailureBackoff } from "./failure-backoff.js";
+import { findToolByName, formatSchema } from "./tool-metadata.js";
+import { renderTsShape } from "./ts-shape.js";
+export const DEFAULT_MCP_SCRIPT_TIMEOUT_MS = 30000;
+
+class McpScriptTimeoutError extends Error {
+  constructor(timeoutMs) {
+    super(`mcpScript timed out after ${timeoutMs}ms`);
+    this.name = "McpScriptTimeoutError";
+  }
+}
+function needsInspectableFormatting(value, stack = new WeakSet) {
+  if (value === undefined || typeof value === "bigint" || typeof value === "function" || typeof value === "symbol")
+    return true;
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (stack.has(value))
+    return true;
+  if (value instanceof Map || value instanceof Set || value instanceof WeakMap || value instanceof WeakSet)
+    return true;
+  stack.add(value);
+  try {
+    return Object.values(value).some((entry) => needsInspectableFormatting(entry, stack));
+  } finally {
+    stack.delete(value);
+  }
+}
+function formatValue(value) {
+  if (typeof value === "string")
+    return value;
+  try {
+    if (!needsInspectableFormatting(value)) {
+      const json = JSON.stringify(value, null, 2);
+      if (json !== undefined)
+        return json;
+    }
+    return formatWithOptions({ colors: false, depth: 6 }, value);
+  } catch {
+    return "[unserializable value]";
+  }
+}
+function toContentBlock(value) {
+  if (typeof value === "object" && value !== null) {
+    const block = value;
+    if (block.type === "text" && typeof block.text === "string") {
+      return { type: "text", text: block.text };
+    }
+    if (block.type === "image" && typeof block.data === "string" && typeof block.mimeType === "string") {
+      return { type: "image", data: block.data, mimeType: block.mimeType };
+    }
+  }
+  return { type: "text", text: formatValue(value) };
+}
+function textFromContent(content) {
+  return content.filter((block) => block.type === "text").map((block) => block.text).join(`
+`);
+}
+function abortReasonError(reason) {
+  return reason instanceof Error ? reason : new Error(String(reason ?? "MCP request aborted"));
+}
+function parseWorkerMessage(value) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const message = value;
+  if (message.type === "emit" && "block" in message)
+    return { type: "emit", block: message.block };
+  if (message.type === "call" && typeof message.id === "number" && typeof message.path === "string") {
+    return "args" in message ? { type: "call", id: message.id, path: message.path, args: message.args } : { type: "call", id: message.id, path: message.path };
+  }
+  if ((message.type === "search" || message.type === "describe") && typeof message.id === "number") {
+    return "input" in message ? { type: message.type, id: message.id, input: message.input } : { type: message.type, id: message.id };
+  }
+  if (message.type === "done") {
+    return "returnBlock" in message ? { type: "done", returnBlock: message.returnBlock } : { type: "done" };
+  }
+  if (message.type === "error" && typeof message.message === "string") {
+    return { type: "error", message: message.message };
+  }
+  return null;
+}
+export async function runMcpScript(state, code, timeoutMs = DEFAULT_MCP_SCRIPT_TIMEOUT_MS, getPiTools, signal) {
+  const resolvedTimeoutMs = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.floor(timeoutMs) : DEFAULT_MCP_SCRIPT_TIMEOUT_MS;
+  const output = [];
+  const externalSignal = combineAbortSignals(state.owner?.signal, signal);
+  const timeoutController = new AbortController;
+  const callSignal = combineAbortSignals(externalSignal, timeoutController.signal);
+  const calls = [];
+  const snapshotCalls = () => calls.map(({ startedAt, ...operation }) => ({
+    ...operation,
+    durationMs: "error" in operation && operation.error === "incomplete" ? Math.max(0, Date.now() - startedAt) : operation.durationMs
+  }));
+  let callsSnapshot;
+  const callTool = async (path, args) => {
+    const startedAt = Date.now();
+    const index = calls.push({ operation: "call", path, ok: false, error: "incomplete", durationMs: 0, startedAt }) - 1;
+    const result = await executeCall(state, path, args, undefined, getPiTools, callSignal, "script");
+    const details = result.details;
+    if (details.error !== undefined) {
+      const errorCode = String(details.error);
+      const suggestions = Array.isArray(details.suggestions) ? details.suggestions.filter((suggestion) => typeof suggestion === "string") : [];
+      const message = errorCode === "tool_not_found" ? `Tool "${path}" not found. Use await tools.search({ query: "..." }) inside mcpScript.${suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}` : ""}` : typeof details.message === "string" ? details.message : textFromContent(result.content);
+      calls[index] = { operation: "call", path, ok: false, error: errorCode, durationMs: Date.now() - startedAt, startedAt };
+      return {
+        ok: false,
+        error: { code: errorCode, message }
+      };
+    }
+    calls[index] = { operation: "call", path, ok: true, durationMs: Date.now() - startedAt, startedAt };
+    return {
+      ok: true,
+      data: details.mcpResult !== undefined ? details.mcpResult : textFromContent(result.content)
+    };
+  };
+  const searchTools = (input) => {
+    const startedAt = Date.now();
+    const query = typeof input?.query === "string" ? input.query : "";
+    let error;
+    try {
+      if (query.trim() === "") {
+        return { items: [], total: 0, hasMore: false, nextOffset: null };
+      }
+      const server = typeof input?.server === "string" ? input.server : undefined;
+      const limit = typeof input?.limit === "number" ? input.limit : 12;
+      const offset = typeof input?.offset === "number" ? input.offset : 0;
+      const page = paginate(rankToolMatches(state, query, server), offset, limit);
+      return {
+        ...page,
+        items: page.items.map(({ server: matchServer, tool, score }) => ({
+          path: tool.name,
+          name: tool.originalName,
+          server: matchServer,
+          ...tool.description ? { description: tool.description } : {},
+          score
+        }))
+      };
+    } catch (caught) {
+      error = caught;
+      throw caught;
+    } finally {
+      calls.push(error === undefined ? { operation: "search", query, ok: true, durationMs: Date.now() - startedAt, startedAt } : { operation: "search", query, ok: false, error: error instanceof Error ? error.message : String(error), durationMs: Date.now() - startedAt, startedAt });
+    }
+  };
+  const describeTool = (input) => {
+    const startedAt = Date.now();
+    const path = typeof input?.path === "string" ? input.path : "";
+    let error;
+    try {
+      for (const [server, metadata] of state.toolMetadata) {
+        if (isServerInActiveFailureBackoff(state, server))
+          continue;
+        const tool = findToolByName(metadata, path);
+        if (!tool)
+          continue;
+        const inputTypeScript = tool.inputSchema ? renderTsShape(tool.inputSchema) ?? formatSchema(tool.inputSchema) : null;
+        return {
+          path: tool.name,
+          name: tool.originalName,
+          server,
+          ...tool.description ? { description: tool.description } : {},
+          ...inputTypeScript ? { inputTypeScript } : {}
+        };
+      }
+      const suggestions = path ? rankSuggestions(state, path, 5) : [];
+      error = "tool_not_found";
+      return {
+        path,
+        error: {
+          code: "tool_not_found",
+          message: `Tool not found: ${path}`,
+          suggestions
+        }
+      };
+    } catch (caught) {
+      error = caught;
+      throw caught;
+    } finally {
+      calls.push(error === undefined ? { operation: "describe", path, ok: true, durationMs: Date.now() - startedAt, startedAt } : { operation: "describe", path, ok: false, error: error instanceof Error ? error.message : String(error), durationMs: Date.now() - startedAt, startedAt });
+    }
+  };
+  let worker;
+  let timer;
+  let removeAbortListener = () => {};
+  let errorCode;
+  let errorMessage;
+  try {
+    if (externalSignal?.aborted) {
+      throw abortReasonError(externalSignal.reason);
+    }
+    worker = new Worker(new URL("./mcp-script-worker.mjs", import.meta.url), {
+      workerData: { code },
+      env: {},
+      trackUnmanagedFds: false
+    });
+    const activeWorker = worker;
+    const execution = new Promise((resolve, reject) => {
+      let completed = false;
+      activeWorker.on("message", (value) => {
+        const message = parseWorkerMessage(value);
+        if (!message || completed)
+          return;
+        if (message.type === "emit") {
+          output.push(toContentBlock(message.block));
+          return;
+        }
+        if (message.type === "done") {
+          completed = true;
+          if ("returnBlock" in message)
+            output.push(toContentBlock(message.returnBlock));
+          resolve();
+          return;
+        }
+        if (message.type === "error") {
+          completed = true;
+          reject(new Error(message.message));
+          return;
+        }
+        (async () => {
+          let envelope;
+          if (message.type === "call") {
+            envelope = await callTool(message.path, message.args);
+          } else if (message.type === "search") {
+            envelope = searchTools(message.input);
+          } else {
+            envelope = describeTool(message.input);
+          }
+          const response = { type: "result", id: message.id, envelope };
+          activeWorker.postMessage(response);
+        })().catch(reject);
+      });
+      activeWorker.once("error", reject);
+      activeWorker.once("exit", (code) => {
+        if (!completed && code !== 0)
+          reject(new Error(`mcpScript worker exited with code ${code}`));
+      });
+    });
+    const timeoutError = new McpScriptTimeoutError(resolvedTimeoutMs);
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        callsSnapshot = snapshotCalls();
+        timeoutController.abort(timeoutError);
+        activeWorker.terminate();
+        reject(timeoutError);
+      }, resolvedTimeoutMs);
+    });
+    const aborted = externalSignal ? new Promise((_resolve, reject) => {
+      const onAbort = () => {
+        callsSnapshot = snapshotCalls();
+        activeWorker.terminate();
+        reject(abortReasonError(externalSignal.reason));
+      };
+      externalSignal.addEventListener("abort", onAbort, { once: true });
+      removeAbortListener = () => externalSignal.removeEventListener("abort", onAbort);
+    }) : new Promise(() => {});
+    await Promise.race([execution, timeout, aborted]);
+  } catch (error) {
+    if (error instanceof McpScriptTimeoutError) {
+      errorCode = "timeout";
+      errorMessage = `mcpScript timed out after ${resolvedTimeoutMs}ms`;
+    } else if (externalSignal?.aborted) {
+      errorCode = "aborted";
+      errorMessage = error instanceof Error ? error.message : String(error);
+    } else {
+      errorCode = "script_error";
+      errorMessage = error instanceof Error ? error.message : String(error);
+    }
+    output.push({ type: "text", text: errorMessage });
+  } finally {
+    clearTimeout(timer);
+    removeAbortListener();
+    callsSnapshot ??= snapshotCalls();
+    timeoutController.abort(new Error("mcpScript finished"));
+    await worker?.terminate();
+  }
+  const guarded = await guardMcpOutput(output.length > 0 ? [...output] : [{ type: "text", text: "(no output)" }], resolveMcpOutputGuardOptions(state.config.settings));
+  return {
+    content: guarded.content,
+    details: {
+      mode: "script",
+      ...errorCode ? { error: errorCode, message: errorMessage } : {},
+      timeoutMs: resolvedTimeoutMs,
+      ...callsSnapshot.length > 0 ? { calls: callsSnapshot } : {},
+      ...guardedMcpDetails(guarded)
+    }
+  };
+}

package/extensions/dm-mcp-adapter/mcp-keyring-helper.cjs

@@ -0,0 +1,88 @@
+var __filename = "/Users/que/Projects/dm/dm-mono/packages/coding-agent/dist/extensions/dm-mcp-adapter/mcp-keyring-helper.cjs";
+const { createRequire } = require("node:module");
+const { dirname, join } = require("node:path");
+const requireFromHere = createRequire(__filename);
+function loadKeyringEntryClass() {
+  try {
+    return requireFromHere("@napi-rs/keyring").Entry;
+  } catch (loaderError) {
+    const suffixes = getNativeBindingSuffixes(process.platform, process.arch);
+    let lastError;
+    for (const suffix of suffixes) {
+      try {
+        const packageJsonPath = requireFromHere.resolve(`@napi-rs/keyring-${suffix}/package.json`);
+        return requireFromHere(join(dirname(packageJsonPath), `keyring.${suffix}.node`)).Entry;
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    const error = new Error(`Failed to load @napi-rs/keyring in recovery helper: ${lastError?.message ?? loaderError.message}`);
+    error.cause = loaderError;
+    throw error;
+  }
+}
+function getNativeBindingSuffixes(platform, arch) {
+  if (platform === "linux") {
+    if (arch === "arm64")
+      return ["linux-arm64-gnu", "linux-arm64-musl"];
+    if (arch === "arm")
+      return ["linux-arm-gnueabihf"];
+    if (arch === "riscv64")
+      return ["linux-riscv64-gnu"];
+    if (arch === "x64")
+      return ["linux-x64-gnu", "linux-x64-musl"];
+  }
+  return [];
+}
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let input = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      input += chunk;
+      if (input.length > 1024 * 1024) {
+        reject(new Error("request too large"));
+        process.stdin.destroy();
+      }
+    });
+    process.stdin.on("error", reject);
+    process.stdin.on("end", () => resolve(input));
+  });
+}
+function writeResponse(response) {
+  process.stdout.write(`${JSON.stringify(response)}
+`);
+}
+(async () => {
+  try {
+    const request = JSON.parse(await readStdin());
+    if (!request || typeof request !== "object")
+      throw new Error("invalid request");
+    const { operation, service, account, payload } = request;
+    if (!["read", "write", "remove"].includes(operation))
+      throw new Error("invalid operation");
+    if (typeof service !== "string" || !service)
+      throw new Error("invalid service");
+    if (typeof account !== "string" || !account)
+      throw new Error("invalid account");
+    const Entry = loadKeyringEntryClass();
+    const entry = new Entry(service, account);
+    if (operation === "read") {
+      const value = entry.getPassword();
+      writeResponse(value === null ? { ok: true, found: false } : { ok: true, found: true, value });
+      return;
+    }
+    if (operation === "write") {
+      if (typeof payload !== "string")
+        throw new Error("invalid payload");
+      entry.setPassword(payload);
+      writeResponse({ ok: true });
+      return;
+    }
+    entry.deleteCredential();
+    writeResponse({ ok: true });
+  } catch (error) {
+    writeResponse({ ok: false, error: error instanceof Error ? error.message : String(error) });
+    process.exitCode = 1;
+  }
+})();