dsh-plugin-pack 1.0.10 → 1.0.12

package/client.js

@@ -103,6 +103,9 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
     'import.restoreData': '还原数据目录',
     'import.link': '建立 node_modules 链接',
     'import.done': '导入完成',
+    'import.written': '已写入磁盘',
+    'import.whyNotListed':
+      '文件、依赖和配置都已经写到 profile 里了。「已安装」列表是 dsh 启动时读取的，重启后新插件才会出现在那里 —— 现在没显示不代表没装上。',
     'import.restart': '重启 dsh 后生效',
     'import.empty': '先选一个 zip 文件',
     'import.source.bundle': '整合包',
@@ -286,6 +289,9 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
     'import.restoreData': 'Restore data dirs',
     'import.link': 'Link node_modules',
     'import.done': 'Import finished',
+    'import.written': 'Written to disk',
+    'import.whyNotListed':
+      'Files, dependencies and config are already written into the profile. The "Installed" list is read by dsh at startup, so new plugins appear there only after a restart — not showing now does not mean it failed.',
     'import.restart': 'Restart dsh to apply',
     'import.empty': 'Choose a zip first',
     'import.source.bundle': 'Bundle',
@@ -2626,8 +2632,14 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
                 { kind: 'ok' },
                 importResult.dryRun
                   ? `${t('import.dry')} · ${importResult.plugins?.length ?? 0} ${t('plugins')}`
-                  : `${t('import.done')} · ${t('import.restart')}`,
+                  : `${t('import.written')} · ${importResult.plugins?.length ?? 0} ${t('plugins')} · ${t('import.restart')}`,
               ),
