@moon16u/dsh-plugin-mcp-console 0.1.0

package/lib/clientAdapter.js

@@ -0,0 +1,214 @@
+/**
+ * The ONLY module that touches `@deepseek-ai/dsh-mcp-client` (plan §7 R2:
+ * every official-package coupling converges here).
+ *
+ * Resolution is deliberately DYNAMIC, not a static import: the console
+ * package itself vendors nothing, and the official client is loaded from
+ * the running DSH profile's module graph so that the SAME module instance
+ * the loader used for manually-declared servers is reused. Sharing the
+ * instance matters: the official client keeps its serverName namespace
+ * reservation in module-level state, and one instance means conflicts with
+ * profile-declared entries are caught by the official mechanism itself, not
+ * only by our pre-check.
+ *
+ * Search order (profile first — see the module doc for why sharing the
+ * loader's instance matters):
+ *   1. `<DSH_HOME>/profiles/node_modules` — the profiles workspace hoisted
+ *      root (plan §2.1 verified layout);
+ *   2. `<DSH_HOME>/profiles/<profile>/node_modules` for every profile;
+ *   3. plain specifier resolution from this package (standalone installs
+ *      whose peer deps are locally resolvable).
+ */
+import { createRequire } from "node:module";
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+/** serverName contract, mirrored from the official client's schema. */
+export const SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]{1,32}$/;
+
+/** Official default for per-tool-call timeout (ms). */
+export const DEFAULT_TOOL_CALL_TIMEOUT_MS = 60000;
+
+/** Mask shown for secret-shaped values in API responses and the panel. */
+export const MASK = "••••";
+
+const CLIENT_SPECIFIER = "@deepseek-ai/dsh-mcp-client";
+
+let cachedClient = undefined;
+
+/** Candidate resolution bases for the official client, most specific first. */
+export function resolutionBases(dshHome) {
+  const root = dshHome ?? process.env.DSH_HOME ?? join(homedir(), ".dsh");
+  const bases = [];
+  const profilesRoot = join(root, "profiles");
+  const hoisted = join(profilesRoot, "node_modules");
+  if (existsSync(hoisted)) bases.push(hoisted);
+  try {
+    for (const entry of readdirSync(profilesRoot, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const base = join(profilesRoot, entry.name, "node_modules");
+      if (existsSync(base) && !bases.includes(base)) bases.push(base);
+    }
+  } catch {
+    // no profiles dir: the hoisted base (if any) plus self-resolution remain
+  }
+  return bases;
+}
+
+/**
+ * Resolve the official client plugin module ({ name, inject, Config, apply }).
+ * Memoized; failures are retried on the next call.
+ *
+ * @returns {Promise<typeof import("@deepseek-ai/dsh-mcp-client")>}
+ */
+export async function resolveMcpClient() {
+  if (cachedClient !== undefined) return cachedClient;
+  const attempts = [];
+  for (const base of resolutionBases()) {
+    try {
+      const require = createRequire(join(base, "clientAdapter-anchor.js"));
+      const resolved = require.resolve(CLIENT_SPECIFIER);
+      if (typeof resolved !== "string" || !existsSync(resolved)) continue;
+      cachedClient = await import(pathToFileURL(resolved).href);
+      return cachedClient;
+    } catch (error) {
+      attempts.push(`${base}: ${String(error?.message ?? error)}`);
+    }
+  }
+  // fallback: self-context resolution (standalone installs with locally
+  // resolvable peer deps — resolves to the same instance there anyway)
+  try {
+    cachedClient = await import(CLIENT_SPECIFIER);
+    return cachedClient;
+  } catch (error) {
+    attempts.push(`self: ${String(error?.message ?? error)}`);
+  }
+  throw new Error(
+    `mcp-console: cannot resolve ${CLIENT_SPECIFIER} (tried ${resolutionBases().length} profile node_modules bases and self resolution: ${attempts.join(" | ")}). ` +
+      "Ensure dsh is installed and the web profile has been booted at least once.",
+  );
+}
+
+function num(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+function bool(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+
+function strArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : [];
+}
+
+function strMap(value) {
+  if (value === undefined || value === null) return {};
+  if (typeof value !== "object" || Array.isArray(value)) return {};
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof item === "string") out[key] = item;
+  }
+  return out;
+}
+
+/**
+ * Validate one stored server config (console shape) before it is persisted or
+ * assembled. Returns `{ config }` normalized, or `{ error }` explaining the
+ * first problem.
+ *
+ * @param {object} server stored config (may lack defaults)
+ * @returns {{ config?: object, error?: string }}
+ */
+export function validateServerConfig(server) {
+  if (server === null || typeof server !== "object") return { error: "server config must be an object" };
+  const name = str(server.name).trim();
+  if (!SERVER_NAME_PATTERN.test(name)) {
+    return { error: `serverName "${name}" must match [A-Za-z0-9_-]{1,32}` };
+  }
+  const transport = server.transport;
+  if (transport !== "stdio" && transport !== "streamable-http") {
+    return { error: `transport must be "stdio" or "streamable-http" (got ${JSON.stringify(transport)})` };
+  }
+  const config = {
+    name,
+    enabled: bool(server.enabled, true),
+    transport,
+    scope: server.scope === "project" ? "project" : "global",
+    toolCallTimeoutMs: num(server.toolCallTimeoutMs, DEFAULT_TOOL_CALL_TIMEOUT_MS),
+    failOnStartupError: bool(server.failOnStartupError, false),
+    /** Disabled public tool names, per-tool switch (mcp-manager-gui-spec §3.4). */
+    disabledTools: Array.isArray(server.disabledTools)
+      ? server.disabledTools.filter((item) => typeof item === "string")
+      : [],
+  };
+  if (transport === "stdio") {
+    const command = str(server.command).trim();
+    if (command.length === 0) return { error: "stdio transport requires a command" };
+    config.command = command;
+    config.args = strArray(server.args);
+    config.env = strMap(server.env);
+    config.cwd = str(server.cwd);
+  } else {
+    const url = str(server.url).trim();
+    if (!/^https?:\/\//i.test(url)) {
+      return { error: "streamable-http transport requires an http(s) url" };
+    }
+    config.url = url;
+    config.headers = strMap(server.headers);
+  }
+  if (server.reconnect !== undefined && server.reconnect !== null) {
+    if (typeof server.reconnect !== "object" || Array.isArray(server.reconnect)) {
+      return { error: "reconnect must be an object" };
+    }
+    config.reconnect = { ...server.reconnect };
+  }
+  return { config };
+}
+
+/**
+ * Translate one stored console config into the official client's config
+ * (input to `ctx.plugin(mcpClient, config)`). Assumes validateServerConfig()
+ * has passed; still coerces defensively.
+ *
+ * @param {object} server validated console config
+ * @returns {object} official StdioConfig | StreamableHttpConfig
+ */
+export function toClientConfig(server) {
+  const config = {
+    transport: server.transport,
+    serverName: server.name,
+    toolCallTimeoutMs: num(server.toolCallTimeoutMs, DEFAULT_TOOL_CALL_TIMEOUT_MS),
+    failOnStartupError: bool(server.failOnStartupError, false),
+  };
+  if (server.transport === "stdio") {
+    config.command = str(server.command);
+    config.args = strArray(server.args);
+    config.env = strMap(server.env);
+    config.cwd = str(server.cwd);
+  } else {
+    config.url = str(server.url);
+    config.headers = strMap(server.headers);
+  }
+  if (server.reconnect && typeof server.reconnect === "object") {
+    config.reconnect = { ...server.reconnect };
+  }
+  return config;
+}
+
+/**
+ * Mask secret-shaped values for API responses and the panel. env/headers
+ * values become MASK when set; keys are kept so the shape stays visible.
+ */
+export function maskRecord(record) {
+  const out = {};
+  for (const [key, value] of Object.entries(record ?? {})) {
+    out[key] = typeof value === "string" && value.length > 0 ? MASK : value;
+  }
+  return out;
+}

