dsh-autorestart 0.6.2 → 0.8.0

package/lib/health.js

@@ -0,0 +1,264 @@
+/**
+ * dsh-autorestart — "is the new host really up?".
+ *
+ * A restart is only successful when the NEW instance answers its health route.
+ * The old instance's answer proves nothing: the old instance may still be
+ * running (the restart command did nothing), or it may answer on a port the
+ * new instance does not use (the desktop app listens on a random port).
+ *
+ * So the confirmation is built from two facts:
+ *
+ *   1. the INSTANCE RECORD (lib/access.js) of the new instance — it carries a
+ *      boot id that is different from the one of the instance that is being
+ *      replaced, and the port the new instance really listens on;
+ *   2. the health route of THAT port.
+ *
+ * The wait is bounded: when the new instance does not answer in time the
+ * caller gets a REASON, never a silent success.
+ *
+ * ESM only, Node builtins only. No DSH / npm imports.
+ */
+
+import http from 'node:http';
+import { URL } from 'node:url';
+
+import { readAccessRecordFile } from './access.js';
+
+/** How long one health request may take before it counts as "no answer". */
+export const DEFAULT_HEALTH_TIMEOUT_MS = 5000;
+
+/** How long the new instance may take to come up at all. */
+export const DEFAULT_INSTANCE_WAIT_MS = 90000;
+
+/** How often the instance record is read while waiting. */
+export const DEFAULT_INSTANCE_POLL_MS = 1000;
+
+/** @param {unknown} value */
+function errorText(value) {
+  if (value && typeof value.message === 'string' && value.message) return value.message;
+  return String(value);
+}
+
+/**
+ * Sleep for a while. Never rejects.
+ *
+ * @param {number} ms
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, Math.max(0, Number(ms) || 0));
+    if (typeof timer.unref === 'function') timer.unref();
+  });
+}
+
+/**
+ * One plain HTTP GET, answered with the parsed JSON body.
+ *
+ * @param {string} url
+ * @param {number} timeoutMs
+ * @returns {Promise<{ ok: boolean, status: number, body: any, error: string|null }>}
+ */
+function httpGetJson(url, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    let request;
+    try {
+      request = http.get(url, { timeout: timeoutMs }, (response) => {
+        const chunks = [];
+        response.on('data', (chunk) => chunks.push(chunk));
+        response.on('end', () => {
+          const text = Buffer.concat(chunks).toString('utf8');
+          let body = null;
+          try {
+            body = JSON.parse(text);
+          } catch {
+            body = null;
+          }
+          const status = Number(response.statusCode) || 0;
+          finish({
+            ok: status >= 200 && status < 300 && body !== null && body.ok === true,
+            status,
+            body,
+            error: status >= 200 && status < 300
+              ? (body !== null && body.ok === true ? null : 'the health route did not answer ok')
+              : 'the health route answered with status ' + status,
+          });
+        });
+        response.on('error', (error) => {
+          finish({ ok: false, status: 0, body: null, error: errorText(error) });
+        });
+      });
+    } catch (error) {
+      finish({ ok: false, status: 0, body: null, error: errorText(error) });
+      return;
+    }
+    request.on('timeout', () => {
+      try {
+        request.destroy();
+      } catch {
+        /* nothing else to do */
+      }
+      finish({ ok: false, status: 0, body: null, error: 'the health request timed out' });
+    });
+    request.on('error', (error) => {
+      finish({ ok: false, status: 0, body: null, error: errorText(error) });
+    });
+  });
+}
+
+/**
+ * Ask one health route whether the host behind it is alive.
+ *
+ * @param {{ url?: string, timeoutMs?: number, requestImpl?: Function }} [options]
+ * @returns {Promise<{ ok: boolean, status: number, error: string|null }>}
+ */
+export function probeHealth({ url = '', timeoutMs = DEFAULT_HEALTH_TIMEOUT_MS, requestImpl = null } = {}) {
+  const target = typeof url === 'string' ? url.trim() : '';
+  if (target === '') {
+    return Promise.resolve({ ok: false, status: 0, error: 'probeHealth requires a url' });
+  }
+  const budget = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0
+    ? Math.trunc(Number(timeoutMs))
+    : DEFAULT_HEALTH_TIMEOUT_MS;
+  const request = typeof requestImpl === 'function' ? requestImpl : httpGetJson;
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      resolve(result);
+    };
+    const timer = setTimeout(() => {
+      finish({ ok: false, status: 0, error: 'the health request timed out after ' + budget + 'ms' });
+    }, budget);
+    Promise.resolve()
+      .then(() => request(target, budget))
+      .then((response) => {
+        clearTimeout(timer);
+        const status = Number(response && response.status) || 0;
+        if (response && response.ok === true) {
+          finish({ ok: true, status: status || 200, error: null });
+          return;
+        }
+        finish({
+          ok: false,
+          status,
+          error: (response && response.error) || 'the health route did not answer ok',
+        });
+      })
+      .catch((error) => {
+        clearTimeout(timer);
+        finish({ ok: false, status: 0, error: errorText(error) });
+      });
+  });
+}
+
+/**
+ * The health URL of one port on the loopback interface.
+ *
+ * @param {number|string} port
+ * @param {string} healthPath
+ * @returns {string}
+ */
+export function healthUrlForPort(port, healthPath) {
+  const number = Number(port);
+  if (!Number.isFinite(number) || number <= 0) return '';
+  const path = typeof healthPath === 'string' && healthPath.startsWith('/')
+    ? healthPath
+    : '/__dsh_autorestart/health';
+  return 'http://127.0.0.1:' + Math.trunc(number) + path;
+}
+
+/**
+ * Wait until the instance that replaced `expectedBootId` answers its health
+ * route.
+ *
+ * The instance record is the only source of the new port: the desktop app
+ * listens on a random port, so the port of the old instance is meaningless.
+ *
+ * @param {{
+ *   accessFile?: string,
+ *   expectedBootId?: string|null,
+ *   healthPath?: string,
+ *   timeoutMs?: number,
+ *   intervalMs?: number,
+ *   probe?: Function,
+ *   readRecord?: Function,
+ *   now?: Function,
+ *   sleep?: Function,
+ * }} [options]
+ * @returns {Promise<{ ok: boolean, bootId: string|null, port: number|null, url: string|null, reason: string }>}
+ */
+export async function waitForHealthyInstance({
+  accessFile = '',
+  expectedBootId = null,
+  healthPath = '/__dsh_autorestart/health',
+  timeoutMs = DEFAULT_INSTANCE_WAIT_MS,
+  intervalMs = DEFAULT_INSTANCE_POLL_MS,
+  probe = probeHealth,
+  readRecord = readAccessRecordFile,
+  now = () => Date.now(),
+  sleep: sleepFn = sleep,
+} = {}) {
+  const file = typeof accessFile === 'string' ? accessFile.trim() : '';
+  const budget = Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0
+    ? Math.trunc(Number(timeoutMs))
+    : DEFAULT_INSTANCE_WAIT_MS;
+  const step = Number.isFinite(Number(intervalMs)) && Number(intervalMs) > 0
+    ? Math.trunc(Number(intervalMs))
+    : DEFAULT_INSTANCE_POLL_MS;
+  const expected = typeof expectedBootId === 'string' && expectedBootId !== '' ? expectedBootId : null;
+  const deadline = now() + budget;
+  let lastReason = 'the new instance did not come up in time';
+
+  if (file === '') {
+    return { ok: false, bootId: null, port: null, url: null, reason: 'waitForHealthyInstance requires the instance record' };
+  }
+
+  while (now() < deadline) {
+    const read = readRecord(file);
+    const record = read && read.ok === true ? read.record : null;
+    const bootId = record && typeof record.bootId === 'string' ? record.bootId : null;
+    const port = record && Number.isFinite(Number(record.port)) ? Number(record.port) : null;
+    const isNewInstance = bootId !== null && (expected === null || bootId !== expected);
+    if (isNewInstance && port !== null && port > 0) {
+      const url = healthUrlForPort(port, healthPath);
+      const answer = await probe({ url, timeoutMs: DEFAULT_HEALTH_TIMEOUT_MS });
+      if (answer && answer.ok === true) {
+        return { ok: true, bootId, port, url, reason: 'the new instance answered its health route' };
+      }
+      lastReason = (answer && answer.error) || 'the new instance did not answer its health route';
+    } else if (record === null) {
+      lastReason = 'the instance record is not readable yet';
+    } else if (!isNewInstance) {
+      lastReason = 'the instance that answers is still the one that is being replaced';
+    } else {
+      lastReason = 'the new instance did not publish its port yet';
+    }
+    await sleepFn(step);
+  }
+  return { ok: false, bootId: null, port: null, url: null, reason: lastReason };
+}
+
+/**
+ * The token of an access URL, or null.
+ *
+ * @param {string} url
+ * @returns {string|null}
+ */
+export function tokenOf(url) {
+  const text = typeof url === 'string' ? url.trim() : '';
+  if (text === '') return null;
+  try {
+    const parsed = new URL(text);
+    return parsed.searchParams.get('token');
+  } catch {
+    return null;
+  }
+}

