dsh-claude-compat 0.2.0 → 0.6.2

package/src/mcp.js

@@ -0,0 +1,133 @@
+// dsh-claude-compat: MCP servers from <projectRoot>/.mcp.json (Claude Code
+// format). Read once at DSH startup from the launch workspace; each server is
+// mounted as an @deepseek-ai/dsh-mcp-client plugin instance (stdio for
+// `command` entries, streamable-http for `url`/`type:'http'|'sse'` entries).
+//
+// Failure handling is deliberately non-fatal: an unreadable/malformed .mcp.json
+// or an absent dsh-mcp-client package logs a warning and skips, never crashing
+// the harness. failOnStartupError only forwards to the mcp-client plugin.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  findProjectRootSync,
+  pathExists,
+} from './lib.js';
+
+// Pure translation of Claude Code's .mcp.json body into dsh-mcp-client plugin
+// configs, keyed by server name. Malformed entries are skipped and reported.
+export function translateMcpServers(rawJson, { failOnStartupError = false } = {}) {
+  let parsed;
+  try { parsed = JSON.parse(rawJson); }
+  catch {
+    return { servers: [], warns: [`invalid-json: ${String(rawJson).slice(0, 100)}`] };
+  }
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    return { servers: [], warns: ['invalid-json: root must be an object'] };
+  }
+  const servers = parsed.mcpServers;
+  if (typeof servers !== 'object' || servers === null || Array.isArray(servers)) {
+    return { servers: [], warns: ['mcpServers: missing or not an object'] };
+  }
+  const out = [];
+  const warns = [];
+  for (const [name, entry] of Object.entries(servers)) {
+    if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+      warns.push(`${name}: malformed entry, skipped`);
+      continue;
+    }
+    // serverName must match /^[A-Za-z0-9_-]{1,32}$/ (dsh-mcp-client contract).
+    const serverName = name.replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 32);
+    if (serverName.length === 0) {
+      warns.push(`${name}: empty server name, skipped`);
+      continue;
+    }
+    const base = {
+      serverName,
+      toolCallTimeoutMs: 60_000,
+      failOnStartupError,
+    };
+    if (typeof entry.command === 'string' && entry.command.length > 0) {
+      out.push({
+        ...base,
+        transport: 'stdio',
+        command: entry.command,
+        args: Array.isArray(entry.args) ? entry.args.filter((a) => typeof a === 'string') : [],
+        env: stringDict(entry.env),
+        cwd: typeof entry.cwd === 'string' ? entry.cwd : '',
+      });
+    } else if (typeof entry.url === 'string' && entry.url.length > 0) {
+      out.push({
+        ...base,
+        transport: 'streamable-http',
+        url: entry.url,
+        headers: stringDict(entry.headers),
+      });
+    } else if (entry.type === 'http' || entry.type === 'sse') {
+      warns.push(`${name}: type '${entry.type}' without a url, skipped`);
+    } else {
+      warns.push(`${name}: neither command nor url, skipped`);
+    }
+  }
+  return { servers: out, warns };
+}
+
+function stringDict(v) {
+  if (typeof v !== 'object' || v === null || Array.isArray(v)) return {};
+  const out = {};
+  for (const [k, val] of Object.entries(v)) {
+    if (typeof val === 'string') out[k] = val;
+    else if (typeof val === 'number' || typeof val === 'boolean') out[k] = String(val);
+  }
+  return out;
+}
+
+// Mount one mcp-client per server listed in <projectRoot>/.mcp.json. Lifecycle:
+// process-lifetime by design — the file is read once at DSH startup from the
+// launch workspace via process.cwd()-based root discovery; deviating from the
+// per-session cwd rules (which are session-scoped) is intended and documented.
+export async function mountMcpServers(ctx, config) {
+  const projectRoot = findProjectRootSync(process.cwd(), config.projectRootMarkers);
+  if (projectRoot === undefined) return;
+  const mcpPath = join(projectRoot, '.mcp.json');
+  if (!(await pathExists(mcpPath))) return;
+  let raw;
+  try { raw = readFileSync(mcpPath, 'utf8'); } catch (error) {
+    console.warn(`dsh-claude-compat: .mcp.json unreadable: ${error?.message ?? error}`, '(skipping MCP)');
+    return;
+  }
+  const { servers, warns } = translateMcpServers(raw, {
+    failOnStartupError: config.mcpFailOnStartupError ?? false,
+  });
+  warns.forEach((w) => console.warn(`dsh-claude-compat: .mcp.json: ${w}`));
+  await mountMcpConfigs(ctx, servers);
+}
+
+// Mount pre-translated server configs (shared by .mcp.json and plugin MCP).
+export async function mountMcpConfigs(ctx, servers) {
+  if (servers.length === 0) return;
+  let mcpClientModule;
+  try {
+    mcpClientModule = await import('@deepseek-ai/dsh-mcp-client');
+  } catch (error) {
+    console.warn('dsh-claude-compat: @deepseek-ai/dsh-mcp-client not installed', '(MCP disabled)', error?.message ?? error);
+    return;
+  }
+  const mcpClient = mcpClientModule.default ?? mcpClientModule;
+  const mounted = new Set();
+  for (const server of servers) {
+    if (mounted.has(server.serverName)) {
+      console.warn(`dsh-claude-compat: duplicate serverName "${server.serverName}" skipped`);
+      continue;
+    }
+    mounted.add(server.serverName);
+    // ctx.plugin returns a Fiber (PromiseLike) in real cordis; guard for
+    // non-promise returns in tests/embeddings.
+    const fiber = ctx.plugin(mcpClient, server);
+    if (fiber && typeof fiber.catch === 'function') {
+      fiber.catch((error) => {
+        console.warn(`dsh-claude-compat: server "${server.serverName}" failed to mount: ${error?.message ?? error}`);
+      });
+    }
+  }
+}

