@1e0zj/dsh-plugin-mall 0.4.15 → 0.4.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1e0zj/dsh-plugin-mall",
-  "version": "0.4.15",
+  "version": "0.4.17",
   "description": "dsh 插件市场：搜索 GitHub dsh-plugin 话题下的插件仓库，一键安装到本地 dsh profile（agent 工具 + 设置页插件市场 tab）",
   "type": "module",
   "main": "src/index.js",

package/src/client.js

@@ -128,10 +128,73 @@ window.__ModuleLoader__.load({
       return String(e && e.message ? e.message : e);
     }
 
+    // ── 更新按钮的防连点判据 ────────────────────────────────────────────────
+    //
+    // 纯函数，不碰 React；index.js 的 --self-test 把这一整段从本文件里原样抠
+    // 出来跑（同下面 session nonce 那段的做法），所以改坏了这里测试会红。
+    // 往段里加函数会自动被测到，把函数搬出去则当场 ReferenceError。
+
     function isJobActive(status) {
       return status === "running" || status === "stopping";
     }
 
+    // spec → npm 包名。**按包名、不按 spec** 是这段的关键：同一条更新链在不同
+    // 阶段的 spec 并不一样（点的是 foo@1.2.3，服务端防抢注解析后 track 存下的
+    // 可能是别的形态），按 spec 盯就会在解析之后丢失目标。
+    // 与服务端 npmNameOf（github.js）同一套形状；非 npm 形态返回 null。
+    function specPackageName(spec) {
+      if (typeof spec !== "string" || spec.length === 0) return null;
+      if (spec.charAt(0) === "@") {
+        var scoped = /^(@[^/@\s]+\/[^/@\s]+?)(?:@[^/\s]+)?$/.exec(spec);
+        return scoped === null ? null : scoped[1];
+      }
+      var bare = /^([^@/\s:]+)(?:@[^/\s]+)?$/.exec(spec);
+      return bare === null ? null : bare[1];
+    }
+
+    // 这个包上有没有一条没了结的更新链。三段接力，中间不能断：
+    //
+    //   updating   点击 → 预检 job 建立。这段 jobs 里还什么都没有，只有同步
+    //              的 ref 挡得住同一拍里的第二次点击。
+    //   installing 预检落终态 → 安装 job 建立。预检那条已经不 active 了，
+    //              安装那条还没 track 上，中间这一拍靠它顶住。
+    //   jobs       job 全程。**RPC 返回只意味着 job 建好了，pnpm 还没开始跑**
+    //              ——锁必须持续到 job 落终态，不是到 RPC 返回。
+    //              needsApproval 的 status 是 failed，但那是等用户决定的暂停，
+    //              事务没结束，算未了结。
+    //   cards      预检出了风险卡片，停在那里等用户读完再决定。这期间任务是
+    //              终态，但决定还没做，再起一条链就是两条链抢同一个事务。
+    //              **按 jobId 存字典、不是单槽位**：同时可以停着好几张卡片
+    //              （批量更新必然如此，手动连点两个包也够）。单槽位时后来的
+    //              会顶掉前一张，被顶掉那条从此没有任何入口能做决定，job 却
+    //              一直是未了结状态——那一行的更新按钮再也点不亮。
+    //
+    // sources 里递进来的必须是 ref.current 这类当下的值：判定发生在点击那一
+    // 刻，上一次渲染的快照没有意义。
+    function updateChainBusy(sources, name) {
+      if (name === null || name === undefined) return false;
+      if ((sources.updating || {})[name] === true) return true;
+      var installing = sources.installing || {};
+      for (var spec in installing) {
+        if (installing[spec] === true && specPackageName(spec) === name) return true;
+      }
+      var cards = sources.cards || {};
+      for (var cardId in cards) {
+        var card = cards[cardId];
+        if (card && specPackageName(card.spec) === name) return true;
+      }
+      var jobs = sources.jobs || {};
+      for (var id in jobs) {
+        var job = jobs[id];
+        if (!job || typeof job.spec !== "string") continue;
+        if (specPackageName(job.spec) !== name) continue;
+        if (isJobActive(job.status)) return true;
+        if (Array.isArray(job.needsApproval) && job.needsApproval.length > 0) return true;
+      }
+      return false;
+    }
+    // ── 更新按钮的防连点判据结束 ────────────────────────────────────────────
+
     function kindLabel(kind) {
       if (kind === "bundle") return "宿主插件层";
       if (kind === "client") return "浏览器UI插件";
@@ -344,7 +407,8 @@ window.__ModuleLoader__.load({
         }
         commit(next);
       }, [commit]);
-      return { jobs: jobs, track: track, drop: drop, setStatus: setStatus, restore: restore };
+      // jobsRef 一并交出去：防连点的判定读的是当下的值，不是渲染快照。
+      return { jobs: jobs, jobsRef: jobsRef, track: track, drop: drop, setStatus: setStatus, restore: restore };
     }
 
     // ── plugin verification badge ───────────────────────────────────────────