package/lib/host-kind.js

@@ -0,0 +1,145 @@
+/**
+ * dsh-autorestart — WHICH MACHINE IS THIS?
+ *
+ * The plugin has to know whether it runs on Windows, on a real Linux, on a
+ * macOS or INSIDE WSL (the Linux of Windows). The answer changes what may be
+ * done:
+ *
+ *   - the graceful shutdown must reach the PHYSICAL machine (in WSL, shutting
+ *     the distro down only stops the subsystem);
+ *   - the "start at login" of the supervisor is a different thing in WSL
+ *     (a systemd user unit + `loginctl enable-linger`, or a Windows-side
+ *     task) than on a real Linux;
+ *   - inside WSL there is NO Docker/Compose answer: the orchestrator is
+ *     Windows itself.
+ *
+ * So the detection lives HERE, once, and both halves of the plugin use it.
+ *
+ * Everything is dependency-injected (the platform, the environment, the file
+ * probes), so the whole matrix can be tested without a machine.
+ *
+ * ESM only, Node builtins only.
+ */
+
+import fs from 'node:fs'
+
+/** The Windows shutdown binary as it is reachable from WSL. */
+export const WSL_SHUTDOWN_EXE = '/mnt/c/Windows/System32/shutdown.exe'
+
+/** The file that tells a WSL kernel from a real Linux kernel. */
+export const WSL_PROC_VERSION = '/proc/version'
+
+/** The kinds of host the plugin knows. */
+export const HOST_KINDS = Object.freeze({
+  WINDOWS: 'windows',
+  WSL: 'wsl',
+  LINUX: 'linux',
+  MACOS: 'macos',
+  UNSUPPORTED: 'unsupported',
+})
+
+/** @param {unknown} value */
+function nonEmptyString(value) {
+  return typeof value === 'string' && value.trim() !== '' ? value.trim() : ''
+}
+
+/**
+ * The evidence that this Linux is really a WSL distribution.
+ *
+ * Any ONE of them is enough:
+ *   1. `WSL_DISTRO_NAME` is set (WSL exports it into every process),
+ *   2. `WSL_INTEROP` is set (WSL exports it into every process),
+ *   3. `/proc/version` mentions "microsoft" (the WSL kernel says so),
+ *   4. the Windows shutdown binary is reachable under `/mnt/c`.
+ *
+ * @param {object} env
+ * @param {(file: string) => string} readFile
+ * @param {(file: string) => boolean} exists
+ * @returns {string|null} the name of the evidence, or null
+ */
+export function detectWslEvidence(env, readFile, exists) {
+  const environ = env && typeof env === 'object' ? env : {}
+  if (nonEmptyString(environ.WSL_DISTRO_NAME) !== '') return 'WSL_DISTRO_NAME'
+  if (nonEmptyString(environ.WSL_INTEROP) !== '') return 'WSL_INTEROP'
+  let version = ''
+  try {
+    version = String(readFile(WSL_PROC_VERSION) || '')
+  } catch {
+    version = ''
+  }
+  if (version.toLowerCase().includes('microsoft')) return WSL_PROC_VERSION
+  let found = false
+  try {
+    found = exists(WSL_SHUTDOWN_EXE) === true
+  } catch {
+    found = false
+  }
+  if (found) return WSL_SHUTDOWN_EXE
+  return null
+}
+
+/**
+ * Which machine is this?
+ *
+ * `suspect` is true when the ONLY evidence is the mounted Windows drive: a
+ * real Linux with a manually mounted C: drive looks exactly the same. The
+ * plugin says so instead of pretending to be sure — and it does NOT change
+ * any system configuration on such a guess.
+ *
+ * @param {{
+ *   platform?: string,
+ *   env?: object,
+ *   readFile?: (file: string) => string,
+ *   exists?: (file: string) => boolean,
+ * }} [options]
+ * @returns {{
+ *   kind: 'windows'|'wsl'|'linux'|'macos'|'unsupported',
+ *   platform: string,
+ *   evidence: string,
+ *   suspect: boolean,
+ *   distro: string,
+ * }}
+ */
+export function detectHostKind({
+  platform = process.platform,
+  env = process.env,
+  readFile,
+  exists,
+} = {}) {
+  const plat = nonEmptyString(platform) || process.platform
+  const environ = env && typeof env === 'object' ? env : process.env
+  const readFileSafe = typeof readFile === 'function'
+    ? readFile
+    : (file) => fs.readFileSync(file, 'utf8')
+  const existsSafe = typeof exists === 'function'
+    ? exists
+    : (file) => fs.existsSync(file)
+
+  const base = {
+    platform: plat,
+    evidence: 'process.platform',
+    suspect: false,
+    distro: nonEmptyString(environ.WSL_DISTRO_NAME),
+  }
+
+  if (plat === 'win32') {
+    return { ...base, kind: HOST_KINDS.WINDOWS }
+  }
+  if (plat === 'linux') {
+    const evidence = detectWslEvidence(environ, readFileSafe, existsSafe)
+    if (evidence !== null) {
+      return {
+        ...base,
+        kind: HOST_KINDS.WSL,
+        evidence,
+        // Only the mounted drive: that is a HINT, not a proof.
+        suspect: evidence === WSL_SHUTDOWN_EXE,
+      }
+    }
+    return { ...base, kind: HOST_KINDS.LINUX }
+  }
+  if (plat === 'darwin') {
+    return { ...base, kind: HOST_KINDS.MACOS }
+  }
+  return { ...base, kind: HOST_KINDS.UNSUPPORTED }
+}

