total-recall-brain 3.18.2 → 3.19.0

package/src/core/package-auto-update.mjs

@@ -14,12 +14,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { logger } from './logger.mjs';
 
 export const PACKAGE_NAME = 'total-recall-brain';
 export const DEFAULT_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
 
+/** In-process cache so dashboard update checks never block the event loop on every load. */
+let latestVersionCache = { value: null, fetchedAt: 0 };
+const LATEST_VERSION_CACHE_MS = 5 * 60 * 1000;
+
 /**
  * @returns {boolean}
  */
@@ -183,21 +187,113 @@ export function inspectProjectPackage(projectRoot) {
 }
 
 /**
+ * Resolve latest npm version without blocking the Node event loop.
+ * Prefer this from HTTP handlers / daemons.
+ *
+ * @param {{ timeoutMs?: number, force?: boolean }} [opts]
+ * @returns {Promise<string|null>}
+ */
+export function fetchLatestNpmVersionAsync(opts = {}) {
+  const timeout = opts.timeoutMs ?? 8_000;
+  const now = Date.now();
+  if (
+    !opts.force &&
+    latestVersionCache.value &&
+    now - latestVersionCache.fetchedAt < LATEST_VERSION_CACHE_MS
+  ) {
+    return Promise.resolve(latestVersionCache.value);
+  }
+
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      if (value) {
+        latestVersionCache = { value, fetchedAt: Date.now() };
+      }
+      resolve(value);
+    };
+
+    let child;
+    try {
+      child = spawn('npm', ['view', PACKAGE_NAME, 'version'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (err) {
+      logger.debug('package-auto-update', 'npm view spawn failed', { error: err.message });
+      return finish(null);
+    }
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr?.on('data', (chunk) => {
+      stderr += String(chunk);
+    });
+
+    const timer = setTimeout(() => {
+      try {
+        child.kill('SIGTERM');
+      } catch {
+        /* ignore */
+      }
+      logger.debug('package-auto-update', 'npm view timed out', { timeoutMs: timeout });
+      // Return stale cache if any
+      finish(latestVersionCache.value || null);
+    }, timeout);
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      logger.debug('package-auto-update', 'npm view error', { error: err.message });
+      finish(latestVersionCache.value || null);
+    });
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        if (stderr) {
+          logger.debug('package-auto-update', 'npm view failed', { code, stderr: stderr.slice(0, 200) });
+        }
+        return finish(latestVersionCache.value || null);
+      }
+      const v = stdout.trim();
+      finish(v || null);
+    });
+  });
+}
+
+/**
+ * Sync npm view (CLI only). Blocks the process — do NOT call from Express handlers.
+ * Prefer fetchLatestNpmVersionAsync in server/daemon paths.
+ *
  * @param {{ timeoutMs?: number }} [opts]
  * @returns {string|null}
  */
 export function fetchLatestNpmVersion(opts = {}) {
-  const timeout = opts.timeoutMs ?? 20_000;
+  const now = Date.now();
+  if (latestVersionCache.value && now - latestVersionCache.fetchedAt < LATEST_VERSION_CACHE_MS) {
+    return latestVersionCache.value;
+  }
+  const timeout = opts.timeoutMs ?? 8_000;
   const result = spawnSync('npm', ['view', PACKAGE_NAME, 'version'], {
     encoding: 'utf8',
     timeout,
     stdio: ['ignore', 'pipe', 'pipe'],
   });
-  if (!result || result.status !== 0) return null;
+  if (!result || result.status !== 0) return latestVersionCache.value || null;
   const v = (result.stdout || '').trim();
+  if (v) latestVersionCache = { value: v, fetchedAt: Date.now() };
   return v || null;
 }
 
