dsh-plugin-pack 1.0.3 → 1.0.5

package/client.js

@@ -108,6 +108,9 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
     'import.source.bundle': '整合包',
     'import.source.plugin': '本地插件',
     'import.notBundle': 'zip 不是整合包',
+    'import.reading': '正在读取包内容…',
+    'import.uploading': '正在上传…',
+    'import.checking': '正在检查冲突…',
     'drop.title': '把 zip / tgz 或插件文件夹拖到这里',
     'drop.release': '松手就导入',
     'drop.running': '正在导入…',
@@ -266,6 +269,9 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
     'import.source.bundle': 'Bundle',
     'import.source.plugin': 'Local plugin',
     'import.notBundle': 'This zip is not a bundle',
+    'import.reading': 'Reading package contents…',
+    'import.uploading': 'Uploading…',
+    'import.checking': 'Checking for conflicts…',
     'drop.title': 'Drop a zip / tgz or plugin folder here',
     'drop.release': 'Release to import',
     'drop.running': 'Importing…',
@@ -483,6 +489,139 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
   /** 后台任务列表（进行中 + 已完成）。 */
   const getJobs = () => api('/plugin-pack/jobs?limit=20');
   const clearJobs = () => api('/plugin-pack/jobs/clear', { method: 'POST', body: '{}' });