+              /* 说清楚为什么"已安装"列表里还看不到：
+               * 那个列表是 dsh 启动时读 profile 生成的，运行中不会自己刷新。
+               * 文件现在确实已经在磁盘上了 —— 不说明这点用户会以为装失败。 */
+              !importResult.dryRun
+                ? h('div', { className: 'pp-hint', style: { margin: '6px 0 0' } }, t('import.whyNotListed'))
+                : null,
               importResult.plugins?.length
                 ? h(
                     'table',

package/lib/import-plugin.js

@@ -16,7 +16,7 @@ import path from 'node:path';
 import { readJson, writeJson, readText, writeText, ensureDir, isDir, isFile, copyTree, removeTree } from './util.js';
 import { packSegment, stamp, humanBytes } from './home.js';
 import { existingIds, rowId, splitTopLevel, splitInsertChildren, entryMatchesPlugin, appendInsertBlock } from './patch-text.js';
-import { resolveEntry, isAbsoluteSpec } from './scan.js';
+import { resolveEntry, isAbsoluteSpec, clearScanCache } from './scan.js';
 
 /** 从一个目录读出插件身份，判断它能不能装。 */
 export function describeLocalPlugin(dir) {
@@ -33,15 +33,20 @@ export function describeLocalPlugin(dir) {
     throw error;
   }
   const entry = resolveEntry(target, meta);
-  const patchRel = typeof meta?.dsh?.bundle?.patch === 'string' ? meta.dsh.bundle.patch : null;
+  // dsh.bundle.patch 可能是字符串或数组（一个插件可声明多个 patch 文件）
+  const patchSpec = meta?.dsh?.bundle?.patch;
+  const patchRels = (Array.isArray(patchSpec) ? patchSpec : [patchSpec]).filter(
+    (rel) => typeof rel === 'string' && rel.trim(),
+  );
   return {
     dir: target,
     name: meta.name.trim(),
     version: meta.version ?? '0.0.0',
     description: typeof meta.description === 'string' ? meta.description : '',
     entry,
-    hasPatch: patchRel ? isFile(path.join(target, patchRel)) : false,
-    patchRel,
+    hasPatch: patchRels.some((rel) => isFile(path.join(target, rel))),
+    patchRel: patchRels[0] ?? null,
+    patchRels,
     client: meta.dsh?.client ?? null,
     deps: Object.keys(meta.dependencies ?? {}).filter((dep) => !dep.startsWith('@deepseek-ai/')),
   };
@@ -96,7 +101,11 @@ export function importLocalPlugin(options = {}) {
   const insertRows = [];
   const skippedRows = [];
   if (info.hasPatch) {
-    const ownPatch = readText(path.join(info.dir, info.patchRel), '') ?? '';
+    // 多 patch 文件的插件要把每一份都读进来合并，只读第一个会丢配置
+    const ownPatch = (info.patchRels ?? [info.patchRel])
+      .filter(Boolean)
+      .map((rel) => readText(path.join(info.dir, rel), '') ?? '')
+      .join('\n');
     const target = { name: info.name, dirs: [info.dir] };
     for (const entry of splitTopLevel(ownPatch)) {
       if (entry.kind === 'insert') {
@@ -238,6 +247,8 @@ export function importLocalPlugin(options = {}) {
 
   record.links = link ? [link] : [];
   writeJson(path.join(backupRoot, 'record.json'), record);
+  // 装完必须让扫描缓存失效，否则界面还按旧结果报"未安装"
+  clearScanCache();
 
   return {
     ok: true,

package/lib/index.js

@@ -462,7 +462,25 @@ export function apply(ctx, config = {}) {
   try {
     mountRoutes(ctx, cfg);
   } catch (error) {
-    console.warn('[dsh-plugin-pack] 路由挂载失败:', String(error?.message ?? error));
+    console.warn('[dsh-plugin-pack] 路由挂载失败:', String(error?.message || error));
+  }
+
+  /* 启动后台预热扫描缓存。
+   *
+   * 一次完整扫描要遍历上万文件（每个 stat 一次），冷启动要好几秒。
+   * 用户点开插件页时如果正好没缓存，就得干等 —— 这就是"加载插件时间很长"。
+   * 启动后延迟几秒（避开 dsh 自己的启动高峰）在后台扫一次，
+   * 之后界面打开直接命中缓存，毫秒级返回。
+   *
+   * 失败不阻断启动：最坏情况就是第一次打开慢一点。 */
+  try {
+    const warm = setTimeout(() => {
+      scanProfile({}).catch(() => {});
+    }, 5000);
+    warm.unref?.();
+    ctx.effect?.(() => () => clearTimeout(warm), 'dsh-plugin-pack: warm scan cache');
+  } catch {
+    /* 没有 effect 上下文时跳过 */
   }
 
   const commands = ctx.get?.('commands');

package/lib/scan.js

@@ -27,13 +27,73 @@ const OFFICIAL_PREFIX = '@deepseek-ai/';
  * @type {Map<string, { at: number, value: object, pkgMtime: number, patchMtime: number }>}
  */
 const scanCache = new Map();
-const SCAN_TTL_MS = 60 * 1000;
+/**
+ * 缓存有效期。
+ *
+ * 5 分钟：失效主要靠 mtime 判断（配置或插件目录一变就重扫），
+ * TTL 只是兜底防止极端情况下永远不刷新。这样界面打开是毫秒级，
+ * 装完插件下一轮也会立刻看到新状态。
+ */
+const SCAN_TTL_MS = 5 * 60 * 1000;
+
+/**
+ * 单个插件目录的体积缓存（key = 目录真实路径）。
+ *
+ * 整个扫描里最贵的是 measureTree：dsh-ops 那种上万文件的插件，
+ * 光 stat 就要一两秒。但插件没装没删的时候体积不会变，
+ * 按目录 mtime 缓存一下，重复扫描就从"秒级"掉到"毫秒级"。
+ *
+ * 注意：目录 mtime 只在增删直接子项时变化，深处文件被改写不会变。
+ * 所以导出（要精确体积）走 fresh=true 全量测量，只有界面展示用缓存。
+ *
+ * @type {Map<string, { mtimeMs: number, bytes: number, files: number }>}
+ */
+const sizeCache = new Map();
 
-/** 清空缓存（导入/导出/回滚后调用，保证下次读到新的体积）。 */
+/**
+ * 让扫描结果缓存失效（导入/导出/回滚后调用）。
+ *
+ * 只清「扫描结果」，不清「体积缓存」—— 体积缓存是按目录 mtime 自校验的：
+ * 刚装的那个插件目录 mtime 变了，下次自动重算；没动过的插件继续命中，
+ * 这样装完插件后的刷新仍然是快的（不用把上万个文件重新 stat 一遍）。
+ */
 export function clearScanCache() {
   scanCache.clear();
 }
 
+/** 彻底清掉体积缓存（测试用；正式流程不必调，它自己会按 mtime 失效）。 */
+export function clearSizeCache() {
+  sizeCache.clear();
+}
+
+/**
+ * 带缓存版本的 measureTree。
+ *
+ * 目录 mtime 没变就直接用上次的结果，避免重复遍历上万个文件。
+ * 缓存的是"某个目录的总字节/文件数"，与调用方传的 skipDirs 无关 ——
+ * 所以只缓存参数固定的那几处调用（主目录、依赖、数据目录各自独立 key 前缀）。
+ *
+ * @param {string} root
+ * @param {object} options
+ * @param {string} variant 区分不同过滤参数（'main' / 'dep' / 'data'）
+ */
+async function measureCached(root, options, variant) {
+  const key = `${variant}\0${root}`;
+  const mtimeMs = (() => {
+    try {
+      return fs.statSync(root).mtimeMs;
+    } catch {
+      return -1;
+    }
+  })();
+  const hit = sizeCache.get(key);
+  if (hit && hit.mtimeMs === mtimeMs && mtimeMs !== -1) return { bytes: hit.bytes, files: hit.files };
+
+  const measured = await measureTreeAsync(root, options);
+  if (mtimeMs !== -1) sizeCache.set(key, { mtimeMs, bytes: measured.bytes, files: measured.files });
+  return measured;
+}
+
 /** 这些包永远由宿主提供，即便出现在 dependencies 里也不打包。 */
 const HOST_PROVIDED = new Set([
   'react',
@@ -78,20 +138,38 @@ export async function scanProfile(options = {}) {
 
   const pkgFile = path.join(dir, 'package.json');
   const patchFile = path.join(dir, 'cordis.patch.yml');
-
-  /* 缓存：一次完整扫描要 3 秒（dsh-ops 9920 个文件、lark-plus 1033 个，
-   * 每个都要 stat）。界面一打开就调 status，等于每次干等 3 秒。
-   * 缓存 60 秒，且配置文件 mtime 一变就失效。 */
+  const localPluginsDir = path.join(dir, 'local-plugins');
+  const nodeModulesDir = path.join(dir, 'node_modules');
+
+  /* 缓存：一次完整扫描要好几秒（dsh-ops 上万文件，每个都要 stat）。
+   * 界面一打开就调 status，等于每次干等。
+   *
+   * 失效条件（任一）：
+   *   - 超过 TTL
+   *   - package.json / cordis.patch.yml 变了
+   *   - local-plugins 或 node_modules 目录 mtime 变了
+   *     ← 这一条很关键：装完插件如果只往 local-plugins 放了目录、
+   *       而 package.json 因为某些原因没变，旧缓存会让界面显示"未安装"。
+   */
   const cacheKey = [dir, includeSecrets ? 's' : '', includeData ? 'd' : '', (options.include ?? []).join('|'), (options.exclude ?? []).join('|')].join('\0');
+
+  /** 读一个路径的 mtimeMs（不存在返回 -1），用于判断缓存是否还新鲜。 */
+  const mtimeOf = (target) => {
+    try {
+      return fs.statSync(target).mtimeMs;
+    } catch {
+      return -1;
+    }
+  };
+
   if (!options.fresh) {
     const cached = scanCache.get(cacheKey);
     if (cached && Date.now() - cached.at < SCAN_TTL_MS) {
-      let stampOk = false;
-      try {
-        stampOk = fs.statSync(pkgFile).mtimeMs === cached.pkgMtime && fs.statSync(patchFile).mtimeMs === cached.patchMtime;
-      } catch {
-        stampOk = false;
-      }
+      const stampOk =
+        mtimeOf(pkgFile) === cached.pkgMtime &&
+        mtimeOf(patchFile) === cached.patchMtime &&
+        mtimeOf(localPluginsDir) === cached.localMtime &&
+        mtimeOf(nodeModulesDir) === cached.modulesMtime;
       if (stampOk) return cached.value;
     }
   }
@@ -99,6 +177,14 @@ export async function scanProfile(options = {}) {
   const pkg = readJson(pkgFile, null);
   if (!pkg) warnings.push(`没有找到 profile 的 package.json: ${pkgFile}`);
 
+  /**
+   * 正式路径用的体积测量。
+   *   fresh=true  → 全量重算（导出要精确数字）
+   *   否则        → 命中目录 mtime 缓存（界面展示要快）
+   */
+  const effectiveMeasure = async (root, opts, variant = 'x') =>
+    options.fresh ? measureTreeAsync(root, opts) : measureCached(root, opts, variant);
+
   const bundles = Array.isArray(pkg?.dsh?.profile?.bundles) ? [...pkg.dsh.profile.bundles] : [];
   const dependencies = pkg?.dependencies && typeof pkg.dependencies === 'object' ? { ...pkg.dependencies } : {};
 
@@ -154,8 +240,7 @@ export async function scanProfile(options = {}) {
     addCandidate({ dir: resolved, declaredName: depName, link: spec, inBundles: false, source: 'dependencies' });
   }
 
-  // 3) local-plugins 下手工放的
-  const localPluginsDir = path.join(dir, 'local-plugins');
+  // 3) local-plugins 下手工放的（目录变量在上面缓存校验时已声明）
   if (isDir(localPluginsDir)) {
     for (const entry of fs.readdirSync(localPluginsDir, { withFileTypes: true })) {
       if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
@@ -182,7 +267,8 @@ export async function scanProfile(options = {}) {
       includeSecrets,
       includeData,
       warnings,
-      measure: options.measure,
+      // 测试可注入自定义 measure；正式路径用带缓存的版本
+      measure: options.measure ?? effectiveMeasure,
     });
     if (!plugin) continue;
     // dependencies 来源可能是纯工具库：既不是 dsh-* 命名，也没有 dsh 字段，
@@ -245,13 +331,15 @@ export async function scanProfile(options = {}) {
     warnings,
   };
 
-  // 写入缓存（记下两份配置的 mtime，之后据此判断失效）
+  // 写入缓存（记下配置与插件目录的 mtime，之后据此判断失效）
   try {
     scanCache.set(cacheKey, {
       at: Date.now(),
       value: result,
-      pkgMtime: fs.statSync(pkgFile).mtimeMs,
-      patchMtime: fs.statSync(patchFile).mtimeMs,
+      pkgMtime: mtimeOf(pkgFile),
+      patchMtime: mtimeOf(patchFile),
+      localMtime: mtimeOf(localPluginsDir),
+      modulesMtime: mtimeOf(nodeModulesDir),
     });
   } catch {
     /* 缓存可有可无 */
@@ -355,10 +443,14 @@ async function collectDepsAsync(rootDir, meta, { profileDir, includeSecrets, war
       if (seen.has(depDir)) continue;
       seen.add(depDir);
       const depMeta = readJson(path.join(depDir, 'package.json'), {});
-      const size = await measure(depDir, {
-        skipDirs: new Set([...SKIP_DIRS, 'node_modules']),
-        keepFile,
-      });
+      const size = await measure(
+        depDir,
+        {
+          skipDirs: new Set([...SKIP_DIRS, 'node_modules']),
+          keepFile,
+        },
+        'dep',
+      );
       const record = {
         name: depName,
         version: depMeta.version ?? '0.0.0',
@@ -438,10 +530,14 @@ async function buildPlugin(item, { profileDir, dshHome, topEntries, includeSecre
   }
 
   const skipFileKeep = fileFilter({ includeSecrets });
-  const mainSize = await measure(item.dir, {
-    skipDirs: new Set([...SKIP_DIRS, 'node_modules']),
-    keepFile: skipFileKeep,
-  });
+  const mainSize = await measure(
+    item.dir,
+    {
+      skipDirs: new Set([...SKIP_DIRS, 'node_modules']),
+      keepFile: skipFileKeep,
+    },
+    'main',
+  );
   const deps = await collectDepsAsync(item.dir, meta, { profileDir, includeSecrets, warnings: pluginWarnings, measure });
 
   const patchInfo = matchPatchRows(topEntries, { name, dir: item.dir });
@@ -450,7 +546,7 @@ async function buildPlugin(item, { profileDir, dshHome, topEntries, includeSecre
   const dataDirs = [];
   if (includeData) {
     for (const candidate of dataCandidates) {
-      const size = await measure(candidate.path, { skipDirs: SKIP_DIRS, keepFile: skipFileKeep });
+      const size = await measure(candidate.path, { skipDirs: SKIP_DIRS, keepFile: skipFileKeep }, 'data');
       dataDirs.push({ ...candidate, bytes: size.bytes, files: size.files });
     }
   }
@@ -461,6 +557,17 @@ async function buildPlugin(item, { profileDir, dshHome, topEntries, includeSecre
   if (!entry && meta) pluginWarnings.push('找不到入口文件，导入后可能加载失败');
   if (pluginWarnings.length) warnings.push(...pluginWarnings.map((text) => `${name}: ${text}`));
 
+  /**
+   * `dsh.bundle.patch` 可能是字符串，也可能是数组
+   * （一个插件声明多个 patch 文件，实测 dsh-agentic-pet 就是数组）。
+   * 早先只当字符串处理，遇到数组会让 path.join 抛
+   * ERR_INVALID_ARG_TYPE: The "path" argument must be of type string。
+   */
+  const patchSpec = meta?.dsh?.bundle?.patch;
+  const patchRels = (Array.isArray(patchSpec) ? patchSpec : [patchSpec]).filter(
+    (rel) => typeof rel === 'string' && rel.trim(),
+  );
+
   return {
     name,
     version: meta?.version ?? '0.0.0',
@@ -472,8 +579,10 @@ async function buildPlugin(item, { profileDir, dshHome, topEntries, includeSecre
     inBundles: item.inBundles,
     bundleIndex: item.bundleIndex,
     sources: [...item.sources],
-    hasPatch: Boolean(meta?.dsh?.bundle?.patch) && isFile(path.join(item.dir, meta.dsh.bundle.patch)),
-    patchRel: typeof meta?.dsh?.bundle?.patch === 'string' ? meta.dsh.bundle.patch : null,
+    hasPatch: patchRels.some((rel) => isFile(path.join(item.dir, rel))),
+    // 主 patch 路径（多文件时取第一个，其余在 patchRels 里）
+    patchRel: patchRels[0] ?? null,
+    patchRels,
     client: meta?.dsh?.client ?? null,
     entry,
     deps,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-pack",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "DeepSeek Harness 插件整合包：一键把当前 profile 的第三方插件连依赖和配置导出成 zip（内部每个插件是标准 npm tgz），换机/换 profile 拖进去就能还原。",
   "type": "module",
   "main": "lib/index.js",