dsh-plugin-pack 1.0.3 → 1.0.4

package/client.js

@@ -483,6 +483,10 @@ 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，返回宿主落盘后的绝对路径。 */
   async function uploadZip(file) {
@@ -1434,8 +1438,15 @@ 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 [jobs, setJobs] = useState([]);
     /** 体积上限（MiB），0 = 不限制。默认跟着服务端配置走。 */
@@ -1509,6 +1520,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();
@@ -1558,8 +1627,11 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
           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 ?? [],
@@ -1605,6 +1677,9 @@ 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;
+      // 明确了选择，就别让卸载钩子把它当"未决策"取消掉
+      pendingJobId.current = null;
       setPendingImport(null);
       setBusy(true);
       setImportResult(null);
@@ -1615,6 +1690,8 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
           restoreData: true,
           linkNodeModules: true,
           decisions,
+          // 复用同一个任务记录，界面上是同一条从"待决策"变成"完成"
+          ...(jobId ? { jobId } : {}),
         });
         setImportResult(result);
         await load();
@@ -1626,6 +1703,20 @@ window.__ModuleLoader__.load({ id: 'dsh-plugin-pack', factory: (require) => {
       }
     };
 
+    /** 用户点了取消 / 按了 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') });
@@ -2173,7 +2264,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 +2299,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.4",
   "description": "DeepSeek Harness 插件整合包：一键把当前 profile 的第三方插件连依赖和配置导出成 zip（内部每个插件是标准 npm tgz），换机/换 profile 拖进去就能还原。",
   "type": "module",
   "main": "lib/index.js",