dsh-claude-compat 0.6.2 → 0.7.0

package/README.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/badge/version-0.6.2-blue?style=flat-square" alt="Version">
+  <img src="https://img.shields.io/badge/version-0.7.0-blue?style=flat-square" alt="Version">
   <img src="https://img.shields.io/badge/node-%3E%3D20-green?style=flat-square&logo=node.js&logoColor=white" alt="Node">
   <img src="https://img.shields.io/badge/license-MIT-orange?style=flat-square" alt="License">
 </p>
@@ -46,6 +46,7 @@ Installing this plugin adds three management skills to the catalog:
 | `/cc-plugin` | Full Claude Code plugin management: `list`, `install <name>[@marketplace]`, `uninstall`, `enable`, `disable`, `update [name]`, `search <term>`, `marketplace list\|add\|remove\|update`. One-shot syntax `/cc-plugin <name>@<marketplace>` installs directly. Engine: the `claude` CLI when available, otherwise a built-in fallback (direct JSON + git, with timestamped backups of every file it touches). All state stays in Claude-native locations (`~/.claude/plugins`, `~/.claude/settings.json` `enabledPlugins`) so Claude Code and DSH read the same truth. |
 | `/reload-cc-plugins` | Hot-reload the skill catalog: drop cached provider lists and notify observers so newly installed/removed skills appear in the **current session** — no restart, no new session. |
 | `/reload-skills` | Alias of `/reload-cc-plugins`. |
+| `/cc-resume` | List Claude Code conversation sessions for the current project (`~/.claude/projects/`) and import any of them into DSH with full user/assistant/tool history. Imported sessions appear in the DSH session list titled `cc: <preview>` and resume like native ones. `list` / `import <sessionId>` / `--limit-turns N` for huge sessions. |
 
 Typical loop: `/cc-plugin install ralph-loop@claude-plugins-official` → `/reload-cc-plugins` → new skills visible immediately. Plugin-shipped MCP servers still require a DSH restart (process-lifetime mount).
 
@@ -109,6 +110,20 @@ Restart DSH (`dsh web`). Done — skills show up in `/`, rules are injected into
 
 ## Troubleshooting
 
