@1e0zj/dsh-plugin-mall 0.4.2 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1e0zj/dsh-plugin-mall",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "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

@@ -64,7 +64,29 @@ async function requestJson(path, { apiBase, token, signal }) {
     }
     const remaining = response.headers.get("x-ratelimit-remaining");
     const resetAt = response.headers.get("x-ratelimit-reset");
-    const body = await response.json().catch(() => undefined);
+    // 读体阶段的三种失败必须分开，不能一把 catch 成 undefined：
+    //   调用方取消（响应头已到、body 读到一半浏览器断开）→ AbortError 上抛；
+    //   内部超时打断读体 → 与请求阶段超时同待遇，退避后重试；
+    //   响应体根本不是 JSON（镜像的 HTML 错误页等）→ 维持 undefined，交给
+    //   下面的状态码分支。
+    // 此前这里是无差别 .catch(() => undefined)：mid-body 取消被吞掉，200 响应
+    // 返回 undefined，search 拿到的是 TypeError 而不是取消；4xx 路径则把一次
+    // 取消谎报成 not found。
+    let body;
+    try {
+      body = await response.json();
+    } catch (error) {
+      if (error?.name === "AbortError" && signal?.aborted) throw error;
+      // 读体超时只在成功响应上重试。4xx 的结论在读体之前就已确定
+      // （见上方契约：4xx 判定式失败，从不重试）——404 有 404 的报法、
+      // 403 限流有专用诊断，读不出 body 不改变任何一件事；重试三次
+      // 只会把正确答案换成一句超时。
+      if (error?.name === "TimeoutError" && response.ok) {
+        lastError = new Error(`GitHub API response body timed out after ${REQUEST_TIMEOUT / 1000}s (attempt ${attempt + 1})`);
+        continue;
+      }
+      body = undefined;
+    }
     if (response.status === 403 && remaining === "0" && resetAt !== null) {
       const reset = new Date(Number(resetAt) * 1000).toISOString();
       throw new Error(`GitHub API rate limit exceeded; resets at ${reset} (UTC). Set GITHUB_TOKEN or DSH_MARKET_GITHUB_TOKEN for a higher limit.`);
@@ -173,16 +195,19 @@ function normalizeRegistry(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).
+ *   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, signal } = {}) {
+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 都在）。
@@ -215,6 +240,44 @@ export async function npmPackageInfo(name, { registry, signal } = {}) {
   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
@@ -577,6 +640,9 @@ export async function repoInfo({ repo, apiBase, token, signal }) {
   try {
     meta = await requestJson(`/repos/${trimmed}`, { apiBase, token, signal });
   } catch (error) {
+    // 取消不是「仓库不存在」：包装会把这个信号翻译成业务错误，调用方据此
+    // 报告一个不存在的网络故障。取消原样上抛。
+    if (error?.name === "AbortError") throw error;
     throw new Error(`market_info: repository ${trimmed} not found on GitHub (${error.message})`);
   }
   let packageJson;
@@ -585,7 +651,8 @@ export async function repoInfo({ repo, apiBase, token, signal }) {
     if (typeof contents.content === "string") {
       packageJson = JSON.parse(Buffer.from(contents.content, "base64").toString("utf8"));
     }
-  } catch {
+  } catch (error) {
+    if (error?.name === "AbortError") throw error; // 取消不是「没有 package.json」
     packageJson = undefined; // no package.json at the repo root
   }
   return {
@@ -687,6 +754,79 @@ if (process.argv[1]?.endsWith("github.js") && process.argv.includes("--self-test
     }
     if (clampFailed > 0) process.exit(1);
   }
+  // requestJson 读体阶段的三种失败。打桩 fetch——离线、确定性；abort 在
+  // json() 内部发生（不是调用前预 abort），逼近「响应头已到、body 读一半
+  // 浏览器断开」的真实时序。
+  {
+    const realFetch = globalThis.fetch;
+    const makeError = (name) => { const error = new Error("synthetic"); error.name = name; return error; };
+    const fakeResponse = ({ status, headers, json }) => ({
+      ok: status < 400,
+      status,
+      statusText: status === 404 ? "Not Found" : status === 403 ? "Forbidden" : "OK",
+      headers: headers ?? new Headers(),
+      json,
+    });
+    let failed = 0;
+    try {
+      // 1) mid-body 取消：json() 里才 abort。修复前 .catch(()=>undefined)
+      //    把它吞掉——200 变 undefined（search 得 TypeError）、4xx 谎报 not found。
+      {
+        const controller = new AbortController();
+        let threw;
+        globalThis.fetch = async () => fakeResponse({
+          status: 200,
+          json: async () => { controller.abort(); throw makeError("AbortError"); },
+        });
+        try {
+          await requestJson("/repos/owner/repo", { signal: controller.signal });
+        } catch (error) { threw = error; }
+        if (threw?.name === "AbortError") console.log("  PASS 读体期间取消 → AbortError 上抛（不吞成 undefined）");
+        else { failed++; console.log(`  FAIL 读体期间取消应抛 AbortError，实得 ${threw ? `${threw.name}: ${threw.message}` : "未抛（body 变 undefined）"}`); }
+      }
+
+      // 2) 成功响应的读体超时 → 记一次失败，退避重试（重试轮换成成功）。
+      {
+        let attempts = 0;
+        globalThis.fetch = async () => fakeResponse({
+          status: 200,
+          json: async () => { attempts++; if (attempts === 1) throw makeError("TimeoutError"); return { ok: true }; },
+        });
+        const retried = await requestJson("/repos/owner/repo", {});
+        if (retried?.ok === true && attempts === 2) console.log("  PASS 读体超时（200）→ 记一次失败并重试成功");
+        else { failed++; console.log(`  FAIL 读体超时（200）应重试一次，实得 attempts=${attempts} result=${JSON.stringify(retried)}`); }
+      }
+
+      // 3) 4xx 的结论在读体之前就已确定，读体超时绝不重试——重试只会把
+      //    正确的 404 换成一句超时。一次调用、报 404 的报法。
+      {
+        let calls = 0;
+        globalThis.fetch = async () => { calls++; return fakeResponse({ status: 404, json: async () => { throw makeError("TimeoutError"); } }); };
+        let threw;
+        try {
+          await requestJson("/repos/owner/absent", {});
+        } catch (error) { threw = error; }
+        if (calls === 1 && /GitHub API 404/.test(threw?.message ?? "")) console.log("  PASS 读体超时（404）→ 不重试，保留 404 结论");
+        else { failed++; console.log(`  FAIL 404+读体超时应一次调用报 404，实得 calls=${calls} error=${threw?.message}`); }
+      }
+
+      // 4) 403 限流同理：专用诊断靠响应头（不依赖 body），必须一次到位。
+      {
+        let calls = 0;
+        const limited = new Headers({ "x-ratelimit-remaining": "0", "x-ratelimit-reset": "4102444800" });
+        globalThis.fetch = async () => { calls++; return fakeResponse({ status: 403, headers: limited, json: async () => { throw makeError("TimeoutError"); } }); };
+        let threw;
+        try {
+          await requestJson("/search/repositories", {});
+        } catch (error) { threw = error; }
+        if (calls === 1 && /rate limit exceeded/.test(threw?.message ?? "")) console.log("  PASS 读体超时（403 限流）→ 不重试，保留限流诊断");
+        else { failed++; console.log(`  FAIL 403+读体超时应一次调用给限流诊断，实得 calls=${calls} error=${threw?.message}`); }
+      }
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+    if (failed > 0) process.exit(1);
+  }
   if (process.argv.includes("--offline")) process.exit(0);
   const apiBase = "https://api.github.com";
   const result = await searchPlugins({ query: "", perPage: 3, apiBase });