@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-mcp-adapter/dist/ui-resource-handler.js

@@ -1,204 +0,0 @@
-import { RESOURCE_MIME_TYPE } from "./ui-app-bridge-helpers.js";
-import { UrlElicitationRequiredError } from "@modelcontextprotocol/client";
-import { getInputRequiredNeedsUiDetails, InputRequiredNeedsUiError, ResourceFetchError, ResourceParseError } from "./errors.js";
-import { logger } from "./logger.js";
-import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
-import { isServerDisabled } from "./types.js";
-
-export class UiResourceHandler {
-  manager;
-  config;
-  log = logger.child({ component: "UiResourceHandler" });
-  constructor(manager, config = undefined) {
-    this.manager = manager;
-    this.config = config;
-  }
-  async readUiResource(serverName, uri, options = {}) {
-    const log = this.log.child({ server: serverName, uri });
-    if (!uri.startsWith("ui://")) {
-      throw new ResourceParseError(uri, "URI must start with ui://", { server: serverName });
-    }
-    log.debug("Fetching UI resource");
-    let result;
-    try {
-      const config = options.config ?? this.config;
-      if (config && isServerDisabled(config.mcpServers[serverName])) {
-        throw new Error(`MCP server "${serverName}" is disabled`);
-      }
-      if (config) {
-        this.manager.touch(serverName);
-        this.manager.incrementInFlight(serverName);
-        try {
-          result = await withSessionRecovery({
-            manager: this.manager,
-            config,
-            ...options.signal ? { signal: options.signal } : {},
-            ...options.onNeedsAuth ? { onNeedsAuth: options.onNeedsAuth } : {}
-          }, serverName, async (connection) => {
-            const refreshRead = await this.manager.prepareResourceUse?.(serverName, uri, connection);
-            const requestOptions = this.manager.getRequestOptions(serverName, options.signal);
-            return connection.client.readResource({ uri }, refreshRead ? { ...requestOptions, cacheMode: "refresh" } : requestOptions);
-          });
-        } finally {
-          this.manager.decrementInFlight(serverName);
-          this.manager.touch(serverName);
-        }
-      } else {
-        result = await this.manager.readResource(serverName, uri, options.signal);
-      }
-    } catch (error) {
-      if (error instanceof UrlElicitationRequiredError || error instanceof SessionRecoveryAuthRequiredError)
-        throw error;
-      const inputRequired = getInputRequiredNeedsUiDetails(error, { server: serverName, resourceUri: uri });
-      if (inputRequired) {
-        throw new InputRequiredNeedsUiError(inputRequired, error instanceof Error ? error : undefined);
-      }
-      const message = error instanceof Error ? error.message : String(error);
-      log.error("Failed to read resource", error instanceof Error ? error : undefined);
-      throw new ResourceFetchError(uri, message, {
-        server: serverName,
-        ...error instanceof Error ? { cause: error } : {}
-      });
-    }
-    const content = selectContent(result, uri);
-    const mimeType = content.mimeType;
-    if (mimeType && !isHtmlMimeType(mimeType)) {
-      log.warn("Unsupported MIME type", { mimeType });
-      throw new ResourceParseError(uri, `unsupported MIME type "${mimeType}" (expected text/html or ${RESOURCE_MIME_TYPE})`, { server: serverName, mimeType });
-    }
-    const html = toHtml(content);
-    if (!html.trim()) {
-      log.warn("Resource content is empty");
-      throw new ResourceParseError(uri, "content is empty", { server: serverName });
-    }
-    const contentMeta = extractUiMeta(content._meta);
-    const listMeta = extractUiMeta(this.getListResourceMeta(serverName, uri));
-    log.debug("Resource loaded successfully", {
-      contentLength: html.length,
-      hasCsp: !!contentMeta.csp || !!listMeta.csp
-    });
-    return {
-      uri: content.uri ?? uri,
-      html,
-      mimeType: mimeType ?? RESOURCE_MIME_TYPE,
-      meta: {
-        ...(contentMeta.csp ?? listMeta.csp) !== undefined ? { csp: contentMeta.csp ?? listMeta.csp } : {},
-        ...(contentMeta.permissions ?? listMeta.permissions) !== undefined ? { permissions: contentMeta.permissions ?? listMeta.permissions } : {},
-        ...(contentMeta.domain ?? listMeta.domain) !== undefined ? { domain: contentMeta.domain ?? listMeta.domain } : {},
-        ...(contentMeta.prefersBorder ?? listMeta.prefersBorder) !== undefined ? { prefersBorder: contentMeta.prefersBorder ?? listMeta.prefersBorder } : {}
-      }
-    };
-  }
-  getListResourceMeta(serverName, uri) {
-    const connection = this.manager.getConnection(serverName);
-    if (!connection?.resources?.length)
-      return;
-    const resource = connection.resources.find((entry) => entry.uri === uri);
-    if (!resource || !resource._meta || typeof resource._meta !== "object")
-      return;
-    return resource._meta;
-  }
-}
-function selectContent(result, preferredUri) {
-  const contents = result.contents ?? [];
-  if (contents.length === 0) {
-    throw new Error(`No contents returned for UI resource: ${preferredUri}`);
-  }
-  const byUri = contents.find((content) => content.uri === preferredUri);
-  if (byUri)
-    return byUri;
-  const byHtmlMime = contents.find((content) => content.mimeType && isHtmlMimeType(content.mimeType));
-  if (byHtmlMime)
-    return byHtmlMime;
-  const firstContent = contents[0];
-  if (!firstContent) {
-    throw new Error(`No contents returned for UI resource: ${preferredUri}`);
-  }
-  return firstContent;
-}
-function isHtmlMimeType(mimeType) {
-  const normalized = mimeType.toLowerCase();
-  return normalized.startsWith("text/html") || normalized === RESOURCE_MIME_TYPE.toLowerCase();
-}
-function toHtml(content) {
-  if (typeof content.text === "string") {
-    return content.text;
-  }
-  if (typeof content.blob === "string") {
-    return Buffer.from(content.blob, "base64").toString("utf-8");
-  }
-  throw new Error(`UI resource ${content.uri ?? "(unknown)"} did not include text or blob content`);
-}
-const OPENAI_CSP_FIELD_MAPPINGS = [
-  ["resource_domains", "resourceDomains"],
-  ["connect_domains", "connectDomains"],
-  ["frame_domains", "frameDomains"]
-];
-const UI_CSP_DOMAIN_FIELDS = [
-  "resourceDomains",
-  "connectDomains",
-  "frameDomains",
-  "baseUriDomains"
-];
-function extractUiMeta(meta) {
-  if (!meta || typeof meta !== "object")
-    return {};
-  const ui = isRecord(meta.ui) ? meta.ui : undefined;
-  const out = {};
-  const openAiCsp = Object.hasOwn(meta, "openai/widgetCSP") ? normalizeOpenAiWidgetCsp(meta["openai/widgetCSP"]) : undefined;
-  const hasStandardCsp = !!ui && Object.hasOwn(ui, "csp");
-  const standardCspValue = hasStandardCsp ? ui.csp : undefined;
-  if (hasStandardCsp && !isRecord(standardCspValue)) {
-    out.csp = {};
-  } else {
-    const standardCsp = hasStandardCsp ? normalizeUiResourceCsp(standardCspValue) : undefined;
-    if (openAiCsp || standardCsp) {
-      out.csp = { ...openAiCsp, ...standardCsp };
-      if (isRecord(standardCspValue)) {
-        for (const [, standardField] of OPENAI_CSP_FIELD_MAPPINGS) {
-          if (Object.hasOwn(standardCspValue, standardField) && !copyStringArray(standardCspValue[standardField])) {
-            delete out.csp[standardField];
-          }
-        }
-      }
-    }
-  }
-  if (ui && isRecord(ui.permissions)) {
-    out.permissions = ui.permissions;
-  }
-  if (ui && typeof ui.domain === "string") {
-    out.domain = ui.domain;
-  }
-  if (ui && typeof ui.prefersBorder === "boolean") {
-    out.prefersBorder = ui.prefersBorder;
-  }
-  return out;
-}
-function normalizeUiResourceCsp(value) {
-  if (!isRecord(value))
-    return {};
-  const csp = {};
-  for (const field of UI_CSP_DOMAIN_FIELDS) {
-    const domains = copyStringArray(value[field]);
-    if (domains)
-      csp[field] = domains;
-  }
-  return csp;
-}
-function normalizeOpenAiWidgetCsp(value) {
-  if (!isRecord(value))
-    return {};
-  const csp = {};
-  for (const [sourceField, targetField] of OPENAI_CSP_FIELD_MAPPINGS) {
-    const domains = copyStringArray(value[sourceField]);
-    if (domains)
-      csp[targetField] = domains;
-  }
-  return csp;
-}
-function copyStringArray(value) {
-  return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? [...value] : undefined;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/extensions/dm-mcp-adapter/dist/ui-stream-types.js

@@ -1,58 +0,0 @@
-import { z } from "zod";
-export const UI_STREAM_HOST_CONTEXT_KEY = "dm-mcp-adapter/stream";
-export const UI_STREAM_REQUEST_META_KEY = "dm-mcp-adapter/stream-token";
-export const UI_STREAM_RESULT_PATCH_METHOD = "notifications/dm-mcp-adapter/ui-result-patch";
-export const SERVER_STREAM_RESULT_PATCH_METHOD = "notifications/dm-mcp-adapter/result-patch";
-export const UI_STREAM_STRUCTURED_CONTENT_KEY = "dm-mcp-adapter/stream";
-export const uiStreamModeSchema = z.enum(["eager", "stream-first"]);
-export const visualizationStreamPhaseSchema = z.enum(["shell", "narrative", "structure", "detail", "settled"]);
-export const visualizationStreamFrameTypeSchema = z.enum(["patch", "checkpoint", "final"]);
-export const visualizationStreamStatusSchema = z.enum(["ok", "error"]);
-const looseRecordSchema = z.record(z.string(), z.unknown());
-const looseArraySchema = z.array(z.unknown());
-export const uiStreamHostContextSchema = z.object({
-  mode: uiStreamModeSchema,
-  streamId: z.string().min(1),
-  intermediateResultPatches: z.boolean(),
-  partialInput: z.boolean()
-});
-export const visualizationStreamEnvelopeSchema = z.object({
-  streamId: z.string().min(1),
-  sequence: z.number().int().nonnegative(),
-  frameType: visualizationStreamFrameTypeSchema,
-  phase: visualizationStreamPhaseSchema,
-  status: visualizationStreamStatusSchema,
-  message: z.string().optional(),
-  spec: looseRecordSchema.optional(),
-  checkpoint: looseRecordSchema.optional()
-});
-export const uiStreamCallToolResultSchema = z.object({
-  content: looseArraySchema.optional(),
-  structuredContent: looseRecordSchema.optional(),
-  isError: z.boolean().optional(),
-  _meta: looseRecordSchema.optional()
-}).passthrough();
-export const uiStreamResultPatchNotificationSchema = z.object({
-  method: z.literal(UI_STREAM_RESULT_PATCH_METHOD),
-  params: uiStreamCallToolResultSchema
-});
-export const serverStreamResultPatchNotificationSchema = z.object({
-  method: z.literal(SERVER_STREAM_RESULT_PATCH_METHOD),
-  params: z.object({
-    streamToken: z.string().min(1),
-    result: uiStreamCallToolResultSchema
-  })
-});
-export function getUiStreamHostContext(hostContext) {
-  const candidate = hostContext?.[UI_STREAM_HOST_CONTEXT_KEY];
-  const parsed = uiStreamHostContextSchema.safeParse(candidate);
-  return parsed.success ? parsed.data : undefined;
-}
-export function getVisualizationStreamEnvelope(structuredContent) {
-  if (!structuredContent || typeof structuredContent !== "object" || Array.isArray(structuredContent)) {
-    return;
-  }
-  const candidate = structuredContent[UI_STREAM_STRUCTURED_CONTENT_KEY];
-  const parsed = visualizationStreamEnvelopeSchema.safeParse(candidate);
-  return parsed.success ? parsed.data : undefined;
-}

package/extensions/dm-mcp-adapter/dist/ui-tool-visibility.js

@@ -1,26 +0,0 @@
-export function extractUiToolVisibility(meta) {
-  if (!meta || typeof meta !== "object")
-    return;
-  const ui = meta.ui;
-  if (!ui || typeof ui !== "object" || Array.isArray(ui))
-    return;
-  const visibility = ui.visibility;
-  if (visibility === undefined)
-    return;
-  if (!Array.isArray(visibility))
-    return [];
-  const values = [];
-  for (const entry of visibility) {
-    if (entry !== "model" && entry !== "app")
-      return [];
-    if (!values.includes(entry))
-      values.push(entry);
-  }
-  return values;
-}
-export function isUiToolVisibleToModel(visibility) {
-  return visibility === undefined || visibility.includes("model");
-}
-export function isUiToolCallableByApp(visibility) {
-  return visibility === undefined || visibility.includes("app");
-}

package/extensions/dm-mcp-adapter/dist/unix-socket-transport.js

@@ -1,83 +0,0 @@
-import { createConnection } from "node:net";
-import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/client";
-
-export class UnixSocketClientTransport {
-  socketPath;
-  socket;
-  readBuffer = new ReadBuffer;
-  onclose;
-  onerror;
-  onmessage;
-  constructor(socketPath) {
-    this.socketPath = socketPath;
-  }
-  async start() {
-    if (this.socket) {
-      throw new Error("UnixSocketClientTransport already started");
-    }
-    await new Promise((resolve, reject) => {
-      const socket = createConnection(this.socketPath);
-      this.socket = socket;
-      let connected = false;
-      socket.once("connect", () => {
-        connected = true;
-        resolve();
-      });
-      socket.on("data", (chunk) => {
-        try {
-          this.readBuffer.append(chunk);
-          while (true) {
-            const message = this.readBuffer.readMessage();
-            if (message === null)
-              break;
-            this.onmessage?.(message);
-          }
-        } catch (error) {
-          const cause = error instanceof Error ? error : new Error(String(error));
-          this.onerror?.(cause);
-          this.close();
-        }
-      });
-      socket.on("error", (error) => {
-        if (!connected)
-          reject(error);
-        this.onerror?.(error);
-      });
-      socket.on("close", () => {
-        if (this.socket === socket)
-          this.socket = undefined;
-        this.readBuffer.clear();
-        this.onclose?.();
-      });
-    });
-  }
-  async close() {
-    const socket = this.socket;
-    this.socket = undefined;
-    this.readBuffer.clear();
-    if (!socket || socket.destroyed)
-      return;
-    await new Promise((resolve) => {
-      const timeout = setTimeout(() => socket.destroy(), 2000);
-      timeout.unref();
-      socket.once("close", () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-      socket.end();
-    });
-  }
-  async send(message) {
-    const socket = this.socket;
-    if (!socket || socket.destroyed)
-      throw new Error("Unix socket is not connected");
-    await new Promise((resolve, reject) => {
-      socket.write(serializeMessage(message), (error) => {
-        if (error)
-          reject(error);
-        else
-          resolve();
-      });
-    });
-  }
-}