+### Known limitation: `/cc-resume` via the skill tool
+
+In some DSH runtime configurations the `skill` tool resolves in an agent-scoped
+layer where globally registered providers are not visible — the invocation
+returns `skill "cc-resume" is unknown or no longer available` even though the
+catalog lists it. This is a DSH runtime layering behavior, not a plugin bug.
+The skill body only instructs the model to run the CLI, which is always
+available:
+
+```bash
+node node_modules/dsh-claude-compat/scripts/cc-resume.mjs list
+node node_modules/dsh-claude-compat/scripts/cc-resume.mjs import <sessionId>
+```
+
 **DSH won't start back up after a restart / port 3080 stuck.** Old process still holding the port (symptom: `EADDRINUSE` in logs). Use the bundled restart script — it waits for a clean stop, falls back to SIGKILL, and verifies the port before reporting success:
 
 ```bash
@@ -121,6 +136,8 @@ The script also re-applies the idempotent `dsh-terminal-bash` prompt patch, whic
 
 **Installed a plugin via `/cc-plugin` but its skills don't show.** Run `/reload-cc-plugins`. Still missing → restart DSH (plugin-shipped MCP servers always need a restart).
 
+**`/cc-resume` import fails on compression.** The importer needs the `zstd` binary (macOS: `brew install zstd`; most Linux images ship it).
+
 **`/cc-plugin` reports "claude CLI unavailable".** The fallback engine handles install/enable/disable; for marketplace add/update, install Claude Code (`npm install -g @anthropic-ai/claude-code`) or manage marketplaces from Claude Code directly.
 
 ## Acknowledgments

package/README.zh-CN.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <img src="https://img.shields.io/badge/version-0.6.2-blue?style=flat-square" alt="Version">
+  <img src="https://img.shields.io/badge/version-0.7.0-blue?style=flat-square" alt="Version">
   <img src="https://img.shields.io/badge/node-%3E%3D20-green?style=flat-square&logo=node.js&logoColor=white" alt="Node">
   <img src="https://img.shields.io/badge/license-MIT-orange?style=flat-square" alt="License">
 </p>
@@ -46,6 +46,7 @@
 | `/cc-plugin` | 完整 Claude Code 插件管理：`list`、`install <名>[@市场]`、`uninstall`、`enable`、`disable`、`update [名]`、`search <词>`、`marketplace list\|add\|remove\|update`。一键语法 `/cc-plugin <名>@<市场>` 直接安装。引擎：有 `claude` CLI 时优先调度，否则内置降级（直接操作 JSON + git，被改文件自动时间戳备份）。状态全部落在 Claude 原生位置（`~/.claude/plugins`、`~/.claude/settings.json` 的 `enabledPlugins`），Claude Code 与 DSH 读同一份真相。 |
 | `/reload-cc-plugins` | 热重载 skill catalog：清缓存并广播变更，新装/卸载的插件技能**当前会话**立即可见 —— 无需重启、无需新会话。 |
 | `/reload-skills` | `/reload-cc-plugins` 的别名。 |
+| `/cc-resume` | 列出当前项目的 Claude Code 会话（`~/.claude/projects/`），并把任意一个导入 DSH —— 完整 user/assistant/工具历史。导入会话以 `cc: <预览>` 标题出现在 DSH 会话列表，可像原生会话一样恢复。`list` / `import <sessionId>` / `--limit-turns N`（大会话只导最近 N 轮）。 |
 
 典型闭环：`/cc-plugin install ralph-loop@claude-plugins-official` → `/reload-cc-plugins` → 新技能立即可见。插件自带的 MCP 服务器仍需重启 DSH（进程级挂载）。
 
@@ -109,6 +110,15 @@ dsh plugin --profile web add github:biedongbin/dsh-claude-compat
 
 ## 故障排查
 
+### 已知限制：通过 skill 工具调用 `/cc-resume`
+
+部分 DSH 运行时配置下，`skill` 工具在 agent scoped 层解析，看不到全局层注册的 provider —— 即使 catalog 列表里有，调用仍返回 `skill "cc-resume" is unknown or no longer available`。这是 DSH 运行时分层行为，非插件缺陷。skill 本体只是指导模型跑 CLI，CLI 始终可用：
+
+```bash
+node node_modules/dsh-claude-compat/scripts/cc-resume.mjs list
+node node_modules/dsh-claude-compat/scripts/cc-resume.mjs import <sessionId>
+```
+
 **重启后 DSH 起不来 / 3080 端口卡死。** 旧进程占着端口（日志特征 `EADDRINUSE`）。用自带重启脚本 —— 干净等待停止、SIGKILL 兜底、探活端口后才报成功：
 
 ```bash
@@ -121,6 +131,8 @@ bash scripts/dsh-restart.sh --no-patch   # 跳过 prompt 补丁，只重启
 
 **`/cc-plugin` 装了插件但技能没出现。** 先 `/reload-cc-plugins`。仍没有 → 重启 DSH（插件自带 MCP 服务器必须重启）。
 
+**`/cc-resume` 导入时报压缩错误。** 导入器需要 `zstd` 二进制（macOS：`brew install zstd`；多数 Linux 镜像自带）。
+
 **`/cc-plugin` 提示 claude CLI 不可用。** 降级引擎已覆盖 install/enable/disable；marketplace add/update 需要安装 Claude Code（`npm install -g @anthropic-ai/claude-code`）或直接在 Claude Code 里管理市场。
 
 ## 社区鸣谢

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-claude-compat",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "DeepSeek Harness plugin: bridge Claude Code's .claude/ directories (project and ~/.claude: skills, commands, rules) into DSH native skill registry and message-stream rules injection.",
   "type": "module",
   "main": "src/index.js",

