herdr-remote 0.2.16 → 0.2.17

package/dist/tui.mjs

@@ -415,6 +415,9 @@ var require_updater = __commonJS({
       }
       return "npm";
     }
+    function updateChecksEnabled2(env = process.env) {
+      return env.HERDR_REMOTE_UPDATE_CHECK !== "0";
+    }
     function canSelfUpdate2() {
       return installKind2() === "npm";
     }
@@ -466,92 +469,173 @@ var require_updater = __commonJS({
       }
       return 0;
     }
-    async function askRegistry(registry, { timeoutMs, fetchImpl }) {
+    async function fetchJson(url, { timeoutMs, fetchImpl }) {
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), timeoutMs);
       try {
-        const response = await fetchImpl(`${registry}/${PACKAGE_NAME}/latest`, {
+        const response = await fetchImpl(url, {
           signal: controller.signal,
-          headers: { Accept: "application/vnd.npm.install-v1+json" }
+          headers: { Accept: "application/json", "Cache-Control": "no-cache" }
         });
         if (!response.ok) return { ok: false, message: `HTTP ${response.status ?? "?"}` };
-        const body = await response.json();
-        const latest = typeof body?.version === "string" ? body.version : null;
-        if (!latest) return { ok: false, message: "registry answered without a version" };
-        return { ok: true, latest };
+        return { ok: true, body: await response.json() };
       } catch (error) {
         return { ok: false, message: error?.name === "AbortError" ? "timed out" : String(error?.message || error) };
       } finally {
         clearTimeout(timer);
       }
     }
+    async function askRegistry(registry, { timeoutMs, fetchImpl }) {
+      const endpoints = [
+        { url: `${registry}/-/package/${PACKAGE_NAME}/dist-tags`, read: (body) => body?.latest },
+        { url: `${registry}/${PACKAGE_NAME}/latest`, read: (body) => body?.version }
+      ];
+      let message = null;
+      for (const endpoint of endpoints) {
+        const attempt = await fetchJson(endpoint.url, { timeoutMs, fetchImpl });
+        if (!attempt.ok) {
+          message = attempt.message;
+          continue;
+        }
+        const latest = endpoint.read(attempt.body);
+        if (typeof latest === "string" && latest) return { ok: true, latest };
+        message = "registry answered without a version";
+      }
+      return { ok: false, message };
+    }
     async function checkForUpdate2({
       timeoutMs = 6e3,
       fetchImpl = globalThis.fetch,
       registries = registryCandidates()
     } = {}) {
       const current = currentVersion();
-      const failures = [];
-      for (const registry of registries) {
-        const attempt = await askRegistry(registry, { timeoutMs, fetchImpl });
-        if (attempt.ok) {
-          return {
-            ok: true,
-            current,
-            latest: attempt.latest,
-            registry,
-            updateAvailable: compareVersions(attempt.latest, current) > 0
-          };
-        }
-        failures.push(`${registry}: ${attempt.message}`);
+      const attempts = await Promise.all(registries.map(async (registry) => ({
+        registry,
+        ...await askRegistry(registry, { timeoutMs, fetchImpl })
+      })));
+      const answers = attempts.filter((attempt) => attempt.ok);
+      if (answers.length === 0) {
+        return {
+          ok: false,
+          current,
+          errorKey: "update.errorNetwork",
+          message: attempts.map((attempt) => `${attempt.registry}: ${attempt.message}`).join("; "),
+          triedRegistries: registries
+        };
       }
+      const latest = answers.map((answer) => answer.latest).reduce((best, version) => compareVersions(version, best) > 0 ? version : best);
+      const sources = answers.filter((answer) => compareVersions(answer.latest, latest) === 0).map((answer) => answer.registry);
+      const behind = answers.filter((answer) => compareVersions(answer.latest, latest) < 0).map((answer) => ({ registry: answer.registry, version: answer.latest }));
       return {
-        ok: false,
+        ok: true,
         current,
-        errorKey: "update.errorNetwork",
-        message: failures.join("; "),
-        triedRegistries: registries
+        latest,
+        registry: sources[0],
+        sources,
+        behind,
+        updateAvailable: compareVersions(latest, current) > 0
       };
     }
-    function performUpdate2({
-      spawnImpl = spawn,
-      timeoutMs = 18e4,
-      // Seam for tests: the suite runs from a checkout, where the guard below is
-      // correctly the only reachable outcome.
-      installKindImpl = installKind2,
-      // The registry that just answered the version check. Installing from
-      // somewhere the machine has been shown to reach beats installing from a
-      // default it may have no route to. Empty means "whatever npm is configured
-      // with", which is the right answer when no check has run.
-      registry = ""
-    } = {}) {
+    function npmErrorSummary(output) {
+      const lines = String(output || "").split(/\r?\n/).map((line) => line.trim()).filter((line) => /^npm (error|ERR!)/.test(line) && !/complete log of this run/i.test(line)).map((line) => line.replace(/^npm (error|ERR!)\s*/, "")).filter(Boolean);
+      return (lines.length > 0 ? lines.slice(0, 3) : String(output || "").trim().split(/\r?\n/).slice(-3)).join(" ");
+    }
+    function isNotYetPublished(output) {
+      return /\bETARGET\b|notarget|No matching version found/i.test(String(output || ""));
+    }
+    function installedVersionOnDisk() {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8")).version;
+      } catch {
+        return null;
+      }
+    }
+    function runNpm(spawnImpl, args, timeoutMs) {
       return new Promise((resolve) => {
-        const kind = installKindImpl();
-        if (kind !== "npm") {
-          resolve({ ok: false, errorKey: `update.cannot.${kind}` });
+        let child;
+        try {
+          child = spawnImpl("npm", args, { timeout: timeoutMs });
+        } catch (error) {
+          resolve({ ok: false, spawnFailed: true, output: String(error?.message || error) });
           return;
         }
-        const args = ["install", "-g", `${PACKAGE_NAME}@latest`];
-        const normalizedRegistry = normalizeRegistry(registry);
-        if (normalizedRegistry) args.push("--registry", normalizedRegistry);
-        const child = spawnImpl("npm", args, {
-          encoding: "utf8",
-          timeout: timeoutMs
-        });
         let output = "";
+        let settled = false;
+        const finish = (result) => {
+          if (!settled) {
+            settled = true;
+            resolve(result);
+          }
+        };
         const collect = (chunk) => {
           output += String(chunk);
         };
         child.stdout?.on("data", collect);
         child.stderr?.on("data", collect);
-        child.on("error", (error) => {
-          resolve({ ok: false, errorKey: "update.errorFailed", output: error.message });
-        });
-        child.on("close", (code) => {
-          resolve({ ok: code === 0, output: output.trim().slice(-2e3) });
-        });
+        child.on("error", (error) => finish({ ok: false, spawnFailed: true, output: error.message }));
+        child.on("close", (code) => finish({ ok: code === 0, output: output.trim() }));
       });
     }
+    var VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+    async function performUpdate2({
+      spawnImpl = spawn,
+      timeoutMs = 18e4,
+      // Seam for tests: the suite runs from a checkout, where the guard below is
+      // correctly the only reachable outcome.
+      installKindImpl = installKind2,
+      // The registries that reported `version`, preferred first. Empty means
+      // "whatever npm is configured with", which is right when no check has run.
+      registry = "",
+      sources = [],
+      version = null,
+      attempts = 3,
+      retryDelayMs = 15e3,
+      sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+      readInstalledVersion = installedVersionOnDisk,
+      onAttempt = () => {
+      }
+    } = {}) {
+      const kind = installKindImpl();
+      if (kind !== "npm") return { ok: false, errorKey: `update.cannot.${kind}` };
+      const target = typeof version === "string" && VERSION_PATTERN.test(version) ? version : null;
+      const spec = `${PACKAGE_NAME}@${target || "latest"}`;
+      const registries = [];
+      for (const candidate of [registry, ...sources]) {
+        const normalized = normalizeRegistry(candidate);
+        if (normalized && !registries.includes(normalized)) registries.push(normalized);
+      }
+      if (registries.length === 0) registries.push("");
+      let last = { output: "" };
+      let notYetPublished = false;
+      for (const source of registries) {
+        for (let attempt = 1; attempt <= attempts; attempt += 1) {
+          onAttempt({ registry: source, attempt });
+          const args = ["install", "-g", spec, "--prefer-online"];
+          if (source) args.push("--registry", source);
+          const result = await runNpm(spawnImpl, args, timeoutMs);
+          if (result.ok) {
+            const installed = readInstalledVersion();
+            if (target && installed && compareVersions(installed, target) < 0) {
+              return { ok: false, errorKey: "update.errorNotApplied", installed, output: result.output.slice(-2e3) };
+            }
+            return { ok: true, installed, output: result.output.slice(-2e3) };
+          }
+          last = result;
+          if (result.spawnFailed) {
+            return { ok: false, errorKey: "update.errorFailed", output: result.output, summary: result.output };
+          }
+          notYetPublished = isNotYetPublished(result.output);
+          if (!notYetPublished) break;
+          if (attempt < attempts) await sleep(retryDelayMs);
+        }
+      }
+      return {
+        ok: false,
+        errorKey: notYetPublished ? "update.errorNotYetPublished" : "update.errorFailed",
+        output: String(last.output || "").slice(-2e3),
+        summary: npmErrorSummary(last.output)
+      };
+    }
     module.exports = {
       PACKAGE_NAME,
       DEFAULT_REGISTRY,
@@ -561,8 +645,11 @@ var require_updater = __commonJS({
       compareVersions,
       currentVersion,
       installKind: installKind2,
+      installedVersionOnDisk,
+      npmErrorSummary,
       performUpdate: performUpdate2,
-      registryCandidates
+      registryCandidates,
+      updateChecksEnabled: updateChecksEnabled2
     };
   }
 });
@@ -910,16 +997,22 @@ var require_en = __commonJS({
       "hint.save": "s save",
       "hint.editing": "\u21B5 confirm \xB7 esc cancel",
       "update.title": "Updates",
+      "update.banner": "herdr-remote {latest} is out (running {current}). Press 7 and Enter on the update row to install.",
       "update.check": "Check for updates",
       "update.checking": "Checking npm\u2026",
       "update.upToDate": "Up to date ({version})",
       "update.available": "Update {version} available (press Enter to install)",
       "update.updating": "Installing {version}\u2026",
+      "update.updatingRetry": "Installing {version}\u2026 (npm has not caught up yet, attempt {attempt})",
       "update.done": "Updated to {version}",
       "update.restartHint": "Update installed. Restart herdr-remote to apply.",
       "update.errorNetwork": "Could not reach any npm registry",
       "update.errorNetworkDetail": "No registry answered: {message}",
-      "update.errorFailed": "Update failed. Run: npm install -g herdr-remote@latest",
+      "update.errorFailed": "Update failed. Run: npm install -g herdr-remote@{version} --prefer-online",
+      "update.errorFailedDetail": "npm: {message}",
+      "update.errorNotYetPublished": "npm has not caught up with {version} yet (common in the first minutes after a release). Press Enter to try again shortly.",
+      "update.errorNotApplied": "npm reported success, but {installed} is still installed",
+      "update.mirrorBehind": "{registries} still has an older version; installing from {source}",
       "update.cannot.source": "Source checkout \u2014 update with git",
       "update.cannot.linked": "Linked package \u2014 managed by npm link"
     };
@@ -1131,16 +1224,22 @@ var require_zh = __commonJS({
       "hint.save": "s \u4FDD\u5B58",
       "hint.editing": "\u21B5 \u786E\u8BA4 \xB7 esc \u53D6\u6D88",
       "update.title": "\u66F4\u65B0",
+      "update.banner": "herdr-remote {latest} \u5DF2\u53D1\u5E03\uFF08\u5F53\u524D {current}\uFF09\uFF0C\u6309 7 \u8FDB\u5165\u300C\u8BED\u8A00\u4E0E\u5173\u4E8E\u300D\uFF0C\u5728\u66F4\u65B0\u4E00\u884C\u6309 Enter \u5B89\u88C5\u3002",
       "update.check": "\u68C0\u67E5\u66F4\u65B0",
       "update.checking": "\u67E5\u8BE2 npm \u4E2D\u2026",
       "update.upToDate": "\u5DF2\u662F\u6700\u65B0\uFF08{version}\uFF09",
       "update.available": "\u65B0\u7248\u672C {version} \u53EF\u7528\uFF08\u6309 Enter \u5B89\u88C5\uFF09",
       "update.updating": "\u5B89\u88C5 {version} \u4E2D\u2026",
+      "update.updatingRetry": "\u5B89\u88C5 {version} \u4E2D\u2026\uFF08npm \u5C1A\u672A\u540C\u6B65\uFF0C\u7B2C {attempt} \u6B21\u5C1D\u8BD5\uFF09",
       "update.done": "\u5DF2\u66F4\u65B0\u81F3 {version}",
       "update.restartHint": "\u66F4\u65B0\u5DF2\u5B89\u88C5\uFF0C\u91CD\u542F herdr-remote \u751F\u6548\u3002",
       "update.errorNetwork": "\u6240\u6709 npm registry \u5747\u65E0\u6CD5\u8FDE\u63A5",
       "update.errorNetworkDetail": "\u65E0 registry \u5E94\u7B54\uFF1A{message}",
-      "update.errorFailed": "\u66F4\u65B0\u5931\u8D25\uFF0C\u53EF\u624B\u52A8\u6267\u884C\uFF1Anpm install -g herdr-remote@latest",
+      "update.errorFailed": "\u66F4\u65B0\u5931\u8D25\uFF0C\u53EF\u624B\u52A8\u6267\u884C\uFF1Anpm install -g herdr-remote@{version} --prefer-online",
+      "update.errorFailedDetail": "npm\uFF1A{message}",
+      "update.errorNotYetPublished": "npm \u8FD8\u6CA1\u540C\u6B65\u5230 {version}\uFF08\u521A\u53D1\u5E03\u7684\u51E0\u5206\u949F\u5185\u5E38\u89C1\uFF09\uFF0C\u7A0D\u540E\u6309 Enter \u91CD\u8BD5\u3002",
+      "update.errorNotApplied": "npm \u62A5\u544A\u6210\u529F\uFF0C\u4F46\u5B89\u88C5\u7684\u4ECD\u662F {installed}",
+      "update.mirrorBehind": "{registries} \u4ECD\u662F\u65E7\u7248\u672C\uFF0C\u5C06\u4ECE {source} \u5B89\u88C5",
       "update.cannot.source": "\u6E90\u7801\u76EE\u5F55\u8FD0\u884C\uFF0C\u8BF7\u4F7F\u7528 git \u66F4\u65B0",
       "update.cannot.linked": "npm link \u5DE5\u4F5C\u526F\u672C\uFF0C\u7531 npm link \u7BA1\u7406"
     };
@@ -2625,7 +2724,7 @@ var require_lifecycle = __commonJS({
 import { render } from "ink";
 
 // tui/src/App.tsx
-import { useCallback as useCallback2, useEffect as useEffect6, useMemo as useMemo4, useRef as useRef3, useState as useState10 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect7, useMemo as useMemo4, useRef as useRef3, useState as useState10 } from "react";
 import { Box as Box11, Text as Text11, useApp, useInput as useInput9 } from "ink";
 
 // tui/src/mouse/index.tsx
@@ -3819,14 +3918,16 @@ function HerdrScreen({ ctx }) {
 }
 
 // tui/src/screens/About.tsx
-import { useState as useState8 } from "react";
+import { useEffect as useEffect6, useState as useState8 } from "react";
 import { Box as Box9, Text as Text9, useInput as useInput7 } from "ink";
 import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var registryHost = (registry) => registry.replace(/^https?:\/\//, "");
 function About({ ctx }) {
   const { t, draft } = ctx;
   const [selected, setSelected] = useState8("auto");
   const [update, setUpdate] = useState8({ phase: "idle" });
-  const registryRef = useState8(() => ({ current: "" }))[0];
+  const [sourceNote, setSourceNote] = useState8(null);
+  const checkRef = useState8(() => ({ current: { registry: "", sources: [] } }))[0];
   const detected = detectLocale({ preference: "auto" });
   const languageOptions = [
     { id: "auto", label: t("about.languageAuto", { detected }) },
@@ -3843,36 +3944,57 @@ function About({ ctx }) {
       case "available":
         return t("update.available", { version: update.latest });
       case "updating":
-        return t("update.updating", { version: update.latest });
+        return update.attempt > 1 ? t("update.updatingRetry", { version: update.latest, attempt: update.attempt }) : t("update.updating", { version: update.latest });
       case "done":
         return t("update.done", { version: update.latest });
       case "error":
-        return t(update.messageKey);
+        return t(update.messageKey, update.params);
       default:
         return t("update.check");
     }
   })();
   const options = [...languageOptions, { id: "update", label: updateLabel }];
+  const applyCheck = (result) => {
+    checkRef.current = { registry: result.registry ?? "", sources: result.sources ?? [] };
+    const behind = result.behind ?? [];
+    setSourceNote(result.updateAvailable && behind.length > 0 && result.registry ? t("update.mirrorBehind", {
+      registries: behind.map((entry) => `${registryHost(entry.registry)} ${entry.version ?? ""}`.trim()).join(", "),
+      source: registryHost(result.registry)
+    }) : null);
+    setUpdate(result.updateAvailable ? { phase: "available", latest: result.latest } : { phase: "current", latest: result.latest });
+  };
+  useEffect6(() => {
+    if (ctx.updateCheck?.ok && update.phase === "idle") applyCheck(ctx.updateCheck);
+  }, [ctx.updateCheck]);
   const runCheck = async () => {
     setUpdate({ phase: "checking" });
+    setSourceNote(null);
     const result = await (0, import_updater.checkForUpdate)();
     if (!result.ok) {
       setUpdate({ phase: "error", messageKey: result.errorKey ?? "update.errorNetwork" });
       if (result.message) ctx.notify(t("update.errorNetworkDetail", { message: result.message }), "error");
       return;
     }
-    registryRef.current = result.registry ?? "";
-    setUpdate(result.updateAvailable ? { phase: "available", latest: result.latest } : { phase: "current", latest: result.latest });
+    ctx.setUpdateCheck(result);
+    applyCheck(result);
   };
   const runUpdate = async (latest) => {
-    setUpdate({ phase: "updating", latest });
-    const result = await (0, import_updater.performUpdate)({ registry: registryRef.current });
+    setUpdate({ phase: "updating", latest, attempt: 1 });
+    const result = await (0, import_updater.performUpdate)({
+      registry: checkRef.current.registry,
+      sources: checkRef.current.sources,
+      version: latest,
+      onAttempt: ({ attempt }) => setUpdate({ phase: "updating", latest, attempt })
+    });
     if (!result.ok) {
-      setUpdate({ phase: "error", messageKey: result.errorKey ?? "update.errorFailed" });
-      ctx.notify(t("update.errorFailed"), "error");
+      const params = { version: latest, installed: result.installed ?? "" };
+      setUpdate({ phase: "error", messageKey: result.errorKey ?? "update.errorFailed", params });
+      ctx.notify(result.summary ? t("update.errorFailedDetail", { message: result.summary }) : t(result.errorKey ?? "update.errorFailed", params), "error");
       return;
     }
     setUpdate({ phase: "done", latest });
+    setSourceNote(null);
+    ctx.setUpdateCheck(null);
     ctx.notify(t("update.restartHint"), "success");
   };
   const activateUpdate = () => {
@@ -3931,19 +4053,22 @@ function About({ ctx }) {
       option.id
     )) }),
     /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: t("update.title") }),
-    /* @__PURE__ */ jsx10(Box9, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx10(
-      Selectable,
-      {
-        selected: selected === "update",
-        onSelect: () => {
-          setSelected("update");
-          activateUpdate();
-        },
-        onHover: () => setSelected("update"),
-        children: updateLabel
-      }
-    ) }),
-    /* @__PURE__ */ jsx10(Row, { label: t("about.version"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: "0.2.16" }) }),
+    /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx10(
+        Selectable,
+        {
+          selected: selected === "update",
+          onSelect: () => {
+            setSelected("update");
+            activateUpdate();
+          },
+          onHover: () => setSelected("update"),
+          children: updateLabel
+        }
+      ),
+      sourceNote ? /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: `  ${sourceNote}` }) : null
+    ] }),
+    /* @__PURE__ */ jsx10(Row, { label: t("about.version"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: "0.2.17" }) }),
     /* @__PURE__ */ jsx10(Row, { label: t("about.configPath"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: (0, import_config.configPath)() }) }),
     /* @__PURE__ */ jsx10(Row, { label: t("about.statePath"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: (0, import_config.stateDir)() }) }),
     /* @__PURE__ */ jsx10(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: t("about.docs") }) }),