package/lib/node-runtime.js

@@ -0,0 +1,144 @@
+/**
+ * dsh-autorestart — the NODE INTERPRETER the supervisor is started with.
+ *
+ * WHY THIS FILE EXISTS:
+ *
+ * The supervisor is a plain node script. The record that starts it at login
+ * must therefore name a REAL node interpreter. `process.execPath` is NOT
+ * always node:
+ *
+ *   - in the hosted web host it is node (`/usr/bin/node`, `node.exe`);
+ *   - in the DESKTOP APP it is the Electron client
+ *     (`…\DeepSeek Harness.exe`).
+ *
+ * A login record that starts the Electron client would open a SECOND copy of
+ * the client at every login (the login record inherits the environment of the
+ * user, which does NOT carry `ELECTRON_RUN_AS_NODE=1`, so the exe starts the
+ * full application instead of running the script as node).
+ *
+ * So the interpreter is RESOLVED, never guessed:
+ *
+ *   1. the process itself IS node (the file name starts with `node`);
+ *   2. the runtime that ships with the installation
+ *      (`resources/runtime/primary-runtime/dependencies/node/bin/node.exe`);
+ *   3. the `node` of the PATH.
+ *
+ * When none of them is there the answer is "no interpreter": the caller
+ * refuses the installation and says why. The application executable is NEVER
+ * used as a stand-in for node.
+ *
+ * ESM only, Node builtins only.
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * The node interpreter inside the runtime that ships with the installation.
+ *
+ * It is relative to the directory of the application executable.
+ */
+export const BUNDLED_NODE_RELATIVE_PATH = Object.freeze([
+  'resources',
+  'runtime',
+  'primary-runtime',
+  'dependencies',
+  'node',
+  'bin',
+  'node.exe',
+])
+
+/**
+ * Is this file name the name of a node interpreter?
+ *
+ * `node`, `node.exe`, `node22.exe` and `nodejs` are interpreters; a directory
+ * called `node_modules` is not.
+ *
+ * @param {string} execPath
+ * @returns {boolean}
+ */
+export function isNodeExecutable(execPath) {
+  const text = String(execPath ?? '').trim()
+  if (text === '') return false
+  const base = path.basename(text).toLowerCase()
+  if (!base.startsWith('node')) return false
+  return !base.includes('node_modules')
+}
+
+/**
+ * The directories of the PATH (Windows spells it `Path` as well).
+ *
+ * @param {object} env
+ * @returns {string[]}
+ */
+function pathDirectories(env) {
+  const raw = typeof env.PATH === 'string' && env.PATH !== ''
+    ? env.PATH
+    : (typeof env.Path === 'string' ? env.Path : '')
+  if (raw === '') return []
+  return raw.split(path.delimiter).map((part) => part.trim()).filter((part) => part !== '')
+}
+
+/**
+ * Find a real node interpreter on this machine.
+ *
+ * @param {{
+ *   execPath?: string,
+ *   platform?: string,
+ *   env?: object,
+ *   existsSyncFn?: Function,
+ * }} [options]
+ * @returns {{
+ *   ok: boolean,
+ *   path: string,
+ *   source: 'process'|'install-dir'|'path'|'',
+ *   reason: string,
+ *   tried: string[],
+ * }}
+ */
+export function resolveNodeInterpreter(options = {}) {
+  const platform = typeof options.platform === 'string' ? options.platform : process.platform
+  const execPath = String(options.execPath ?? '')
+  const env = options.env && typeof options.env === 'object' ? options.env : process.env
+  const exists = typeof options.existsSyncFn === 'function' ? options.existsSyncFn : fs.existsSync
+  const tried = []
+
+  // (1) The process IS node.
+  if (isNodeExecutable(execPath)) {
+    return { ok: true, path: execPath, source: 'process', reason: '', tried }
+  }
+
+  // (2) The runtime that ships with the installation.
+  if (execPath !== '') {
+    const directory = path.dirname(execPath)
+    const candidates = platform === 'win32'
+      ? [path.join(directory, ...BUNDLED_NODE_RELATIVE_PATH)]
+      : []
+    for (const candidate of candidates) {
+      tried.push(candidate)
+      if (exists(candidate)) {
+        return { ok: true, path: candidate, source: 'install-dir', reason: '', tried }
+      }
+    }
+  }
+
+  // (3) The PATH.
+  const names = platform === 'win32' ? ['node.exe'] : ['node']
+  for (const directory of pathDirectories(env)) {
+    for (const name of names) {
+      const candidate = path.join(directory, name)
+      tried.push(candidate)
+      if (exists(candidate)) {
+        return { ok: true, path: candidate, source: 'path', reason: '', tried }
+      }
+    }
+  }
+
+  return {
+    ok: false,
+    path: '',
+    source: '',
+    reason: 'no node interpreter was found: the executable of this process is not node, the installation carries no bundled node, and the PATH has none either — the application executable is never used as a stand-in for node',
+    tried,
+  }
+}