+  /** 待决策任务（导入遇到重名时登记的）：切回来捡弹窗用。 */
+  const getWaiting = () => api('/plugin-pack/waiting');
+  const cancelWaiting = (id, reason) =>
+    api('/plugin-pack/waiting/cancel', { method: 'POST', body: JSON.stringify({ id, reason }) });
+
+  /* ------------------------- 浏览器端读 zip 头部 ------------------------- */
+
+  /**
+   * 只读 zip 的中央目录，取出条目名（不解压内容）。
+   *
+   * 为什么在浏览器里做：拖入一个几百 MB 的包，原来的流程是
+   * 「整个文件 POST 上去 → 服务端 dryRun → 才弹冲突窗」，
+   * 用户要等上传完才看到"哪些要覆盖"。
+   *
+   * zip 的中央目录在文件尾部（最后 22 字节是 EOCD，里面记着目录偏移），
+   * 所以只读尾部 ~1 MB 就能得到全部条目名，不用传整个文件。
+   * 这样拖进来几百毫秒就能弹出冲突列表，点确认之后才真正上传。
+   *
+   * @param {File} file
+   * @returns {Promise<{ names: string[], manifest: any | null } | null>}
+   *   不是有效 zip 时返回 null（交给服务端给出正式错误）
+   */
+  async function peekZip(file) {
+    try {
+      const size = file.size;
+      if (size < 22) return null;
+
+      // 1) 读尾部，找 EOCD
+      const tailLen = Math.min(size, 2 * 1024 * 1024);
+      const tail = new Uint8Array(await file.slice(size - tailLen).arrayBuffer());
+      let eocd = -1;
+      for (let i = tail.length - 22; i >= 0; i -= 1) {
+        if (tail[i] === 0x50 && tail[i + 1] === 0x4b && tail[i + 2] === 0x05 && tail[i + 3] === 0x06) {
+          eocd = i;
+          break;
+        }
+      }
+      if (eocd < 0) return null;
+
+      const total = tail[eocd + 10] | (tail[eocd + 11] << 8);
+      const cdSize = tail[eocd + 12] | (tail[eocd + 13] << 8) | (tail[eocd + 14] << 16) | (tail[eocd + 15] << 24);
+      const cdOffset = tail[eocd + 16] | (tail[eocd + 17] << 8) | (tail[eocd + 18] << 16) | (tail[eocd + 19] << 24);
+
+      // 2) 按需读中央目录那一段
+      let cd = tail;
+      if (cdOffset < size - tailLen) {
+        cd = new Uint8Array(await file.slice(cdOffset, cdOffset + cdSize).arrayBuffer());
+      }
+
+      const names = [];
+      let p = 0;
+      const base = cdOffset < size - tailLen ? 0 : cdOffset - (size - tailLen);
+      p = base;
+      while (p + 46 <= cd.length && names.length < total) {
+        if (!(cd[p] === 0x50 && cd[p + 1] === 0x4b && cd[p + 2] === 0x01 && cd[p + 3] === 0x02)) break;
+        const nameLen = cd[p + 28] | (cd[p + 29] << 8);
+        const extraLen = cd[p + 30] | (cd[p + 31] << 8);
+        const commentLen = cd[p + 32] | (cd[p + 33] << 8);
+        const raw = cd.subarray(p + 46, p + 46 + nameLen);
+        let name = '';
+        for (let k = 0; k < raw.length; k += 1) name += String.fromCharCode(raw[k]);
+        try {
+          name = decodeURIComponent(escape(name));
+        } catch {
+          /* 保持原样 */
+        }
+        names.push(name.replace(/\\/g, '/'));
+        p += 46 + nameLen + extraLen + commentLen;
+      }
+      if (!names.length) return null;
+
+      // 3) 有 manifest.json 才解压它（其余一律不解压）
+      let manifest = null;
+      const manifestEntry = names.find((n) => n === 'manifest.json');
+      if (manifestEntry) {
+        manifest = await readZipEntryAsJson(file, cd, base, manifestEntry, cdOffset < size - tailLen);
+      }
+
+      return { names, manifest };
+    } catch {
+      return null;
+    }
+  }
+
+  /** 从中央目录找到某条目，解压它并 JSON.parse。失败返回 null。 */
+  async function readZipEntryAsJson(file, cd, base, targetName, cdIsSeparate) {
+    try {
+      let p = base;
+      let found = null;
+      while (p + 46 <= cd.length) {
+        if (!(cd[p] === 0x50 && cd[p + 1] === 0x4b && cd[p + 2] === 0x01 && cd[p + 3] === 0x02)) break;
+        const method = cd[p + 10] | (cd[p + 11] << 8);
+        const compSize = cd[p + 20] | (cd[p + 21] << 8) | (cd[p + 22] << 16) | (cd[p + 23] << 24);
+        const nameLen = cd[p + 28] | (cd[p + 29] << 8);
+        const extraLen = cd[p + 30] | (cd[p + 31] << 8);
+        const commentLen = cd[p + 32] | (cd[p + 33] << 8);
+        const localOffset = cd[p + 42] | (cd[p + 43] << 8) | (cd[p + 44] << 16) | (cd[p + 45] << 24);
+        const raw = cd.subarray(p + 46, p + 46 + nameLen);
+        let name = '';
+        for (let k = 0; k < raw.length; k += 1) name += String.fromCharCode(raw[k]);
+        try {
+          name = decodeURIComponent(escape(name));
+        } catch {
+          /* 保持原样 */
+        }
+        if (name.replace(/\\/g, '/') === targetName) {
+          found = { method, compSize, localOffset };
+          break;
+        }
+        p += 46 + nameLen + extraLen + commentLen;
+      }
+      if (!found) return null;
+
+      // 读本地头拿到文件名/extra 的实际长度
+      const local = new Uint8Array(await file.slice(found.localOffset, found.localOffset + 30).arrayBuffer());
+      const lNameLen = local[26] | (local[27] << 8);
+      const lExtraLen = local[28] | (local[29] << 8);
+      const dataStart = found.localOffset + 30 + lNameLen + lExtraLen;
+      const raw = new Uint8Array(await file.slice(dataStart, dataStart + found.compSize).arrayBuffer());
+
+      let bytes = raw;
+      if (found.method === 8) {
+        // deflate 解压用浏览器内置的 DecompressionStream
+        const stream = new Blob([raw]).stream().pipeThrough(new DecompressionStream('deflate-raw'));
+        const buf = await new Response(stream).arrayBuffer();
+        bytes = new Uint8Array(buf);
+      }
+      const text = new TextDecoder('utf-8').decode(bytes);
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  }
 
   /** 上传一个 zip，返回宿主落盘后的绝对路径。 */
   async function uploadZip(file) {
@@ -1038,7 +1177,7 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
    * @param {boolean} [props.busy]
    * @param {string} [props.hint]
    */
-  function DropZone({ onFile, busy = false, hint, dropRef }) {
+  function DropZone({ onFile, busy = false, hint, dropRef, phase }) {
     const [over, setOver] = useState(false);
     const [hover, setHover] = useState(false);
     const inputRef = useRef(null);
@@ -1095,7 +1234,11 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
       h(
         'div',
         { style: { fontSize: 13, fontWeight: 500 } },
-        busy ? translate('drop.running') : over ? translate('drop.release') : translate('drop.title'),
+        busy
+          ? phase || translate('drop.running')
+          : over
+            ? translate('drop.release')
+            : translate('drop.title'),
       ),
       h('div', { className: 'pp-hint', style: { marginTop: 4 } }, hint ?? translate('drop.hint')),
       h('input', {
@@ -1434,8 +1577,17 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
     const [pickerDir, setPickerDir] = useState('');
     const [pickerMode, setPickerMode] = useState('file');
     const [importPluginResult, setImportPluginResult] = useState(null);
-    /** 待确认的重名冲突：{ kind, file, conflicts, plugins }。非空时弹窗。 */
+    /**
+     * 待确认的重名冲突：{ jobId, kind, file, conflicts, plugins }。非空时弹窗。
+     *
+     * 这个状态来自服务端的"待决策"任务，不是纯前端内存 ——
+     * 切走画面再回来能捡回弹窗，否则会留下文件已上传但没人处理的悬空状态。
+     */
     const [pendingImport, setPendingImport] = useState(null);
+    /** 当前弹窗对应的服务端任务 id（取消时要通知服务端）。 */
+    const pendingJobId = useRef(null);
+    /** 导入进度阶段文案（读取中 / 上传中 / 检查冲突…），空串表示没在跑。 */
+    const [phase, setPhase] = useState('');
     /** 后台任务列表：切走画面回来靠它恢复 */
     const [jobs, setJobs] = useState([]);
     /** 体积上限（MiB），0 = 不限制。默认跟着服务端配置走。 */
@@ -1509,6 +1661,64 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
       }
     }, []);
 
+    /* 挂载时捡回"待决策"的导入。
+     *
+     * 场景：用户在冲突弹窗里没做选择就切走了画面。组件卸载后前端 state 丢了，
+     * 但服务端还记着这个待决策任务 —— 回来时把它捡回来重开弹窗，
+     * 而不是让那次导入悬在半空（文件传上去了，没人处理）。
+     */
+    useEffect(() => {
+      let alive = true;
+      (async () => {
+        try {
+          const data = await getWaiting();
+          if (!alive) return;
+          const list = Array.isArray(data?.waiting) ? data.waiting : [];
+          const first = list[0];
+          if (!first) return;
+          pendingJobId.current = first.id;
+          setPendingImport({
+            kind: 'bundle',
+            jobId: first.id,
+            file: first.payload?.file ?? null,
+            conflicts: first.payload?.conflicts ?? [],
+            plugins: first.payload?.plugins ?? [],
+            resumed: true,
+          });
+        } catch {
+          /* 服务端还没这个接口就静默跳过 */
+        }
+      })();
+      return () => {
+        alive = false;
+      };
+    }, []);
+
+    /* 组件卸载 = 用户切走画面/关页面。
+     *
+     * 此时如果弹窗还开着、用户没做选择，就通知服务端取消这次导入，
+     * 避免留下"文件已上传但不处理"的悬空任务。
+     */
+    useEffect(
+      () => () => {
+        const id = pendingJobId.current;
+        if (!id) return;
+        pendingJobId.current = null;
+        // 卸载时不能等结果，用 keepalive 尽量送达
+        try {
+          fetch(new URL('/plugin-pack/waiting/cancel', window.location.origin).toString(), {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ id, reason: '用户切走了画面，未做选择' }),
+            keepalive: true,
+          }).catch(() => {});
+        } catch {
+          /* 忽略 */
+        }
+      },
+      [],
+    );
+
     const clearJobHistory = async () => {
       try {
         await clearJobs();
@@ -1551,20 +1761,80 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
         // 两者都走"上传 → 导入"，具体分流由服务端按扩展名决定。
         const isArchive = /\.(zip|tgz|tar\.gz)$/i.test(name);
         if (isArchive) {
+          /* 第一步：先在浏览器里只读 zip 尾部，几百毫秒就知道包里有哪些插件、
+           * 哪些跟已装的重名 —— 不用等整个文件传完。
+           * 用户把几百 MB 的包拖进来时，这个差别是"秒弹"和"等半分钟"的区别。 */
+          const isZip = /\.zip$/i.test(name);
+          let quick = null;
+          if (isZip) {
+            setPhase(t('import.reading'));
+            quick = await peekZip(file);
+          }
+
+          if (quick && Array.isArray(quick.names) && quick.names.length) {
+            const installed = new Map((status?.plugins ?? []).map((plugin) => [plugin.name, plugin]));
+            const packPlugins = (quick.manifest?.plugins ?? []).filter(Boolean);
+            const conflicts = packPlugins
+              .filter((plugin) => installed.has(plugin.name))
+              .map((plugin) => ({
+                name: plugin.name,
+                version: plugin.version ?? null,
+                installedVersion: installed.get(plugin.name)?.version ?? null,
+                dest: installed.get(plugin.name)?.dir ?? null,
+                bytes: plugin.bytes ?? null,
+                sameVersion: (installed.get(plugin.name)?.version ?? null) === (plugin.version ?? null),
+              }));
+
+            // 不是整合包就直接报，省得白传一遍
+            const looksLikeBundle = Boolean(quick.manifest) && String(quick.manifest?.format ?? '').startsWith('dsh-plugin-pack@');
+            if (!looksLikeBundle) {
+              setImportResult({
+                error: `zip 不是整合包：这个 zip 里没有 dsh-plugin-pack 的 manifest.json（共 ${quick.names.length} 个文件）。它可能是普通的压缩包，或者是别的工具打的包。`,
+                code: 'NOT_A_BUNDLE',
+              });
+              setBusy(false);
+              setPhase('');
+              return;
+            }
+
+            if (conflicts.length) {
+              /* 先把冲突列表给出来，用户选完才上传 + 真导入。
+               * 这时还没上传，所以待决策任务在服务端也不存在 —— 全靠确认时再登记。 */
+              setPendingImport({
+                kind: 'bundle',
+                pendingFile: file, // 还没上传，先拿着 File 对象
+                file: null,
+                conflicts,
+                plugins: packPlugins,
+                quick: true,
+              });
+              setBusy(false);
+              setPhase('');
+              return;
+            }
+          }
+
+          // 第二步：确认无冲突（或拿不到快速清单）才上传
+          setPhase(t('import.uploading'));
           const uploaded = await uploadZip(file);
           setZipPath(uploaded.file);
 
           // 先 dryRun 探一次：有重名冲突就弹窗让用户决定
+          setPhase(t('import.checking'));
           const preview = await doImport({ file: uploaded.file, dryRun: true });
           const conflicts = Array.isArray(preview?.conflicts) ? preview.conflicts : [];
           if (conflicts.length) {
+            // 服务端在 dryRun 时已登记了"待决策"任务，带 jobId 回来
+            pendingJobId.current = preview?.jobId ?? null;
             setPendingImport({
               kind: 'bundle',
+              jobId: preview?.jobId ?? null,
               file: uploaded.file,
               conflicts,
               plugins: preview.plugins ?? [],
             });
             setBusy(false);
+            setPhase('');
             return;
           }
 
@@ -1596,6 +1866,7 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
         if (/\.(zip|tgz|tar\.gz)$/i.test(String(file?.name ?? ''))) setImportResult({ error: message, code });
         else setImportPluginResult({ error: message, code });
       } finally {
+        setPhase('');
         setBusy(false);
         lastDrop.dataTransfer = null;
       }
@@ -1605,27 +1876,63 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
     const confirmImport = async (decisions) => {
       const pending = pendingImport;
       if (!pending) return;
+      const jobId = pending.jobId ?? pendingJobId.current ?? null;
+      // 明确了选择，就别让卸载钩子把它当"未决策"取消掉
+      pendingJobId.current = null;
       setPendingImport(null);
       setBusy(true);
       setImportResult(null);
       try {
+        /* quick 模式：拖进来时只读了 zip 尾部就弹了冲突窗，文件还没上传。
+         * 现在用户确认了，才真正把文件传上去。 */
+        let file = pending.file;
+        if (!file && pending.pendingFile) {
+          setPhase(t('import.uploading'));
+          const uploaded = await uploadZip(pending.pendingFile);
+          setZipPath(uploaded.file);
+          file = uploaded.file;
+          setPhase(t('import.checking'));
+          // 服务端 dryRun 一次，把待决策任务登记上（这样切走也能取消）
+          const preview = await doImport({ file, dryRun: true });
+          pendingJobId.current = preview?.jobId ?? null;
+        }
+
+        setPhase('');
         const result = await doImport({
-          file: pending.file,
+          file,
           dryRun: false,
           restoreData: true,
           linkNodeModules: true,
           decisions,
+          // 复用同一个任务记录，界面上是同一条从"待决策"变成"完成"
+          ...(jobId || pendingJobId.current ? { jobId: jobId ?? pendingJobId.current } : {}),
         });
+        pendingJobId.current = null;
         setImportResult(result);
         await load();
         await refreshJobs();
       } catch (err) {
         setImportResult({ error: String(err?.message ?? err) });
       } finally {
+        setPhase('');
         setBusy(false);
       }
     };
 
+    /** 用户点了取消 / 按了 Esc / 点了遮罩：视为放弃这次导入。 */
+    const cancelImport = async () => {
+      const id = pendingJobId.current ?? pendingImport?.jobId ?? null;
+      pendingJobId.current = null;
+      setPendingImport(null);
+      if (!id) return;
+      try {
+        await cancelWaiting(id, '用户取消了导入');
+        await refreshJobs();
+      } catch {
+        /* 取消失败不阻塞界面 */
+      }
+    };
+
     const runExport = async () => {
       if (!chosen.length) {
         setExportResult({ error: translate('export.empty') });
@@ -1912,7 +2219,7 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
     const importPage = h(
       'div',
       null,
-      h(DropZone, { onFile: runDrop, busy, dropRef: lastDrop }),
+      h(DropZone, { onFile: runDrop, busy, dropRef: lastDrop, phase }),
       // 后台任务：切走画面回来能看到刚才那次导入的结果
       h(JobList, { jobs, onClear: clearJobHistory, t }),
 
@@ -2173,7 +2480,14 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
               .then((preview) => {
                 const conflicts = Array.isArray(preview?.conflicts) ? preview.conflicts : [];
                 if (conflicts.length) {
-                  setPendingImport({ kind: 'bundle', file: picked, conflicts });
+                  pendingJobId.current = preview?.jobId ?? null;
+                  setPendingImport({
+                    kind: 'bundle',
+                    jobId: preview?.jobId ?? null,
+                    file: picked,
+                    conflicts,
+                    plugins: preview?.plugins ?? [],
+                  });
                   return;
                 }
                 return doImport({ file: picked, dryRun: false, mode: 'merge', restoreData: true, linkNodeModules: true }).then(
@@ -2201,7 +2515,7 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
         pending: pendingImport,
         t,
         onConfirm: confirmImport,
-        onCancel: () => setPendingImport(null),
+        onCancel: cancelImport,
       }),
     );
   }

package/lib/jobs.js

@@ -39,13 +39,13 @@ function newId() {
 function prune() {
   const now = Date.now();
   for (const [id, job] of jobs) {
-    const finished = job.status === 'done' || job.status === 'failed';
+    const finished = job.status === 'done' || job.status === 'failed' || job.status === 'cancelled';
     if (finished && now - job.finishedAt > KEEP_DONE_MS) jobs.delete(id);
   }
   // 超过上限时，先删最老的已完成任务
   if (jobs.size > MAX_JOBS) {
     const finished = [...jobs.values()]
-      .filter((job) => job.status === 'done' || job.status === 'failed')
+      .filter((job) => job.status === 'done' || job.status === 'failed' || job.status === 'cancelled')
       .sort((a, b) => a.seq - b.seq);
     for (const job of finished) {
       if (jobs.size <= MAX_JOBS) break;
@@ -54,6 +54,94 @@ function prune() {
   }
 }
 
+/**
+ * 登记一个「等用户决策」的任务。
+ *
+ * 解决的问题：导入遇到重名时要弹窗问「覆盖还是跳过」，但弹窗状态原本只在
+ * 前端内存里 —— 用户切走画面再回来，组件卸载，弹窗就没了，导入悬在半空：
+ * 文件传上去了但没人处理。
+ *
+ * 所以要有一个服务端的"待决策"位，让界面切回来能捡回来。用户不决策直接
+ * 切走/关页面，就走 cancelWaiting 视为取消。
+ *
+ * @param {object} options
+ * @param {'import'} options.kind
+ * @param {string} options.title
+ * @param {object} [options.meta]
+ * @param {object} options.payload 给界面用的数据（冲突列表等）
+ * @returns {string} 任务 id
+ */
+export function openWaiting({ kind, title, meta = {}, payload = {} }) {
+  prune();
+  const id = newId();
+  const job = {
+    id,
+    kind,
+    title,
+    meta,
+    seq: ++sequence,
+    status: 'waiting',
+    createdAt: Date.now(),
+    finishedAt: null,
+    progress: [{ at: Date.now(), message: '等待选择覆盖或跳过' }],
+    percent: 0,
+    result: null,
+    error: null,
+    payload,
+  };
+  jobs.set(id, job);
+  return id;
+}
+
+/** 取一个待决策任务的完整数据（含 payload）。 */
+export function getWaiting(id) {
+  const job = jobs.get(String(id ?? ''));
+  if (!job || job.status !== 'waiting') return null;
+  return { ...publicJob(job), payload: job.payload ?? {} };
+}
+
+/** 列出所有待决策任务（界面切回来要捡的那种）。 */
+export function listWaiting() {
+  prune();
+  return [...jobs.values()]
+    .filter((job) => job.status === 'waiting')
+    .sort((a, b) => b.seq - a.seq)
+    .map((job) => ({ ...publicJob(job), payload: job.payload ?? {} }));
+}
+
+/**
+ * 取消一个待决策任务（用户切走、关页面、点取消都走这里）。
+ *
+ * @param {string} id
+ * @param {string} [reason]
+ * @returns {boolean} 是否真的取消了（不存在或已决策返回 false）
+ */
+export function cancelWaiting(id, reason = '已取消') {
+  const job = jobs.get(String(id ?? ''));
+  if (!job || job.status !== 'waiting') return false;
+  job.status = 'cancelled';
+  job.finishedAt = Date.now();
+  job.durationMs = job.finishedAt - job.createdAt;
+  job.error = reason;
+  job.payload = null;
+  return true;
+}
+
+/**
+ * 从等待转为执行中（用户做了决策）。
+ *
+ * @param {string} id
+ * @returns {boolean}
+ */
+export function resumeWaiting(id) {
+  const job = jobs.get(String(id ?? ''));
+  if (!job || job.status !== 'waiting') return false;
+  job.status = 'running';
+  job.payload = null;
+  job.progress.push({ at: Date.now(), message: '开始导入' });
+  return true;
+}
+
 /**
  * 跑一个后台任务（支持同步或异步 task）。
  *
@@ -64,13 +152,15 @@ function prune() {
  * @param {'export'|'import'|'rollback'|'import-plugin'} options.kind
  * @param {string} options.title 人读的标题（如 "导出 5 个插件"）
  * @param {object} [options.meta] 任意附加信息（参数摘要等）
+ * @param {string} [options.jobId] 复用既有任务记录（决策后继续用同一个 id）
  * @param {(report: (message: string, percent?: number) => void) => any | Promise<any>} options.task
  * @returns {Promise<{ id: string, result: any, job: object }>}
  */
-export async function runJob({ kind, title, meta = {}, task }) {
+export async function runJob({ kind, title, meta = {}, task, jobId }) {
   prune();
-  const id = newId();
-  const job = {
+  const id = jobId ?? newId();
+  const existing = jobId ? jobs.get(String(jobId)) : null;
+  const job = existing ?? {
     id,
     kind,
     title,
@@ -84,6 +174,14 @@ export async function runJob({ kind, title, meta = {}, task }) {
     result: null,
     error: null,
   };
+  if (existing) {
+    existing.status = 'running';
+    existing.payload = null;
+    existing.error = null;
+  }
+  job.status = 'running';
+  job.payload = null;
+  job.error = null;
   jobs.set(id, job);
 
   const report = (message, percent) => {

package/lib/server.js

@@ -29,7 +29,17 @@ 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 { runJob, listJobs, getJob, runningJobs, clearFinished } from './jobs.js';
+import {
+  runJob,
+  listJobs,
+  getJob,
+  runningJobs,
+  clearFinished,
+  openWaiting,
+  getWaiting,
+  listWaiting,
+  cancelWaiting,
+} from './jobs.js';
 import { dshHome as resolveDshHome, profileDir as resolveProfileDir, profileName as resolveProfileName, humanBytes } from './home.js';
 import { readJson, writeJson, isDir, isFile } from './util.js';
 
@@ -585,6 +595,7 @@ export function mountRoutes(ctx, config = {}) {
               return;
             }
             const dryRun = Boolean(body.dryRun);
+            const decisions = body.decisions && typeof body.decisions === 'object' ? body.decisions : {};
             const doImportBundle = (report) =>
               importBundle({
                 file: body.file,
@@ -595,17 +606,40 @@ export function mountRoutes(ctx, config = {}) {
                 linkNodeModules: body.linkNodeModules !== false,
                 only: Array.isArray(body.only) && body.only.length ? body.only : null,
                 // 逐插件决策：界面弹窗后传进来，优先级高于全局 mode
-                decisions: body.decisions && typeof body.decisions === 'object' ? body.decisions : {},
+                decisions,
                 onProgress: report,
               });
             if (dryRun) {
-              sendJson(response, 200, doImportBundle(() => {}));
+              const preview = doImportBundle(() => {});
+              const conflicts = Array.isArray(preview?.conflicts) ? preview.conflicts : [];
+              /* 有冲突且用户还没决策 → 登记成"待决策"任务。
+               * 这样用户切走画面再回来，界面能从 /plugin-pack/waiting 捡回这个弹窗；
+               * 一直不决策就走 cancel，不会留下"文件传了但没人处理"的悬空状态。 */
+              if (conflicts.length && !Object.keys(decisions).length) {
+                const jobId = openWaiting({
+                  kind: 'import',
+                  title: `导入整合包（${conflicts.length} 个重名待决定）`,
+                  meta: { file: body.file },
+                  payload: {
+                    file: body.file,
+                    conflicts,
+                    plugins: preview.plugins ?? [],
+                    restoreData: body.restoreData !== false,
+                    linkNodeModules: body.linkNodeModules !== false,
+                  },
+                });
+                sendJson(response, 200, { ...preview, jobId });
+                return;
+              }
+              sendJson(response, 200, preview);
               return;
             }
             const { id, result } = await runJob({
               kind: 'import',
               title: `导入整合包`,
               meta: { file: body.file },
+              // 决策后继续用同一个任务 id，界面上就是同一条记录从"待决策"变成"完成"
+              jobId: body.jobId ? String(body.jobId) : undefined,
               task: (report) => doImportBundle(report),
             });
             sendJson(response, 200, { ...result, jobId: id });
@@ -614,6 +648,48 @@ export function mountRoutes(ctx, config = {}) {
         'plugin-pack: import',
       );
 
+      /* 待决策任务：导入遇到重名时登记，界面切走再回来靠它捡回弹窗。
+       *   GET  /plugin-pack/waiting            列出待决策任务（含冲突列表）
+       *   POST /plugin-pack/waiting/cancel     取消（用户切走/关页面/点取消）
+       */
+      register(
+        {
+          kind: 'exact',
+          path: `${PREFIX}/waiting`,
+          handler: async (request, response) => {
+            if (request.method !== 'GET') {
+              sendJson(response, 405, { ok: false, error: '只支持 GET' });
+              return;
+            }
+            const url = new URL(request.url ?? '/', 'http://localhost');
+            const id = url.searchParams.get('id');
+            if (id) {
+              sendJson(response, 200, { ok: true, waiting: getWaiting(id) });
+              return;
+            }
+            sendJson(response, 200, { ok: true, waiting: listWaiting() });
+          },
+        },
+        'plugin-pack: waiting',
+      );
+
+      register(
+        {
+          kind: 'exact',
+          path: `${PREFIX}/waiting/cancel`,
+          handler: async (request, response) => {
+            if (request.method !== 'POST') {
+              sendJson(response, 405, { ok: false, error: '只支持 POST' });
+              return;
+            }
+            const body = await readJsonBody(request);
+            const cancelled = cancelWaiting(body.id, body.reason || '用户取消了导入');
+            sendJson(response, 200, { ok: true, cancelled });
+          },
+        },
+        'plugin-pack: waiting-cancel',
+      );
+
       register(
         {
           kind: 'exact',

package/package.json

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