@@ -4260,7 +4385,11 @@ function Tab({ label, active, onSelect }) {
 function Footer({ hints }) {
   return /* @__PURE__ */ jsx12(Box11, { marginTop: 1, paddingX: 1, children: /* @__PURE__ */ jsx12(Text11, { color: theme.muted, children: hints.join("  \xB7  ") }) });
 }
-function App({ initialLanguage, needsWizard }) {
+function App({
+  initialLanguage,
+  needsWizard,
+  updateChecker = (0, import_updater.updateChecksEnabled)() ? import_updater.checkForUpdate : null
+}) {
   const { exit } = useApp();
   const mouse = useMouse();
   const [config, setConfig] = useState10(() => (0, import_config.loadConfig)());
@@ -4272,6 +4401,18 @@ function App({ initialLanguage, needsWizard }) {
   const [busy, setBusy] = useState10(false);
   const [editingId, setEditingId] = useState10(null);
   const [wizardDone, setWizardDone] = useState10(!needsWizard);
+  const [updateCheck, setUpdateCheck] = useState10(null);
+  useEffect7(() => {
+    if (!updateChecker) return void 0;
+    let cancelled = false;
+    updateChecker().then((result) => {
+      if (!cancelled && result?.ok) setUpdateCheck(result);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [updateChecker]);
   const locale = useMemo4(
     () => detectLocale({ preference: initialLanguage ?? draft.ui.language }),
     [initialLanguage, draft.ui.language]
@@ -4298,7 +4439,7 @@ function App({ initialLanguage, needsWizard }) {
       refresh();
     });
   }, [notify, refresh]);
-  useEffect6(() => {
+  useEffect7(() => {
     if (!wizardDone) return void 0;
     refresh();
     const timer = setInterval(() => {
@@ -4307,7 +4448,7 @@ function App({ initialLanguage, needsWizard }) {
     return () => clearInterval(timer);
   }, [wizardDone, refresh, editingId]);
   const mouseChoice = useRef3(null);
-  useEffect6(() => {
+  useEffect7(() => {
     if (mouseChoice.current !== null) return;
     if (mouse.supported && !mouse.enabled) mouse.enable();
   }, [mouse.supported, mouse.enabled, mouse]);
@@ -4327,7 +4468,9 @@ function App({ initialLanguage, needsWizard }) {
     notify,
     run,
     refresh,
-    message
+    message,
+    updateCheck,
+    setUpdateCheck
   };
   useInput9((input, key) => {
     if (key.ctrl && input === "c") {
@@ -4387,9 +4530,12 @@ function App({ initialLanguage, needsWizard }) {
     t("hint.quit")
   ].filter(Boolean);
   return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
-    /* @__PURE__ */ jsxs11(Box11, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsx12(Text11, { bold: true, children: t("app.name") }),
-      /* @__PURE__ */ jsx12(Text11, { color: theme.muted, children: `  ${t("app.tagline")}` })
+    /* @__PURE__ */ jsxs11(Box11, { marginBottom: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs11(Box11, { children: [
+        /* @__PURE__ */ jsx12(Text11, { bold: true, children: t("app.name") }),
+        /* @__PURE__ */ jsx12(Text11, { color: theme.muted, children: `  ${t("app.tagline")}` })
+      ] }),
+      updateCheck?.updateAvailable ? /* @__PURE__ */ jsx12(Text11, { color: theme.warn, children: t("update.banner", { latest: updateCheck.latest ?? "", current: updateCheck.current }) }) : null
     ] }),
     /* @__PURE__ */ jsx12(Box11, { marginBottom: 1, children: TABS.map((entry, entryIndex) => /* @__PURE__ */ jsx12(
       Tab,

package/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "herdr.remote.web"
 name = "Herdr Remote Web"
-version = "0.2.16"
+version = "0.2.17"
 min_herdr_version = "0.9.1"
 description = "Browser access to Herdr workspaces via local or self-hosted relay"
 platforms = ["linux", "macos"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "herdr-remote",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "description": "Browser access to Herdr workspaces: plugin, host connector, and configuration TUI",
   "license": "MIT",
   "repository": {

package/src/host-connector.js

@@ -31,6 +31,16 @@ const { sameSummary, summarizeAgents } = require('./agent-status');
 const { EXIT_REPLACED, EXIT_AUTH_FAILED } = require('./exit-codes');
 const { savePastedFile, cleanPastedDir } = require('./pasted-files');
 const { ensureHerdrServer, probeHerdrServer } = require('./herdr-server');
+const {
+  checkForUpdate,
+  compareVersions,
+  currentVersion,
+  installedVersionOnDisk,
+  updateChecksEnabled,
+} = require('./updater');
+
+/** Windows opening within this long of a check reuse its answer. */
+const UPDATE_RECHECK_MS = 60_000;
 
 /** How often the agent summary is re-read while a browser is watching. */
 const AGENT_STATUS_POLL_MS = 5_000;
@@ -129,6 +139,18 @@ class HostConnector {
     this.probingStarts = new Map();
     /** One start at a time, however many windows asked for it. */
     this.herdrLaunch = null;
+    /**
+     * Whether a newer herdr-remote is out, asked when a window opens. The
+     * version this process runs is fixed at start; the one on disk moves when
+     * somebody updates without restarting.
+     */
+    this.checkUpdate = options.checkUpdate !== undefined
+      ? options.checkUpdate
+      : (updateChecksEnabled() ? checkForUpdate : null);
+    this.readInstalledVersion = options.readInstalledVersion || installedVersionOnDisk;
+    this.runningVersion = options.runningVersion || currentVersion();
+    this.updateCheckedAt = 0;
+    this.updateCheck = null;
     /** The side channel that answers "does anything need me?"; see startAgentStatus. */
     this.requestHerdr = options.requestHerdr || requestHerdr;
     this.subscribeHerdr = options.subscribeHerdr || subscribeHerdr;
@@ -414,6 +436,8 @@ class HostConnector {
     const streamId = typeof message.streamId === 'string' ? message.streamId : message.clientId;
     if (!streamId) return undefined;
     this.stopSession(streamId);
+    // A window opening is when a person is looking; that is when to ask.
+    this.reportUpdateStatus();
     const missingHerdr = this.ensureHerdrCommand();
     if (missingHerdr) {
       process.stderr.write(`herdr-remote host connector: ${missingHerdr}\n`);
@@ -445,6 +469,37 @@ class HostConnector {
     });
   }
 
+  /**
+   * Tell every window whether this workstation's herdr-remote is behind the
+   * newest release. Asked at most once a minute however many windows open;
+   * the relay keeps the last answer for windows that open in between. A failed
+   * check says nothing: offline is not news.
+   */
+  reportUpdateStatus({ now = Date.now() } = {}) {
+    if (!this.checkUpdate || this.updateCheck) return this.updateCheck;
+    if (now - this.updateCheckedAt < UPDATE_RECHECK_MS) return null;
+    this.updateCheckedAt = now;
+    this.updateCheck = Promise.resolve()
+      .then(() => this.checkUpdate())
+      .then((result) => {
+        if (!result?.ok || !result.latest) return;
+        const running = this.runningVersion;
+        const installed = this.readInstalledVersion() || running;
+        sendJson(this.ws, {
+          type: 'update_status',
+          current: running,
+          installed,
+          latest: result.latest,
+          updateAvailable: compareVersions(result.latest, running) > 0,
+          // Updated on disk, still running the old code: a restart finishes it.
+          restartPending: compareVersions(installed, running) > 0,
+        });
+      })
+      .catch(() => {})
+      .finally(() => { this.updateCheck = null; });
+    return this.updateCheck;
+  }
+
   /**
    * Hold a window's session until Herdr runs, and ask the browser whether it
    * should be started. Nothing starts until somebody says yes.

package/src/i18n/en.js

@@ -219,16 +219,22 @@ module.exports = {
   'hint.save': 's save',
   'hint.editing': '↵ confirm · esc cancel',
   'update.title': 'Updates',
+  'update.banner': 'herdr-remote {latest} is out (running {current}). Press 7 and Enter on the update row to install.',
   'update.check': 'Check for updates',
   'update.checking': 'Checking npm…',
   'update.upToDate': 'Up to date ({version})',
   'update.available': 'Update {version} available (press Enter to install)',
   'update.updating': 'Installing {version}…',
+  'update.updatingRetry': 'Installing {version}… (npm has not caught up yet, attempt {attempt})',
   'update.done': 'Updated to {version}',
   'update.restartHint': 'Update installed. Restart herdr-remote to apply.',
   'update.errorNetwork': 'Could not reach any npm registry',
   'update.errorNetworkDetail': 'No registry answered: {message}',
-  'update.errorFailed': 'Update failed. Run: npm install -g herdr-remote@latest',
+  'update.errorFailed': 'Update failed. Run: npm install -g herdr-remote@{version} --prefer-online',
+  'update.errorFailedDetail': 'npm: {message}',
+  'update.errorNotYetPublished': 'npm has not caught up with {version} yet (common in the first minutes after a release). Press Enter to try again shortly.',
+  'update.errorNotApplied': 'npm reported success, but {installed} is still installed',
+  'update.mirrorBehind': '{registries} still has an older version; installing from {source}',
   'update.cannot.source': 'Source checkout — update with git',
   'update.cannot.linked': 'Linked package — managed by npm link',
 };

package/src/i18n/zh.js

@@ -218,16 +218,22 @@ module.exports = {
   'hint.save': 's 保存',
   'hint.editing': '↵ 确认 · esc 取消',
   'update.title': '更新',
+  'update.banner': 'herdr-remote {latest} 已发布（当前 {current}），按 7 进入「语言与关于」，在更新一行按 Enter 安装。',
   'update.check': '检查更新',
   'update.checking': '查询 npm 中…',
   'update.upToDate': '已是最新（{version}）',
   'update.available': '新版本 {version} 可用（按 Enter 安装）',
   'update.updating': '安装 {version} 中…',
+  'update.updatingRetry': '安装 {version} 中…（npm 尚未同步，第 {attempt} 次尝试）',
   'update.done': '已更新至 {version}',
   'update.restartHint': '更新已安装，重启 herdr-remote 生效。',
   'update.errorNetwork': '所有 npm registry 均无法连接',
   'update.errorNetworkDetail': '无 registry 应答：{message}',
-  'update.errorFailed': '更新失败，可手动执行：npm install -g herdr-remote@latest',
+  'update.errorFailed': '更新失败，可手动执行：npm install -g herdr-remote@{version} --prefer-online',
+  'update.errorFailedDetail': 'npm：{message}',
+  'update.errorNotYetPublished': 'npm 还没同步到 {version}（刚发布的几分钟内常见），稍后按 Enter 重试。',
+  'update.errorNotApplied': 'npm 报告成功，但安装的仍是 {installed}',
+  'update.mirrorBehind': '{registries} 仍是旧版本，将从 {source} 安装',
   'update.cannot.source': '源码目录运行，请使用 git 更新',
   'update.cannot.linked': 'npm link 工作副本，由 npm link 管理',
 };

package/src/updater.js

@@ -57,6 +57,11 @@ function installKind() {
   return 'npm';
 }
 
+/** `HERDR_REMOTE_UPDATE_CHECK=0` turns the automatic checks off (offline machines, tests). */
+function updateChecksEnabled(env = process.env) {
+  return env.HERDR_REMOTE_UPDATE_CHECK !== '0';
+}
+
 function canSelfUpdate() {
   return installKind() === 'npm';
 }
@@ -130,20 +135,17 @@ function compareVersions(a, b) {
   return 0;
 }
 
-/** One registry, one question: what is the latest published version? */
-async function askRegistry(registry, { timeoutMs, fetchImpl }) {
+/** One JSON request with a deadline. Never throws. */
+async function fetchJson(url, { timeoutMs, fetchImpl }) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const response = await fetchImpl(`${registry}/${PACKAGE_NAME}/latest`, {
+    const response = await fetchImpl(url, {
       signal: controller.signal,
-      headers: { Accept: 'application/vnd.npm.install-v1+json' },
+      headers: { Accept: 'application/json', 'Cache-Control': 'no-cache' },
     });
     if (!response.ok) return { ok: false, message: `HTTP ${response.status ?? '?'}` };
-    const body = await response.json();
-    const latest = typeof body?.version === 'string' ? body.version : null;
-    if (!latest) return { ok: false, message: 'registry answered without a version' };
-    return { ok: true, latest };
+    return { ok: true, body: await response.json() };
   } catch (error) {
     return { ok: false, message: error?.name === 'AbortError' ? 'timed out' : String(error?.message || error) };
   } finally {
@@ -151,13 +153,45 @@ async function askRegistry(registry, { timeoutMs, fetchImpl }) {
   }
 }
 
+/**
+ * One registry, one question: what is the latest published version?
+ *
+ * The dist-tags endpoint first: a few bytes, answered fresh by npmjs and
+ * npmmirror alike. `/<package>/latest` is the fallback for registries without
+ * it, asked for plain JSON. It used to be asked for npm's abbreviated install
+ * format, which npmjs refuses on that path with a 406, so every check quietly
+ * fell through to a mirror that had not synced the release yet.
+ */
+async function askRegistry(registry, { timeoutMs, fetchImpl }) {
+  const endpoints = [
+    { url: `${registry}/-/package/${PACKAGE_NAME}/dist-tags`, read: (body) => body?.latest },
+    { url: `${registry}/${PACKAGE_NAME}/latest`, read: (body) => body?.version },
+  ];
+  let message = null;
+  for (const endpoint of endpoints) {
+    const attempt = await fetchJson(endpoint.url, { timeoutMs, fetchImpl });
+    if (!attempt.ok) {
+      message = attempt.message;
+      continue;
+    }
+    const latest = endpoint.read(attempt.body);
+    if (typeof latest === 'string' && latest) return { ok: true, latest };
+    message = 'registry answered without a version';
+  }
+  return { ok: false, message };
+}
+
 /**
  * Ask what the current release is.
  *
  * Never throws: an update check is a convenience, and a machine that is offline
- * or behind a proxy should still get a working settings screen. Each configured
- * registry is tried in turn, because the first one is only a guess at which
- * mirror this machine can actually reach.
+ * or behind a proxy should still get a working settings screen.
+ *
+ * Every registry is asked at once and the newest answer wins. Taking the first
+ * answer let a mirror a few minutes (or hours) behind report the release before
+ * last as current. `sources` lists the registries that already carry the
+ * newest version, preferred order first, which is where an install should come
+ * from; `behind` lists the ones that do not, so the screen can say why.
  */
 async function checkForUpdate({
   timeoutMs = 6000,
@@ -165,77 +199,182 @@ async function checkForUpdate({
   registries = registryCandidates(),
 } = {}) {
   const current = currentVersion();
-  const failures = [];
-
-  for (const registry of registries) {
-    const attempt = await askRegistry(registry, { timeoutMs, fetchImpl });
-    if (attempt.ok) {
-      return {
-        ok: true,
-        current,
-        latest: attempt.latest,
-        registry,
-        updateAvailable: compareVersions(attempt.latest, current) > 0,
-      };
-    }
-    failures.push(`${registry}: ${attempt.message}`);
+  const attempts = await Promise.all(registries.map(async (registry) => ({
+    registry,
+    ...(await askRegistry(registry, { timeoutMs, fetchImpl })),
+  })));
+  const answers = attempts.filter((attempt) => attempt.ok);
+
+  if (answers.length === 0) {
+    // The reason is carried out with the failure. "Could not reach npm
+    // registry" with nothing after it leaves the user guessing between DNS, a
+    // proxy, a firewall and a mirror that does not carry the package.
+    return {
+      ok: false,
+      current,
+      errorKey: 'update.errorNetwork',
+      message: attempts.map((attempt) => `${attempt.registry}: ${attempt.message}`).join('; '),
+      triedRegistries: registries,
+    };
   }
 
-  // The reason is carried out with the failure. "Could not reach npm registry"
-  // with nothing after it leaves the user guessing between DNS, a proxy, a
-  // firewall and a mirror that does not carry the package.
+  const latest = answers
+    .map((answer) => answer.latest)
+    .reduce((best, version) => (compareVersions(version, best) > 0 ? version : best));
+  const sources = answers
+    .filter((answer) => compareVersions(answer.latest, latest) === 0)
+    .map((answer) => answer.registry);
+  const behind = answers
+    .filter((answer) => compareVersions(answer.latest, latest) < 0)
+    .map((answer) => ({ registry: answer.registry, version: answer.latest }));
+
   return {
-    ok: false,
+    ok: true,
     current,
-    errorKey: 'update.errorNetwork',
-    message: failures.join('; '),
-    triedRegistries: registries,
+    latest,
+    registry: sources[0],
+    sources,
+    behind,
+    updateAvailable: compareVersions(latest, current) > 0,
   };
 }
 
+/** Just the lines npm meant for a person: its `npm error` / `npm ERR!` summary. */
+function npmErrorSummary(output) {
+  const lines = String(output || '').split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => /^npm (error|ERR!)/.test(line) && !/complete log of this run/i.test(line))
+    .map((line) => line.replace(/^npm (error|ERR!)\s*/, ''))
+    .filter(Boolean);
+  return (lines.length > 0 ? lines.slice(0, 3) : String(output || '').trim().split(/\r?\n/).slice(-3)).join(' ');
+}
+
+/** "No matching version": the registry has not caught up with its own dist-tag. */
+function isNotYetPublished(output) {
+  return /\bETARGET\b|notarget|No matching version found/i.test(String(output || ''));
+}
+
+/** What is actually installed now, read from disk rather than the require cache. */
+function installedVersionOnDisk() {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8')).version;
+  } catch {
+    return null;
+  }
+}
+
+function runNpm(spawnImpl, args, timeoutMs) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawnImpl('npm', args, { timeout: timeoutMs });
+    } catch (error) {
+      resolve({ ok: false, spawnFailed: true, output: String(error?.message || error) });
+      return;
+    }
+    let output = '';
+    let settled = false;
+    const finish = (result) => { if (!settled) { settled = true; resolve(result); } };
+    const collect = (chunk) => { output += String(chunk); };
+    child.stdout?.on('data', collect);
+    child.stderr?.on('data', collect);
+    child.on('error', (error) => finish({ ok: false, spawnFailed: true, output: error.message }));
+    child.on('close', (code) => finish({ ok: code === 0, output: output.trim() }));
+  });
+}
+
+const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+
 /**
- * Install the newest release over this one.
+ * Install a release over this one.
  *
  * Resolves with `{ ok, output }` rather than rejecting, so the caller can show
  * npm's own message; npm's diagnostics are more useful than anything that could
  * be invented here.
+ *
+ * - The exact version the check found is installed, not `@latest`, from a
+ *   registry that reported it, with `--prefer-online` so npm revalidates the
+ *   package metadata it cached before the release existed.
+ * - Right after a release, npm's view of the package can still lack the new
+ *   version although its dist-tag already points at it: npm answers ETARGET.
+ *   That is a wait, not a failure, so it is retried a few times, then the next
+ *   registry that carries the version is tried.
+ * - Success is what is on disk afterwards, not npm's exit code.
+ *
+ * @param {{
+ *   spawnImpl?: Function,
+ *   timeoutMs?: number,
+ *   installKindImpl?: () => string,
+ *   registry?: string,
+ *   sources?: string[],
+ *   version?: string | null,
+ *   attempts?: number,
+ *   retryDelayMs?: number,
+ *   sleep?: (ms: number) => Promise<unknown>,
+ *   readInstalledVersion?: () => string | null,
+ *   onAttempt?: (progress: { registry: string, attempt: number }) => void,
+ * }} [options]
+ * @returns {Promise<{ ok: boolean, errorKey?: string, installed?: string | null, output?: string, summary?: string }>}
  */
-function performUpdate({
+async function performUpdate({
   spawnImpl = spawn,
   timeoutMs = 180_000,
   // Seam for tests: the suite runs from a checkout, where the guard below is
   // correctly the only reachable outcome.
   installKindImpl = installKind,
-  // The registry that just answered the version check. Installing from
-  // somewhere the machine has been shown to reach beats installing from a
-  // default it may have no route to. Empty means "whatever npm is configured
-  // with", which is the right answer when no check has run.
+  // The registries that reported `version`, preferred first. Empty means
+  // "whatever npm is configured with", which is right when no check has run.
   registry = '',
+  sources = [],
+  version = null,
+  attempts = 3,
+  retryDelayMs = 15_000,
+  sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  readInstalledVersion = installedVersionOnDisk,
+  onAttempt = () => {},
 } = {}) {
-  return new Promise((resolve) => {
-    const kind = installKindImpl();
-    if (kind !== 'npm') {
-      resolve({ ok: false, errorKey: `update.cannot.${kind}` });
-      return;
+  const kind = installKindImpl();
+  if (kind !== 'npm') return { ok: false, errorKey: `update.cannot.${kind}` };
+
+  const target = typeof version === 'string' && VERSION_PATTERN.test(version) ? version : null;
+  const spec = `${PACKAGE_NAME}@${target || 'latest'}`;
+  const registries = [];
+  for (const candidate of [registry, ...sources]) {
+    const normalized = normalizeRegistry(candidate);
+    if (normalized && !registries.includes(normalized)) registries.push(normalized);
+  }
+  if (registries.length === 0) registries.push('');
+
+  let last = { output: '' };
+  let notYetPublished = false;
+  for (const source of registries) {
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+      onAttempt({ registry: source, attempt });
+      const args = ['install', '-g', spec, '--prefer-online'];
+      if (source) args.push('--registry', source);
+      const result = await runNpm(spawnImpl, args, timeoutMs);
+      if (result.ok) {
+        const installed = readInstalledVersion();
+        if (target && installed && compareVersions(installed, target) < 0) {
+          return { ok: false, errorKey: 'update.errorNotApplied', installed, output: result.output.slice(-2000) };
+        }
+        return { ok: true, installed, output: result.output.slice(-2000) };
+      }
+      last = result;
+      if (result.spawnFailed) {
+        return { ok: false, errorKey: 'update.errorFailed', output: result.output, summary: result.output };
+      }
+      notYetPublished = isNotYetPublished(result.output);
+      if (!notYetPublished) break; // Not a wait: this registry will not do better.
+      if (attempt < attempts) await sleep(retryDelayMs);
     }
-    const args = ['install', '-g', `${PACKAGE_NAME}@latest`];
-    const normalizedRegistry = normalizeRegistry(registry);
-    if (normalizedRegistry) args.push('--registry', normalizedRegistry);
-    const child = spawnImpl('npm', args, {
-      encoding: 'utf8',
-      timeout: timeoutMs,
-    });
-    let output = '';
-    const collect = (chunk) => { output += String(chunk); };
-    child.stdout?.on('data', collect);
-    child.stderr?.on('data', collect);
-    child.on('error', (error) => {
-      resolve({ ok: false, errorKey: 'update.errorFailed', output: error.message });
-    });
-    child.on('close', (code) => {
-      resolve({ ok: code === 0, output: output.trim().slice(-2000) });
-    });
-  });
+  }
+  return {
+    ok: false,
+    errorKey: notYetPublished ? 'update.errorNotYetPublished' : 'update.errorFailed',
+    output: String(last.output || '').slice(-2000),
+    summary: npmErrorSummary(last.output),
+  };
 }
 
 module.exports = {
@@ -247,6 +386,9 @@ module.exports = {
   compareVersions,
   currentVersion,
   installKind,
+  installedVersionOnDisk,
+  npmErrorSummary,
   performUpdate,
   registryCandidates,
+  updateChecksEnabled,
 };