@@ -607,7 +671,7 @@ window.__ModuleLoader__.load({
       if (ids.length === 0 && !props.error) return null;
       var hasSettled = ids.some(function (id) {
         var job = props.jobs[id];
-        var hasDecision = (props.preflight && props.preflight.jobId === id)
+        var hasDecision = props.preflights[id] !== undefined
           || (job.needsApproval && job.needsApproval.length > 0);
         return !isJobActive(job.status) && !hasDecision;
       });
@@ -620,7 +684,7 @@ window.__ModuleLoader__.load({
         ids.map(function (id) {
           var job = props.jobs[id];
           var done = job.status === "completed" || job.status === "failed" || job.status === "killed";
-          var preflightDecision = props.preflight && props.preflight.jobId === id ? props.preflight : null;
+          var preflightDecision = props.preflights[id] || null;
           var awaitingDecision = preflightDecision !== null || (job.needsApproval && job.needsApproval.length > 0);
           return h("div", { key: id, className: "mkt_job" },
             // 不再显示 market-N 这种内部 id——对用户没有意义，反而让人以为
@@ -640,12 +704,12 @@ window.__ModuleLoader__.load({
               ? h(ApprovalRequest, {
                 spec: job.spec,
                 needsApproval: job.needsApproval,
-                busy: props.approving === job.spec,
+                busy: props.specBusy(job.spec),
                 onApprove: function (names) {
                   // 不先 drop：旧条目由重试任务的 track(carryFromId) 原子接管
                   // （撤条目 + 日志接续一拍完成）。install RPC 现在只做本地校验、
                   // 立刻返回新 job id，但保留这个次序仍然是它最稳的形态——
-                  // 万一 RPC 失败，旧条目和日志还在。等待期间按钮由 approving
+                  // 万一 RPC 失败，旧条目和日志还在。等待期间按钮由 specBusy
                   // 态显示「继续中…」。
                   props.onApprove(job.spec, names, job.approvalToken, id);
                 },
@@ -655,9 +719,9 @@ window.__ModuleLoader__.load({
                 ? h(PreflightCard, {
                   spec: preflightDecision.spec,
                   report: preflightDecision.report,
-                  busy: props.preflightBusy === true,
-                  onConfirm: props.onConfirmPreflight,
-                  onClose: props.onClosePreflight,
+                  busy: props.specBusy(preflightDecision.spec),
+                  onConfirm: function () { props.onConfirmPreflight(id); },
+                  onClose: function () { props.onClosePreflight(id); },
                 })
                 : job.detail ? h("div", { className: job.status === "failed" ? "mkt_error" : "mkt_desc" }, job.detail) : null,
             // 预检完成不提示重启——它没有改动任何东西，接下来才是安装。
@@ -715,6 +779,7 @@ window.__ModuleLoader__.load({
               var togglable = entry !== undefined && dep.name !== MARKET_PACKAGE;
               var enabled = entry === undefined ? true : entry.enabled !== false;
               var toggling = (props.toggling || {})[dep.name] === true;
+              var updating = props.isUpdating(dep.name);
               return h("div", { key: dep.name, className: "mkt_depRow" },
                 h("span", { className: "mkt_desc" + (enabled ? "" : " mkt_depOff") }, dep.name + "@" + dep.version),
                 h("span", { className: "mkt_depActions" },
@@ -728,8 +793,11 @@ window.__ModuleLoader__.load({
                   }, h("span", { className: "mkt_switchKnob" })) : null,
                   upd && upd.hasUpdate ? h("button", {
                     className: "mkt_btn mkt_btnSm",
-                    onClick: function () { props.onInstallSpec(dep.name + "@" + upd.latest); },
-                  }, "更新至 " + upd.latest) : null,
+                    // 和 doUpdate 里的守卫读同一个判据，两边不会漂移——不一致
+                    // 就会出现「按钮看着能点，点了什么也不发生」。
+                    disabled: updating,
+                    onClick: function () { props.onUpdate(dep.name, dep.name + "@" + upd.latest); },
+                  }, updating ? "更新中…" : "更新至 " + upd.latest) : null,
                   h("button", {
                     className: "mkt_btn mkt_btnDanger mkt_btnSm",
                     disabled: busy,
@@ -812,9 +880,32 @@ window.__ModuleLoader__.load({
       var _hostStartedAt = useState(0);
       var hostStartedAt = _hostStartedAt[0];
       var setHostStartedAt = _hostStartedAt[1];
-      var _preflight = useState(null);
-      var preflight = _preflight[0];
-      var setPreflight = _preflight[1];
+      // jobId -> { spec, report, jobId }。字典而不是单个：见 updateChainBusy
+      // 的 cards 一节——同时可以有好几张待决策的风险卡片。
+      var _preflights = useState({});
+      var preflights = _preflights[0];
+      var setPreflights = _preflights[1];
+      var dropPreflight = useCallback(function (jobId) {
+        setPreflights(function (prev) {
+          if (!(jobId in prev)) return prev;
+          var next = Object.assign({}, prev);
+          delete next[jobId];
+          return next;
+        });
+      }, []);
+
+      // 更新按钮防连点用的三份当下值（见 updateChainBusy）。ref 而不是 state：
+      // 判定发生在点击那一刻，而 setState 到重渲染之间还有一拍能点。ref 不触发
+      // 渲染，所以每次改动配一次 bumpBusy，让按钮当场变样。
+      var updatingRef = useRef({});   // 包名 -> true，点击到预检 job 建立之间
+      var installingRef = useRef({}); // spec  -> true，安装 RPC 在途
+      var preflightsRef = useRef({});
+      preflightsRef.current = preflights; // 渲染期同步，同 resultsRef 的写法
+      var _busyTick = useState(0);
+      var setBusyTick = _busyTick[1];
+      var bumpBusy = useCallback(function () {
+        setBusyTick(function (n) { return n + 1; });
+      }, []);
 
       // Opaque one-shot approval tokens issued from needsApproval outcomes (spec -> token).
       // Cleared on success, unrelated failure, cancel, modal close, or spec change.
@@ -983,6 +1074,17 @@ window.__ModuleLoader__.load({
       var polling = useJobPolling(call, onJobSettled, onApprovalToken, onPreflightSettled);
       var track = polling.track;
       var jobs = polling.jobs;
+      var jobsRef = polling.jobsRef;
+
+      // 按钮的 disabled 和 handler 里的守卫都读这一个函数，两边不会漂移。
+      var updateBusy = useCallback(function (packageName) {
+        return updateChainBusy({
+          updating: updatingRef.current,
+          installing: installingRef.current,
+          cards: preflightsRef.current,
+          jobs: jobsRef.current,
+        }, packageName);
+      }, [jobsRef]);
       var dropJob = polling.drop;
       var setJobStatus = polling.setStatus;
 
@@ -1000,6 +1102,10 @@ window.__ModuleLoader__.load({
       }, []);
 
       var doRawInstall = useCallback(function (spec, extra, carryFromId) {
+        // ref 与 state 同时置位：state 负责触发渲染，ref 才是判定读的那一份
+        // （见 updateChainBusy）。这一段是预检 job 已落终态、安装 job 还没
+        // track 上的空档，中间断一拍更新按钮就会复活。
+        installingRef.current[spec] = true;
         setInstalling(function (prev) {
           var next = Object.assign({}, prev, { [spec]: true });
           return next;
@@ -1012,6 +1118,7 @@ window.__ModuleLoader__.load({
           delete approvalTokensRef.current[spec];
           reportError("tasks", e);
         }).finally(function () {
+          delete installingRef.current[spec];
           setInstalling(function (prev) {
             var next = Object.assign({}, prev);
             delete next[spec];
@@ -1041,20 +1148,29 @@ window.__ModuleLoader__.load({
             // 安全：接过预检的日志、撤掉预检条目，面板上只剩这一个任务。
             doRawInstall(spec, {}, jobId);
           } else {
-            setPreflight({ spec: spec, report: report, jobId: jobId });
+            // 按 jobId 落格，不覆盖别的包停着的卡片。
+            setPreflights(function (prev) {
+              var next = Object.assign({}, prev);
+              next[jobId] = { spec: spec, report: report, jobId: jobId };
+              return next;
+            });
           }
         };
       }, [doRawInstall, reportError]);
 
       // 点安装 = 立刻起一个预检 job，面板马上有东西看、日志实时流。
       // 结论由轮询经 onPreflightSettled 交回上面的 handler，这里不等待。
-      var preflightAndInstall = useCallback(function (spec) {
+      // onStarted：RPC 落定（不论成败）时回调一次。更新按钮用它把「点击 →
+      // job 建立」这一段的锁交给 job，市场卡片不传，行为一字未变。
+      var preflightAndInstall = useCallback(function (spec, onStarted) {
         delete approvalTokensRef.current[spec];
         setError(null);
         call("preflight", { spec: spec }).then(function (value) {
           track(value.jobId, value.spec || spec);
         }).catch(function (e) {
           reportError("tasks", e);
+        }).finally(function () {
+          if (typeof onStarted === "function") onStarted();
         });
       }, [call, reportError, track]);
 
@@ -1062,6 +1178,26 @@ window.__ModuleLoader__.load({
         preflightAndInstall("github:" + repo);
       }, [preflightAndInstall]);
 
+      // 已装列表的「更新至 X」。此前它是那一行里唯一没有 disabled 的按钮，
+      // 而起链要走联网的 registry 解析，那几秒里 jobs 还是空的、按钮还是可点
+      // 的——连点几下就是几条预检+安装链，profile 事务队列会把它们排队串行
+      // 跑完，同一个版本被反复装好几遍。
+      //
+      // 守卫按包名（updateChainBusy 的注释说明了为什么不能按 spec），同步的
+      // ref 挡住同一拍里的第二次点击；RPC 返回只解开 updating 那一段，之后由
+      // 对应的 job 接管，锁一直持续到 job 落终态。
+      var doUpdate = useCallback(function (packageName, spec) {
+        if (updateBusy(packageName)) return;
+        updatingRef.current[packageName] = true;
+        bumpBusy();
+        preflightAndInstall(spec, function () {
+          // preflight RPC 已返回：jobs 里已经有条目接手，这里才允许松手。
+          // 顺序反过来会闪出一拍「谁都不认为它在忙」的可点窗口。
+          delete updatingRef.current[packageName];
+          bumpBusy();
+        });
+      }, [preflightAndInstall, updateBusy, bumpBusy]);
+
       var doRestart = useCallback(function () {
         clearRestartPing();
         setRestarting(true);
@@ -1185,18 +1321,22 @@ window.__ModuleLoader__.load({
           toggling: toggling,
           onToggle: doToggle,
           onUninstall: doUninstall,
-          onInstallSpec: preflightAndInstall,
+          onUpdate: doUpdate,
+          isUpdating: updateBusy,
           error: error && error.scope === "installed" ? error.message : null,
         }),
         h(JobsPanel, {
           jobs: jobs,
           error: error && error.scope === "tasks" ? error.message : null,
-          preflight: preflight,
-          preflightBusy: preflight ? installing[preflight.spec] === true : false,
+          preflights: preflights,
+          // 这张卡片/这条批准请求对应的 install RPC 在不在途。原来是「取
+          // installing 里的第一个 spec」的单值，同时两条链在途时只有一条显示
+          // 得对；按 spec 问就没有这个假设了。
+          specBusy: function (spec) { return installing[spec] === true; },
           onClear: function () {
             Object.keys(jobs).forEach(function (id) {
               var job = jobs[id];
-              var hasDecision = job && ((preflight && preflight.jobId === id)
+              var hasDecision = job && (preflights[id] !== undefined
                 || (job.needsApproval && job.needsApproval.length > 0));
               if (!job || isJobActive(job.status) || hasDecision) return;
               var token = job && job.approvalToken ? job.approvalToken : (job && job.spec ? approvalTokensRef.current[job.spec] : undefined);
@@ -1215,33 +1355,34 @@ window.__ModuleLoader__.load({
             });
           },
           onApprove: doApprove,
-          onConfirmPreflight: function () {
-            if (!preflight) return;
-            var spec = preflight.spec;
-            var carry = preflight.jobId;
-            var report = preflight.report;
-            setPreflight(null);
+          onConfirmPreflight: function (jobId) {
+            var decision = preflights[jobId];
+            if (!decision) return;
+            dropPreflight(jobId);
             // consentDigest 来自预检 job 的 extras，装的时候与当前报告比对：
             // 用户点「继续」到安装真正开跑之间候选包或 profile 变了，
             // 布尔同意不得沿用，要重新看新的警告。
-            doRawInstall(spec, { acceptWarnings: true, acceptedReportDigest: report.consentDigest }, carry);
+            doRawInstall(decision.spec, { acceptWarnings: true, acceptedReportDigest: decision.report.consentDigest }, jobId);
           },
-          onClosePreflight: function () {
-            if (preflight && preflight.spec) delete approvalTokensRef.current[preflight.spec];
-            setPreflight(null);
+          onClosePreflight: function (jobId) {
+            var decision = preflights[jobId];
+            if (decision && decision.spec) delete approvalTokensRef.current[decision.spec];
+            dropPreflight(jobId);
           },
           onDismiss: function (id) {
             var job = jobs[id];
             var token = job && job.approvalToken ? job.approvalToken : (job && job.spec ? approvalTokensRef.current[job.spec] : undefined);
             if (job && job.spec) delete approvalTokensRef.current[job.spec];
             call("jobDismiss", { jobId: id, token: token }).catch(function () {});
+            // job 条目撤了，挂在它上面的卡片没有宿主了。不一并撤的话
+            // updateChainBusy 的 cards 分支会一直锁着那个包名。
+            dropPreflight(id);
             dropJob(id);
           },
           onDrop: dropJob,
           onRestart: function () { setRestartConfirm(true); },
           restarting: restarting,
           hostStartedAt: hostStartedAt,
-          approving: Object.keys(installing).filter(function (s) { return installing[s]; })[0],
         }),
         h("div", { className: "mkt_list" },
           results == null

package/src/index.js

@@ -3309,6 +3309,70 @@ export async function runSelfTests() {
         storageTouches === 0, `touches=${storageTouches}`);
     }
 
+    // 已装列表「更新至 X」的防连点判据。同样从 src/client.js 原样抠出来跑
+    // ——它在浏览器里是 React 闭包，测不到；提成纯函数就是为了能在这里钉住。
+    //
+    // 钉住的两件事，各对应一个真实的洞：
+    //   1. 按包名判定 —— 按 spec 判定会在服务端解析之后丢失目标；
+    //   2. 锁到 job 终态 —— 只锁 RPC 往返的话，jobId 一返回按钮就复活，而那
+    //      时 pnpm 还一步都没跑。
+    {
+      const clientSource = readFileSync(join(dirname(fileURLToPath(import.meta.url)), "client.js"), "utf8");
+      const begin = clientSource.indexOf("// ── 更新按钮的防连点判据 ─");
+      const end = clientSource.indexOf("// ── 更新按钮的防连点判据结束 ─");
+      if (begin === -1 || end === -1 || end < begin) throw new Error("client.js 里找不到「更新按钮的防连点判据」整段");
+      // 整段抠，不是逐个函数挑：依赖（isJobActive、specPackageName）就在段内，
+      // 往段里加函数会自动被测到，搬出段外则当场 ReferenceError。
+      const front = new Function([
+        clientSource.slice(begin, end),
+        "return { specPackageName, updateChainBusy };",
+      ].join("\n"))();
+
+      const busy = (patch, name) => front.updateChainBusy(
+        Object.assign({ updating: {}, installing: {}, cards: {}, jobs: {} }, patch), name);
+      const running = (spec) => ({ spec, status: "running" });
+
+      check("更新防连点：裸包名折算", front.specPackageName("foo") === "foo");
+      check("更新防连点：带版本折算", front.specPackageName("foo@1.2.3") === "foo");
+      check("更新防连点：scoped 折算", front.specPackageName("@a/b@9.9.9") === "@a/b");
+      check("更新防连点：非 npm 形态返回 null", front.specPackageName("github:o/r") === null);
+
+      check("更新防连点：点击到 job 建立之间靠同步 ref 挡住（第二次点击）",
+        busy({ updating: { foo: true } }, "foo") === true);
+      check("更新防连点：预检 job 在跑时锁着",
+        busy({ jobs: { a: running("foo@1.2.3") } }, "foo") === true);
+      check("更新防连点：预检落终态、安装 RPC 在途的空档也锁着",
+        busy({ installing: { "foo@1.2.3": true }, jobs: { a: { spec: "foo@1.2.3", status: "completed" } } }, "foo") === true);
+      check("更新防连点：安装 job 在跑时锁着（RPC 早返回了，pnpm 才刚开始）",
+        busy({ jobs: { a: running("foo@1.2.3") } }, "foo") === true);
+      check("更新防连点：stopping 也算在跑",
+        busy({ jobs: { a: { spec: "foo@1.2.3", status: "stopping" } } }, "foo") === true);
+      check("更新防连点：停在批准卡片上（failed + needsApproval）算未了结",
+        busy({ jobs: { a: { spec: "foo@1.2.3", status: "failed", needsApproval: [{ name: "x" }] } } }, "foo") === true);
+      check("更新防连点：停在风险卡片上时锁着（决定还没做，再起一条就是两条链）",
+        busy({ cards: { j1: { spec: "foo@1.2.3" } } }, "foo") === true);
+      // 单槽位时代的真实卡死：第二张卡片顶掉第一张，被顶掉那条再没有入口能
+      // 做决定，job 却一直未了结——那一行的更新按钮永远点不亮。
+      check("更新防连点：多张卡片同时停着，各锁各的包（批量更新的必然形状）",
+        busy({ cards: { j1: { spec: "foo@1.2.3" }, j2: { spec: "bar@2.0.0" } } }, "foo") === true
+          && busy({ cards: { j1: { spec: "foo@1.2.3" }, j2: { spec: "bar@2.0.0" } } }, "bar") === true);
+      check("更新防连点：撤掉其中一张不影响另一张的锁",
+        busy({ cards: { j2: { spec: "bar@2.0.0" } } }, "foo") === false
+          && busy({ cards: { j2: { spec: "bar@2.0.0" } } }, "bar") === true);
+
+      check("更新防连点：job 落终态后解锁，用户可以重试",
+        busy({ jobs: { a: { spec: "foo@1.2.3", status: "failed" } } }, "foo") === false);
+      check("更新防连点：completed 后解锁",
+        busy({ jobs: { a: { spec: "foo@1.2.3", status: "completed" } } }, "foo") === false);
+      check("更新防连点：别的包在跑不锁本行",
+        busy({ jobs: { a: running("bar@1.0.0") } }, "foo") === false);
+      check("更新防连点：风险卡片停在别的包上不锁本行",
+        busy({ cards: { j1: { spec: "bar@1.0.0" } } }, "foo") === false);
+      check("更新防连点：什么都没在途 → 不锁", busy({}, "foo") === false);
+      check("更新防连点：包名为 null 时不误判",
+        busy({ jobs: { a: running("foo@1.2.3") } }, null) === false);
+    }
+
     let cancelRefused = false;
     try {
       sessionTracker.cancel(sessionJobId, "session-beta");