package/scripts/cc-resume.mjs

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+// cc-resume.mjs — list and import Claude Code sessions into DeepSeek Harness.
+//
+//   node cc-resume.mjs list   [--cwd <dir>] [--limit N]
+//   node cc-resume.mjs import <sessionId> [--cwd <dir>] [--limit-turns N]
+//
+// "list" prints one line per Claude session found under
+// ~/.claude/projects/<munged-cwd>/: id, date, message count, first-user-text
+// preview, and whether it is already imported into DSH.
+//
+// "import" translates a Claude Code session JSONL into a DSH event-sourced
+// session log (~/.dsh/sessions/<munged>/session-cc-<id>/session.jsonl.zstd)
+// so `dsh --resume` / the Web GUI can open the conversation with full
+// history: user messages, assistant text, tool calls and results.
+//
+// Translation rules:
+//   Claude user message      → DSH user/message + turn + step wrapper
+//   Claude assistant text    → DSH assistant/message (content block "text")
+//   Claude thinking          → skipped (DSH reasoning blocks are stream chunks;
+//                              reconstructed reasoning would confuse replay)
+//   Claude tool_use          → DSH tool/call
+//   Claude tool_result       → DSH tool/result (as a tool-sourced user message)
+//   Sidechain (subagent)     → skipped; only the main thread is imported
+//
+// The imported session gets `delegationDepth: 0`, preset `standard`, and a
+// session/title event ("cc: <first user text>") so it is recognizable in the
+// DSH session list. Idempotent: importing twice reuses the same target dir
+// (events are truncated and rewritten).
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { zstdFramesSync } from './zstd-compat.mjs';
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function munge(dir) {
+  return dir.replaceAll('/', '-');
+}
+
+function claudeProjectDir(cwd) {
+  return join(homedir(), '.claude', 'projects', munge(cwd));
+}
+
+function dshSessionsDir(cwd) {
+  // DSH munges /Users/x/proj → --Users-x-proj-- (leading '-' for the empty
+  // segment before the absolute path's first '/'), unlike Claude's
+  // -Users-x-proj (no leading '-'). Both keep a trailing '-'.
+  return join(homedir(), '.dsh', 'sessions', `-${munge(cwd)}--`);
+}
+
+function targetSessionDir(sessionId, cwd) {
+  return join(dshSessionsDir(cwd), `session-cc-${sessionId}`);
+}
+
+/** Parse a Claude JSONL into ordered main-thread turns. */
+export function parseClaudeSession(path) {
+  const turns = [];
+  let pendingAssistantBlocks = null; // blocks of the assistant message in flight
+  let title = null;
+  let createdAt = null;
+  let cwd = null;
+  let msgCount = 0;
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    if (line.trim() === '') continue;
+    let d;
+    try { d = JSON.parse(line); } catch { continue; }
+    if (d.cwd && !cwd) cwd = d.cwd;
+    if (d.timestamp && !createdAt) createdAt = Date.parse(d.timestamp);
+    if (d.type === 'custom-title' && d.title) title = d.title;
+    if (d.isSidechain) continue;
+    if (d.type === 'user') {
+      const content = d.message?.content;
+      // Tool-result-only user messages continue the pending assistant turn;
+      // only a real text message closes it and starts a new turn.
+      const isToolResultOnly = Array.isArray(content) && content.length > 0
+        && content.every((b) => b.type === 'tool_result');
+      if (isToolResultOnly) {
+        for (const b of content) pendingAssistantBlocks?.toolResults.push(b);
+        continue;
+      }
+      if (pendingAssistantBlocks) { flushAssistant(); }
+      const text = typeof content === 'string'
+        ? content
+        : Array.isArray(content)
+          ? content.filter((b) => b.type === 'text').map((b) => b.text).join('\n')
+          : '';
+      if (text.trim() === '') continue;
+      turns.push({ kind: 'user', text, time: Date.parse(d.timestamp) || Date.now() });
+      msgCount += 1;
+    } else if (d.type === 'assistant') {
+      const content = d.message?.content ?? [];
+      if (!Array.isArray(content)) continue;
+      if (!pendingAssistantBlocks) pendingAssistantBlocks = { text: [], toolUses: [], toolResults: [], time: Date.parse(d.timestamp) || Date.now() };
+      else if (pendingAssistantBlocks.toolUses.length > 0 && pendingAssistantBlocks.toolResults.length >= pendingAssistantBlocks.toolUses.length) flushAssistant(),
+        pendingAssistantBlocks = { text: [], toolUses: [], toolResults: [], time: Date.parse(d.timestamp) || Date.now() };
+      for (const b of content) {
+        if (b.type === 'text' && b.text.trim() !== '') pendingAssistantBlocks.text.push(b.text);
+        if (b.type === 'tool_use') pendingAssistantBlocks.toolUses.push(b);
+      }
+      msgCount += 1;
+    }
+  }
+  flushAssistant();
+  return { turns, title, createdAt, cwd, msgCount };
+
+  function flushAssistant() {
+    if (!pendingAssistantBlocks) return;
+    const { text, toolUses, toolResults, time } = pendingAssistantBlocks;
+    if (text.length > 0 || toolUses.length > 0) {
+      turns.push({ kind: 'assistant', text: text.join('\n'), toolUses, toolResults, time });
+    }
+    pendingAssistantBlocks = null;
+  }
+}
+
+/** Build a DSH event log (array of plain events, seq assigned) from parsed turns. */
+export function buildDshEvents(parsed, { limitTurns } = {}) {
+  const events = [];
+  let seq = 0;
+  const t0 = parsed.createdAt ?? Date.now();
+  const push = (type, data, dt = 0) => {
+    events.push({ type, seq, time: t0 + dt, data });
+    seq += 1;
+  };
+  push('permission/preset', { preset: 'workspace-write' });
+  push('sandbox/mode', { mode: 'workspace-write' });
+  push('approval/policy', { policy: 'ask' });
+
+  const turns = Number.isFinite(limitTurns) && limitTurns > 0 ? parsed.turns.slice(-limitTurns * 2) : parsed.turns;
+  let turnNo = 0;
+  let dt = 1000;
+  let turnOpen = false;
+  for (const t of turns) {
+    if (t.kind === 'user') {
+      if (turnOpen) { push('turn/end', { turn: turnNo, reason: { kind: 'completed' } }, dt); dt += 10; }
+      turnNo += 1;
+      turnOpen = true;
+      push('turn/start', { turn: turnNo }, dt); dt += 10;
+      push('step/start', { turn: turnNo, step: 1 }, dt); dt += 10;
+      push('user/message', { content: [{ type: 'text', text: t.text }] }, dt); dt += 50;
+      push('step/end', { turn: turnNo, step: 1 }, dt); dt += 10;
+    } else {
+      // Assistant reply continues the preceding user message's turn
+      // (user path already emitted turn/end? no — we defer turn/end to here).
+      const turn = turnNo;
+      if (turn === 0) { turnNo += 1; push('turn/start', { turn }, dt); dt += 10; }
+      push('step/start', { turn, step: 2 }, dt); dt += 10;
+      const content = [];
+      if (t.text) content.push({ type: 'text', text: t.text });
+      for (const u of t.toolUses) content.push({ type: 'tool_use', id: u.id, name: u.name, input: u.input ?? {} });
+      if (content.length > 0) {
+        push('assistant/message', { turn, step: 2, message: { role: 'assistant', content } }, dt);
+        dt += 50;
+      }
+      let callSeq = 0;
+      for (const r of t.toolResults) {
+        const callId = r.tool_use_id ?? `imported-${turn}-${callSeq}`;
+        const rc = typeof r.content === 'string'
+          ? [{ type: 'text', text: r.content }]
+          : Array.isArray(r.content)
+            ? r.content.map((b) => ({ type: 'text', text: b.type === 'text' ? b.text : JSON.stringify(b) }))
+            : [{ type: 'text', text: String(r.content ?? '') }];
+        push('tool/result', {
+          turn, step: 2,
+          message: {
+            id: `imported-${callId}-${callSeq}`,
+            role: 'user',
+            source: { kind: 'tool', callId },
+            content: [{ type: 'tool-result', toolCallId: callId, isError: Boolean(r.is_error), content: rc }],
+          },
+        }, dt);
+        callSeq += 1;
+        dt += 10;
+      }
+      push('step/end', { turn, step: 2 }, dt); dt += 10;
+    }
+  }
+  if (turnOpen) { push('turn/end', { turn: turnNo, reason: { kind: 'completed' } }, dt); dt += 10; }
+  // Title from first real user text.
+  const firstUser = parsed.turns.find((t) => t.kind === 'user' && !t.text.startsWith('<'));
+  const titleText = parsed.title ?? (firstUser ? firstUser.text.slice(0, 60) : 'claude session');
+  push('session/title', { title: `cc: ${titleText}`, messageSeqs: [], source: { kind: 'user' } });
+  push('session/end-seed', {});
+  return events;
+}
+
+/** Write events as the DSH session log (header + events, zstd-compressed). */
+export function writeDshSession(sessionDir, id, cwd, events) {
+  mkdirSync(sessionDir, { recursive: true });
+  const logPath = join(sessionDir, 'session.jsonl.zstd');
+  rmSync(logPath, { force: true });
+  const header = {
+    type: 'session',
+    version: 0,
+    id,
+    createdAt: events[0]?.time ?? Date.now(),
+    cwd,
+    delegationDepth: 0,
+    agentPreset: 'standard',
+  };
+  const headerLine = JSON.stringify(header) + '\n';
+  const body = events.map((e) => JSON.stringify(e)).join('\n') + (events.length ? '\n' : '');
+  writeFileSync(logPath, zstdFramesSync(headerLine, body));
+  return logPath;
+}
+
+/** List Claude sessions for a cwd. */
+export function listClaudeSessions(cwd, limit = 30) {
+  const dir = claudeProjectDir(cwd);
+  if (!existsSync(dir)) return [];
+  const out = readdirSync(dir)
+    .filter((f) => f.endsWith('.jsonl'))
+    .map((f) => {
+      const id = f.replace(/\.jsonl$/, '');
+      const full = join(dir, f);
+      try {
+        const parsed = parseClaudeSession(full);
+        const st = statSync(full);
+        return {
+          id,
+          path: full,
+          mtime: st.mtimeMs,
+          createdAt: parsed.createdAt,
+          messages: parsed.msgCount,
+          title: parsed.title ?? (parsed.turns.find((t) => t.kind === 'user' && !t.text.startsWith('<'))?.text ?? '').slice(0, 60),
+          turns: parsed.turns.length,
+          imported: existsSync(targetSessionDir(id, cwd)),
+        };
+      } catch { return null; }
+    })
+    .filter(Boolean)
+    .sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0))
+    .slice(0, limit);
+  return out;
+}
+
+// ── CLI (guarded: only when run directly, not imported for tests) ──────────
+
+const invokedDirectly = process.argv[1]?.endsWith('cc-resume.mjs') ?? false;
+if (invokedDirectly) {
+const [cmd, ...rest] = process.argv.slice(2);
+const flag = (name) => {
+  const i = rest.indexOf(`--${name}`);
+  return i >= 0 ? rest[i + 1] : undefined;
+};
+const cwd = flag('cwd') ?? process.cwd();
+
+if (cmd === 'list') {
+  const sessions = listClaudeSessions(cwd, Number(flag('limit') ?? 30));
+  if (sessions.length === 0) {
+    console.log(`No Claude sessions found for ${cwd} (looked in ${claudeProjectDir(cwd)})`);
+    process.exit(0);
+  }
+  for (const s of sessions) {
+    const date = s.createdAt ? new Date(s.createdAt).toISOString().slice(0, 16).replace('T', ' ') : '?';
+    console.log(`${s.imported ? '*' : ' '} ${s.id}  ${date}  ${String(s.messages).padStart(4)}msg  ${s.title || '(no text)'}`);
+  }
+  console.log(`\nImport with: node cc-resume.mjs import <sessionId> --cwd ${cwd}`);
+} else if (cmd === 'import') {
+  const sessionId = rest.find((a) => !a.startsWith('--'));
+  if (!sessionId) { console.error('usage: import <sessionId> [--cwd dir] [--limit-turns N]'); process.exit(2); }
+  const src = join(claudeProjectDir(cwd), `${sessionId}.jsonl`);
+  if (!existsSync(src)) { console.error(`not found: ${src}`); process.exit(1); }
+  const parsed = parseClaudeSession(src);
+  if (parsed.turns.length === 0) { console.error('session has no importable turns'); process.exit(1); }
+  const events = buildDshEvents(parsed, { limitTurns: Number(flag('limit-turns')) });
+  const id = `session-cc-${sessionId}`;
+  const dir = targetSessionDir(sessionId, cwd);
+  const logPath = writeDshSession(dir, id, cwd, events);
+  console.log(`imported ${parsed.turns.length} turns (${events.length} events) → ${logPath}`);
+  console.log(`session id: ${id}`);
+  console.log('Open it in the DSH session list (refresh the GUI), or: dsh --profile web --resume ' + id);
+} else {
+  console.error('usage: cc-resume.mjs list|import [<sessionId>] [--cwd dir] [--limit N] [--limit-turns N]');
+  process.exit(2);
+}
+}