package/lib/import.js

@@ -0,0 +1,105 @@
+/**
+ * mcpServers JSON import (plan §5.5).
+ *
+ * Accepts the Claude Code / Codex family of shapes:
+ *
+ *   { "mcpServers": { "<name>": { "command": "...", "args": [...], "env": {...} } } }
+ *   { "mcpServers": { "<name>": { "url": "https://...", "headers": {...}, "type": "http" } } }
+ *
+ * plus the bare map without the `mcpServers` wrapper. stdio entries map
+ * 1:1; http entries are normalized to the official client's
+ * `streamable-http` transport, tolerating the common key variants
+ * (`url`/`serverUrl`/`endpoint`, `type: "http"|"streamable-http"|"sse"`).
+ * Names are reported, never overwritten — conflicts are the caller's to
+ * surface (the orchestrator skips and reports them).
+ */
+
+const NAME_LIMIT = 100;
+
+/**
+ * Parse pasted JSON into console server configs.
+ * @param {string} text
+ * @returns {{ servers: {name: string, config: object}[], errors: string[] }}
+ */
+export function parseMcpServers(text) {
+  const errors = [];
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    return { servers: [], errors: [`invalid JSON: ${String(error?.message ?? error)}`] };
+  }
+  let map = parsed;
+  if (isPlainObject(parsed) && isPlainObject(parsed.mcpServers)) {
+    map = parsed.mcpServers;
+  } else if (isPlainObject(parsed) && isPlainObject(parsed.servers) && !parsed.command && !parsed.url) {
+    map = parsed.servers;
+  }
+  if (!isPlainObject(map)) {
+    return { servers: [], errors: ["expected an object like { mcpServers: { name: { command, args, env } } }"] };
+  }
+  const servers = [];
+  for (const [name, entry] of Object.entries(map)) {
+    if (servers.length >= NAME_LIMIT) {
+      errors.push(`import capped at ${NAME_LIMIT} servers; remaining entries ignored`);
+      break;
+    }
+    if (!isPlainObject(entry)) {
+      errors.push(`"${name}": not an object, skipped`);
+      continue;
+    }
+    const config = mapEntry(name, entry);
+    if (config) servers.push({ name, config });
+    else errors.push(`"${name}": neither a stdio (command/args/env) nor an http (url/headers) entry, skipped`);
+  }
+  return { servers, errors };
+}
+
+function mapEntry(name, entry) {
+  const common = {
+    enabled: true,
+    scope: "global",
+    toolCallTimeoutMs: typeof entry.toolCallTimeoutMs === "number" ? entry.toolCallTimeoutMs : undefined,
+    failOnStartupError: entry.failOnStartupError === true,
+  };
+  const url = firstString(entry.url, entry.serverUrl, entry.endpoint);
+  if (url) {
+    return {
+      ...common,
+      transport: "streamable-http",
+      url,
+      headers: stringMap(entry.headers),
+    };
+  }
+  if (typeof entry.command === "string" && entry.command.length > 0) {
+    return {
+      ...common,
+      transport: "stdio",
+      command: entry.command,
+      args: Array.isArray(entry.args) ? entry.args.filter((item) => typeof item === "string") : [],
+      env: stringMap(entry.env),
+      cwd: typeof entry.cwd === "string" ? entry.cwd : "",
+    };
+  }
+  return null;
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && /^https?:\/\//i.test(value)) return value;
+  }
+  return null;
+}
+
+function stringMap(value) {
+  if (!isPlainObject(value)) return {};
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (typeof item === "string") out[key] = item;
+  }
+  return out;
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/lib/index.js

