dsh-plugin-pack 1.0.14 → 1.0.15

package/client.js

@@ -204,6 +204,9 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
     'backup.rollback': '回滚',
     'backup.rolling': '正在回滚…',
     'backup.done': '回滚完成',
+    'backup.surgicalHint': '只撤销了这次导入加的东西，你之后改的其它配置都保留着。',
+    'backup.fullHint': '这次的备份是老格式，只能整份还原 —— 导入之后改的配置可能被覆盖。',
+    'backup.preSnapshot': '回滚前的配置已另存（想反悔可从这儿取回）：',
     'backup.confirm': '确定要回滚到这份备份吗？本次导入新增的插件会被删掉。',
     'backup.createdAt': '时间',
     'backup.items': '项',
@@ -400,6 +403,9 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
     'backup.rollback': 'Roll back',
     'backup.rolling': 'Rolling back…',
     'backup.done': 'Rollback finished',
+    'backup.surgicalHint': 'Only what this import added was reverted; your later config changes are untouched.',
+    'backup.fullHint': 'This backup is an old format and can only be restored wholesale — config you changed after the import may be overwritten.',
+    'backup.preSnapshot': 'Your config before rollback was saved here (recover from it if needed): ',
     'backup.confirm': 'Roll back to this snapshot? Plugins added by that import will be removed.',
     'backup.createdAt': 'Time',
     'backup.items': 'items',
@@ -2982,9 +2988,25 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
                 'div',
                 null,
                 h(Alert, { kind: 'ok' }, `${t('backup.done')} · ${t('import.restart')}`),
+                h(
+                  'div',
+                  { className: 'pp-hint', style: { marginTop: 6 } },
+                  rollbackResult.mode === 'surgical'
+                    ? t('backup.surgicalHint')
+                    : t('backup.fullHint'),
+                ),
                 rollbackResult.restored?.length
                   ? h('div', { className: 'pp-note' }, `恢复: ${rollbackResult.restored.join(', ')}`)
                   : null,
+                // 回滚前把当时配置另存了一份，路径给出来方便反悔
+                rollbackResult.preRollbackDir
+                  ? h(
+                      'div',
+                      { className: 'pp-hint', style: { marginTop: 6 } },
+                      t('backup.preSnapshot'),
+                      h('code', { className: 'pp-mono', style: { fontSize: 11, wordBreak: 'break-all' } }, rollbackResult.preRollbackDir),
+                    )
+                  : null,
               )
           : null,
       ),

package/lib/import.js