package/scripts/zstd-compat.mjs

@@ -0,0 +1,19 @@
+// zstd-compat.mjs — compress strings with the `zstd` binary via stdin.
+// (macOS: `brew install zstd`; most Linux CI images and the DSH runtime
+// environment already ship it — DSH itself shell-outs to zstd for its own
+// session logs.)
+import { execFileSync } from 'node:child_process';
+
+export function zstdSync(text) {
+  return execFileSync('zstd', ['-3', '-T0', '-q', '-'], {
+    input: text,
+    maxBuffer: 1 << 28,
+    stdio: ['pipe', 'pipe', 'inherit'],
+  });
+}
+
+// DSH session logs require the first zstd frame to hold exactly the header
+// line (assertZstdHeaderFrame); events must be in separate frames.
+export function zstdFramesSync(...texts) {
+  return Buffer.concat(texts.map((t) => zstdSync(t)));
+}

package/src/cc-resume-skill.mjs

@@ -0,0 +1,35 @@
+// Skill body for /cc-resume — instructs the model to drive scripts/cc-resume.mjs.
+export const CC_RESUME_SKILL_BODY = `# Claude Code Session Resume
+
+List and import Claude Code conversation sessions into DSH. Imported sessions
+appear in the DSH session list (refresh the GUI) with full user/assistant/tool
+history and can be resumed like any native session.
+
+## Commands
+Run from the session's working directory (or pass \`--cwd <dir>\`):
+
+1. **List** Claude sessions for the current project:
+   \`\`\`bash
+   node <plugin-root>/scripts/cc-resume.mjs list --limit 20
+   \`\`\`
+   Output: one line per session — imported marker (\`*\`), id, date, message
+   count, first-user-text preview. Pick the \`sessionId\` the user wants.
+
+2. **Import** a session:
+   \`\`\`bash
+   node <plugin-root>/scripts/cc-resume.mjs import <sessionId>
+   \`\`\`
+   Options: \`--limit-turns N\` imports only the last N turns (useful for huge
+   sessions), \`--cwd <dir>\` overrides the project directory.
+
+3. Tell the user: refresh the DSH GUI session list and open the session titled
+   \`cc: <preview>\`, or the imported id can be resumed directly.
+
+## Behavior notes
+- Imports are main-thread only (Claude sidechain/subagent messages skipped).
+- Thinking blocks are dropped (DSH reasoning is stream-based; replaying
+  reconstructed reasoning would corrupt the log).
+- Re-importing the same session is idempotent (same target, events rewritten).
+- The imported conversation is static history — continuing it starts a fresh
+  DSH turn flow on top of that context.
+- Requires the \`zstd\` binary on PATH (macOS: \`brew install zstd\`).`;

package/src/index.js

@@ -175,6 +175,10 @@ class ClaudeCompatSkillProvider {
         'Hot-reload the skill catalog: pick up newly installed/removed Claude Code plugin skills without a new session.'));
       candidates.push(this.reloadSkillDef('reload-skills',
         'Hot-reload the skill catalog (alias of /reload-cc-plugins).'));
+      candidates.push(this.managerSkillCandidate('cc-resume',
+        'List and import Claude Code sessions into DSH: browse ~/.claude/projects history and resume any conversation.',
+        'User wants to resume, list, or import a Claude Code conversation/session into DSH. Usage: /cc-resume list, /cc-resume import <sessionId>.',
+        (await import('./cc-resume-skill.mjs')).CC_RESUME_SKILL_BODY));
     }
     if (this.config.enablePlugins !== false) {
       const pluginCandidates = await discoverPluginContent(