dsh-app-updater 1.3.0 → 1.3.2

package/lib/engine.js

@@ -27,6 +27,7 @@ import {
 import { readRegistryApps, normalizeName } from "./registry.js";
 import { compareVersions, isNewer, looksLikeVersion } from "./version.js";
 import { detectEnvironment, describeEnvironment, engineFor, ENGINE_BREW, ENGINE_WINGET } from "./platform.js";
+import { scanAppBundles, fetchCaskCatalog, parseCaskCatalog, buildMacosItems } from "./macos.js";
 
 const INSTALLER_EXT = /\.(exe|msi|msix|appx|msixbundle|pkg|dmg)$/i;
 
@@ -1113,88 +1114,70 @@ export function parseBrewOutdated(text) {
 
 async function scanMacos({ settings, log, signal, env, startedAt, warnings }) {
   const brewPath = findBrew();
-  const items = [];
 
-  if (!brewPath) {
-    warnings.push("未找到 Homebrew，macOS 上无法检测/更新应用（安装 Homebrew 后重新检测即可）");
+  /* ---------------------------------------------------------------- *
+   * 1. 先枚举「本机到底装了哪些应用」——这一步不依赖 Homebrew。
+   *    旧实现只读 `brew list --cask`，没走 Homebrew 装的应用一个都看不到，
+   *    于是正常 Mac 上就是「未检测到任何已安装应用」。
+   * ---------------------------------------------------------------- */
+  log("info", "正在枚举应用目录（/Applications 等）…");
+  const apps = await scanAppBundles({ log });
+
+  /* ---------------------------------------------------------------- *
+   * 2. Homebrew：哪些 cask 已装、哪些有新版（没装 Homebrew 也继续）。
+   * ---------------------------------------------------------------- */
+  let brewVersion = "";
+  const brews = new Map();
+  const outdated = new Map();
+
+  if (brewPath) {
+    const verRes = await runBrew(brewPath, ["--version"], { timeoutMs: 30000 });
+    brewVersion = firstLine(outputText(verRes)).replace(/^Homebrew\s+/i, "");
+    log("info", `Homebrew ${brewVersion}（${brewPath}）· ${env.archLabel}`);
+
+    const listRes = await runBrew(brewPath, ["list", "--cask", "--versions"], { signal });
+    for (const [token, version] of parseBrewCaskVersions(listRes.stdout)) brews.set(token, version);
+    log("info", `Homebrew 报告 ${brews.size} 个已安装 cask`);
+
+    const outRes = await runBrew(brewPath, ["outdated", "--json=v2", "--cask", "--greedy"], { signal });
+    for (const [token, version] of parseBrewOutdated(outRes.stdout)) outdated.set(token, version);
+    log("info", `其中 ${outdated.size} 个有新版本`);
+  } else {
+    warnings.push("未找到 Homebrew：可以列出已安装应用，但无法判断/驱动更新（安装 Homebrew 后可一键升级 cask 应用）");
     log("warn", warnings[warnings.length - 1]);
-    return {
-      env,
-      engine: { id: ENGINE_BREW, available: false, version: "", path: "" },
-      scannedAt: Date.now(),
-      startedAt,
-      stats: { total: 0, upgradable: 0, unsupported: 0 },
-      items,
-      warnings,
-    };
-  }
-
-  const verRes = await runBrew(brewPath, ["--version"], { timeoutMs: 30000 });
-  const brewVersion = firstLine(outputText(verRes)).replace(/^Homebrew\s+/i, "");
-  log("info", `Homebrew ${brewVersion}（${brewPath}）· ${env.archLabel}`);
-
-  const listRes = await runBrew(brewPath, ["list", "--cask", "--versions"], { signal });
-  const installed = parseBrewCaskVersions(listRes.stdout);
-  log("info", `Homebrew 报告 ${installed.size} 个已安装 cask 应用`);
-
-  const outRes = await runBrew(brewPath, ["outdated", "--json=v2", "--cask", "--greedy"], { signal });
-  const outdated = parseBrewOutdated(outRes.stdout);
-  log("info", `其中 ${outdated.size} 个有新版本`);
-
-  for (const [token, version] of installed) {
-    const available = outdated.get(token) || "";
-    const hasUpdate = Boolean(available) && (!version || isNewer(available, version));
-    items.push({
-      id: `brew:${token}`,
-      name: token,
-      version: version || "",
-      available: hasUpdate ? available : "",
-      publisher: "Homebrew cask",
-      source: "homebrew",
-      installLocation: "",
-      hasUpdate,
-      updateSupported: hasUpdate,
-      reason: hasUpdate ? null : null,
-      kind: "cask",
-    });
   }
 
-  // 有更新但没在「已安装」列表里露出的（例如 --greedy 强制升级项）也补进来
-  for (const [token, available] of outdated) {
-    if (installed.has(token)) continue;
-    items.push({
-      id: `brew:${token}`,
-      name: token,
-      version: "",
-      available,
-      publisher: "Homebrew cask",
-      source: "homebrew",
-      installLocation: "",
-      hasUpdate: true,
-      updateSupported: true,
-      reason: null,
-      kind: "cask",
-    });
+  /* ---------------------------------------------------------------- *
+   * 3. cask 目录：把 .app 反查到 cask token，才能知道官网最新版本。
+   *    抓不到就降级（只显示 Homebrew 自己报告的信息），不中断扫描。
+   * ---------------------------------------------------------------- */
+  let catalog = null;
+  if (brewPath) {
+    const list = await fetchCaskCatalog({ log, warnings });
+    if (list) catalog = parseCaskCatalog(list);
   }
 
-  items.sort((a, b) => {
-    if (a.hasUpdate !== b.hasUpdate) return a.hasUpdate ? -1 : 1;
-    return String(a.name).localeCompare(String(b.name));
-  });
+  /* ---------------------------------------------------------------- *
+   * 4. 合并：已装应用 + Homebrew 管理状态 → 最终列表
+   * ---------------------------------------------------------------- */
+  const built = buildMacosItems({ apps, brews, outdated, catalog, settings });
+  const items = built.items;
+  for (const w of built.warnings) if (!warnings.includes(w)) warnings.push(w);
 
   const stats = {
     total: items.length,
     upgradable: items.filter((i) => i.hasUpdate).length,
-    unsupported: 0,
+    unsupported: items.filter((i) => !i.updateSupported).length,
   };
   log("success", `扫描完成：${stats.total} 个应用，${stats.upgradable} 个可更新`);
+
   if (settings.includeStoreApps) {
-    warnings.push("macOS 的应用商店（App Store）应用不在 Homebrew 覆盖范围内，本插件不会更新它们");
+    warnings.push("App Store 应用只列出、不由本插件更新（由 App Store 自己负责升级）");
   }
 
   return {
     env,
-    engine: { id: ENGINE_BREW, available: true, version: brewVersion, path: brewPath },
+    engine: { id: ENGINE_BREW, available: Boolean(brewPath), version: brewVersion, path: brewPath || "" },
     scannedAt: Date.now(),
     startedAt,
     stats,
@@ -1227,6 +1210,19 @@ async function runMacosUpdates({ ids, settings, log, onProgress, signal, env })
       log("warn", `已取消：${rawId}`);
       break;
     }
+    // 非 Homebrew 管理的应用（macapp:…）没有可交给 brew 的 token：
+    // 明确报「不由本插件更新」，而不是把一个 bundle id 当 cask 名去执行。
+    if (!String(rawId).startsWith("brew:")) {
+      index += 1;
+      results.push({
+        id: rawId,
+        ok: false,
+        error: "该应用不由 Homebrew 管理（拖 DMG / 手动安装），本插件只能列出、不能更新它；请在应用内或官网升级",
+      });
+      log("warn", `${rawId} 跳过：非 Homebrew 管理的应用`);
+      onProgress({ running: true, total: queue.length, done: index, current: null, results });
+      continue;
+    }
     index += 1;
     const token = String(rawId).replace(/^brew:/, "");
     onProgress({ running: true, total: queue.length, done: index - 1, current: token });

package/lib/index.js

@@ -2,7 +2,8 @@
  * dsh-app-updater 宿主半身。
  *
  * 职责：暴露 HTTP 路由给设置页 UI，串行调度「扫描」与「更新」两条后台任务，
- * 把进度写进持久化状态。所有写操作都要求 loopback 来源 + confirm:true。
+ * 把进度写进持久化状态。所有路由默认拒绝：先过宿主 connection 准入；写操作另需
+ * confirm:true。仅在用户显式开启兼容模式时，才按「回环地址」放行（默认关闭）。
  *
  * 设计上不依赖宿主内部服务（不用 llm / tools / agent），只依赖 webServer，
  * 因此在没有 Web 的 composition 里它会安静地不挂载任何路由。
@@ -86,46 +87,110 @@ export function hasConnectionCredentials(req) {
 }
 
 /**
- * connection 准入（宿主信任边界）。
+ * 兼容模式开关：只允许在用户**显式开启**时按「回环地址」放行。
+ *
+ * 1.3.0 在 `connection` 不可用（或没有凭据可核验）时会直接按回环放行，旧宿主上
+ * 等于绕过了认证就能调用安装接口 —— 市场复核要求这条路径改为默认拒绝。
+ * 因此 1.3.1 起默认关闭，只有下面两种显式动作之一才恢复（并会在响应头、状态接口
+ * 与日志里标注，方便复核）：
+ *   - 插件配置 `allowLegacyLoopback: true`（cordis patch 的 `config`）
+ *   - 环境变量 `DSH_APP_UPDATER_ALLOW_LEGACY_LOOPBACK=1`
+ */
+export const LEGACY_LOOPBACK_ENV = "DSH_APP_UPDATER_ALLOW_LEGACY_LOOPBACK";
+
+function truthyFlag(value) {
+  if (value === true || value === 1) return true;
+  if (typeof value !== "string") return false;
+  return /^(1|true|yes|on)$/i.test(value.trim());
+}
+
+/** 解析兼容模式开关：插件配置优先，其次环境变量；默认（两者都没有）为 false。 */
+export function resolveLegacyLoopbackOptIn(config, env = process.env) {
+  if (config && truthyFlag(config.allowLegacyLoopback)) return true;
+  return truthyFlag((env || {})[LEGACY_LOOPBACK_ENV]);
+}
+
+/** 兼容模式放行时打标记，便于复核与排障：正常准入不会出现这两个头。 */
+function markLegacyAdmission(res) {
+  if (typeof res.setHeader !== "function") return;
+  res.setHeader("X-DSH-Admission", "loopback-legacy-optin");
+  res.setHeader("X-DSH-Admission-Warning", "legacy-loopback-compatibility-enabled");
+}
+
+/** 统一写出拒绝响应，并标明是「被拒绝」而不是「未经过闸门」。 */
+function denyAdmission(res, status, error) {
+  if (typeof res.setHeader === "function") res.setHeader("X-DSH-Admission", "denied");
+  json(res, status, { ok: false, error, admission: "denied" });
+}
+
+/**
+ * connection 准入（宿主信任边界）。**默认拒绝**。
  *
  * DSH 的 `connection` 服务负责插件 HTTP 路由的信任校验：`admit(request)` 先做
  * Host/Origin 校验，再做浏览器会话 / API 认证，返回本次调用对应的 Peer，或用
- * `401`（未认证）/`403`（不可信来源）拒绝 —— 宿主自己的 `/api` 路由用的就是它。
+ * `401`（未认证）/`403`（不可信来源）/`409`（连接已被占用）拒绝 —— 宿主自己的
+ * `/api` 路由用的就是它。
  *
- * 退回策略（只有一条，且完全不涉及凭据）：宿主没有 `connection` 服务，
- * 或者请求**没有携带任何连接凭据**、来自回环地址时，按旧的「回环」规则放行，
- * 并在响应头标注 `X-DSH-Admission: loopback-legacy`。
- * 带凭据的请求一律以 admission 的结果为准；非回环请求一律拒绝。
+ * 规则（按顺序）：
+ * 1. 宿主有 `connection`：一律以 `admit()` 为准，通过就放行；
+ *    只有「401 + 回环 + 没有任何凭据 + 用户显式开启兼容模式」这一种情况例外，
+ *    否则按 `admit()` 给出的状态码拒绝。
+ * 2. 宿主没有 `connection`：**默认拒绝**（403）。只有用户显式开启兼容模式、
+ *    且请求来自回环地址时才放行。
  *
  * @returns {boolean} 已放行 true；已写出拒绝响应 false
  */
-export function admissionGate(req, res, connection) {
+export function admissionGate(req, res, connection, options = {}) {
   const loopback = isLoopback(req);
+  const optIn = options.allowLegacyLoopback === true;
   if (connection && typeof connection.admit === "function") {
     let admission;
     try {
       admission = connection.admit(req);
     } catch (err) {
-      json(res, 500, { ok: false, error: `连接准入失败：${String((err && err.message) || err)}` });
+      denyAdmission(res, 500, `连接准入失败：${String((err && err.message) || err)}`);
+      return false;
+    }
+    if (!admission || typeof admission !== "object") {
+      // 宿主实现异常时宁可拒绝，也不要把「看不懂的结果」当成放行
+      denyAdmission(res, 500, "连接准入返回了无法识别的结果，按默认拒绝处理");
       return false;
     }
-    if (!admission || typeof admission.rejection !== "number") return true;
-    if (admission.rejection === 401 && loopback && !hasConnectionCredentials(req)) {
-      // 宿主自己的载体（Electron 经 IPC 桥接的 fetch）与本机脚本都不带 Cookie，
-      // 没有可核验的凭据，只能按回环信任放行 —— 与接入准入之前的行为一致。
-      if (typeof res.setHeader === "function") res.setHeader("X-DSH-Admission", "loopback-legacy");
+    if (!("rejection" in admission)) return true;
+    if (typeof admission.rejection !== "number") {
+      denyAdmission(res, 403, "连接准入返回了无法识别的拒绝码，按默认拒绝处理");
+      return false;
+    }
+    if (admission.rejection === 401 && loopback && !hasConnectionCredentials(req) && optIn) {
+      // 例外路径：宿主自己的载体（Electron 经 IPC 桥接的 fetch）与本机脚本都不带
+      // Cookie，没有可核验的凭据。只有用户显式开启兼容模式才退回回环信任。
+      markLegacyAdmission(res);
       return true;
     }
-    res.writeHead(admission.rejection, { "Content-Type": "text/plain; charset=utf-8" });
-    res.end(admission.rejection === 401 ? "unauthorized" : "forbidden");
+    const status = admission.rejection === 403 ? 403 : admission.rejection === 409 ? 409 : 401;
+    denyAdmission(
+      res,
+      status,
+      status === 401
+        ? "请求未通过 DSH connection 认证：缺少有效的会话 Cookie / API 凭据"
+        : status === 409
+          ? "请求对应的连接已被占用"
+          : "请求来源不受信任：Host/Origin 校验未通过"
+    );
     return false;
   }
-  if (!loopback) {
-    json(res, 403, { ok: false, error: "只接受本机请求（loopback）：当前宿主没有可用的 connection 准入服务" });
-    return false;
+  if (optIn && loopback) {
+    markLegacyAdmission(res);
+    return true;
   }
-  if (typeof res.setHeader === "function") res.setHeader("X-DSH-Admission", "loopback-legacy");
-  return true;
+  denyAdmission(
+    res,
+    403,
+    optIn
+      ? "只接受本机（loopback）请求：当前宿主没有可用的 connection 准入服务"
+      : "拒绝访问：当前宿主没有 connection 准入服务，兼容模式（仅回环放行）未开启，按默认拒绝处理"
+  );
+  return false;
 }
 
 /**
@@ -343,16 +408,30 @@ function openFolder(path) {
 
 export default {
   name: "dsh-app-updater",
-  apply(ctx) {
+  apply(ctx, config) {
+    // 兼容模式：默认关闭。只有用户显式写进插件配置或环境变量才开启（见 LEGACY_LOOPBACK_ENV）。
+    const allowLegacyLoopback = resolveLegacyLoopbackOptIn(config);
+
     ctx.effect(() => {
-      store.load().catch(() => {});
+      store
+        .load()
+        .then(() => {
+          if (allowLegacyLoopback) {
+            store.log(
+              "warn",
+              "兼容模式（allowLegacyLoopback）已开启：没有连接凭据的回环请求会按本机信任放行；" +
+                "建议只在旧宿主（没有 connection 服务）上临时使用"
+            );
+          }
+        })
+        .catch(() => {});
     }, "dsh-app-updater: load state");
 
     ctx.inject(["webServer"], (webCtx) => {
       const webServer = webCtx.webServer;
 
       // connection 准入：宿主提供的信任边界（Host/Origin 校验 + 浏览器/API 认证）。
-      // 它在宿主没有 Web 载体时不存在，此时 admissionGate 退回旧的「回环」检查。
+      // 它在宿主没有 Web 载体时不存在，此时 admissionGate 默认拒绝，除非兼容模式显式开启。
       let connection = null;
       ctx.inject(["connection"], (connCtx) => {
         connection = connCtx.connection;
@@ -362,6 +441,22 @@ export default {
       });
       const routes = [];
 
+      /** 准入现状：写进状态接口，界面/复核者不必读代码就知道当前走的是哪条路径。 */
+      const admissionInfo = () => ({
+        mode: connection
+          ? allowLegacyLoopback
+            ? "connection+loopback-legacy"
+            : "connection"
+          : allowLegacyLoopback
+            ? "loopback-legacy-optin"
+            : "deny",
+        service: Boolean(connection),
+        allowLegacyLoopback,
+        warning: allowLegacyLoopback
+          ? "兼容模式已开启：没有连接凭据的本机回环请求会被放行，仅应在旧宿主上临时使用"
+          : null,
+      });
+
       /**
        * 注册一条路由：请求先过 connection 准入（见 admissionGate），再进业务处理。
        * 写接口另有 `confirm:true` 闸门（writeGate）。
@@ -372,7 +467,7 @@ export default {
             kind: "exact",
             path: `${PREFIX}${path}`,
             handler: (req, res) => {
-              if (!admissionGate(req, res, connection)) return;
+              if (!admissionGate(req, res, connection, { allowLegacyLoopback })) return;
               return handler(req, res);
             },
           })
@@ -382,7 +477,7 @@ export default {
       register("/state.json", async (req, res) => {
         try {
           await store.load();
-          json(res, 200, buildStatePayload());
+          json(res, 200, { ...buildStatePayload(), admission: admissionInfo() });
         } catch (err) {
           json(res, 500, { ok: false, error: String((err && err.message) || err) });
         }
@@ -479,6 +574,7 @@ export default {
           envSummary: describeEnvironment(env),
           engine,
           capabilities: capabilitiesFor(env, Boolean(engine.available)),
+          admission: admissionInfo(),
           routes: routes.length,
           dataDir: join(process.env.DSH_HOME || join(homedir(), ".dsh"), "dsh-app-updater"),
         });