@@ -447,6 +447,11 @@ export function importBundle(options = {}) {
   pkg.dsh = pkg.dsh && typeof pkg.dsh === 'object' ? pkg.dsh : {};
   pkg.dsh.profile = pkg.dsh.profile && typeof pkg.dsh.profile === 'object' ? pkg.dsh.profile : {};
   pkg.dsh.profile.bundles = Array.isArray(pkg.dsh.profile.bundles) ? pkg.dsh.profile.bundles : [];
+  /* 改写前先记下"每个被碰过的字段原来是什么"。
+   * 回滚时只把这几个字段还原，不动用户后来改的其它配置 ——
+   * 早先回滚是整份覆盖，会把导入之后设的 API 密钥之类一起抹掉。 */
+  const depsBefore = { ...pkg.dependencies };
+  const bundlesBefore = [...pkg.dsh.profile.bundles];
   /* enable=false：只把文件装上、依赖写好，但不进 dsh.profile.bundles
    * —— 也就是"装好了但先不启用"。用户之后可以在界面上再打开。
    * files 与依赖照常写，所以不启用不等于没装。 */
@@ -460,13 +465,30 @@ export function importBundle(options = {}) {
   }
   writeJson(pkgFile, pkg);
 
+  // 记录：哪些依赖被改（含改前值）、哪些 bundle 是新加的
+  record.pkgDepsBefore = {};
+  for (const item of plan) {
+    if (item.action === 'skip' || item.pathPlugin) continue;
+    const had = Object.prototype.hasOwnProperty.call(depsBefore, item.name);
+    record.pkgDepsBefore[item.name] = {
+      before: had ? depsBefore[item.name] : null,
+      after: `link:./local-plugins/${item.segment}`,
+    };
+  }
+  record.pkgBundlesAdded = pkg.dsh.profile.bundles.filter((name) => !bundlesBefore.includes(name));
+
   // cordis.patch.yml
   let nextPatch = patchText;
   if (patchPlan.topRows.length) nextPatch = appendTopRows(nextPatch, patchPlan.topRows, `plugin-pack ${stampText}`);
   if (patchPlan.insertRows.length) {
     nextPatch = appendInsertBlock(nextPatch, dedentRows(patchPlan.insertRows), `plugin-pack ${stampText}`).text;
   }
-  if (nextPatch !== patchText) writeText(patchFile, nextPatch);
+  if (nextPatch !== patchText) {
+    writeText(patchFile, nextPatch);
+    /* 记下这次"追加的那一段原文"。回滚时只把这几个字串摘掉，
+     * 保留用户后来在同一个文件里做的其它修改。 */
+    record.patchAppended = nextPatch.startsWith(patchText) ? nextPatch.slice(patchText.length) : null;
+  }
 
   // node_modules 链接
   onProgress('建立 node_modules 链接', 92);
@@ -701,15 +723,77 @@ export function rollbackImport(options = {}) {
   const removed = [];
   const relinked = [];
 
-  const backupPkg = path.join(backupRoot, 'package.json');
-  const backupPatch = path.join(backupRoot, 'cordis.patch.yml');
-  if (isFile(backupPkg)) {
-    fs.copyFileSync(backupPkg, path.join(profile, 'package.json'));
-    restored.push('package.json');
+  const pkgFile = path.join(profile, 'package.json');
+  const patchFile = path.join(profile, 'cordis.patch.yml');
+
+  /* 第一步：先把**当前**的配置文件另存一份。
+   *
+   * 回滚会改 package.json / cordis.patch.yml，早先直接整份覆盖，
+   * 用户在这之后设的 API 密钥、改过的 provider 全没了且找不回来。
+   * 现在无论走精准回滚还是整份还原，都先留一份可反悔的副本。 */
+  const preRollbackDir = path.join(backupRoot, `pre-rollback-${stamp()}`);
+  let preRollbackFiles = [];
+  try {
+    ensureDir(preRollbackDir);
+    for (const [src, name] of [
+      [pkgFile, 'package.json'],
+      [patchFile, 'cordis.patch.yml'],
+    ]) {
+      if (isFile(src)) {
+        fs.copyFileSync(src, path.join(preRollbackDir, name));
+        preRollbackFiles.push(name);
+      }
+    }
+  } catch {
+    /* 存不了也继续，不阻断回滚 */
+  }
+
+  /* 第二步：优先精准回滚 —— 只撤销这次导入加的东西，保留用户后续改动。
+   * 老备份没有这些字段，才退回整份还原（那种情况确实是快照替换）。 */
+  let mode = 'full';
+
+  if (record.pkgDepsBefore || Array.isArray(record.pkgBundlesAdded)) {
+    mode = 'surgical';
+    const pkg = readJson(pkgFile, null);
+    if (pkg && typeof pkg === 'object') {
+      pkg.dependencies = pkg.dependencies && typeof pkg.dependencies === 'object' ? pkg.dependencies : {};
+      // 依赖：只在"当前值还是我们写进去的那个"时才还原，避免覆盖用户后来的改动
+      for (const [name, info] of Object.entries(record.pkgDepsBefore ?? {})) {
+        if (pkg.dependencies[name] !== info.after) continue;
+        if (info.before === null) delete pkg.dependencies[name];
+        else pkg.dependencies[name] = info.before;
+      }
+      // bundles：只移除这次加的，且现在还在的
+      const addedSet = new Set(record.pkgBundlesAdded ?? []);
+      if (Array.isArray(pkg.dsh?.profile?.bundles)) {
+        pkg.dsh.profile.bundles = pkg.dsh.profile.bundles.filter((name) => !addedSet.has(name));
+      }
+      writeJson(pkgFile, pkg);
+      restored.push('package.json（仅撤销本次导入的依赖与 bundles）');
+    }
+  }
+
+  if (typeof record.patchAppended === 'string') {
+    mode = mode === 'surgical' ? 'surgical' : 'surgical';
+    const currentPatch = readText(patchFile, null);
+    if (typeof currentPatch === 'string' && record.patchAppended && currentPatch.includes(record.patchAppended)) {
+      // 只摘掉当初追加的那一段，其它内容（含用户后加的）原样保留
+      const nextText = currentPatch.replace(record.patchAppended, '');
+      writeText(patchFile, nextText);
+      restored.push('cordis.patch.yml（仅移除本次导入追加的行）');
+    }
+  }
+
+  // 精准回滚没覆盖到的老备份，才退回整份还原
+  const pkgHandled = restored.some((item) => item.startsWith('package.json'));
+  const patchHandled = restored.some((item) => item.startsWith('cordis.patch.yml'));
+  if (!pkgHandled && isFile(path.join(backupRoot, 'package.json'))) {
+    fs.copyFileSync(path.join(backupRoot, 'package.json'), pkgFile);
+    restored.push('package.json（整份还原：老备份没有精准记录）');
   }
-  if (isFile(backupPatch)) {
-    fs.copyFileSync(backupPatch, path.join(profile, 'cordis.patch.yml'));
-    restored.push('cordis.patch.yml');
+  if (!patchHandled && isFile(path.join(backupRoot, 'cordis.patch.yml'))) {
+    fs.copyFileSync(path.join(backupRoot, 'cordis.patch.yml'), patchFile);
+    restored.push('cordis.patch.yml（整份还原：老备份没有精准记录）');
   }
 
   for (const dest of record.addedDirs ?? []) {
@@ -748,32 +832,33 @@ export function rollbackImport(options = {}) {
     removed.push(file);
   }
 
-  // 标记该备份已消费：重命名加 .done，之后「最新备份」指向更早的、还没回滚过的那次。
+  // 回滚改了配置和插件目录，扫描缓存必须失效
+  // （早先这行写在 return 之后，成功路径根本执行不到）
+  clearScanCache();
+
+  /* 标记该备份已消费：重命名加 .done，之后「最新备份」指向更早的、还没回滚过的那次。
+   * 注意：pre-rollback 快照在备份目录里，重命名后它跟着一起搬到 .done 里，
+   * 仍然可以取出来反悔。 */
+  let backupArchived = null;
   try {
     const done = `${backupRoot}.done`;
     fs.renameSync(backupRoot, done);
-    return {
-      ok: true,
-      backup: backupRoot,
-      backupArchived: done,
-      restored,
-      removed,
-      unlinked: relinked,
-      restartRequired: true,
-    };
+    backupArchived = done;
   } catch {
     /* 重命名失败不影响回滚结果 */
   }
 
-  // 回滚改了配置和插件目录，扫描缓存失效
-  clearScanCache();
-
   return {
     ok: true,
     backup: backupRoot,
+    backupArchived,
+    mode,
     restored,
     removed,
     unlinked: relinked,
+    // 回滚前把当时的配置另存了一份，路径给出来方便反悔
+    preRollbackDir: preRollbackFiles.length ? preRollbackDir : null,
+    preRollbackFiles,
     restartRequired: true,
   };
 }

package/package.json

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