@wisdoverse/dsh-inline-media-viewer 1.0.1

package/index.js

@@ -0,0 +1,185 @@
+/**
+ * dsh-inline-media-viewer — host half.
+ *
+ * Serves media bytes for the web client over a dedicated RPC channel
+ * (`/inline-media/read`), reading workspace-local files under the calling
+ * session's workspace root and proxying ComfyUI media URLs onto the
+ * user-configured ComfyUI origin (default: `http://127.0.0.1:8188`,
+ * ComfyUI's standard local address). Registers a persistent user settings
+ * namespace (`inline-media`) so the client can tune display preferences
+ * and the ComfyUI server address.
+ *
+ * Security model (see SECURITY.md): local reads are confined to the session
+ * workspace (realpath + containment), remote reads always fetch from the
+ * configured ComfyUI origin (never the source host), and every payload is
+ * size-capped before transfer.
+ *
+ * @module dsh-inline-media-viewer
+ */
+
+import { readFile, realpath, stat } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import z from "@deepseek-ai/schemastery";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+
+import { COMFY_DEFAULT_ORIGIN, MAX_BYTES, comfyUrl, isInside, mimeOf, normalizeComfyOrigin, testing } from "./lib.js";
+
+export { testing } from "./lib.js";
+
+export const name = "dsh-inline-media-viewer";
+export const inject = ["connection", "sessions", "settings"];
+
+const CHANNEL = "/inline-media";
+const ENDPOINT = "read";
+
+/** Persistent user settings namespace for this plugin. */
+export const MEDIA_SETTINGS_NAMESPACE = settingsNamespace("inline-media");
+
+/** Schema of the user settings section. */
+export const MEDIA_SETTINGS_SCHEMA = z.object({
+  autoRender: z.boolean().required(),
+  displayCap: z.number().step(1).min(1).max(30).required(),
+  imageMaxPx: z.number().step(1).min(160).max(1200).required(),
+  comfyUrl: z.string().max(512).required(),
+});
+
+/** Composition defaults; the user layer overrides these. */
+export const MEDIA_SETTINGS_DEFAULTS = Object.freeze({
+  autoRender: true,
+  displayCap: 12,
+  imageMaxPx: 380,
+  // Empty means "use the built-in default" (`http://127.0.0.1:8188`),
+  // so the settings UI only shows addresses the user actually set.
+  comfyUrl: "",
+});
+
+function success(value) {
+  return { ok: true, value };
+}
+
+function failure(message) {
+  return {
+    ok: false,
+    error: { code: "internal", message, details: {} },
+  };
+}
+
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+async function responseBytes(response, signal) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > MAX_BYTES) {
+    throw new Error(`media exceeds ${MAX_BYTES} bytes`);
+  }
+  if (!response.body) return Buffer.alloc(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let length = 0;
+  try {
+    for (;;) {
+      if (signal.aborted) throw signal.reason;
+      const { done, value } = await reader.read();
+      if (done) break;
+      length += value.byteLength;
+      if (length > MAX_BYTES) throw new Error(`media exceeds ${MAX_BYTES} bytes`);
+      chunks.push(Buffer.from(value));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, length);
+}
+
+async function readRemote(source, signal, settingsValue) {
+  const configured = settingsValue && typeof settingsValue.comfyUrl === "string"
+    ? settingsValue.comfyUrl.trim()
+    : "";
+  const origin = configured === ""
+    ? normalizeComfyOrigin(COMFY_DEFAULT_ORIGIN)
+    : normalizeComfyOrigin(configured);
+  if (!origin) throw new Error("configured ComfyUI address is invalid");
+  const url = comfyUrl(source, origin);
+  if (!url) throw new Error("remote URL is not an allowed ComfyUI media URL");
+  const timeout = AbortSignal.timeout(20_000);
+  const combined = AbortSignal.any([signal, timeout]);
+  const response = await fetch(url, {
+    method: "GET",
+    redirect: "error",
+    signal: combined,
+  });
+  if (!response.ok) throw new Error(`ComfyUI returned HTTP ${response.status}`);
+  const bytes = await responseBytes(response, combined);
+  const mime = mimeOf(source) || response.headers.get("content-type")?.split(";", 1)[0];
+  if (!mime || !/^(?:image|video|audio)\//.test(mime)) {
+    throw new Error("unsupported media type");
+  }
+  return { dataUrl: `data:${mime};base64,${bytes.toString("base64")}`, mime };
+}
+
+async function readLocal(ctx, source, sessionId) {
+  const session = ctx.sessions.get(sessionId);
+  const cwd = session?.header?.cwd;
+  if (!cwd) throw new Error("session working directory is unavailable");
+  const mime = mimeOf(source);
+  if (!mime) throw new Error("unsupported media extension");
+
+  const root = await realpath(cwd);
+  const candidate = isAbsolute(source) ? resolve(source) : resolve(root, source);
+  const target = await realpath(candidate);
+  if (!isInside(root, target)) throw new Error("media path is outside the session workspace");
+
+  const info = await stat(target);
+  if (!info.isFile()) throw new Error("media path is not a file");
+  if (info.size > MAX_BYTES) throw new Error(`media exceeds ${MAX_BYTES} bytes`);
+  const bytes = await readFile(target);
+  return { dataUrl: `data:${mime};base64,${bytes.toString("base64")}`, mime };
+}
+
+async function handleRead(ctx, endpoint, payload, signal, resolveSettings) {
+  if (endpoint !== ENDPOINT) return failure("unknown inline-media endpoint");
+  if (!payload || typeof payload !== "object") return failure("invalid request");
+  const { source, sessionId } = payload;
+  if (typeof source !== "string" || source.length === 0 || source.length > 4096) {
+    return failure("invalid media source");
+  }
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    return failure("invalid session id");
+  }
+  try {
+    const value = /^https?:\/\//i.test(source)
+      ? await readRemote(source, signal, resolveSettings())
+      : await readLocal(ctx, source, sessionId);
+    return success(value);
+  } catch (error) {
+    return failure(messageOf(error));
+  }
+}
+
+export function apply(ctx) {
+  let resolveSettings = () => MEDIA_SETTINGS_DEFAULTS;
+  ctx.effect(() => {
+    const dispose = ctx.connection.rpc.handle(
+      CHANNEL,
+      (endpoint, payload, signal) => handleRead(ctx, endpoint, payload, signal, resolveSettings),
+      { authority: "trusted-host" },
+    );
+    return () => {
+      void dispose();
+    };
+  }, "inline-media: rpc");
+
+  // Register the user settings namespace (defaults + schema). The client reads
+  // and writes this section through the settings mirror. autoRender /
+  // displayCap / imageMaxPx are consumed client-side; comfyUrl is read here,
+  // per request, to decide which remote URLs to proxy and where to fetch them.
+  installSettingsSection(ctx, MEDIA_SETTINGS_NAMESPACE, MEDIA_SETTINGS_SCHEMA, MEDIA_SETTINGS_DEFAULTS, {
+    setSource: (source) => {
+      resolveSettings = source;
+    },
+    onChange: () => {},
+  });
+}
+
+export { MIME } from "./lib.js";

