herdr-remote 0.2.2 → 0.2.4

package/src/settings-model.js

@@ -11,6 +11,7 @@ const {
   ACCESS_MODES,
   KEEPALIVE_MANAGERS,
   LANGUAGES,
+  OFFICIAL_RELAY_URL,
   configDir,
   configPath,
   isLoopbackHost,
@@ -40,6 +41,30 @@ const FIELDS = [
 
 const EMPTY = '';
 
+/**
+ * The access modes a *person* chooses between.
+ *
+ * The official relay is stored as `remote` with a known URL, because that is
+ * exactly what it is and nothing downstream should have to learn a fourth mode.
+ * It is still a separate answer to "how do I reach this workstation", though:
+ * one option needs no server and no credentials, the other needs both. Keeping
+ * that distinction here — rather than in whichever screen happens to draw it —
+ * is what stops the official relay from being displayed as "self-hosted relay"
+ * that merely happens to hold our address.
+ */
+const SELECTABLE_MODES = ['local', 'lan', 'official', 'remote'];
+
+/** Which of `SELECTABLE_MODES` this draft represents. */
+function selectedMode(draft) {
+  if (draft.relay.mode === 'remote' && draft.relay.remoteUrl === OFFICIAL_RELAY_URL) return 'official';
+  return draft.relay.mode;
+}
+
+/** True when the relay is the one we run, so its address and password are ours. */
+function isOfficialRelay(draft) {
+  return selectedMode(draft) === 'official';
+}
+
 function clone(value) {
   return JSON.parse(JSON.stringify(value));
 }
@@ -121,7 +146,22 @@ function setField(draft, id, rawValue) {
 
   switch (id) {
     case 'mode': {
-      if (!ACCESS_MODES.includes(value)) return { draft, errorKey: 'error.invalidMode' };
+      if (!SELECTABLE_MODES.includes(value)) return { draft, errorKey: 'error.invalidMode' };
+      // Picking the official relay fills in its address in the same edit: a
+      // remote mode with no URL is not a valid state, and asking for the
+      // address we already know would be asking the user to do our filing.
+      if (value === 'official') {
+        next.relay.mode = 'remote';
+        next.relay.remoteUrl = OFFICIAL_RELAY_URL;
+        next.relay.publicUrl = EMPTY;
+        break;
+      }
+      // Leaving the official relay clears its address, so the self-hosted URL
+      // field is empty and asking to be filled in rather than pre-loaded with
+      // an address that belongs to somebody else's server.
+      if (value === 'remote' && next.relay.remoteUrl === OFFICIAL_RELAY_URL) {
+        next.relay.remoteUrl = EMPTY;
+      }
       next.relay.mode = value;
       if (value === 'lan'
         && (isLoopbackHost(next.relay.lanHost) || isUnspecifiedAddress(next.relay.lanHost))) {
@@ -254,8 +294,11 @@ function requiresRestart(before, after) {
 
 module.exports = {
   FIELDS,
+  SELECTABLE_MODES,
   createDraft,
   fieldsForMode,
+  isOfficialRelay,
+  selectedMode,
   getField,
   getFieldPlaceholder,
   setField,

package/src/updater.js

@@ -8,12 +8,23 @@
 // checkout would replace the tree someone is working in.
 
 const fs = require('node:fs');
+const os = require('node:os');
 const path = require('node:path');
 const { spawn } = require('node:child_process');
 const { PACKAGE_ROOT } = require('./config');
 
 const PACKAGE_NAME = 'herdr-remote';
-const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+
+/**
+ * A public mirror, tried last.
+ *
+ * `registry.npmjs.org` is not reachable from every network this runs on — in
+ * mainland China it usually is not — and "could not reach npm registry" on a
+ * machine that installs packages perfectly well is a bug report, not a
+ * diagnosis. The mirror is read-only and only ever asked for a version number.
+ */
+const MIRROR_REGISTRY = 'https://registry.npmmirror.com';
 
 function currentVersion() {
   try {
@@ -50,6 +61,59 @@ function canSelfUpdate() {
   return installKind() === 'npm';
 }
 
+function normalizeRegistry(value) {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim().replace(/\/+$/, '');
+  if (!/^https?:\/\//i.test(trimmed)) return null;
+  return trimmed;
+}
+
+/** The `registry=` line from an npmrc file, if it has one. */
+function registryFromNpmrc(filePath) {
+  let contents;
+  try {
+    contents = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+  let found = null;
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#') || line.startsWith(';')) continue;
+    const match = /^registry\s*=\s*(.+)$/i.exec(line);
+    // The last assignment wins, as it does for npm itself.
+    if (match) found = normalizeRegistry(match[1].replace(/^["']|["']$/g, ''));
+  }
+  return found;
+}
+
+/**
+ * Where to ask, in the order to ask.
+ *
+ * Whatever npm itself is configured to use comes first: a machine behind a
+ * corporate proxy or on a mirror has already answered this question, and
+ * ignoring that answer is what made the check fail on a machine where
+ * `npm install` works. The public registry and then a public mirror follow, so
+ * a private registry that does not carry this package is not the end of it.
+ */
+function registryCandidates({ env = process.env, home = os.homedir(), cwd = process.cwd() } = {}) {
+  const candidates = [];
+  const add = (value) => {
+    const normalized = normalizeRegistry(value);
+    if (normalized && !candidates.includes(normalized)) candidates.push(normalized);
+  };
+
+  // npm exports its whole config into the environment of anything it runs.
+  add(env.npm_config_registry);
+  add(env.NPM_CONFIG_REGISTRY);
+  add(env.HERDR_REMOTE_REGISTRY);
+  add(registryFromNpmrc(path.join(cwd, '.npmrc')));
+  add(registryFromNpmrc(path.join(home, '.npmrc')));
+  add(DEFAULT_REGISTRY);
+  add(MIRROR_REGISTRY);
+  return candidates;
+}
+
 /** Compare two `MAJOR.MINOR.PATCH` strings. Returns 1, -1 or 0. */
 function compareVersions(a, b) {
   const parse = (value) => String(value)
@@ -66,40 +130,69 @@ function compareVersions(a, b) {
   return 0;
 }
 
-/**
- * Ask the registry 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.
- */
-async function checkForUpdate({ timeoutMs = 8000, fetchImpl = globalThis.fetch } = {}) {
-  const current = currentVersion();
+/** One registry, one question: what is the latest published version? */
+async function askRegistry(registry, { timeoutMs, fetchImpl }) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const response = await fetchImpl(REGISTRY_URL, {
+    const response = await fetchImpl(`${registry}/${PACKAGE_NAME}/latest`, {
       signal: controller.signal,
       headers: { Accept: 'application/vnd.npm.install-v1+json' },
     });
-    if (!response.ok) {
-      return { ok: false, current, errorKey: 'update.errorNetwork' };
-    }
+    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, current, errorKey: 'update.errorNetwork' };
-    return {
-      ok: true,
-      current,
-      latest,
-      updateAvailable: compareVersions(latest, current) > 0,
-    };
-  } catch {
-    return { ok: false, current, errorKey: 'update.errorNetwork' };
+    if (!latest) return { ok: false, message: 'registry answered without a version' };
+    return { ok: true, latest };
+  } catch (error) {
+    return { ok: false, message: error?.name === 'AbortError' ? 'timed out' : String(error?.message || error) };
   } finally {
     clearTimeout(timer);
   }
 }
 
+/**
+ * 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.
+ */
+async function checkForUpdate({
+  timeoutMs = 6000,
+  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}`);
+  }
+
+  // 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: failures.join('; '),
+    triedRegistries: registries,
+  };
+}
+
 /**
  * Install the newest release over this one.
  *
@@ -113,6 +206,11 @@ function performUpdate({
   // 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.
+  registry = '',
 } = {}) {
   return new Promise((resolve) => {
     const kind = installKindImpl();
@@ -120,7 +218,10 @@ function performUpdate({
       resolve({ ok: false, errorKey: `update.cannot.${kind}` });
       return;
     }
-    const child = spawnImpl('npm', ['install', '-g', `${PACKAGE_NAME}@latest`], {
+    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,
     });
@@ -139,10 +240,13 @@ function performUpdate({
 
 module.exports = {
   PACKAGE_NAME,
+  DEFAULT_REGISTRY,
+  MIRROR_REGISTRY,
   canSelfUpdate,
   checkForUpdate,
   compareVersions,
   currentVersion,
   installKind,
   performUpdate,
+  registryCandidates,
 };