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

package/package.json

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

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.`);
@@ -618,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;
@@ -626,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 {
@@ -728,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 });

package/src/index.js

@@ -1771,7 +1771,19 @@ function rpcFail(error) {
 /**
  * Dispatch one /market RPC endpoint.
  */
-async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
+/**
+ * `signal` is the RPC carrier's AbortSignal: the Host aborts it when the
+ * browser side drops the connection mid-request (fetch aborted, tab closed,
+ * network gone) — see docs/dsh-notes.md「issue #7」. Per the official posture
+ * (tools.zh.md: "Async work must observe or forward exec.signal"), every
+ * branch that awaits NETWORK work inside the request lifetime forwards it, so
+ * a closed page stops the Host-side fetches instead of running them to the
+ * end for a response nobody will read. Branches that only start a job and
+ * return its id deliberately do NOT wire it: the job must outlive the request
+ * (same reason the agent producer does not consume exec.signal), its kill
+ * path is the job panel's cancel.
+ */
+async function rpcDispatch(ctx, endpoint, payload, config, token, tracker, signal) {
   const { defaultProfile = "web", apiBase = "https://api.github.com", perPageMax = 30, npmRegistry = "", rawSources = [] } = config;
   switch (endpoint) {
     case "search": {
@@ -1784,11 +1796,12 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
         minStars: payload?.minStars,
         apiBase,
         token,
+        signal,
       });
       return rpcOk(result);
     }
     case "verify": {
-      const result = await verifyPlugins({ repos: payload?.repos, sources: rawSources });
+      const result = await verifyPlugins({ repos: payload?.repos, sources: rawSources, signal });
       return rpcOk(result);
     }
     case "compat": {
@@ -1805,7 +1818,7 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
       const repos = [...new Set((Array.isArray(payload?.repos) ? payload.repos : []).map(String)
         .filter((repo) => /^[^@/\s][^/\s]*\/[^/\s]+$/.test(repo) && !repo.includes("..")))].slice(0, 30);
       if (repos.length === 0) return rpcOk({ results: {} });
-      await verifyPlugins({ repos, sources: rawSources }); // populates the manifest cache
+      await verifyPlugins({ repos, sources: rawSources, signal }); // populates the manifest cache
       let fingerprint;
       const results = {};
       await mapLimit(repos, NETWORK_CONCURRENCY, async (repo) => {
@@ -1817,7 +1830,7 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
         try {
           let patchText;
           if (typeof manifest.dsh?.bundle?.patch === "string") {
-            patchText = await fetchRawFile(repo, manifest.dsh.bundle.patch, { sources: rawSources });
+            patchText = await fetchRawFile(repo, manifest.dsh.bundle.patch, { sources: rawSources, signal });
           }
           fingerprint ??= computeProfileFingerprint(profileDir);
           const cacheKey = `${fingerprint}::${repo}`;
@@ -1833,7 +1846,10 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
           };
           compatCacheSet(cacheKey, entry);
           results[repo] = entry;
-        } catch {
+        } catch (error) {
+          // 取消必须先于兜底放行：客户端已经断开，把 AbortError 吞成
+          // "unknown" 会让剩下的仓库继续被逐个扫完——为一份没人读的响应。
+          if (isAbortError(error)) throw error;
           results[repo] = { state: "unknown", summary: "兼容性检查失败" };
         }
       });
@@ -1852,7 +1868,7 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
       const results = {};
       await mapLimit(deps, NETWORK_CONCURRENCY, async (dep) => {
         if (dep.kind === "missing") { results[dep.name] = { latest: null }; return; }
-        const info = await npmPackageInfo(dep.name, { registry });
+        const info = await npmPackageInfo(dep.name, { registry, signal });
         results[dep.name] = info === null
           ? { latest: null }
           : { latest: info.latest, hasUpdate: compareVersions(info.latest, dep.version) > 0 };
@@ -1860,7 +1876,7 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
       return rpcOk(results);
     }
     case "info": {
-      const result = await repoInfo({ repo: payload?.repo, apiBase, token });
+      const result = await repoInfo({ repo: payload?.repo, apiBase, token, signal });
       return rpcOk(result);
     }
     case "installed": {
@@ -1947,7 +1963,10 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
       }
       try {
         const registry = await registryFor(profile, npmRegistry);
-        const resolved = await preferNpmSpec({ spec, registry, sources: rawSources });
+        // registryFor 刻意不接 signal（缓存的是 promise，一次取消会污染整条
+        // 缓存——见 createInstallJobProducer 的注释）；它之后的联网步骤接。
+        const resolved = await preferNpmSpec({ spec, registry, sources: rawSources, signal });
+        signal?.throwIfAborted(); // 断连发生在解析完成与建 job 之间：一个 job 都不要建
         const jobId = tracker.startCustom({
           kind: "dsh-plugin-preflight",
           label: `preflight ${resolved}`,
@@ -1983,6 +2002,9 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
         });
         return rpcOk({ jobId, profile, spec: resolved });
       } catch (error) {
+        // 取消不是业务失败：客户端已断开，rpcFail 的响应没人读，还会在
+        // 存活的重连页面上被当成市场故障渲染出来。
+        if (isAbortError(error)) throw error;
         return rpcFail(error);
       }
     }
@@ -2232,9 +2254,16 @@ function registerRpcChannel(ctx, config, token) {
   const tracker = createJobTracker();
   ctx.inject(["connection"], (connectionCtx) => {
     connectionCtx.connection.rpc.handle("/market", async (endpoint, payload, signal) => {
+      // signal 是 carrier 的取消信号：浏览器断开（关页/断网/主动 abort）时
+      // Host 侧 abort（见 docs/dsh-notes.md「issue #7」）。此前在这里被扔掉，
+      // 查询类 RPC 在页面关掉后照跑到底。
       try {
-        return await rpcDispatch(ctx, endpoint, payload ?? {}, config, token, tracker);
+        return await rpcDispatch(ctx, endpoint, payload ?? {}, config, token, tracker, signal);
       } catch (error) {
+        // 取消归类为「输给取消」而非业务错误：不打错误日志（每次关页都会
+        // 触发一次，纯噪音），也不转 rpcFail——响应早已无人读，转了只会在
+        // 存活的重连页面上被渲染成市场故障。
+        if (isAbortError(error)) throw error;
         console.error(`[dsh-plugin-mall] /market/${String(endpoint)} failed:`, error);
         return rpcFail(error);
       }
@@ -3714,6 +3743,39 @@ export async function runSelfTests() {
         `extras=${JSON.stringify(integrationDelta.snapshot?.extras)?.slice(0, 120)}`);
     }
 
+    // ── 12d. 查询类 RPC 响应 carrier 取消（issue #7）────────────────────────
+    //
+    // carrier signal 在 Host 收到浏览器断连时 abort。用预 abort 的 signal 验
+    // 接线：fetch 在发起任何网络请求前立刻拒绝。若某个分支没接（收了没传），
+    // 离线环境里它会真去连网——要么慢超时要么返回正常结果，断言随之下沉。
+    {
+      const cfg = { apiBase: "https://api.github.com", npmRegistry: "https://registry.npmjs.org", rawSources: [] };
+      const assertAborts = async (label, endpoint, rpcPayload) => {
+        try {
+          const value = await rpcDispatch(null, endpoint, rpcPayload, cfg, undefined, createJobTracker(), AbortSignal.abort());
+          check(label, false, `返回了 ${JSON.stringify(value).slice(0, 60)}——signal 没接进 ${endpoint}`);
+        } catch (error) {
+          check(label, isAbortError(error), `抛了 ${error?.name}: ${String(error?.message).slice(0, 60)}`);
+        }
+      };
+      await assertAborts("search 预取消 → AbortError（不发任何请求）", "search", { query: "x" });
+      await assertAborts("verify 预取消 → AbortError", "verify", { repos: ["owner/repo"] });
+      await assertAborts("info 预取消 → AbortError（不被包装成 not found）", "info", { repo: "owner/repo" });
+
+      // preflight：断连发生在解析与建 job 之间——一个 job 都不许建，否则
+      // 面板上会冒出一个注定无人认领的孤儿任务。
+      const abortTracker = createJobTracker();
+      const abortSession = `sess_${"a".repeat(32)}`; // 合法 nonce 形状
+      try {
+        const preflightValue = await rpcDispatch(null, "preflight", { session: abortSession, spec: "github:owner/repo" }, cfg, undefined, abortTracker, AbortSignal.abort());
+        check("preflight 预取消 → AbortError 且不建 job", false, `没有抛，返回 ${JSON.stringify(preflightValue).slice(0, 200)}`);
+      } catch (error) {
+        check("preflight 预取消 → AbortError 且不建 job",
+          isAbortError(error) && abortTracker.list(abortSession).length === 0,
+          `${error?.name} jobs=${abortTracker.list(abortSession).length}`);
+      }
+    }
+
     // ── 13. market_install：整条链跑在 job 里（issue #8）────────────────────
     // 原来 registry 查询 → 防抢注解析 → 隔离预检全在 ctx.jobs.start() 之前 await，
     // 于是几十秒里没有 job id、没有日志、job_kill 够不着，而工具描述写的是