package/lib.js

@@ -0,0 +1,178 @@
+/**
+ * dsh-inline-media-viewer — pure helpers.
+ *
+ * This module has NO runtime dependencies: unit tests and reviewers can import
+ * it anywhere. Integration concerns (RPC channel, settings registration) live
+ * in `index.js`.
+ *
+ * @module dsh-inline-media-viewer/lib
+ */
+
+import { extname, isAbsolute, relative, resolve, sep } from "node:path";
+
+export const MAX_BYTES = 48 * 1024 * 1024;
+
+/**
+ * Built-in loopback aliases: host:port pairs treated as ComfyUI media URLs
+ * even before any address is configured. Every alias is rewritten to the
+ * configured origin before fetching (like any other accepted source).
+ */
+export const COMFY_HOSTS = Object.freeze([
+  "127.0.0.1",
+  "localhost",
+]);
+
+/** ComfyUI's standard HTTP port. */
+export const COMFY_PORTS = Object.freeze(["8188"]);
+
+/**
+ * Default fetch origin (ComfyUI's standard local address). Point the
+ * settings `comfyUrl` at any other server the host process can reach.
+ */
+export const COMFY_DEFAULT_ORIGIN = "http://127.0.0.1:8188";
+
+export const MIME = Object.freeze({
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  avif: "image/avif",
+  bmp: "image/bmp",
+  svg: "image/svg+xml",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  m4v: "video/x-m4v",
+  mkv: "video/x-matroska",
+  avi: "video/x-msvideo",
+  ogv: "video/ogg",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  ogg: "audio/ogg",
+  oga: "audio/ogg",
+  flac: "audio/flac",
+  opus: "audio/ogg",
+});
+
+export const MEDIA_EXTENSIONS = Object.freeze(Object.keys(MIME));
+
+export function extensionOf(source) {
+  try {
+    const url = new URL(source);
+    const filename = url.searchParams.get("filename");
+    if (filename) return extname(filename).slice(1).toLowerCase();
+    return extname(url.pathname).slice(1).toLowerCase();
+  } catch {
+    return extname(source.split(/[?#]/, 1)[0]).slice(1).toLowerCase();
+  }
+}
+
+export function mimeOf(source) {
+  return MIME[extensionOf(source)];
+}
+
+export function isInside(root, target) {
+  const rel = relative(root, target);
+  return rel === "" || (!isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`));
+}
+
+/**
+ * Parse a user-configured ComfyUI address into a canonical origin URL.
+ *
+ * Accepts `http(s)://host[:port]` or a bare `host[:port]` (http assumed).
+ * Credentials, extra path segments, queries, and hashes are rejected so the
+ * value is always a bare origin. A missing port defaults to ComfyUI's
+ * standard 8188 for http and 443 for https.
+ *
+ * @param {unknown} input - the configured address string.
+ * @returns {URL | null} canonical origin URL, or null when unparseable.
+ */
+export function normalizeComfyOrigin(input) {
+  if (typeof input !== "string") return null;
+  let raw = input.trim();
+  if (!raw) return null;
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) raw = `http://${raw}`;
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+  if (!url.hostname || url.username || url.password) return null;
+  const host = url.hostname;
+  if (!/^[a-z0-9.-]+$/i.test(host) && !/^\[[0-9a-f:.%]+\]$/i.test(host)) return null;
+  if (url.pathname !== "" && url.pathname !== "/") return null;
+  if (url.search || url.hash) return null;
+  const port = url.port || (url.protocol === "https:" ? "443" : "8188");
+  return new URL(`${url.protocol}//${url.hostname}:${port}`);
+}
+
+/**
+ * All source origins the proxy accepts for one canonical configured origin:
+ * the built-in loopback aliases plus the configured host:port itself.
+ *
+ * @param {URL} origin - canonical origin from {@link normalizeComfyOrigin}.
+ * @returns {Set<string>} accepted "host:port" keys.
+ */
+export function allowedComfyOrigins(origin) {
+  const origins = new Set();
+  for (const host of COMFY_HOSTS) {
+    for (const port of COMFY_PORTS) origins.add(`${host}:${port}`);
+  }
+  if (origin instanceof URL) {
+    const port = origin.port || (origin.protocol === "https:" ? "443" : "8188");
+    origins.add(`${origin.hostname}:${port}`);
+  }
+  return origins;
+}
+
+/**
+ * Rewrite an allowed ComfyUI media URL onto the canonical configured origin.
+ *
+ * The fetch target is ALWAYS the configured origin (default
+ * `http://127.0.0.1:8188`) — never the source host — so chat content can only
+ * select a path/query on a server the user configured. Source origins are
+ * accepted when their host:port is a loopback alias or matches the configured
+ * origin.
+ *
+ * @param {string} source - absolute http(s) URL.
+ * @param {string | URL | null} [origin] - configured ComfyUI address
+ *   (canonical or parseable string); invalid input falls back to the default.
+ * @returns {URL | null} the rewritten fetch URL, or null when not allowed.
+ */
+export function comfyUrl(source, origin = null) {
+  let url;
+  try {
+    url = new URL(source);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+  const port = url.port || (url.protocol === "https:" ? "443" : "80");
+  const canonical = typeof origin === "string" && origin.trim() !== ""
+    ? normalizeComfyOrigin(origin) ?? normalizeComfyOrigin(COMFY_DEFAULT_ORIGIN)
+    : origin instanceof URL && origin.hostname
+      ? origin
+      : normalizeComfyOrigin(COMFY_DEFAULT_ORIGIN);
+  if (!allowedComfyOrigins(canonical).has(`${url.hostname}:${port}`)) return null;
+  const target = new URL(canonical.href);
+  target.pathname = url.pathname;
+  target.search = url.search;
+  target.hash = "";
+  target.username = "";
+  target.password = "";
+  return target;
+}
+
+export const testing = Object.freeze({
+  allowedComfyOrigins,
+  comfyUrl,
+  extensionOf,
+  isInside,
+  mimeOf,
+  normalizeComfyOrigin,
+});

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@wisdoverse/dsh-inline-media-viewer",
+  "version": "1.0.1",
+  "description": "Persistent inline image, video, and audio previews for DeepSeek Harness Web conversations, with workspace-confined local reads and a configurable ComfyUI proxy.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Wisdoverse/dsh-inline-media-viewer-plugin.git"
+  },
+  "homepage": "https://github.com/Wisdoverse/dsh-inline-media-viewer-plugin#readme",
+  "bugs": {
+    "url": "https://github.com/Wisdoverse/dsh-inline-media-viewer-plugin/issues"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "web",
+    "plugin",
+    "media",
+    "image",
+    "video",
+    "audio",
+    "comfyui"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json",
+    "./lib.js": "./lib.js"
+  },
+  "files": [
+    "index.js",
+    "lib.js",
+    "client/",
+    "cordis.patch.yml",
+    "README.md",
+    "README.zh-CN.md",
+    "SECURITY.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node test.mjs",
+    "lint": "node --check index.js && node --check lib.js && node --check test.mjs"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-settings": "^0.1.1-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-locale"
+      ],
+      "platform": "web"
+    }
+  }
+}