@@ -0,0 +1,113 @@
+/**
+ * Host-side entry for @moon16u/dsh-plugin-mcp-console.
+ *
+ * A thin composition root (plan §4): Store (persistence) + Orchestrator
+ * (dynamic assembly of the official `@deepseek-ai/dsh-mcp-client`) +
+ * Status (observation) + Routes (loopback HTTP API + SSE).
+ *
+ * The MCP protocol itself is never implemented here — every connection, tool
+ * registration and reconnect belongs to the official client plugin, loaded
+ * one fiber per server through `ctx.plugin()`.
+ *
+ * Service wiring uses `ctx.inject(["webServer", "tools"], ...)` rather than a
+ * static `inject` export: on a host without the web profile (no webServer)
+ * the plugin stays dormant instead of blocking the whole dsh-pouch bundle.
+ */
+import { Store, globalStorePath, projectStorePath } from "./store.js";
+import { Orchestrator } from "./orchestrator.js";
+import { computeSnapshot } from "./status.js";
+import { registerRoutes } from "./routes.js";
+import { homedir } from "node:os";
+import { resolve, parse, join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+
+/** Cordis plugin name used by loader diagnostics. */
+export const name = "mcp-console";
+
+export function apply(ctx) {
+  ctx.inject(["webServer", "tools"], (scope) => {
+    const globalStore = new Store(globalStorePath());
+    const orchestrator = new Orchestrator(scope, { globalStore, onChange: () => notify() });
+
+    // 项目工作区自动感知：
+    // 1. 优先排除法 (process.cwd() 不是家目录或根目录)
+    // 2. 降级读取 DSH 本身存储的当前活跃工作区 (~/.dsh/storages/workspace.json)
+    try {
+      let activeWorkspace = null;
+      const cwd = process.cwd();
+      const home = homedir();
+      const isHomeOrRoot = !cwd || resolve(cwd) === resolve(home) || resolve(cwd) === parse(cwd).root;
+      if (!isHomeOrRoot && existsSync(cwd)) {
+        activeWorkspace = cwd;
+      } else {
+        const wsStoragePath = join(home, ".dsh", "storages", "workspace.json");
+        if (existsSync(wsStoragePath)) {
+          const raw = JSON.parse(readFileSync(wsStoragePath, "utf8"));
+          const workspaces = raw?.tables?.workspaces;
+          if (workspaces && typeof workspaces === "object") {
+            const list = Object.values(workspaces);
+            list.sort((a, b) => new Date(b.updatedAt || 0) - new Date(a.updatedAt || 0));
+            const target = list.find((w) => w.path && existsSync(w.path) && resolve(w.path) !== resolve(home));
+            if (target) activeWorkspace = target.path;
+          }
+        }
+      }
+
+      if (activeWorkspace) {
+        const projStore = new Store(projectStorePath(activeWorkspace));
+        orchestrator.setProjectStore(projStore, activeWorkspace);
+      }
+    } catch {
+      // 容错降级：保持 global-only
+    }
+
+    const routes = registerRoutes(scope, { orchestrator, uiStore: globalStore });
+    const notify = () => routes.notify();
+
+    // Per-tool disable (mcp-manager-gui-spec §3.4): a plain-context guard
+    // applies globally — the official dsh-tools contract for masking a tool
+    // for every agent. Disposed automatically with this scope.
+    scope.tools.guard((execution) => orchestrator.toolGuard(execution));
+
+    // Status change sources (plan §5.3): tool registrations anywhere,
+    // lifecycle transitions of OUR fibers, and a fallback timer while any
+    // managed server is mid-connect (zero tools inside the grace window).
+    scope.on("tools/change", () => notify());
+    scope.on("internal/status", (fiber) => {
+      for (const entry of orchestrator.ledger.values()) {
+        if (entry.fiber === fiber) {
+          notify();
+          return;
+        }
+      }
+    });
+
+    // Fallback poll (5s): bridges status transitions that emit no events —
+    // chiefly "connecting -> failed" when a server never produces tools.
+    // notify() dedups identical snapshots, so the poll is silent when idle.
+    let settleTimer = null;
+    settleTimer = setInterval(() => notify(), 5000);
+    if (typeof settleTimer.unref === "function") settleTimer.unref();
+
+    scope.effect(() => {
+      void orchestrator.bootstrap().then(() => notify());
+      return () => {
+        clearInterval(settleTimer);
+        routes.dispose();
+      };
+    }, "mcp-console: composition");
+  });
+}
+
+export { Store, globalStorePath, projectStorePath } from "./store.js";
+export { Orchestrator, ConsoleError } from "./orchestrator.js";
+export { computeSnapshot } from "./status.js";
+export { parseMcpServers } from "./import.js";
+export { registerRoutes, ROUTE_PREFIX, sanitizeUi } from "./routes.js";
+export { validateServerConfig, toClientConfig } from "./clientAdapter.js";
+export {
+  ingestProfileMcpEntries,
+  exportStoreToProfileYaml,
+  formatMcpYamlEntry,
+  defaultProfilePatchYamlPath,
+} from "./yamlMigrator.js";