@1e0zj/dsh-plugin-mall 0.4.1 → 0.4.3

package/package.json

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

package/src/client.js

@@ -499,10 +499,10 @@ window.__ModuleLoader__.load({
                 busy: props.approving === job.spec,
                 onApprove: function (names) {
                   // 不先 drop：旧条目由重试任务的 track(carryFromId) 原子接管
-                  // （撤条目 + 日志接续一拍完成）。先删的话，call("install")
-                  // 要走数秒（重试还会重跑一次隔离预检），面板会空白一段，
-                  // 「批准后任务消失、开始安装才冒出来」的割裂就是这么来的。
-                  // 等待期间按钮由 approving 态显示「继续中…」。
+                  // （撤条目 + 日志接续一拍完成）。install RPC 现在只做本地校验、
+                  // 立刻返回新 job id，但保留这个次序仍然是它最稳的形态——
+                  // 万一 RPC 失败，旧条目和日志还在。等待期间按钮由 approving
+                  // 态显示「继续中…」。
                   props.onApprove(job.spec, names, job.approvalToken, id);
                 },
                 onDismiss: function () { props.onDismiss(id); },
@@ -1056,7 +1056,10 @@ window.__ModuleLoader__.load({
             var spec = preflight.spec;
             var carry = preflight.jobId;
             setPreflight(null);
-            doRawInstall(spec, { acceptWarnings: true }, carry);
+            // consentDigest 来自预检 job 的 extras，装的时候与当前报告比对：
+            // 用户点「继续」到安装真正开跑之间候选包或 profile 变了，
+            // 布尔同意不得沿用，要重新看新的警告。
+            doRawInstall(spec, { acceptWarnings: true, acceptedReportDigest: preflight.report.consentDigest }, carry);
           },
           onClose: function () {
             if (preflight && preflight.spec) delete approvalTokensRef.current[preflight.spec];

package/src/github.js

@@ -172,15 +172,20 @@ function normalizeRegistry(registry) {
  * Look up a package's `latest` manifest on an npm registry.
  * @param name - the npm package name.
  * @param options - `registry` defaults to npmjs; pass what pnpm installs from.
+ *   `signal` cancels the request (and, critically, keeps the cancellation out
+ *   of the cache — see below). `fresh` skips the read side of the cache: a
+ *   cached "current version" is stale by construction, and the preflight
+ *   staleness check exists precisely to compare against what the registry
+ *   says NOW (the write side still populates the cache for other callers).
  * @returns `{latest, repositoryUrl, hostDeps}`, or null when unknown/unreachable.
  */
-export async function npmPackageInfo(name, { registry } = {}) {
+export async function npmPackageInfo(name, { registry, signal, fresh = false } = {}) {
   const clean = String(name ?? "").trim();
   if (clean.length === 0 || !/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i.test(clean)) return null;
   const base = normalizeRegistry(registry);
   const key = `${base}|${clean}`;
   const cached = npmCache.get(key);
-  if (cached !== undefined && Date.now() - cached.at < NPM_CACHE_TTL) return cached.info;
+  if (fresh !== true && cached !== undefined && Date.now() - cached.at < NPM_CACHE_TTL) return cached.info;
   let info = null;
   try {
     // 单版本端点返回 latest 的完整 manifest（dependencies + repository 都在）。
@@ -188,6 +193,7 @@ export async function npmPackageInfo(name, { registry } = {}) {
     // 镜像（npmmirror 等）的同名端点响应格式一致，两个字段都保留。
     const response = await fetch(`${base}/${clean.replace("/", "%2F")}/latest`, {
       headers: { "User-Agent": "dsh-plugin-mall", Accept: "application/json" },
+      signal,
     });
     if (response.ok) {
       const body = await response.json();
@@ -201,19 +207,61 @@ export async function npmPackageInfo(name, { registry } = {}) {
         };
       }
     }
-  } catch {
+  } catch (error) {
+    // 取消不是「查不到」。若把 AbortError 也吞成 null，下面的 npmCache.set 会把
+    // 这个空答案钉住整个 TTL——用户取消一次，接下来 5 分钟里防抢注永远不匹配、
+    // 宿主影子检查看不到清单，而且完全无声。取消一律上抛，不进缓存。
+    if (error?.name === "AbortError") throw error;
     info = null; // registry unreachable — caller falls back
   }
   npmCache.set(key, { info, at: Date.now() });
   return info;
 }
 
+const npmVersionsCache = new Map();
+
+/**
+ * All published version strings of a package, oldest to newest, for resolving
+ * a RANGE spec ("pkg@^1.2.0") to the version pnpm would actually pick today.
+ * `/latest` cannot answer that — a new release inside the range is invisible
+ * to it until it becomes latest. Fetches the full packument (one request),
+ * which is why this lives behind its own TTL like npmPackageInfo. Same
+ * cancellation rule: AbortError is rethrown, never cached as an empty answer.
+ * @returns string[], or null when unreachable/unknown.
+ */
+export async function npmPackageVersions(name, { registry, signal, fresh = false } = {}) {
+  const clean = String(name ?? "").trim();
+  if (clean.length === 0 || !/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i.test(clean)) return null;
+  const base = normalizeRegistry(registry);
+  const key = `${base}|${clean}`;
+  const cached = npmVersionsCache.get(key);
+  if (fresh !== true && cached !== undefined && Date.now() - cached.at < NPM_CACHE_TTL) return cached.versions;
+  let versions = null;
+  try {
+    const response = await fetch(`${base}/${clean.replace("/", "%2F")}`, {
+      headers: { "User-Agent": "dsh-plugin-mall", Accept: "application/json" },
+      signal,
+    });
+    if (response.ok) {
+      const body = await response.json();
+      if (body?.versions !== null && typeof body?.versions === "object") {
+        versions = Object.keys(body.versions);
+      }
+    }
+  } catch (error) {
+    if (error?.name === "AbortError") throw error;
+    versions = null;
+  }
+  npmVersionsCache.set(key, { versions, at: Date.now() });
+  return versions;
+}
+
 /**
  * Rewrite "github:owner/repo" (or "owner/repo") to the npm package name when
  * that package exists on npm AND its repository URL points back at the repo
  * (anti-squatting). Anything else passes through untouched.
  */
-export async function preferNpmSpec({ spec, registry, sources }) {
+export async function preferNpmSpec({ spec, registry, sources, signal }) {
   const raw = String(spec ?? "");
   // A scoped npm name ("@scope/name", "@scope/name@1.2.3") is shaped exactly
   // like owner/repo and matches the regex below, sending every such install
@@ -223,10 +271,10 @@ export async function preferNpmSpec({ spec, registry, sources }) {
   const githubMatch = /^(?:github:)?([^/\s]+\/[^/\s]+?)(?:\.git)?$/i.exec(raw);
   if (githubMatch === null) return raw;
   const repo = githubMatch[1];
-  const { results } = await verifyPlugins({ repos: [repo], sources }); // cache hit after first verify
+  const { results } = await verifyPlugins({ repos: [repo], sources, signal }); // cache hit after first verify
   const declaredName = results[repo]?.name;
   if (typeof declaredName !== "string") return raw;
-  const info = await npmPackageInfo(declaredName, { registry });
+  const info = await npmPackageInfo(declaredName, { registry, signal });
   if (info === null || info.repositoryUrl === undefined) return raw;
   const pointsBack = new RegExp(`github\\.com[/:]${repo.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(/|\\.git|$)`, "i").test(info.repositoryUrl);
   return pointsBack ? declaredName : raw;
@@ -254,7 +302,7 @@ export function npmNameOf(raw) {
   return match === null ? null : match[1];
 }
 
-export async function assertSafeToInstall({ spec, registry, sources }) {
+export async function assertSafeToInstall({ spec, registry, sources, signal }) {
   const raw = String(spec ?? "");
   let hostDeps;
   if (/^(?:file:|link:)/i.test(raw)) {
@@ -268,7 +316,7 @@ export async function assertSafeToInstall({ spec, registry, sources }) {
     }
   } else if (/^github:([^/\s]+\/[^/\s]+?)(?:\.git)?(?:#.+)?$/i.test(raw)) {
     const repo = /^github:([^/\s]+\/[^/\s]+?)(?:\.git)?(?:#.+)?$/i.exec(raw)[1];
-    const { results } = await verifyPlugins({ repos: [repo], sources });
+    const { results } = await verifyPlugins({ repos: [repo], sources, signal });
     hostDeps = results[repo]?.hostDeps;
   } else if (/^https?:\/\//i.test(raw)) {
     return; // 远程 tarball 下载前无法廉价检查；罕见路径，放行
@@ -279,7 +327,7 @@ export async function assertSafeToInstall({ spec, registry, sources }) {
       // 无法识别形状的 spec 一律拒绝，而不是静默跳过检查。
       throw new Error(`cannot analyze install spec ${JSON.stringify(raw)} for host-shadow dependencies — refusing to install`);
     }
-    const info = await npmPackageInfo(name, { registry });
+    const info = await npmPackageInfo(name, { registry, signal });
     hostDeps = info?.hostDeps;
   }
   if (hostDeps !== undefined && hostDeps !== null && hostDeps.length > 0) {

package/src/guard.js

@@ -1460,8 +1460,49 @@ export function pnpmSpawnPlan({ platform = process.platform, pathEnv = process.e
   return { command: `"${cmd}"`, shell: true, treeKill: true };
 }
 
-function spawnCapture(command, args, options, onOutput) {
+/** Build the cancellation error every caller here recognises by `name`. */
+function abortError(message) {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+
+/**
+ * Whether an error is a cancellation rather than a failure. fetch/AbortSignal
+ * throw a DOMException named "AbortError"; abortError() above matches it. The
+ * distinction is load-bearing: a cancellation must never be reported as a
+ * verdict, cached, or turned into a failed install.
+ */
+export function isAbortError(error) {
+  return error?.name === "AbortError";
+}
+
+/**
+ * Spawn, stream, and capture — with an optional cancellation seam.
+ *
+ * `options.signal`/`options.treeKill` (5th argument) make the child killable:
+ * an already-aborted signal spawns nothing at all, and an abort mid-run
+ * terminates the child. `treeKill` mirrors installer.js killProcessTree — on
+ * Windows a shell-wrapped pnpm is a GRANDCHILD of cmd.exe, so killing the
+ * wrapper leaves the real pnpm running and still writing; taskkill /T /F takes
+ * the whole tree. Either way the promise still settles on 'close', never on
+ * the abort itself: the caller must not get control back (and start deleting
+ * the probe directory) while a pnpm process is still writing into it.
+ *
+ * 'close' bounds the WRITING, not the operating system's bookkeeping. It
+ * arrives the instant taskkill signals the wrapper, while Windows still holds
+ * the probe directory — it is the killed pnpm's cwd — for a moment longer, so
+ * an rmSync right here still hits EPERM. That last stretch belongs to
+ * cleanupProbeDir's retries, not to this promise.
+ */
+function spawnCapture(command, args, options, onOutput, { signal, treeKill = false } = {}) {
   return new Promise((resolvePromise) => {
+    if (signal?.aborted === true) {
+      // 已经取消了就一个字节都别做：spawn 之后再杀，probe 目录里会留下半棵
+      // 依赖树，pnpm store 也已经被写过。
+      resolvePromise({ exitCode: 1, output: "", aborted: true });
+      return;
+    }
     let child;
     const chunks = [];
     const push = (value) => {
@@ -1480,13 +1521,31 @@ function spawnCapture(command, args, options, onOutput) {
       resolvePromise({ exitCode: 1, output: "", error });
       return;
     }
+    let aborted = false;
+    const onAbort = () => {
+      aborted = true;
+      if (treeKill === true && process.platform === "win32" && typeof child.pid === "number") {
+        try {
+          spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true, timeout: 10000 });
+        } catch { /* taskkill 不在 PATH 上——退回下面的普通 kill */ }
+      }
+      try { child.kill(); } catch { /* already gone */ }
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const settle = (result) => {
+      signal?.removeEventListener("abort", onAbort);
+      resolvePromise({ ...result, aborted });
+    };
     child.stdout?.on("data", push);
     child.stderr?.on("data", push);
-    child.on("error", (error) => resolvePromise({ exitCode: 1, output: chunks.join(""), error }));
-    child.on("close", (exitCode) => resolvePromise({ exitCode: exitCode ?? 1, output: chunks.join("") }));
+    child.on("error", (error) => settle({ exitCode: 1, output: chunks.join(""), error }));
+    child.on("close", (exitCode) => settle({ exitCode: exitCode ?? 1, output: chunks.join("") }));
   });
 }
 
+/** Exported only so the self-test can drive the cancel path with a real child. */
+export const _spawnCaptureForTests = spawnCapture;
+
 // The install spec is eventually handed to `pnpm add` — through a cmd shell on
 // Windows, where Node joins the args with spaces and does not per-argument
 // quote. It must therefore be validated at the exported preflight boundary too,
@@ -1521,8 +1580,14 @@ function probeAddArgs(spec) {
 /**
  * Install a candidate into a disposable directory with every lifecycle script
  * disabled, then inspect its actual package manifest and patch files.
+ *
+ * `signal` cancels the probe. Cancellation is reported by THROWING an
+ * AbortError, never as a report: a report is a verdict about the candidate,
+ * and the caller caches and acts on it. "The user pressed cancel" is not a
+ * verdict — folding it into a blocked report would pin a fabricated blocker
+ * into the preflight cache for the rest of its TTL.
  */
-export async function preflightInstall({ profileDir, spec, onOutput }) {
+export async function preflightInstall({ profileDir, spec, onOutput, signal }) {
   try {
     assertSafeSpec(spec);
   } catch (error) {
@@ -1536,6 +1601,7 @@ export async function preflightInstall({ profileDir, spec, onOutput }) {
   }
   const probeDir = mkdtempSync(join(tmpdir(), "dsh-plugin-guard-"));
   try {
+    if (signal?.aborted === true) throw abortError(`preflight of ${spec} was cancelled before it started`);
     writeFileSync(join(probeDir, "package.json"), JSON.stringify({ name: "dsh-plugin-guard-probe", private: true }, undefined, 2) + "\n");
     writeFileSync(join(probeDir, "pnpm-workspace.yaml"), "packages:\n  - .\n\nnodeLinker: hoisted\n");
     // Reuse the profile's registry/auth settings for the probe. The file may
@@ -1545,7 +1611,18 @@ export async function preflightInstall({ profileDir, spec, onOutput }) {
     if (existsSync(profileNpmrc)) copyFileSync(profileNpmrc, join(probeDir, ".npmrc"));
     onOutput?.(`[dsh-plugin-guard] probing ${spec} with install scripts disabled\n`);
     const plan = pnpmSpawnPlan();
-    const result = await spawnCapture(plan.command, probeAddArgs(spec), { cwd: probeDir, env: process.env, shell: plan.shell }, onOutput);
+    const result = await spawnCapture(
+      plan.command,
+      probeAddArgs(spec),
+      { cwd: probeDir, env: process.env, shell: plan.shell },
+      onOutput,
+      { signal, treeKill: plan.treeKill },
+    );
+    // 取消先判：被杀掉的 pnpm 退出码非 0，不先分流就会被报成
+    // "无法在隔离环境解析插件" —— 一条纯属捏造的阻断结论。
+    if (result.aborted === true || signal?.aborted === true) {
+      throw abortError(`preflight of ${spec} was cancelled`);
+    }
     if (result.exitCode !== 0) {
       return {
         ok: false,
@@ -1570,6 +1647,10 @@ export async function preflightInstall({ profileDir, spec, onOutput }) {
     if (candidatePath === undefined) throw new Error(`installed package ${names[0]} has no resolvable package.json`);
     return inspectCandidate({ profileDir, candidateManifestPath: candidatePath, spec });
   } catch (error) {
+    // 取消必须先于这个兜底放行。兜底存在的意义是「任何意外都变成一份可读的
+    // 阻断报告」，而取消不是意外，是用户的指令；混进来就成了一条会被缓存、
+    // 会被当成候选包问题展示的假结论。
+    if (isAbortError(error)) throw error;
     return {
       ok: false,
       verdict: "blocked",
@@ -1580,7 +1661,41 @@ export async function preflightInstall({ profileDir, spec, onOutput }) {
   } finally {
     // probeDir is created by mkdtemp directly under the system temp folder;
     // it never contains user-authored files.
-    rmSync(probeDir, { recursive: true, force: true });
+    cleanupProbeDir(probeDir, onOutput);
+  }
+}
+
+/**
+ * Delete the throwaway probe directory — WITHOUT ever changing the outcome of
+ * the preflight that created it.
+ *
+ * Two things bite here, and they compound:
+ *
+ *  1. On Windows `'close'` arrives the instant taskkill /T /F signals the
+ *     wrapper, but the killed pnpm and its children release their file
+ *     handles a moment later. rmSync straight after a cancel therefore hits
+ *     EPERM on a directory that is about to become deletable. `maxRetries`
+ *     (Node retries exactly EBUSY/EMFILE/ENFILE/ENOTEMPTY/EPERM) rides that
+ *     out; the delay backs off linearly, so 10 × 100ms is ~5s worst case.
+ *
+ *  2. This runs in a `finally`, and an exception thrown from `finally`
+ *     REPLACES the one already propagating. So a failed cleanup used to
+ *     swallow the AbortError of a cancelled preflight and surface as
+ *     `failed: EPERM \\?\C:\...\dsh-plugin-guard-XXXX` — the user pressed
+ *     cancel and got an unreadable path error about a temp directory they
+ *     never knew existed. Leaking a temp dir the OS will reap anyway is far
+ *     cheaper than misreporting why the job ended, so the throw stops here.
+ *
+ * `remove` is a test seam. The real EPERM comes from an OS race — the probe
+ * directory is the killed pnpm's cwd, and Windows keeps it locked until that
+ * process is truly gone — which cannot be reproduced reliably in a fixture.
+ * The fixture therefore pins OUR error handling, not the kernel's timing.
+ */
+function cleanupProbeDir(probeDir, onOutput, remove = rmSync) {
+  try {
+    remove(probeDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+  } catch (error) {
+    onOutput?.(`[dsh-plugin-guard] could not remove probe directory ${probeDir} (${error?.code ?? error?.message}) — leaving it for the OS to reclaim\n`);
   }
 }
 
@@ -4575,6 +4690,94 @@ async function selfTest() {
       }
     }
 
+    // ── 取消传播（spawnCapture / preflightInstall）─────────────────────────
+    //
+    // 预检是 market_install 里唯一真正耗时的一段（隔离目录探装）。它此前完全
+    // 不可取消：按下 job_kill 只是标记了记录，pnpm 照跑到底。这三条钉的是
+    // 取消语义本身——不 spawn、等 close、以及「取消不是一份阻断报告」。
+    {
+      const marker = join(root, "child-ran.txt");
+      const writeMarker = `require("node:fs").writeFileSync(${JSON.stringify(marker)}, "ran")`;
+
+      // 1) 已经取消 → 一个子进程都不该起。
+      const preAborted = await _spawnCaptureForTests(
+        process.execPath,
+        ["-e", writeMarker],
+        { env: process.env },
+        undefined,
+        { signal: AbortSignal.abort() },
+      );
+      if (preAborted.aborted !== true) throw new Error("已 abort 的 signal 必须标记 aborted");
+      if (existsSync(marker)) throw new Error("已 abort 的 signal 仍然 spawn 了子进程");
+      console.log("PASS 取消：已 abort 的 signal 不 spawn 子进程");
+
+      // 2) 飞行中取消 → 杀掉子进程，但仍然等到 'close' 才 resolve。
+      //    （resolve 早于进程退出，调用方就会在 pnpm 还在写的时候删 probe 目录。）
+      const controller = new AbortController();
+      const startedAt = Date.now();
+      let closedAt;
+      const running = _spawnCaptureForTests(
+        process.execPath,
+        ["-e", `process.on("exit", () => {}); setTimeout(() => { ${writeMarker} }, 30000)`],
+        { env: process.env },
+        undefined,
+        { signal: controller.signal, treeKill: false },
+      ).then((result) => { closedAt = Date.now(); return result; });
+      await new Promise((r) => setTimeout(r, 150));
+      controller.abort();
+      const killed = await running;
+      const elapsed = closedAt - startedAt;
+      if (killed.aborted !== true) throw new Error("飞行中取消必须标记 aborted");
+      if (elapsed > 20000) throw new Error(`取消后应立即终止子进程，实测等了 ${elapsed}ms`);
+      if (existsSync(marker)) throw new Error("取消后子进程仍然跑完了它的工作");
+      console.log(`PASS 取消：飞行中取消终止子进程并等到 close 才 resolve（${elapsed}ms）`);
+
+      // 3) preflightInstall 取消 → 抛 AbortError，而不是返回一份 blocked 报告。
+      //    兜底 catch 会把任何异常变成「预检执行失败」的阻断结论；那份结论会
+      //    被上层缓存、展示成候选包的问题，而用户只是按了取消。
+      let cancelOutcome = "<resolved>";
+      try {
+        const report = await preflightInstall({ profileDir, spec: "any-package", signal: AbortSignal.abort() });
+        cancelOutcome = `report:${report.verdict}`;
+      } catch (error) {
+        cancelOutcome = isAbortError(error) ? "abort" : `error:${error?.name}`;
+      }
+      if (cancelOutcome !== "abort") throw new Error(`preflightInstall 取消必须上抛 AbortError，实得 ${cancelOutcome}`);
+      console.log("PASS 取消：preflightInstall 上抛 AbortError（不伪造阻断报告）");
+
+      // 4) 探针目录删不掉时，清理不许改变结局。
+      //    实测踩到的：取消后 taskkill /T /F 一发，wrapper 的 'close' 立刻到，
+      //    但探针目录是那个被强杀的 pnpm 的 cwd，Windows 会一直锁着它，
+      //    finally 里的 rmSync 撞 EPERM —— 而 finally 抛出的异常会顶掉正在
+      //    上抛的 AbortError，于是「用户按了取消」在 job 里显示成一条看不懂的
+      //    EPERM 临时目录路径。
+      //    这里注入一个必抛的 remove：真实 EPERM 靠的是 OS 时序，fixture 复现
+      //    不稳定（Node 的 openSync 带 FILE_SHARE_DELETE，占着句柄照样能删），
+      //    而要钉住的本来就是我们的错误处理，不是内核的时机。
+      const cleanupDir = mkdtempSync(join(tmpdir(), "dsh-guard-cleanup-"));
+      let cleanupThrew;
+      let cleanupReport = "";
+      try {
+        cleanupProbeDir(cleanupDir, (text) => { cleanupReport += text; }, () => {
+          const error = new Error(`EPERM, Permission denied: ${cleanupDir}`);
+          error.code = "EPERM";
+          throw error;
+        });
+      } catch (error) {
+        cleanupThrew = error;
+      }
+      if (cleanupThrew !== undefined) {
+        throw new Error(`cleanupProbeDir 抛了 ${cleanupThrew?.code ?? cleanupThrew?.message}——它跑在 finally 里，会顶掉 AbortError`);
+      }
+      if (!cleanupReport.includes("could not remove probe directory")) {
+        throw new Error("清理失败必须被报告出来，而不是静默吞掉");
+      }
+      // 真能删的时候要真的删掉——上面那条别把清理本身测没了。
+      cleanupProbeDir(cleanupDir, undefined);
+      if (existsSync(cleanupDir)) throw new Error("cleanupProbeDir 未能删除可删除的目录");
+      console.log("PASS 取消：探针目录清理失败不改变结局（且可删时确实删掉）");
+    }
+
     console.log("PASS conflict scan and snapshot/pending/rollback fixtures");
   } finally {
     rmSync(root, { recursive: true, force: true });