dsh-plugin-pack 1.0.9 → 1.0.11

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/fetch-bundle.js

@@ -417,8 +417,9 @@ export async function fetchBundleFrom({ source, home, onProgress = () => {} }) {
   report(`下载完成：${(data.length / 1048576).toFixed(1)} MiB`);
 
   // 落到 inbox（保留扩展名，后续按 .zip/.tgz 分流）
+  // origin='network'：安装成功后可以自动删掉这份副本，不占用户磁盘
   pruneSafe(home);
-  const saved = saveIncomingZip({ home, filename: name, data });
+  const saved = saveIncomingZip({ home, filename: name, data, origin: 'network' });
   report(`已保存到 ${saved.file}`);
 
   /* 校验阶段分两种：

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) {
@@ -238,6 +238,8 @@ export function importLocalPlugin(options = {}) {
 
   record.links = link ? [link] : [];
   writeJson(path.join(backupRoot, 'record.json'), record);
+  // 装完必须让扫描缓存失效，否则界面还按旧结果报"未安装"
+  clearScanCache();
 
   return {
     ok: true,

package/lib/inbox.js

@@ -20,6 +20,32 @@ import { ensureDir, removeTree } from './util.js';
 /** 单次落盘上限（默认 1 GiB，够大包也够防呆）。 */
 const MAX_BYTES = 1024 * 1024 * 1024;
 
+/** 记录这份 inbox 副本来源的标记文件名。 */
+const ORIGIN_MARK = '.origin';
+
+/**
+ * 在 root 下建一个唯一的子目录：`<时间戳>-<4位随机>`。
+ *
+ * stamp() 只到秒，同一秒内多次落盘会撞名；加随机后缀既保持可读
+ * （按时间排序仍然有效），又能避免互相覆盖。
+ *
+ * @param {string} root
+ * @returns {string} 已创建的目录绝对路径
+ */
+function uniqueDir(root) {
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const suffix = Math.random().toString(16).slice(2, 6).padEnd(4, '0');
+    const dir = path.join(root, `${stamp()}-${suffix}`);
+    if (fs.existsSync(dir)) continue;
+    ensureDir(dir);
+    return dir;
+  }
+  // 极端情况下兜底：用纳秒精度的时间戳
+  const dir = path.join(root, `${stamp()}-${Date.now() % 100000}`);
+  ensureDir(dir);
+  return dir;
+}
+
 /**
  * 从 multipart/form-data 里解析出文件条目。
  *
@@ -27,8 +53,7 @@ const MAX_BYTES = 1024 * 1024 * 1024;
  * 不引第三方库。
  *
  * @param {Buffer} body 整个请求体
- * @param {string} boundary boundary 字符串（不含前置 --）
- * @returns {Array<{ name: string, filename: string|null, data: Buffer }>}
+ * @param {string} boundary boundary 字符串（不含前置 --） * @returns {Array<{ name: string, filename: string|null, data: Buffer }>}
  */
 export function parseMultipart(body, boundary) {
   const delimiter = Buffer.from(`--${boundary}`);
@@ -87,9 +112,12 @@ export function boundaryOf(contentType) {
  * @param {string} options.home $DSH_HOME
  * @param {string} options.filename 原始文件名
  * @param {Buffer} options.data 内容
+ * @param {'upload'|'network'} [options.origin]
+ *   来源。`network` = 从 GitHub/npm 下载来的，装完可以自动删；
+ *   `upload` = 用户从本地拖/选的，装完要留着（用户自己的文件）。
  * @returns {{ file: string, bytes: number }}
  */
-export function saveIncomingZip({ home, filename, data }) {
+export function saveIncomingZip({ home, filename, data, origin = 'upload' }) {
   if (!data?.length) {
     const error = new Error('上传内容为空');
     error.code = 'BAD_UPLOAD';
@@ -101,8 +129,16 @@ export function saveIncomingZip({ home, filename, data }) {
     throw error;
   }
   const base = safeName(String(filename ?? '').trim() || `bundle-${stamp()}.zip`);
-  const dir = path.join(home, 'plugin-pack', 'inbox', stamp());
-  ensureDir(dir);
+  /* 目录名要唯一：stamp() 只到秒，同一秒内连拖两个包会落到同一个目录，
+   * 后一个会覆盖前一个的 .origin 标记（甚至同名时覆盖文件本身）。
+   * 加个短随机后缀避开。 */
+  const dir = uniqueDir(path.join(home, 'plugin-pack', 'inbox'));
+  // 记下来源：安装成功后据此决定要不要删掉这份落盘副本
+  try {
+    fs.writeFileSync(path.join(dir, ORIGIN_MARK), origin === 'network' ? 'network' : 'upload');
+  } catch {
+    /* 标记写不进去不影响导入 */
+  }
   // 保留原始扩展名：.zip = 整合包，.tgz/.tar.gz = 单个插件的 npm tarball
   const lower = base.toLowerCase();
   const hasKnownExt = lower.endsWith('.zip') || lower.endsWith('.tgz') || lower.endsWith('.tar.gz');
@@ -192,3 +228,47 @@ export function pruneInbox(home, days = 7) {
   }
   return removed;
 }
+
+/**
+ * 读这份 inbox 副本的来源。
+ *
+ * @param {string} file inbox 里的文件绝对路径
+ * @returns {'upload'|'network'|null} 读不到标记时返回 null（老版本落盘的文件）
+ */
+export function inboxOrigin(file) {
+  try {
+    const mark = path.join(path.dirname(String(file)), ORIGIN_MARK);
+    const text = fs.readFileSync(mark, 'utf8').trim();
+    return text === 'network' ? 'network' : 'upload';
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 删掉 inbox 里的一份落盘副本（连它所在的时间戳目录一起删）。
+ *
+ * 只删 inbox 内部的目录：传进来的路径必须在 `<home>/plugin-pack/inbox` 之下，
+ * 否则直接拒绝 —— 免得哪天参数传错把用户自己的文件删了。
+ *
+ * @param {string} home $DSH_HOME
+ * @param {string} file inbox 里的文件路径
+ * @returns {boolean} 是否真的删了
+ */
+export function removeInboxEntry(home, file) {
+  try {
+    const root = path.resolve(home, 'plugin-pack', 'inbox');
+    const target = path.resolve(String(file));
+    // 必须严格在 inbox 之下，且不能就是 inbox 本身
+    if (target === root || !target.startsWith(root + path.sep)) return false;
+    const dir = path.dirname(target);
+    // 目录必须是 inbox 的直接子目录（时间戳目录），不能是更外层
+    if (path.dirname(dir) !== root) return false;
+    // 目录本身要存在，否则不算"删掉了"
+    if (!fs.existsSync(dir)) return false;
+    removeTree(dir);
+    return true;
+  } catch {
+    return false;
+  }
+}

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 });
     }
   }

package/lib/server.js

@@ -28,7 +28,15 @@ import { importBundle, inspectBundle, rollbackImport, listBackups } from './impo
 import { reloadClientPackage, clientStatus, localVerdict } from '../hotload.js';
 import { importLocalPlugin } from './import-plugin.js';
 import { importTarball, isTarball } from './import-tgz.js';
-import { parseMultipart, boundaryOf, saveIncomingZip, saveIncomingDir, pruneInbox } from './inbox.js';
+import {
+  parseMultipart,
+  boundaryOf,
+  saveIncomingZip,
+  saveIncomingDir,
+  pruneInbox,
+  inboxOrigin,
+  removeInboxEntry,
+} from './inbox.js';
 import { runJob, listJobs, getJob, runningJobs, clearFinished, openWaiting, getWaiting, listWaiting, cancelWaiting } from './jobs.js';
 import { fetchBundleFrom, parseSource } from './fetch-bundle.js';
 import { dshHome as resolveDshHome, profileDir as resolveProfileDir, profileName as resolveProfileName, humanBytes } from './home.js';
@@ -80,6 +88,28 @@ function sendJson(response, status, value) {
 }
 
 /** 把异常翻译成 HTTP 状态；其余仍是 500。 */
+/**
+ * 安装成功后清理 inbox 里的落盘副本。
+ *
+ * 只删「从网络下载」的那份；用户自己拖/选的本地文件永远保留 ——
+ * 那是他自己的文件，工具不该动它。
+ *
+ * @param {object} config
+ * @param {string} file 本次导入用的文件路径
+ * @returns {boolean} 是否真的删掉了
+ */
+function autoCleanInbox(config, file) {
+  try {
+    if (!file) return false;
+    const home = contextOf(config).home;
+    // 只有网络下载的来源才删
+    if (inboxOrigin(file) !== 'network') return false;
+    return removeInboxEntry(home, file);
+  } catch {
+    return false;
+  }
+}
+
 function statusOf(error) {
   const explicit = Number(error?.status ?? error?.statusCode);
   if (Number.isFinite(explicit) && explicit >= 400 && explicit < 600) return explicit;
@@ -590,7 +620,9 @@ export function mountRoutes(ctx, config = {}) {
                 meta: { file: body.file },
                 task: (report) => doImport(report),
               });
-              sendJson(response, 200, { ...result, jobId: id });
+              // 网络下载来的 tgz，装完同样清掉副本
+              const cleanedTgz = autoCleanInbox(config, body.file);
+              sendJson(response, 200, { ...result, jobId: id, ...(cleanedTgz ? { inboxCleaned: true } : {}) });
               return;
             }
             const dryRun = Boolean(body.dryRun);
@@ -641,7 +673,11 @@ export function mountRoutes(ctx, config = {}) {
               jobId: body.jobId ? String(body.jobId) : undefined,
               task: (report) => doImportBundle(report),
             });
-            sendJson(response, 200, { ...result, jobId: id });
+            /* 装完清掉网络下载的副本：
+             * 从 GitHub/npm 下下来的包，装好后原件就没用了，留着白占磁盘。
+             * 但用户自己拖/选的本地文件（origin='upload'）一律保留 —— 那是他的东西。 */
+            const cleaned = autoCleanInbox(config, body.file);
+            sendJson(response, 200, { ...result, jobId: id, ...(cleaned ? { inboxCleaned: true } : {}) });
           },
         },
         'plugin-pack: import',

package/package.json

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