herdr-remote 0.2.15 → 0.2.17

package/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "herdr.remote.web"
 name = "Herdr Remote Web"
-version = "0.2.15"
+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.15",
+  "version": "0.2.17",
   "description": "Browser access to Herdr workspaces: plugin, host connector, and configuration TUI",
   "license": "MIT",
   "repository": {

package/src/config.js

@@ -77,6 +77,9 @@ const DEFAULTS = {
     socketPath: null,
     args: [],
     cwd: os.homedir(),
+    // Start Herdr's server when herdr-remote starts (at boot, under keep-alive).
+    // Off: Herdr starts when the user runs it, or confirms it from the WebUI.
+    autoStart: false,
   },
   auth: {
     pairingTtlMs: 10 * 60 * 1000,
@@ -288,6 +291,7 @@ function validate(config) {
   if (typeof config.herdr.cwd !== 'string' || config.herdr.cwd.length === 0) {
     config.herdr.cwd = os.homedir();
   }
+  config.herdr.autoStart = config.herdr.autoStart === true;
 
   // A "remote" config without a relay URL cannot reach anything; fall back to
   // local rather than silently starting a host connector that dials nowhere.

package/src/herdr-server.js

@@ -0,0 +1,201 @@
+'use strict';
+
+// Whether Herdr's server is running on this workstation, and starting it when
+// the user asked for that.
+//
+// herdr-remote never starts Herdr on its own initiative. It starts one when a
+// browser paired to this workstation asks for it, or at service start when the
+// user switched that on — and both go through here.
+//
+// Two traps shape this file:
+//
+// - A socket file is not a server. Herdr leaves `herdr.sock` behind when it dies
+//   without cleaning up (a crash, a power cut), and a `herdr` client pointed at
+//   a dead socket quietly starts a server of its own. So "running" means a
+//   connection was accepted, not that the path exists.
+// - A server started from inside herdr-remote's systemd service lives in that
+//   service's cgroup, and `systemctl restart herdr-remote` — an update, a keep-
+//   alive restart, Herdr's own plugin startup hook — would kill it along with
+//   every agent in it. Under a service it is therefore started in a transient
+//   scope of its own, the same place it would live had the user started it
+//   from a terminal.
+
+const fs = require('node:fs');
+const net = require('node:net');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+const { inspectSocket } = require('./socket-discovery');
+const { ensureDir } = require('./state');
+
+/** A Unix socket either accepts at once or is dead; this only guards a hang. */
+const PROBE_TIMEOUT_MS = 1_000;
+/** Herdr restores the saved session before its API socket opens. */
+const START_TIMEOUT_MS = 20_000;
+const START_POLL_MS = 200;
+
+/**
+ * Is Herdr's server answering on `socketPath`?
+ *
+ * Resolves `{ state }`: `running`, `stopped` (no socket, or a socket nothing is
+ * listening on), or `unavailable` with a `reason` — a path that is not a socket
+ * or belongs to another user. That last one is never "stopped": the socket may
+ * well be live, just not ours to use, and starting a second server beside it
+ * would be starting somebody else's Herdr.
+ */
+function probeHerdrServer(socketPath, { connect = net.connect, timeout = PROBE_TIMEOUT_MS } = {}) {
+  const info = inspectSocket(socketPath);
+  if (!info.ok) {
+    return Promise.resolve(info.missing ? { state: 'stopped' } : { state: 'unavailable', reason: info.reason });
+  }
+  return new Promise((resolve) => {
+    let socket;
+    const finish = (result) => {
+      clearTimeout(timer);
+      if (socket) {
+        socket.removeAllListeners();
+        socket.on('error', () => {});
+        socket.destroy();
+      }
+      resolve(result);
+    };
+    // A socket that neither accepts nor refuses has a listener behind it that
+    // is slow, not absent; starting another server would only fight it.
+    const timer = setTimeout(() => finish({ state: 'running' }), timeout);
+    if (typeof timer.unref === 'function') timer.unref();
+    socket = connect(socketPath);
+    socket.once('connect', () => finish({ state: 'running' }));
+    socket.once('error', (error) => finish(
+      error.code === 'ECONNREFUSED' || error.code === 'ENOENT'
+        ? { state: 'stopped', stale: true }
+        : { state: 'unavailable', reason: error.message },
+    ));
+  });
+}
+
+/**
+ * True when this process is a systemd service (herdr-remote's keep-alive), so
+ * anything it starts would be killed with it.
+ */
+function runningInSystemdService({ platform = process.platform, readCgroup = () => fs.readFileSync('/proc/self/cgroup', 'utf8') } = {}) {
+  if (platform !== 'linux') return false;
+  try {
+    const unified = readCgroup().split('\n').find((line) => line.startsWith('0::'));
+    return Boolean(unified) && /\.service$/.test(unified.trim());
+  } catch {
+    return false;
+  }
+}
+
+/** The server's environment: the one a Herdr pane would give its client. */
+function serverEnv(socketPath, env = process.env) {
+  const next = { ...env };
+  for (const key of Object.keys(next)) {
+    if (key.startsWith('HERDR_')) delete next[key];
+  }
+  if (socketPath) next.HERDR_SOCKET_PATH = socketPath;
+  return next;
+}
+
+/**
+ * The argv that starts Herdr's server: Herdr's own global arguments (a
+ * `--session`, say) followed by `server`, wrapped in `systemd-run --scope` when
+ * the caller is a systemd service.
+ */
+function serverCommand({ command, args = [], inService = runningInSystemdService() }) {
+  const herdr = [command, ...args, 'server'];
+  if (!inService) return { file: herdr[0], args: herdr.slice(1) };
+  return {
+    file: 'systemd-run',
+    args: ['--user', '--scope', '--quiet', '--collect', '--description=Herdr server started by herdr-remote', '--', ...herdr],
+  };
+}
+
+/**
+ * Start Herdr's server in the background. Detached from this process, with its
+ * output appended to `logPath` rather than piped here: a pipe would break the
+ * moment herdr-remote exits and take the server with it.
+ */
+function launchHerdrServer({ command, args = [], socketPath, cwd, logPath, spawnProcess = spawn, inService }) {
+  const { file, args: argv } = serverCommand({ command, args, inService });
+  ensureDir(path.dirname(logPath));
+  const out = fs.openSync(logPath, 'a');
+  let child;
+  try {
+    child = spawnProcess(file, argv, {
+      cwd,
+      env: serverEnv(socketPath),
+      detached: true,
+      stdio: ['ignore', out, out],
+    });
+  } finally {
+    fs.closeSync(out);
+  }
+  child.on('error', () => {});
+  child.unref();
+  return child;
+}
+
+function readLogTail(logPath, bytes = 2_000) {
+  try {
+    const text = fs.readFileSync(logPath, 'utf8');
+    return text.slice(-bytes).trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Make sure Herdr's server is running, starting it if it is not.
+ *
+ * Resolves `{ started }`, or rejects with a message that says what happened:
+ * the socket belongs to someone else, the server exited, or it never opened
+ * its socket. The last lines Herdr printed ride along, because "did not start"
+ * with no reason is a message nobody can act on.
+ */
+async function ensureHerdrServer({
+  command,
+  args = [],
+  socketPath,
+  cwd,
+  logPath,
+  probe = probeHerdrServer,
+  launch = launchHerdrServer,
+  timeout = START_TIMEOUT_MS,
+  interval = START_POLL_MS,
+}) {
+  const before = await probe(socketPath);
+  if (before.state === 'running') return { started: false };
+  if (before.state === 'unavailable') {
+    throw new Error(`Herdr socket at ${socketPath} cannot be used: ${before.reason}`);
+  }
+
+  const child = launch({ command, args, socketPath, cwd, logPath });
+  let exit = null;
+  child.once('exit', (code, signal) => { exit = { code, signal }; });
+
+  const deadline = Date.now() + timeout;
+  for (;;) {
+    await new Promise((resolve) => setTimeout(resolve, interval));
+    const now = await probe(socketPath);
+    if (now.state === 'running') return { started: true };
+    const tail = readLogTail(logPath);
+    const detail = tail ? `\n${tail}` : '';
+    if (exit) {
+      throw new Error(`Herdr server exited (${exit.signal || `code ${exit.code}`}) before opening ${socketPath}.${detail}`);
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(`Herdr server did not open ${socketPath} within ${Math.round(timeout / 1000)}s.${detail}`);
+    }
+  }
+}
+
+module.exports = {
+  PROBE_TIMEOUT_MS,
+  START_TIMEOUT_MS,
+  probeHerdrServer,
+  runningInSystemdService,
+  serverEnv,
+  serverCommand,
+  launchHerdrServer,
+  ensureHerdrServer,
+};

package/src/host-connector.js

@@ -30,6 +30,17 @@ const { requestHerdr, subscribeHerdr } = require('./herdr-api');
 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;
@@ -118,6 +129,28 @@ class HostConnector {
     this.sessions = new Map();
     this.streamIndexToId = new Map();
     this.PtySession = options.PtySession || PtySession;
+    /** Is Herdr's server answering, and how to start it; injectable for tests. */
+    this.probeHerdr = options.probeHerdr || probeHerdrServer;
+    this.ensureHerdr = options.ensureHerdr || ensureHerdrServer;
+    this.herdrLogPath = options.herdrLogPath || path.join(stateDir(), 'herdr-server.log');
+    /** Windows whose session waits on a Herdr that is not running, by stream. */
+    this.waitingForHerdr = new Map();
+    /** Session starts between their liveness check and their PTY, by stream. */
+    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;
@@ -190,6 +223,12 @@ class HostConnector {
     this.acquireLock();
     this.stopping = false;
     this.connect();
+    // Off unless the user switched it on: Herdr is theirs to start.
+    if (this.config.herdr?.autoStart) {
+      this.startHerdr().catch((error) => {
+        process.stderr.write(`herdr-remote host connector: could not start Herdr: ${error.message}\n`);
+      });
+    }
   }
 
   stop() {
@@ -342,8 +381,9 @@ class HostConnector {
       this.setClientCount(message.clientCount);
       return;
     }
-    if (message.type === 'session_start') this.startSession(message);
-    else if (message.type === 'session_stop') this.stopSession(message.clientId || message.streamId);
+    if (message.type === 'session_start') return this.startSession(message);
+    if (message.type === 'herdr_start') return this.handleHerdrStart(message);
+    if (message.type === 'session_stop') this.stopSession(message.clientId || message.streamId);
     else if (message.type === 'resize') this.resizeSession(message);
     else if (message.type === 'paste_file') this.handlePasteFile(message);
   }
@@ -394,20 +434,136 @@ class HostConnector {
 
   startSession(message) {
     const streamId = typeof message.streamId === 'string' ? message.streamId : message.clientId;
-    if (!streamId) return;
+    if (!streamId) return undefined;
     this.stopSession(streamId);
-    const streamIndex = typeof message.streamIndex === 'number' ? message.streamIndex : null;
+    // 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`);
       sendJson(this.ws, { type: 'error', clientId: streamId, code: 'herdr_not_found', message: missingHerdr });
-      return;
+      return undefined;
     }
     const socketInfo = inspectSocket(this.socketPath);
-    if (!socketInfo.ok) {
+    if (!socketInfo.ok && !socketInfo.missing) {
       sendJson(this.ws, { type: 'error', clientId: streamId, code: 'herdr_socket_unavailable', message: socketInfo.reason });
+      return undefined;
+    }
+    if (!socketInfo.ok) {
+      this.waitForHerdr(streamId, message);
+      return undefined;
+    }
+    // The socket file alone proves nothing: a `herdr` client pointed at a dead
+    // one starts a server of its own, inside this process's service, where the
+    // next restart of herdr-remote would kill it. Only a server that accepts a
+    // connection gets a client.
+    const pending = { message };
+    this.probingStarts.set(streamId, pending);
+    return this.probeHerdr(this.socketPath).then((probe) => {
+      // Stopped, or started again, while the answer was in flight.
+      if (this.probingStarts.get(streamId) !== pending) return;
+      this.probingStarts.delete(streamId);
+      if (probe.state === 'running') this.spawnSession(pending.message);
+      else if (probe.state === 'stopped') this.waitForHerdr(streamId, pending.message);
+      else sendJson(this.ws, { type: 'error', clientId: streamId, code: 'herdr_socket_unavailable', message: probe.reason });
+    });
+  }
+
+  /**
+   * 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.
+   */
+  waitForHerdr(streamId, message) {
+    this.waitingForHerdr.set(streamId, message);
+    sendJson(this.ws, {
+      type: 'error',
+      clientId: streamId,
+      code: 'herdr_not_running',
+      message: `Herdr is not running on this workstation (${this.socketPath}).`,
+    });
+  }
+
+  /**
+   * Start this workstation's Herdr server, once, however many windows or
+   * callers ask at the same time.
+   */
+  startHerdr() {
+    if (!this.herdrLaunch) {
+      this.herdrLaunch = Promise.resolve()
+        .then(() => {
+          const missing = this.ensureHerdrCommand();
+          if (missing) throw new Error(missing);
+          return this.ensureHerdr({
+            command: this.herdrCommand,
+            args: this.herdrArgs,
+            socketPath: this.socketPath,
+            cwd: this.cwd,
+            logPath: this.herdrLogPath,
+          });
+        })
+        .finally(() => { this.herdrLaunch = null; });
+    }
+    return this.herdrLaunch;
+  }
+
+  /**
+   * A browser said yes. The relay only ever routes this from a window paired
+   * to *this* workstation, so what starts is this user's own Herdr, at the
+   * socket this connector is configured for — never one named by the message.
+   * Once it runs, every window waiting on it gets its session.
+   */
+  async handleHerdrStart(message) {
+    const streamId = typeof message.streamId === 'string' ? message.streamId : message.clientId;
+    try {
+      const result = await this.startHerdr();
+      if (result.started) process.stderr.write('herdr-remote host connector: started Herdr at a browser\'s request\n');
+    } catch (error) {
+      process.stderr.write(`herdr-remote host connector: could not start Herdr: ${error.message}\n`);
+      if (streamId) {
+        sendJson(this.ws, { type: 'error', clientId: streamId, code: 'herdr_start_failed', message: error.message });
+      }
       return;
     }
+    const waiting = [...this.waitingForHerdr.values()];
+    this.waitingForHerdr.clear();
+    for (const held of waiting) this.spawnSession(held);
+  }
+
+  /** Start the PTY for a window once Herdr is known to be running. */
+  spawnSession(message) {
+    const streamId = typeof message.streamId === 'string' ? message.streamId : message.clientId;
+    const streamIndex = typeof message.streamIndex === 'number' ? message.streamIndex : null;
     const pty = new this.PtySession({
       command: this.herdrCommand,
       args: this.herdrArgs,
@@ -516,6 +672,8 @@ class HostConnector {
   }
 
   stopSession(streamId) {
+    this.waitingForHerdr.delete(streamId);
+    this.probingStarts.delete(streamId);
     const session = this.sessions.get(streamId);
     if (!session) return;
     this.sessions.delete(streamId);
@@ -676,6 +834,12 @@ class HostConnector {
 
   resizeSession(message) {
     const id = message.clientId || message.streamId;
+    // A window still waiting on Herdr starts at the size it has by then.
+    const held = this.waitingForHerdr.get(id) || this.probingStarts.get(id)?.message;
+    if (held) {
+      if (Number.isInteger(message.cols)) held.cols = message.cols;
+      if (Number.isInteger(message.rows)) held.rows = message.rows;
+    }
     const session = this.sessions.get(id);
     if (!session) return;
     session.cols = Number.isInteger(message.cols) ? Math.min(500, Math.max(2, message.cols)) : session.cols;
@@ -716,6 +880,8 @@ class HostConnector {
     }
     this.sessions.clear();
     this.streamIndexToId.clear();
+    this.waitingForHerdr.clear();
+    this.probingStarts.clear();
   }
 
   sendHeartbeat(force = false) {

package/src/i18n/en.js

@@ -146,14 +146,7 @@ module.exports = {
   'herdr.title': 'Herdr integration',
   'herdr.socketPath': 'Socket path',
   'herdr.args': 'Extra arguments',
-  'herdr.plugin': 'Plugin registration',
-  'herdr.pluginRegistered': 'Registered with Herdr.',
-  'herdr.pluginMissing': 'Not registered with Herdr.',
-  'herdr.register': 'Register as Herdr plugin',
-  'herdr.unregister': 'Unregister plugin',
-  'herdr.registerDone': 'Registered: {path}',
-  'herdr.unregisterDone': 'Plugin unregistered.',
-  'herdr.registerFailed': 'Registration failed: {message}',
+  'herdr.autoStartHint': 'Off: Herdr starts only when you run it, or when you confirm it from a browser. On: herdr-remote also starts it every time it starts, at boot included. Takes effect the next time herdr-remote starts.',
   'herdr.cliMissing': 'Command herdr not found. Set HERDR_BIN_PATH to its full path.',
   'herdr.version': 'Herdr version',
   'herdr.versionOutdated': 'Herdr {version} is older than {minimum}. Run "herdr update": window titles, background machine activation and large pastes misbehave in browser windows before that release.',
@@ -193,6 +186,7 @@ module.exports = {
   'field.publicUrl': 'Browser URL override',
   'field.socketPath': 'Herdr socket path',
   'field.herdrArgs': 'Herdr arguments',
+  'field.herdrAutoStart': 'Auto-start Herdr',
   'field.language': 'Language',
   'field.keepalive': 'Keep-alive manager',
 
@@ -225,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

@@ -145,14 +145,7 @@ module.exports = {
   'herdr.title': 'Herdr 集成',
   'herdr.socketPath': '套接字路径',
   'herdr.args': '附加参数',
-  'herdr.plugin': '插件注册',
-  'herdr.pluginRegistered': '已注册到 Herdr。',
-  'herdr.pluginMissing': '尚未注册到 Herdr。',
-  'herdr.register': '注册为 Herdr 插件',
-  'herdr.unregister': '取消注册',
-  'herdr.registerDone': '已注册：{path}',
-  'herdr.unregisterDone': '已取消注册。',
-  'herdr.registerFailed': '注册失败：{message}',
+  'herdr.autoStartHint': '关：Herdr 只在你手动运行，或在浏览器里确认后才启动。开：herdr-remote 每次启动（包括开机）时一并启动 Herdr。下次 herdr-remote 启动时生效。',
   'herdr.cliMissing': '未找到 herdr 命令，可将 HERDR_BIN_PATH 设为其完整路径。',
   'herdr.version': 'Herdr 版本',
   'herdr.versionOutdated': 'Herdr {version} 低于 {minimum}，请运行 “herdr update”：在该版本之前，浏览器窗口的标题、后台机器激活与大段粘贴都会出问题。',
@@ -192,6 +185,7 @@ module.exports = {
   'field.publicUrl': '浏览器地址（覆盖）',
   'field.socketPath': 'Herdr 套接字路径',
   'field.herdrArgs': 'Herdr 参数',
+  'field.herdrAutoStart': '随服务启动 Herdr',
   'field.language': '语言',
   'field.keepalive': '保活管理方式',
 
@@ -224,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/lifecycle.js

@@ -19,8 +19,12 @@ function managerInUse(config) {
 function startAll(config = loadConfig()) {
   const managed = managerInUse(config);
   if (managed) {
-    keepalive.restart(config);
-    return { ok: true, managed: true, manager: managed.manager };
+    // Start means "make it run", not "restart it". Herdr runs this through the
+    // plugin's startup hook every time a Herdr server starts, and a restart
+    // there dropped every browser attached to the workstation — including the
+    // one that had just asked for that Herdr to be started.
+    if (!managed.active) keepalive.restart(config);
+    return { ok: true, managed: true, manager: managed.manager, alreadyRunning: Boolean(managed.active) };
   }
   return { ...startServices(), managed: false };
 }

package/src/settings-model.js

@@ -35,6 +35,7 @@ const FIELDS = [
   { id: 'publicUrl', kind: 'text', labelKey: 'field.publicUrl' },
   { id: 'socketPath', kind: 'text', labelKey: 'field.socketPath' },
   { id: 'herdrArgs', kind: 'text', labelKey: 'field.herdrArgs' },
+  { id: 'herdrAutoStart', kind: 'toggle', labelKey: 'field.herdrAutoStart' },
   { id: 'language', kind: 'choice', choices: LANGUAGES, labelKey: 'field.language' },
   { id: 'keepaliveManager', kind: 'choice', choices: KEEPALIVE_MANAGERS, labelKey: 'field.keepalive' },
 ];
@@ -94,6 +95,8 @@ function getField(draft, id) {
       return draft.herdr.socketPath || EMPTY;
     case 'herdrArgs':
       return (draft.herdr.args || []).join(' ');
+    case 'herdrAutoStart':
+      return draft.herdr.autoStart ? 'on' : 'off';
     case 'language':
       return draft.ui.language;
     case 'keepaliveManager':
@@ -211,6 +214,13 @@ function setField(draft, id, rawValue) {
       next.herdr.args = args;
       break;
     }
+    case 'herdrAutoStart': {
+      if (value !== true && value !== false && value !== 'on' && value !== 'off') {
+        return { draft, errorKey: 'error.unknownField' };
+      }
+      next.herdr.autoStart = value === true || value === 'on';
+      break;
+    }
     case 'language': {
       if (!LANGUAGES.includes(value)) return { draft, errorKey: 'error.invalidLanguage' };
       next.ui.language = value;
@@ -273,6 +283,7 @@ function saveDraft(draft) {
     ...(current.herdr || {}),
     socketPath: draft.herdr.socketPath,
     args: draft.herdr.args,
+    autoStart: draft.herdr.autoStart === true,
   };
   if (!merged.herdr.socketPath) delete merged.herdr.socketPath;
   merged.keepalive = { ...(current.keepalive || {}), manager: draft.keepalive.manager };

package/src/socket-discovery.js

@@ -32,7 +32,12 @@ function inspectSocket(socketPath, options = {}) {
     }
     return { ok: true, path: socketPath, uid: stat.uid, mode: stat.mode };
   } catch (error) {
-    return { ok: false, reason: error.code === 'ENOENT' ? 'socket does not exist' : error.message, path: socketPath };
+    return {
+      ok: false,
+      missing: error.code === 'ENOENT',
+      reason: error.code === 'ENOENT' ? 'socket does not exist' : error.message,
+      path: socketPath,
+    };
   }
 }