+/** Test helper — clear version cache between specs. */
+export function clearLatestNpmVersionCache() {
+  latestVersionCache = { value: null, fetchedAt: 0 };
+}
+
 /**
  * Semver-ish compare: true if installed is missing or older than latest.
  * Handles simple x.y.z only (npm publish tags).

package/src/core/pairing.mjs

@@ -0,0 +1,168 @@
+/**
+ * Mobile pairing endpoints — reachable URLs for QR codes.
+ * Never hardcodes personal hostnames; derives from live interfaces + server port.
+ */
+import { listLocalInterfaces, isLanIpv4, isOverlayIpv4 } from './network-interfaces.mjs';
+import { getMeshIp } from './mesh.mjs';
+
+/**
+ * @param {{
+ *   port?: number,
+ *   protocol?: 'http'|'https',
+ *   listInterfaces?: () => Array,
+ *   meshIp?: string|null,
+ *   listenHosts?: string[],
+ * }} [opts]
+ */
+export function buildPairingInfo(opts = {}) {
+  const port = Number(opts.port || process.env.TR_SERVER_PORT || process.env.PORT || 3000);
+  const protocol = opts.protocol === 'https' ? 'https' : 'http';
+  const interfaces = typeof opts.listInterfaces === 'function'
+    ? opts.listInterfaces()
+    : listLocalInterfaces();
+  const meshIp = opts.meshIp !== undefined ? opts.meshIp : getMeshIp();
+  const listenHosts = Array.isArray(opts.listenHosts)
+    ? opts.listenHosts
+    : deriveListenHosts(meshIp);
+
+  /** @type {Array<{ kind: string, label: string, ip: string, url: string, interface?: string, recommended: boolean, reachable_hint: string }>} */
+  const endpoints = [];
+  const seen = new Set();
+
+  const add = (kind, label, ip, ifaceName, recommended, hint) => {
+    if (!ip || seen.has(ip)) return;
+    seen.add(ip);
+    const hostPart = ip.includes(':') ? `[${ip}]` : ip;
+    endpoints.push({
+      kind,
+      label,
+      ip,
+      url: `${protocol}://${hostPart}:${port}`,
+      interface: ifaceName || null,
+      recommended: !!recommended,
+      reachable_hint: hint,
+    });
+  };
+
+  // LAN IPv4s first (phone on same Wi‑Fi)
+  for (const iface of interfaces) {
+    for (const addr of iface.addresses || []) {
+      if (addr.family !== 'IPv4' || addr.internal) continue;
+      if (addr.is_lan || isLanIpv4(addr.address)) {
+        add(
+          'lan',
+          'Local Wi‑Fi / LAN',
+          addr.address,
+          iface.name,
+          true,
+          'Phone must be on the same Wi‑Fi. Brain must accept LAN connections (bind 0.0.0.0 or this IP).',
+        );
+      }
+    }
+  }
+
+  // Mesh / Tailscale overlay
+  if (meshIp && isOverlayIpv4(meshIp)) {
+    add(
+      'mesh',
+      'Tailscale / mesh',
+      meshIp,
+      null,
+      endpoints.length === 0,
+      'Phone needs Tailscale (or mesh) installed and online on the same tailnet.',
+    );
+  }
+  for (const iface of interfaces) {
+    for (const addr of iface.addresses || []) {
+      if (addr.family !== 'IPv4' || addr.internal) continue;
+      if (addr.is_overlay || isOverlayIpv4(addr.address)) {
+        add(
+          'mesh',
+          'Tailscale / mesh',
+          addr.address,
+          iface.name,
+          endpoints.every((e) => e.kind !== 'lan'),
+          'Phone needs Tailscale (or mesh) installed and online on the same tailnet.',
+        );
+      }
+    }
+  }
+
+  // Loopback last (only useful on the same machine)
+  add(
+    'loopback',
+    'This computer only',
+    '127.0.0.1',
+    'lo',
+    false,
+    'Only works on this machine — not for phone pairing.',
+  );
+
+  const lanBound = listenHosts.some((h) => h === '0.0.0.0' || isLanIpv4(h));
+  const meshBound = listenHosts.some((h) => h === meshIp || isOverlayIpv4(h) || h === '0.0.0.0');
+  const warnings = [];
+
+  if (!endpoints.some((e) => e.kind === 'lan')) {
+    warnings.push('No LAN IPv4 found — connect this machine to Wi‑Fi/Ethernet for same-network pairing.');
+  } else if (!lanBound) {
+    warnings.push(
+      'Brain is not listening on LAN (only loopback/mesh). Phone on plain Wi‑Fi cannot use the LAN URL until the brain binds 0.0.0.0 (Allow Public Bind + restart) or you use Tailscale on the phone.',
+    );
+  }
+
+  // Prefer an address the server is actually listening on when possible.
+  const isListening = (ip) =>
+    listenHosts.includes(ip) ||
+    listenHosts.includes('0.0.0.0') ||
+    (ip === '127.0.0.1' && listenHosts.includes('127.0.0.1'));
+
+  for (const e of endpoints) {
+    e.recommended = false;
+  }
+
+  let preferred =
+    endpoints.find((e) => e.kind === 'lan' && lanBound && isListening(e.ip)) ||
+    endpoints.find((e) => e.kind === 'mesh' && (meshBound || isListening(e.ip))) ||
+    endpoints.find((e) => e.kind === 'lan') ||
+    endpoints.find((e) => e.kind === 'mesh') ||
+    endpoints.find((e) => e.kind === 'loopback') ||
+    endpoints[0] ||
+    null;
+
+  // When LAN exists but is not bound, prefer mesh if available (works today with Tailscale phones).
+  if (preferred?.kind === 'lan' && !lanBound) {
+    const meshEp = endpoints.find((e) => e.kind === 'mesh');
+    if (meshEp) preferred = meshEp;
+  }
+
+  if (preferred) {
+    for (const e of endpoints) e.recommended = e.ip === preferred.ip;
+  }
+
+  if (endpoints.some((e) => e.kind === 'mesh') && !meshBound && meshIp) {
+    warnings.push(`Mesh IP ${meshIp} is present but may not be the active listen address.`);
+  }
+
+  return {
+    port,
+    protocol,
+    listen_hosts: listenHosts,
+    preferred_url: preferred?.url || null,
+    endpoints,
+    warnings,
+    measured_at: new Date().toISOString(),
+  };
+}
+
+function deriveListenHosts(meshIp) {
+  const hosts = new Set(['127.0.0.1']);
+  if (meshIp) hosts.add(meshIp);
+  const envHost = process.env.HOST || process.env.TR_HOST;
+  if (envHost) hosts.add(envHost);
+  // Production dual-bind pattern in server/index.mjs
+  if (meshIp && meshIp !== '127.0.0.1') {
+    hosts.add(meshIp);
+    hosts.add('127.0.0.1');
+  }
+  return [...hosts];
+}