package/src/plugin-manager.js

@@ -0,0 +1,305 @@
+// dsh-claude-compat: /plugin management skill (v0.6.0).
+//
+// Full Claude-Code-equivalent plugin management surfaced as a user-invocable
+// DSH skill named "plugin". Execution engine: claude CLI first (`claude
+// plugin ...`, present on PATH in most Claude Code setups), self-implemented
+// JSON+git fallback when the CLI is unavailable. All state lives in the
+// Claude-native locations (~/.claude/plugins/*, settings.json enabledPlugins)
+// so both Claude Code and this plugin's discovery bridge read the same truth.
+//
+// Commands (mirroring `claude plugin` semantics):
+//   /plugin                                  — list installed (status incl. enabled/disabled)
+//   /plugin <name>[@market]                  — one-shot install
+//   /plugin install <name>[@market]
+//   /plugin uninstall|remove <name>
+//   /plugin enable <name>
+//   /plugin disable <name>
+//   /plugin update [name]                    — one or all
+//   /plugin search <term>                    — scan known marketplaces
+//   /plugin marketplace list|add|remove|update [...]
+//
+// Safety: never mutates installed_plugins.json / known_marketplaces.json /
+// settings.json directly without a timestamped backup beside the file; the
+// claude-CLI path performs no direct mutation at all (CLI owns the writes).
+
+import { execFile } from 'node:child_process';
+import { copyFileSync, existsSync, readFileSync, readdirSync, writeFileSync, cpSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+const HELP = `# Claude Code Plugin Manager (dsh-claude-compat)
+
+Manage Claude Code plugins and marketplaces. State is stored in Claude-native
+locations (~/.claude/plugins, ~/.claude/settings.json enabledPlugins), so
+Claude Code and DSH see the same plugins. Newly installed plugin content
+appears in the DSH skill catalog on next reconcile (MCP servers need a DSH restart).
+
+## Commands (invoked as /cc-plugin <args>)
+- \`/plugin\` — list installed plugins with enable/disable status
+- \`/plugin <name>[@marketplace]\` — one-shot install (e.g. \`/plugin ralph@omc\`)
+- \`/plugin install <name>[@marketplace]\`
+- \`/plugin uninstall <name>\` (alias: remove)
+- \`/plugin enable <name>\` / \`/plugin disable <name>\`
+- \`/plugin update [name]\` — update one plugin or all
+- \`/plugin search <term>\` — search all known marketplaces
+- \`/plugin marketplace list\`
+- \`/plugin marketplace add <github-repo-or-url>\`
+- \`/plugin marketplace remove <name>\`
+- \`/plugin marketplace update [name]\`
+
+## Execution
+Prefers the \`claude plugin\` CLI when available; falls back to direct
+JSON/git manipulation (with automatic timestamped backups of every file it
+touches). Report which engine ran in the result.`;
+
+/** Run `claude plugin ...` args; resolve {ok, stdout} or {ok:false, error}. */
+async function claudePlugin(args, timeoutMs = 120_000) {
+  return execFileAsync('claude', ['plugin', ...args], { timeout: timeoutMs, encoding: 'utf8' })
+    .then(({ stdout }) => ({ ok: true, stdout: stdout ?? '' }))
+    .catch((error) => ({ ok: false, error: error?.message ?? String(error) }));
+}
+
+function pluginsRoot() {
+  return join(homedir(), '.claude', 'plugins');
+}
+
+function backupFile(path) {
+  if (!existsSync(path)) return undefined;
+  const backup = `${path}.bak-${new Date().toISOString().replace(/[:.]/g, '-')}`;
+  copyFileSync(path, backup);
+  return backup;
+}
+
+function readJson(path, fallback) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); }
+  catch { return fallback; }
+}
+
+/** Pure: parse `claude plugin list` output into [{name, marketplace, version, scope, enabled}]. */
+export function parsePluginList(output) {
+  const plugins = [];
+  const lines = String(output ?? '').split('\n');
+  let current;
+  for (const line of lines) {
+    const entry = line.match(/^\s*❯\s*(\S+)@(\S+)\s*$/);
+    if (entry) {
+      if (current) plugins.push(current);
+      current = { name: entry[1], marketplace: entry[2] };
+      continue;
+    }
+    if (!current) continue;
+    const version = line.match(/^\s*Version:\s*(\S+)/);
+    if (version) current.version = version[1];
+    const scope = line.match(/^\s*Scope:\s*(\S+)/);
+    if (scope) current.scope = scope[1];
+    const status = line.match(/^\s*Status:\s*(✔|✘)\s*(\S+)/);
+    if (status) current.enabled = status[2] === 'enabled';
+  }
+  if (current) plugins.push(current);
+  return plugins;
+}
+
+/** Pure: list plugin entries from installed_plugins.json + enabledPlugins map. */
+export function listFromDisk(pluginsDir = pluginsRoot(), settingsPath = join(homedir(), '.claude', 'settings.json')) {
+  const installed = readJson(join(pluginsDir, 'installed_plugins.json'), { version: 2, plugins: {} });
+  const settings = readJson(settingsPath, {});
+  const enabledMap = settings.enabledPlugins ?? {};
+  const out = [];
+  for (const [key, entries] of Object.entries(installed.plugins ?? {})) {
+    const last = Array.isArray(entries) ? entries[entries.length - 1] : entries;
+    if (!last) continue;
+    const [name, marketplace] = key.split('@');
+    const installedEnabled = enabledMap[key];
+    out.push({
+      name,
+      marketplace,
+      version: last.version,
+      scope: last.scope,
+      // enabledPlugins is authoritative when the key exists; default enabled.
+      enabled: installedEnabled === undefined ? true : Boolean(installedEnabled),
+    });
+  }
+  return out;
+}
+
+/** Pure: search marketplace.json catalogs under marketplaces/ for a term. */
+export function searchMarketplaces(term, pluginsDir = pluginsRoot()) {
+  const marketRoot = join(pluginsDir, 'marketplaces');
+  const needle = String(term ?? '').toLowerCase();
+  const hits = [];
+  let dirs = [];
+  try { dirs = readdirSync(marketRoot, { withFileTypes: true }); } catch { return hits; }
+  for (const dir of dirs) {
+    if (!dir.isDirectory()) continue;
+    const manifest = join(marketRoot, dir.name, '.claude-plugin', 'marketplace.json');
+    if (!existsSync(manifest)) continue;
+    const json = readJson(manifest, null);
+    for (const plugin of json?.plugins ?? []) {
+      const haystack = `${plugin.name} ${plugin.description ?? ''} ${(plugin.tags ?? []).join(' ')}`.toLowerCase();
+      if (needle === '' || haystack.includes(needle)) {
+        hits.push({
+          name: plugin.name,
+          marketplace: dir.name,
+          description: plugin.description ?? '',
+          version: plugin.version,
+          installId: `${plugin.name}@${dir.name}`,
+        });
+      }
+    }
+  }
+  return hits;
+}
+
+/**
+ * Fallback install for no-CLI environments: clone the marketplace repo is
+ * already present under marketplaces/<name>; copy plugin source into cache and
+ * register in installed_plugins.json + enabledPlugins.
+ */
+export async function fallbackInstall(installId, pluginsDir = pluginsRoot(), settingsPath = join(homedir(), '.claude', 'settings.json')) {
+  const [pluginName, marketName] = String(installId).split('@');
+  if (!marketName) return { ok: false, error: 'fallback install needs name@marketplace (marketplace repo must already be cloned)' };
+  const marketJson = join(pluginsDir, 'marketplaces', marketName, '.claude-plugin', 'marketplace.json');
+  const catalog = readJson(marketJson, null);
+  const entry = (catalog?.plugins ?? []).find((p) => p.name === pluginName);
+  if (!entry) return { ok: false, error: `plugin "${pluginName}" not found in marketplace "${marketName}"` };
+  const version = entry.version ?? 'unknown';
+  const sourceRel = String(entry.source ?? './').replace(/^\.\//, '');
+  const from = join(pluginsDir, 'marketplaces', marketName, sourceRel);
+  if (!existsSync(from)) return { ok: false, error: `plugin source missing in marketplace clone: ${sourceRel}` };
+  const dest = join(pluginsDir, 'cache', marketName, pluginName, version);
+  mkdirSync(dest, { recursive: true });
+  cpSync(from, dest, { recursive: true });
+  const installedPath = join(pluginsDir, 'installed_plugins.json');
+  backupFile(installedPath);
+  const installed = readJson(installedPath, { version: 2, plugins: {} });
+  const key = `${pluginName}@${marketName}`;
+  installed.plugins[key] = installed.plugins[key] ?? [];
+  installed.plugins[key].push({
+    scope: 'user',
+    installPath: dest,
+    version,
+    installedAt: new Date().toISOString(),
+    lastUpdated: new Date().toISOString(),
+  });
+  writeFileSync(installedPath, JSON.stringify(installed, null, 2) + '\n');
+  backupFile(settingsPath);
+  const settings = readJson(settingsPath, {});
+  settings.enabledPlugins = settings.enabledPlugins ?? {};
+  settings.enabledPlugins[key] = true;
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  return { ok: true, engine: 'fallback', installPath: dest, version };
+}
+
+/** Fallback enable/disable: flip enabledPlugins in settings.json (backed up). */
+export function fallbackToggle(pluginRef, enable, pluginsDir = pluginsRoot(), settingsPath = join(homedir(), '.claude', 'settings.json')) {
+  const installed = readJson(join(pluginsDir, 'installed_plugins.json'), { plugins: {} });
+  const keys = Object.keys(installed.plugins ?? {});
+  const key = keys.find((k) => k === pluginRef || k.startsWith(`${pluginRef}@`));
+  if (!key) return { ok: false, error: `plugin not found: ${pluginRef}` };
+  backupFile(settingsPath);
+  const settings = readJson(settingsPath, {});
+  settings.enabledPlugins = settings.enabledPlugins ?? {};
+  settings.enabledPlugins[key] = Boolean(enable);
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+  return { ok: true, engine: 'fallback', key, enabled: Boolean(enable) };
+}
+
+/**
+ * Main dispatcher. Input: the raw argument string after "/plugin".
+ * Returns markdown text for the model to present.
+ */
+export async function runPluginCommand(input, deps = {}) {
+  const claudeFn = deps.claude ?? claudePlugin;
+  const args = String(input ?? '').trim().split(/\s+/).filter(Boolean);
+  if (args.length === 0 || args[0] === 'help') return HELP;
+
+  const [cmd, ...rest] = args;
+
+  // `/plugin <name>[@market]` one-shot install.
+  const isOneShot = !['install', 'uninstall', 'remove', 'enable', 'disable',
+    'update', 'search', 'marketplace', 'list'].includes(cmd);
+  if (isOneShot) return doInstall(cmd, claudeFn);
+
+  if (cmd === 'list') {
+    const res = await claudeFn(['list']);
+    if (res.ok) {
+      const parsed = parsePluginList(res.stdout);
+      if (parsed.length === 0) return 'No plugins installed.';
+      return ['Installed plugins:', '',
+        ...parsed.map((p) => `- **${p.name}@${p.marketplace}** v${p.version} [${p.scope}] ${p.enabled ? '✔ enabled' : '✘ disabled'}`),
+        '', 'Enable/disable with `/plugin enable|disable <name>`; install with `/plugin <name>@<marketplace>`.'].join('\n');
+    }
+    const parsed = listFromDisk();
+    if (parsed.length === 0) return 'No plugins installed (CLI unavailable, disk scan found none).';
+    return ['Installed plugins (disk scan; claude CLI unavailable):', '',
+      ...parsed.map((p) => `- **${p.name}@${p.marketplace}** v${p.version} [${p.scope}] ${p.enabled ? '✔ enabled' : '✘ disabled'}`)].join('\n');
+  }
+
+  if (cmd === 'search') {
+    if (rest.length === 0) return 'Usage: `/plugin search <term>`';
+    const hits = searchMarketplaces(rest.join(' '));
+    if (hits.length === 0) return `No marketplace plugin matches "${rest.join(' ')}".`;
+    return [`Marketplace matches for "${rest.join(' ')}":`, '',
+      ...hits.slice(0, 30).map((h) => `- **${h.installId}** v${h.version ?? '?'} — ${h.description.slice(0, 100)}`),
+      '', 'Install with `/plugin <name>@<marketplace>`.'].join('\n');
+  }
+
+  if (cmd === 'marketplace') {
+    const [sub, ...mrest] = rest;
+    const subArgs = { list: ['marketplace', 'list'], add: ['marketplace', 'add', ...mrest], remove: ['marketplace', 'remove', ...mrest], rm: ['marketplace', 'remove', ...mrest], update: ['marketplace', 'update', ...mrest] }[sub];
+    if (!subArgs) return 'Usage: `/plugin marketplace list|add|remove|update [...]`';
+    const res = await claudeFn(subArgs, 300_000);
+    if (res.ok) return `Marketplace ${sub} OK (engine: claude CLI):\n\n${res.stdout.trim()}`;
+    return `Marketplace ${sub} failed. Engine: claude CLI (unavailable or errored).\n\n${res.error}\n\nFallback for marketplace mutation is not implemented (manual: git clone into ~/.claude/plugins/marketplaces/<name> and register in known_marketplaces.json).`;
+  }
+
+  const passThrough = {
+    install: ['install', ...rest],
+    uninstall: ['uninstall', ...rest],
+    remove: ['uninstall', ...rest],
+    enable: ['enable', ...rest],
+    disable: ['disable', ...rest],
+  }[cmd];
+
+  if (cmd === 'update') {
+    const res = await claudeFn(['update', ...rest], 300_000);
+    if (res.ok) return `Update OK (engine: claude CLI):\n\n${res.stdout.trim()}\n\nRestart DSH to apply MCP changes; skills refresh automatically.`;
+    return `Update failed (engine: claude CLI):\n\n${res.error}`;
+  }
+
+  if (passThrough) {
+    if (passThrough[0] === 'install') return doInstall(rest.join(' '), claudeFn);
+    const res = await claudeFn(passThrough, 300_000);
+    if (res.ok) return `\`${cmd} ${rest.join(' ')}\` OK (engine: claude CLI):\n\n${res.stdout.trim()}`;
+    if ((cmd === 'enable' || cmd === 'disable') && /ENOENT|not found|spawn/i.test(res.error)) {
+      const fb = fallbackToggle(rest[0], cmd === 'enable');
+      if (fb.ok) return `\`${cmd} ${rest[0]}\` OK (engine: fallback, settings.json backed up): ${fb.key} → ${fb.enabled ? 'enabled' : 'disabled'}`;
+      return `Both engines failed:\n- claude CLI: ${res.error}\n- fallback: ${fb.error}`;
+    }
+    return `\`${cmd} ${rest.join(' ')}\` failed (engine: claude CLI):\n\n${res.error}`;
+  }
+
+  return HELP;
+}
+
+async function doInstall(installId, claudeFn) {
+  if (!installId) return 'Usage: `/plugin <name>[@marketplace]`';
+  const res = await claudeFn(['install', installId], 300_000);
+  if (res.ok) {
+    return [`Installed **${installId}** (engine: claude CLI).`, '', res.stdout.trim(),
+      '', 'Skills/commands appear in the catalog on next reconcile; restart DSH if the plugin ships MCP servers.'].join('\n');
+  }
+  const fb = await fallbackInstall(installId);
+  if (fb.ok) {
+    return [`Installed **${installId}** (engine: fallback; installed_plugins.json + settings.json backed up).`,
+      '', `installPath: ${fb.installPath}`, '',
+      'Skills/commands appear in the catalog on next reconcile; restart DSH if the plugin ships MCP servers.'].join('\n');
+  }
+  return [`Install failed for **${installId}**:`, '', `- claude CLI: ${res.error}`, `- fallback: ${fb.error}`].join('\n');
+}
+
+export const PLUGIN_SKILL_NAME = 'plugin';
+export const PLUGIN_SKILL_BODY = HELP;

package/src/plugins.js

@@ -0,0 +1,170 @@
+// dsh-claude-compat: installed Claude Code plugins (~/.claude/plugins).
+//
+// Claude Code's plugin-marketplace installs plugins into
+// <pluginsRoot>/cache/<marketplace>/<name>/<version>/ and records them in
+// <pluginsRoot>/installed_plugins.json. Each install root carries a
+// .claude-plugin/plugin.json manifest listing skills dirs / commands dir /
+// agents dir / an .mcp.json. We surface skills/commands/agents as DSH skill
+// candidates at pluginSkillRank (default 750 — the long tail, below
+// user-claude 700 and bundled 600), keeping original names; existing dedupe
+// resolves collisions. Plugin MCP servers mount only when enablePluginMcp is
+// opted in (mounting third-party MCP servers is a bigger trust step than
+// listing skills).
+
+import { readFileSync as rfs } from 'node:fs';
+import { join, resolve } from 'node:path';
+import {
+  pathExists,
+  readTextSafe,
+  resolveUserClaudeDir,
+  parseFrontmatter,
+  stringField,
+} from './lib.js';
+import { translateMcpServers } from './mcp.js';
+
+// Parse installed_plugins.json → [{ key, name, marketplace, installPath,
+// version }] for scope==='user' entries. Dedupe per key, keeping the last
+// entry (Claude Code appends reinstall records; last is freshest).
+export function readInstalledClaudePlugins(pluginsRoot) {
+  const root = resolveUserClaudeDir(pluginsRoot === undefined ? '~/.claude/plugins' : pluginsRoot);
+  const manifestPath = join(root, 'installed_plugins.json');
+  let parsed;
+  try { parsed = JSON.parse(claReadSync(manifestPath)); }
+  catch { return []; }
+  if (typeof parsed !== 'object' || parsed === null) return [];
+  const plugins = parsed.plugins;
+  if (typeof plugins !== 'object' || plugins === null || Array.isArray(plugins)) return [];
+  const byKey = new Map();
+  for (const [key, entries] of Object.entries(plugins)) {
+    if (!Array.isArray(entries)) continue;
+    const record = entries.findLast((e) => e?.scope === 'user');
+    if (record === undefined || typeof record.installPath !== 'string') continue;
+    const at = key.lastIndexOf('@');
+    byKey.set(key, {
+      key,
+      name: at > 0 ? key.slice(0, at) : key,
+      marketplace: at > 0 ? key.slice(at + 1) : '',
+      installPath: record.installPath,
+      version: typeof record.version === 'string' ? record.version : 'unknown',
+    });
+  }
+  return [...byKey.values()];
+}
+
+// readFileSync kept local so readInstalledClaudePlugins stays sync-simple.
+function claReadSync(p) { return rfs(p, 'utf8'); }
+
+// Discover skill/command/agent candidates from all installed plugins. When a
+// plugin has a .claude-plugin/plugin.json manifest, its listed dirs are used;
+// otherwise fall back to scanning <installPath>/skills and <installPath>/commands.
+// Claude Code's discoverCommands drops commands whose only description is the
+// empty string; plugin marketplaces ship many such stubs, so this wrapper
+// re-surfaces them with the filename stem as the description.
+export async function discoverPluginContent(pluginsRoot, providerName, source, rank, { enableAgents } = {}) {
+  const out = [];
+  const plugins = readInstalledClaudePlugins(pluginsRoot);
+  const { discoverSkills, discoverCommands } = await import('./index.js');
+  const { discoverAgents } = await import('./agents.js');
+  const patchedCommands = async (dir) => {
+    const batch = await discoverCommands(dir, providerName, source, rank);
+    if (batch.length > 0) return batch;
+    const kept = new Set(batch.map((c) => c.path));
+    const extra = await discoverCommandsAllowEmpty(dir, providerName, source, rank);
+    return [...batch, ...extra.filter((c) => !kept.has(c.path))];
+  };
+  for (const plugin of plugins) {
+    const { installPath } = plugin;
+    const manifest = await readPluginManifest(installPath);
+    // Dedupe within each KIND only: omc-style plugins ship both skills/ask and
+    // commands/ask.md — same-name cross-kind pairs are surfaced separately and
+    // resolved by registry dedupe (skills are emitted first, so the skill wins,
+    // mirroring Claude Code's own behavior).
+    const seenByKind = { skills: new Set(), commands: new Set(), agents: new Set() };
+    const push = (kind) => (batch) => {
+      for (const c of batch) {
+        if (seenByKind[kind].has(c.name)) continue;
+        seenByKind[kind].add(c.name);
+        out.push(c);
+      }
+    };
+    if (manifest !== undefined) {
+      const skillDirs = manifestDirs(manifest, 'skills', installPath);
+      for (const dir of skillDirs) push('skills')(await discoverSkills(dir, providerName, source, rank));
+      const commandsDir = typeof manifest.commands === 'string' ? resolve(installPath, manifest.commands) : undefined;
+      if (commandsDir !== undefined) push('commands')(await patchedCommands(commandsDir));
+    } else {
+      push('skills')(await discoverSkills(join(installPath, 'skills'), providerName, source, rank));
+      push('commands')(await patchedCommands(join(installPath, 'commands')));
+    }
+    if (enableAgents !== false) {
+      const agentsDir = join(installPath, 'agents');
+      if (await pathExists(agentsDir)) push('agents')(await discoverAgents(agentsDir, providerName, source, rank));
+    }
+  }
+  return out;
+}
+
+// Like discoverCommands but keeps empty-description stubs (stem as description).
+async function discoverCommandsAllowEmpty(rootDir, providerName, source, rank) {
+  const { readdir } = await import('node:fs/promises');
+  const { isSkillName } = await import('@deepseek-ai/dsh-skill');
+  const out = [];  if (!(await pathExists(rootDir))) return out;
+  let entries;
+  try { entries = await readdir(rootDir, { withFileTypes: true, encoding: 'utf8' }); }
+  catch { return out; }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+    const stem = entry.name.slice(0, -3);
+    if (!isSkillName(stem)) continue;
+    const raw = await readTextSafe(join(rootDir, entry.name));
+    if (raw === undefined) continue;
+    const parsed = parseFrontmatter(raw);
+    if (parsed === undefined) continue; // no frontmatter at all → skip (index.js variant covers body-only)
+    const description = stringField(parsed.data, 'description');
+    if (description !== undefined) continue; // non-empty handled by index.js variant
+    out.push({
+      name: stem,
+      description: stem,
+      invocation: { modelInvocable: true, userInvocable: true },
+      provider: providerName,
+      source,
+      rank,
+      locator: { path: join(rootDir, entry.name), directory: rootDir },
+      resourceBase: { kind: 'directory', path: rootDir },
+      path: join(rootDir, entry.name),
+    });
+  }
+  return out;
+}
+
+async function readPluginManifest(installPath) {
+  const raw = await readTextSafe(join(installPath, '.claude-plugin', 'plugin.json'));
+  if (raw === undefined) return undefined;
+  try {
+    const parsed = JSON.parse(raw);
+    return typeof parsed === 'object' && parsed !== null ? parsed : undefined;
+  } catch { return undefined; }
+}
+
+function manifestDirs(manifest, field, installPath) {
+  const v = manifest[field];
+  if (typeof v === 'string') return [resolve(installPath, v)];
+  if (Array.isArray(v)) {
+    return v.filter((d) => typeof d === 'string').map((d) => resolve(installPath, d));
+  }
+  return [];
+}
+
+// Translate a plugin's MCP config into dsh-mcp-client server configs. Returns
+// { servers, warns } (empty when no/invalid mcpServers field). Substitutes the
+// ${CLAUDE_PLUGIN_ROOT} placeholder Claude Code defines for plugin processes.
+export function translatePluginMcp(manifest, installPath, opts = {}) {
+  const ref = manifest?.mcpServers;
+  if (typeof ref !== 'string') return { servers: [], warns: [] };
+  const raw = readTextSafeSync(resolve(installPath, ref));
+  if (raw === undefined) return { servers: [], warns: [`mcpServers file not readable: ${ref}`] };
+  const substituted = raw.replaceAll('${CLAUDE_PLUGIN_ROOT}', installPath);
+  return translateMcpServers(substituted, opts);
+}
+
+function readTextSafeSync(p) { try { return rfs(p, 'utf8'); } catch { return undefined; } }