@duckmind/dm-windows-x64 0.63.6 → 0.63.9

package/extensions/dm-mcp-adapter/tool-registrar.js

@@ -0,0 +1,212 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const MAX_BINARY_RESOURCE_BYTES = 10 * 1024 * 1024;
+const MAX_SESSION_RESOURCE_BYTES = 100 * 1024 * 1024;
+const MAX_SESSION_RESOURCE_FILES = 1e4;
+const CLEANUP_RETRY_DELAY_MS = 30000;
+const MAX_CLEANUP_RETRY_ATTEMPTS = 3;
+function createMaterializedResourceSession() {
+  return {
+    directory: undefined,
+    bytes: 0,
+    files: 0,
+    sequence: 0
+  };
+}
+const defaultMaterializedResourceSession = createMaterializedResourceSession();
+const scopedMaterializedResourceSessions = new WeakMap;
+const pendingCleanupDirectories = new Set;
+const cleanupRetryAttempts = new Map;
+let pendingCleanupRetry;
+function isAbortedScope(scope) {
+  return !!scope && "aborted" in scope && scope.aborted === true;
+}
+function getMaterializedResourceSession(scope) {
+  if (isAbortedScope(scope))
+    return;
+  if (!scope)
+    return defaultMaterializedResourceSession;
+  let session = scopedMaterializedResourceSessions.get(scope);
+  if (!session) {
+    session = createMaterializedResourceSession();
+    scopedMaterializedResourceSessions.set(scope, session);
+  }
+  return session;
+}
+function hasRetryableCleanupDirectory() {
+  for (const directory of pendingCleanupDirectories) {
+    if ((cleanupRetryAttempts.get(directory) ?? 0) < MAX_CLEANUP_RETRY_ATTEMPTS)
+      return true;
+  }
+  return false;
+}
+function schedulePendingCleanupRetry() {
+  if (pendingCleanupRetry || !hasRetryableCleanupDirectory())
+    return;
+  for (const directory of pendingCleanupDirectories) {
+    const attempts = cleanupRetryAttempts.get(directory) ?? 0;
+    if (attempts < MAX_CLEANUP_RETRY_ATTEMPTS)
+      cleanupRetryAttempts.set(directory, attempts + 1);
+  }
+  pendingCleanupRetry = setTimeout(() => {
+    pendingCleanupRetry = undefined;
+    try {
+      drainPendingCleanupDirectories();
+    } catch {}
+  }, CLEANUP_RETRY_DELAY_MS);
+}
+function drainPendingCleanupDirectories() {
+  const failures = [];
+  for (const directory of Array.from(pendingCleanupDirectories)) {
+    try {
+      rmSync(directory, { recursive: true, force: true });
+      pendingCleanupDirectories.delete(directory);
+      cleanupRetryAttempts.delete(directory);
+    } catch (error) {
+      failures.push(error);
+    }
+  }
+  if (pendingCleanupDirectories.size === 0 && pendingCleanupRetry) {
+    clearTimeout(pendingCleanupRetry);
+    pendingCleanupRetry = undefined;
+  }
+  if (failures.length > 0) {
+    schedulePendingCleanupRetry();
+    throw new AggregateError(failures, "Failed to clean materialized MCP resources");
+  }
+}
+export function cleanupMaterializedBinaryResources(scope) {
+  const session = scope ? scopedMaterializedResourceSessions.get(scope) : defaultMaterializedResourceSession;
+  if (session?.directory)
+    pendingCleanupDirectories.add(session.directory);
+  if (session) {
+    session.directory = undefined;
+    session.bytes = 0;
+    session.files = 0;
+    session.sequence = 0;
+    if (scope)
+      scopedMaterializedResourceSessions.delete(scope);
+  }
+  drainPendingCleanupDirectories();
+}
+function replaceBlob(resource, text) {
+  delete resource.blob;
+  resource.text = text;
+  return text;
+}
+function omitBinaryResource(resource, reason) {
+  return replaceBlob(resource, [
+    `[Resource: ${resource.uri ?? "(no URI)"}]`,
+    `Binary content omitted: ${reason}`,
+    `MIME type: ${resource.mimeType ?? "application/octet-stream"}`
+  ].join(`
+`));
+}
+function materializeBinaryResource(resource, scope) {
+  const session = getMaterializedResourceSession(scope);
+  if (!session)
+    return omitBinaryResource(resource, "runtime stopped");
+  const decodedBytes = Buffer.byteLength(resource.blob, "base64");
+  if (decodedBytes > MAX_BINARY_RESOURCE_BYTES) {
+    return omitBinaryResource(resource, "decoded size exceeds 10 MiB");
+  }
+  if (session.bytes + decodedBytes > MAX_SESSION_RESOURCE_BYTES || session.files >= MAX_SESSION_RESOURCE_FILES) {
+    return omitBinaryResource(resource, "session resource limit reached");
+  }
+  try {
+    session.directory ??= mkdtempSync(join(tmpdir(), "pi-mcp-resource-"));
+  } catch {
+    return omitBinaryResource(resource, "could not be saved");
+  }
+  const filePath = join(session.directory, `resource-${++session.sequence}.bin`);
+  session.bytes += decodedBytes;
+  session.files += 1;
+  try {
+    writeFileSync(filePath, Buffer.from(resource.blob, "base64"), { flag: "wx", mode: 384 });
+  } catch {
+    try {
+      rmSync(filePath, { force: true });
+      session.bytes -= decodedBytes;
+      session.files -= 1;
+    } catch {}
+    return omitBinaryResource(resource, "could not be saved");
+  }
+  return replaceBlob(resource, [
+    `[Resource: ${resource.uri ?? "(no URI)"}]`,
+    `Binary content saved to ${filePath}`,
+    `MIME type: ${resource.mimeType ?? "application/octet-stream"}`
+  ].join(`
+`));
+}
+export function transformMcpResourceContents(contents, scope) {
+  return contents.map((resource) => {
+    if (typeof resource.text === "string")
+      return { type: "text", text: resource.text };
+    if (typeof resource.blob === "string")
+      return { type: "text", text: materializeBinaryResource(resource, scope) };
+    return { type: "text", text: JSON.stringify(resource) };
+  });
+}
+export function transformMcpContent(content, scope) {
+  return content.map((c) => {
+    if (c.type === "text") {
+      return { type: "text", text: c.text ?? "" };
+    }
+    if (c.type === "image") {
+      return {
+        type: "image",
+        data: c.data ?? "",
+        mimeType: c.mimeType ?? "image/png"
+      };
+    }
+    if (c.type === "resource") {
+      const resourceUri = c.resource?.uri ?? "(no URI)";
+      if (c.resource && "blob" in c.resource && typeof c.resource.blob === "string") {
+        const binaryResource = c.resource;
+        return {
+          type: "text",
+          text: materializeBinaryResource(binaryResource, scope)
+        };
+      }
+      const resourceContent = c.resource?.text ?? (c.resource ? JSON.stringify(c.resource) : "(no content)");
+      return {
+        type: "text",
+        text: `[Resource: ${resourceUri}]
+${resourceContent}`
+      };
+    }
+    if (c.type === "resource_link") {
+      const linkName = c.name ?? c.uri ?? "unknown";
+      const linkUri = c.uri ?? "(no URI)";
+      return {
+        type: "text",
+        text: `[Resource Link: ${linkName}]
+URI: ${linkUri}`
+      };
+    }
+    if (c.type === "audio") {
+      return {
+        type: "text",
+        text: `[Audio content: ${c.mimeType ?? "audio/*"}]`
+      };
+    }
+    return { type: "text", text: JSON.stringify(c) };
+  });
+}
+export function resolveMcpResultContent(result, scope) {
+  const blocks = transformMcpContent(Array.isArray(result.content) ? result.content : [], scope);
+  if (blocks.length > 0)
+    return blocks;
+  if (result.structuredContent !== undefined && result.structuredContent !== null) {
+    return [{ type: "text", text: stringifyStructuredContent(result.structuredContent) }];
+  }
+  return [];
+}
+function stringifyStructuredContent(value) {
+  try {
+    return JSON.stringify(value, null, 2) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}

package/extensions/dm-mcp-adapter/tool-result-renderer.js

@@ -0,0 +1,355 @@
+import { Text, truncateToWidth, visibleWidth } from "@duckmind/dm-tui";
+const plainTheme = { fg: (_name, text) => text };
+const DEFAULT_MAX_CALL_INPUT_CHARS = 1500;
+const DEFAULT_MAX_COMPACT_INPUT_CHARS = 240;
+const DEFAULT_BOXED_COLLAPSED_LINES = 3;
+const DEFAULT_COMPACT_COLLAPSED_LINES = 1;
+const DEFAULT_MAX_COLLAPSED_CHARS = 8000;
+const COLLAPSED_RENDER_CHAR_SLACK = 8;
+
+class EmptyComponent {
+  render() {
+    return [];
+  }
+  invalidate() {}
+}
+
+class CompactMcpToolResult {
+  title;
+  inputPreview;
+  display;
+  theme;
+  rendered = null;
+  constructor(title, inputPreview, display, theme) {
+    this.title = title;
+    this.inputPreview = inputPreview;
+    this.display = display;
+    this.theme = theme;
+  }
+  render(width) {
+    const safeWidth = Math.max(1, Math.floor(width));
+    if (this.rendered?.width === safeWidth)
+      return this.rendered.lines;
+    const resultLines = this.display.lines.filter((line, index, lines) => {
+      return !(this.display.truncated && index === lines.length - 1 && line === "…");
+    });
+    const lines = resultLines.length > 0 ? resultLines : [""];
+    const bodies = lines.map((line, index) => {
+      const prefix = index === 0 ? this.renderPrefix(safeWidth) : "";
+      return `${prefix}${this.theme.fg("toolOutput", line)}`;
+    });
+    const hiddenText = this.display.truncated || bodies.some((body) => visibleWidth(body) > safeWidth);
+    const rendered = bodies.map((body, index) => {
+      const suffix = hiddenText && index === bodies.length - 1 ? " … (Ctrl+O to expand)" : "";
+      if (!suffix)
+        return truncateToWidth(body, safeWidth, "…");
+      if (safeWidth >= suffix.length + 20) {
+        return `${truncateToWidth(body, safeWidth - suffix.length, "…")}${this.theme.fg("muted", suffix)}`;
+      }
+      const shortSuffix = " (Ctrl+O)";
+      if (safeWidth >= shortSuffix.length + 5) {
+        return `${truncateToWidth(body, safeWidth - shortSuffix.length, "…")}${this.theme.fg("muted", shortSuffix)}`;
+      }
+      return truncateToWidth(this.theme.fg("muted", shortSuffix.trim()), safeWidth, "…");
+    });
+    this.rendered = { width: safeWidth, lines: rendered };
+    return rendered;
+  }
+  invalidate() {
+    this.rendered = null;
+  }
+  renderPrefix(width) {
+    if (!this.title)
+      return "";
+    const arrow = " → ";
+    if (!this.inputPreview)
+      return `${this.theme.fg("toolTitle", this.title)}${arrow}`;
+    const maxPrefixWidth = Math.max(12, Math.floor(width * 0.55));
+    const titleWidth = visibleWidth(this.title);
+    const inputWidth = Math.max(0, maxPrefixWidth - titleWidth - 1);
+    if (inputWidth <= 3) {
+      return `${this.theme.fg("toolTitle", truncateToWidth(this.title, maxPrefixWidth, "…"))}${arrow}`;
+    }
+    const input = truncateToWidth(this.inputPreview, inputWidth, "…");
+    return `${this.theme.fg("toolTitle", this.title)} ${this.theme.fg("muted", input)}${arrow}`;
+  }
+}
+
+class CollapsibleText {
+  text;
+  expanded;
+  maxCollapsedLines;
+  preTruncated;
+  fullText;
+  footerText;
+  collapsedText = null;
+  collapsedRender = null;
+  constructor(text, expanded, maxCollapsedLines, ellipsis, expandHint, preTruncated = false) {
+    this.text = text;
+    this.expanded = expanded;
+    this.maxCollapsedLines = maxCollapsedLines;
+    this.preTruncated = preTruncated;
+    this.fullText = new Text(text, 0, 0);
+    this.footerText = new Text(`${ellipsis}
+${expandHint}`, 0, 0);
+  }
+  render(width) {
+    if (this.expanded) {
+      return this.fullText.render(width);
+    }
+    const safeWidth = Math.max(1, Math.floor(width));
+    const charBudget = safeWidth * (this.maxCollapsedLines + 1) * COLLAPSED_RENDER_CHAR_SLACK;
+    if (!this.collapsedText || this.collapsedText.charBudget !== charBudget) {
+      const prefix = this.text.length > charBudget ? this.text.slice(0, charBudget) : this.text;
+      this.collapsedText = {
+        charBudget,
+        fullyIncluded: prefix === this.text,
+        text: new Text(prefix, 0, 0)
+      };
+      this.collapsedRender = null;
+    }
+    const lines = this.collapsedText.text.render(width);
+    if (!this.preTruncated && this.collapsedText.fullyIncluded && lines.length <= this.maxCollapsedLines)
+      return lines;
+    if (this.collapsedRender?.width === width && this.collapsedRender.charBudget === charBudget) {
+      return this.collapsedRender.lines;
+    }
+    const rendered = [
+      ...lines.slice(0, this.maxCollapsedLines),
+      ...this.footerText.render(width)
+    ];
+    this.collapsedRender = { width, charBudget, lines: rendered };
+    return rendered;
+  }
+  invalidate() {
+    this.fullText.invalidate();
+    this.footerText.invalidate();
+    this.collapsedText?.text.invalidate();
+    this.collapsedRender = null;
+  }
+}
+function truncateText(value, maxChars) {
+  if (value.length <= maxChars)
+    return value;
+  return `${value.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+function formatJsonish(value, maxChars) {
+  if (typeof value === "string") {
+    try {
+      return truncateText(JSON.stringify(JSON.parse(value), null, 2), maxChars);
+    } catch {
+      return truncateText(value, maxChars);
+    }
+  }
+  try {
+    return truncateText(JSON.stringify(value, null, 2), maxChars);
+  } catch {
+    return truncateText(String(value), maxChars);
+  }
+}
+function hasUsefulObjectContent(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+export function formatMcpProxyToolCallLines(args, maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS) {
+  if (args.action === "ui-messages")
+    return [`mcp ${args.action}`];
+  if (args.tool) {
+    const target = args.server ? `${args.tool} @ ${args.server}` : args.tool;
+    const lines = [`mcp call ${target}`];
+    if (args.args)
+      lines.push(formatJsonish(args.args, maxInputChars));
+    return lines;
+  }
+  if (args.connect)
+    return [`mcp connect ${args.connect}`];
+  if (args.describe)
+    return [`mcp describe ${args.describe}`];
+  if (args.search) {
+    let line = `mcp search ${args.search}`;
+    if (args.server)
+      line += ` @ ${args.server}`;
+    if (args.regex === true)
+      line += " (regex)";
+    if (args.includeSchemas === false)
+      line += " (schemas hidden)";
+    return [line];
+  }
+  if (args.server)
+    return [`mcp list ${args.server}`];
+  if (args.action)
+    return [`mcp ${args.action}`];
+  return ["mcp status"];
+}
+export function formatMcpDirectToolCallLines(displayName, args, maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS) {
+  if (!hasUsefulObjectContent(args))
+    return [displayName];
+  return [displayName, formatJsonish(args, maxInputChars)];
+}
+export function formatMcpScriptToolCallLines(args, maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS) {
+  return ["mcpScript", truncateText(args.code, maxInputChars)];
+}
+function renderToolCallLines(lines, theme) {
+  const activeTheme = theme ?? plainTheme;
+  const [title = "mcp", ...rest] = lines;
+  const styledTitle = activeTheme.fg("toolTitle", activeTheme.bold ? activeTheme.bold(title) : title);
+  const styledRest = rest.map((line) => activeTheme.fg("muted", line));
+  return new Text([styledTitle, ...styledRest].join(`
+`), 0, 0);
+}
+function formatCompactInputPreview(lines, maxChars = DEFAULT_MAX_COMPACT_INPUT_CHARS) {
+  return truncateText(lines.slice(1).join(" ").replace(/\s+/g, " ").trim(), maxChars);
+}
+export function resolveMcpToolRenderOptions(settings) {
+  const resultRendering = settings?.toolResultRendering === "boxed" ? "boxed" : "compact";
+  const collapsedLines = settings?.collapsedResultLines;
+  const defaultLines = resultRendering === "boxed" ? DEFAULT_BOXED_COLLAPSED_LINES : DEFAULT_COMPACT_COLLAPSED_LINES;
+  return {
+    resultRendering,
+    collapsedResultLines: collapsedLines === 1 || collapsedLines === 2 || collapsedLines === 3 ? collapsedLines : defaultLines
+  };
+}
+function shouldUseCompactFinalRender(options, context) {
+  return options.resultRendering === "compact" && context !== undefined && context.isPartial === false && context.expanded !== true && context.isError !== true;
+}
+function renderToolCall(lines, theme, context, options) {
+  if (context?.state) {
+    context.state.compactTitle = lines[0] ?? "mcp";
+    context.state.compactInputPreview = formatCompactInputPreview(lines);
+  }
+  if (shouldUseCompactFinalRender(options, context))
+    return new EmptyComponent;
+  return renderToolCallLines(lines, theme);
+}
+export function renderMcpProxyToolCall(args, theme, context) {
+  return renderToolCall(formatMcpProxyToolCallLines(args), theme, context, resolveMcpToolRenderOptions());
+}
+export function createMcpProxyToolCallRenderer(options) {
+  return (args, theme, context) => {
+    return renderToolCall(formatMcpProxyToolCallLines(args), theme, context, options);
+  };
+}
+export function createMcpDirectToolCallRenderer(displayName, options = resolveMcpToolRenderOptions()) {
+  return (args, theme, context) => {
+    return renderToolCall(formatMcpDirectToolCallLines(displayName, args), theme, context, options);
+  };
+}
+export function createMcpScriptToolCallRenderer(options = resolveMcpToolRenderOptions()) {
+  return (args, theme, context) => {
+    if (shouldUseCompactFinalRender(options, context))
+      return new EmptyComponent;
+    return renderToolCallLines(formatMcpScriptToolCallLines(args), theme);
+  };
+}
+function blockToLines(block) {
+  if (block.type === "text") {
+    return block.text.split(`
+`);
+  }
+  return [`[image: ${block.mimeType}]`];
+}
+function collectCollapsedResultLines(content, maxLines, maxChars) {
+  if (content.length === 0)
+    return { lines: ["(empty result)"], truncated: false };
+  const lines = [];
+  let remainingChars = maxChars;
+  let truncated = false;
+  const appendLine = (line) => {
+    if (lines.length === 0) {
+      const previewWidth = Math.min(line.length, remainingChars);
+      if (line.slice(0, previewWidth).trim() === "") {
+        if (line.length >= remainingChars) {
+          truncated = true;
+          remainingChars = 0;
+          return false;
+        }
+        remainingChars -= line.length + 1;
+        return true;
+      }
+    }
+    if (lines.length >= maxLines || remainingChars <= 0) {
+      truncated = true;
+      return false;
+    }
+    if (line.length > remainingChars) {
+      lines.push(line.slice(0, remainingChars));
+      truncated = true;
+      remainingChars = 0;
+      return false;
+    }
+    lines.push(line);
+    remainingChars -= line.length + 1;
+    return true;
+  };
+  for (const block of content) {
+    if (block.type !== "text") {
+      if (!appendLine(`[image: ${block.mimeType}]`))
+        break;
+      continue;
+    }
+    let start = 0;
+    while (start <= block.text.length) {
+      const newline = block.text.indexOf(`
+`, start);
+      const line = newline === -1 ? block.text.slice(start) : block.text.slice(start, newline);
+      if (!appendLine(line))
+        break;
+      if (newline === -1)
+        break;
+      start = newline + 1;
+    }
+    if (truncated)
+      break;
+  }
+  if (lines.length === 0)
+    lines.push(truncated ? "(leading blank output omitted)" : "");
+  if (truncated && lines.length >= maxLines)
+    lines.push("…");
+  return { lines, truncated };
+}
+export function formatMcpToolResultIdentity(details) {
+  if (details?.mode !== "call")
+    return null;
+  const server = typeof details.server === "string" ? details.server : typeof details.hintServer === "string" ? details.hintServer : null;
+  if (!server)
+    return null;
+  if (typeof details.tool === "string")
+    return `MCP ${server}/${details.tool}`;
+  if (typeof details.resourceUri === "string")
+    return `MCP ${server} resource ${details.resourceUri}`;
+  if (typeof details.requestedTool === "string")
+    return `MCP ${server}/${details.requestedTool}`;
+  return null;
+}
+export function formatMcpToolResultLines(result, expanded, maxCollapsedLines = DEFAULT_BOXED_COLLAPSED_LINES, maxCollapsedChars = DEFAULT_MAX_COLLAPSED_CHARS) {
+  if (!expanded) {
+    return collectCollapsedResultLines(result.content, maxCollapsedLines, maxCollapsedChars);
+  }
+  const allLines = result.content.flatMap(blockToLines);
+  const lines = allLines.length > 0 ? allLines : ["(empty result)"];
+  return { lines, truncated: false };
+}
+export function renderMcpToolResult(result, options, theme, context, renderOptions = resolveMcpToolRenderOptions()) {
+  const activeTheme = theme ?? plainTheme;
+  if (options.isPartial) {
+    return new Text(activeTheme.fg("warning", "Running MCP tool..."), 0, 0);
+  }
+  const hasErrorDetails = Boolean(result.details.error);
+  const expanded = options.expanded || context?.isError === true || hasErrorDetails;
+  if (!expanded && renderOptions.resultRendering === "compact") {
+    const display = formatMcpToolResultLines(result, false, renderOptions.collapsedResultLines);
+    const title = context?.state?.compactTitle ?? formatMcpToolResultIdentity(result.details) ?? "";
+    const inputPreview = context?.state?.compactInputPreview ?? "";
+    return new CompactMcpToolResult(title, inputPreview, display, activeTheme);
+  }
+  const display = formatMcpToolResultLines(result, expanded, renderOptions.collapsedResultLines);
+  const identity = formatMcpToolResultIdentity(result.details);
+  const output = [
+    ...identity ? [activeTheme.fg("muted", identity)] : [],
+    ...display.lines.map((line) => activeTheme.fg("toolOutput", line))
+  ].join(`
+`);
+  return new CollapsibleText(output, expanded, renderOptions.collapsedResultLines + (identity ? 1 : 0), activeTheme.fg("muted", "…"), activeTheme.fg("muted", "(Ctrl+O to expand)"), display.truncated);
+}
+export function createMcpToolResultRenderer(renderOptions) {
+  return (result, options, theme, context) => renderMcpToolResult(result, options, theme, context, renderOptions);
+}