herdr-remote 0.2.39 → 0.3.32

package/dist/supervisor.js

@@ -1,323 +0,0 @@
-import fs from 'node:fs';
-import { spawn } from 'node:child_process';
-import { loadConfig } from './config.js';
-import { logPath, stateDir } from './paths.js';
-import { ensureDir } from 'herdr-remote-relay/state';
-import { ensureRuntime, managedPids, recordManagedPid, updateRuntime, } from './runtime.js';
-import { baseEnvironment, serviceSpecs } from './service.js';
-import { EXIT_REPLACED, EXIT_AUTH_FAILED } from './exit-codes.js';
-import { pidAlive, stillRunning } from './lib/process.js';
-const MIN_BACKOFF_MS = 500;
-const MAX_BACKOFF_MS = 30_000;
-// A child that stayed up this long is considered healthy, so the next crash
-// starts backing off from scratch instead of inheriting an old penalty.
-const HEALTHY_UPTIME_MS = 30_000;
-/**
- * Runs the relay and host connector as managed children and restarts them when
- * they die.
- *
- * This is the process a service manager supervises: `herdr-remote run` stays in
- * the foreground so systemd/launchd can track it, and the same class backs the
- * fallback daemon on systems where neither is available.
- */
-class Supervisor {
-    config;
-    state;
-    logToFiles;
-    onEvent;
-    /** What to run; the relay and host connector unless a test says otherwise. */
-    specs;
-    children = new Map();
-    stopping = false;
-    constructor({ config = loadConfig(), state = ensureRuntime(), logToFiles = false, onEvent = null, specs = null, } = {}) {
-        this.config = config;
-        this.state = state;
-        this.logToFiles = logToFiles;
-        this.onEvent = onEvent;
-        this.specs = specs;
-    }
-    emit(event) {
-        if (this.onEvent)
-            this.onEvent(event);
-        const line = `[${new Date().toISOString()}] herdr-remote supervisor: ${event.message}\n`;
-        process.stdout.write(line);
-    }
-    /**
-     * Stop anything a previous, unmanaged start left behind.
-     *
-     * Taking over without this is what produced the runaway: a detached relay
-     * from `herdr-remote start` kept port 8787, so every relay this supervisor
-     * spawned died with EADDRINUSE and retried forever, while the orphaned host
-     * connector and ours both claimed the same host id on the relay and kicked
-     * each other off — which is what browsers saw as an endless reconnect.
-     *
-     * Only ledger entries whose start token still matches are touched: the
-     * ledger survives a reboot, and its pids then belong to whatever the new
-     * boot started.
-     */
-    async reclaimStrays({ timeoutMs = 5000 } = {}) {
-        const strays = managedPids().filter((entry) => entry.pid !== process.pid);
-        if (strays.length === 0)
-            return strays;
-        for (const { pid, name } of strays) {
-            this.emit({
-                type: 'reclaim',
-                name,
-                pid,
-                message: `stopping stray ${name} from an earlier start (pid ${pid})`,
-            });
-            try {
-                process.kill(pid, 'SIGTERM');
-            }
-            catch {
-                // Already gone, or not ours to signal; the liveness check below decides.
-            }
-        }
-        // Wait for them to actually go: the relay only releases its port on exit,
-        // and spawning ours before then just reproduces the EADDRINUSE loop.
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (strays.every(({ pid }) => !pidAlive(pid)))
-                return strays;
-            await new Promise((resolve) => {
-                setTimeout(resolve, 100);
-            });
-        }
-        // Checked again before the harder signal, in case the number moved on meanwhile.
-        for (const { pid, name } of stillRunning(strays)) {
-            this.emit({
-                type: 'reclaim',
-                name,
-                pid,
-                message: `stray ${name} (pid ${pid}) ignored SIGTERM, killing`,
-            });
-            try {
-                process.kill(pid, 'SIGKILL');
-            }
-            catch {
-                // Already gone; SIGKILL was the last resort anyway.
-            }
-        }
-        return strays;
-    }
-    async start() {
-        this.stopping = false;
-        ensureDir(stateDir());
-        await this.reclaimStrays();
-        if (this.stopping)
-            return;
-        for (const spec of this.specs ?? serviceSpecs(this.config, this.state)) {
-            this.children.set(spec.name, {
-                spec,
-                child: null,
-                pid: null,
-                restarts: 0,
-                backoffMs: MIN_BACKOFF_MS,
-                timer: null,
-            });
-            this.spawnChild(spec.name);
-        }
-        this.persistPids();
-    }
-    spawnChild(name) {
-        if (this.stopping)
-            return;
-        const entry = this.children.get(name);
-        if (!entry || entry.child)
-            return;
-        let stdio = ['ignore', 'inherit', 'inherit'];
-        let fd = null;
-        if (this.logToFiles) {
-            fd = fs.openSync(logPath(name), 'a');
-            stdio = ['ignore', fd, fd];
-        }
-        let child;
-        try {
-            child = spawn(entry.spec.command, entry.spec.args, {
-                cwd: entry.spec.cwd,
-                env: { ...baseEnvironment(), ...entry.spec.env },
-                windowsHide: true,
-                stdio,
-            });
-        }
-        catch (error) {
-            this.emit({
-                type: 'spawn_failed',
-                name,
-                message: `could not start ${name}: ${error.message}`,
-            });
-            this.scheduleRestart(name);
-            return;
-        }
-        finally {
-            // The child inherited the descriptor during spawn, so this copy is done.
-            if (fd !== null) {
-                try {
-                    fs.closeSync(fd);
-                }
-                catch {
-                    // The child holds its own copy; failing to close ours leaks one descriptor at worst.
-                }
-            }
-        }
-        entry.child = child;
-        entry.pid = child.pid;
-        entry.startedAt = Date.now();
-        this.emit({
-            type: 'started',
-            name,
-            pid: child.pid,
-            message: `${name} started (pid ${child.pid})`,
-        });
-        this.persistPids();
-        child.on('exit', (code, signal) => {
-            const uptimeMs = Date.now() - (entry.startedAt ?? Date.now());
-            entry.child = null;
-            entry.pid = null;
-            this.persistPids();
-            if (this.stopping)
-                return;
-            if (code === EXIT_REPLACED) {
-                this.emit({
-                    type: 'replaced',
-                    name,
-                    message: `${name} stood down: another instance owns this workstation. Not restarting it.`,
-                });
-                return;
-            }
-            if (code === EXIT_AUTH_FAILED) {
-                this.emit({
-                    type: 'fatal',
-                    name,
-                    message: `${name} stopped: relay authentication failed. Update credentials before restarting it.`,
-                });
-                return;
-            }
-            if (uptimeMs >= HEALTHY_UPTIME_MS)
-                entry.backoffMs = MIN_BACKOFF_MS;
-            this.emit({
-                type: 'exited',
-                name,
-                code,
-                signal,
-                message: `${name} exited (${signal || `code ${code}`}) after ${Math.round(uptimeMs / 1000)}s, restarting in ${entry.backoffMs}ms`,
-            });
-            this.scheduleRestart(name);
-        });
-        child.on('error', (error) => {
-            this.emit({ type: 'error', name, message: `${name} error: ${error.message}` });
-        });
-    }
-    scheduleRestart(name) {
-        if (this.stopping)
-            return;
-        const entry = this.children.get(name);
-        if (!entry || entry.timer)
-            return;
-        const delay = entry.backoffMs;
-        entry.restarts += 1;
-        entry.backoffMs = Math.min(MAX_BACKOFF_MS, Math.round(entry.backoffMs * 2));
-        const timer = setTimeout(() => {
-            entry.timer = null;
-            this.spawnChild(name);
-        }, delay);
-        entry.timer = timer;
-        timer.unref?.();
-    }
-    persistPids() {
-        try {
-            updateRuntime((current) => {
-                current.supervisorPid = process.pid;
-                current.relayPid = this.children.get('relay')?.pid || null;
-                current.hostPid = this.children.get('host')?.pid || null;
-                current.startedAt = current.startedAt || new Date().toISOString();
-                current.mode = this.config.relay.mode;
-                // Merge into the ledger rather than replacing it, so a pid recorded by
-                // another writer is never dropped and left running with nobody tracking
-                // it.
-                recordManagedPid(current, 'supervisor', process.pid);
-                for (const [name, entry] of this.children) {
-                    if (entry.pid)
-                        recordManagedPid(current, name, entry.pid);
-                }
-            });
-        }
-        catch (error) {
-            process.stderr.write(`herdr-remote supervisor: could not persist pids: ${error.message}\n`);
-        }
-    }
-    async stop({ graceMs = 5000 } = {}) {
-        this.stopping = true;
-        const pending = [];
-        for (const entry of this.children.values()) {
-            if (entry.timer) {
-                clearTimeout(entry.timer);
-                entry.timer = null;
-            }
-            const child = entry.child;
-            if (!child)
-                continue;
-            pending.push(new Promise((resolve) => {
-                const killTimer = setTimeout(() => {
-                    try {
-                        child.kill('SIGKILL');
-                    }
-                    catch {
-                        // Already exited between the timer and the kill.
-                    }
-                    resolve();
-                }, graceMs);
-                killTimer.unref?.();
-                child.once('exit', () => {
-                    clearTimeout(killTimer);
-                    resolve();
-                });
-                try {
-                    child.kill('SIGTERM');
-                }
-                catch {
-                    resolve();
-                }
-            }));
-        }
-        await Promise.all(pending);
-        try {
-            updateRuntime((current) => {
-                current.supervisorPid = null;
-                current.relayPid = null;
-                current.hostPid = null;
-                current.startedAt = null;
-                current.managedPids = stillRunning((current.managedPids || []).filter(Boolean));
-            });
-        }
-        catch {
-            // The runtime file is advisory; stopping must finish even if it cannot be written.
-        }
-    }
-}
-/** Entry point for `herdr-remote run`: supervise in the foreground until told to stop. */
-async function runForeground({ logToFiles = false } = {}) {
-    const supervisor = new Supervisor({ logToFiles });
-    await supervisor.start();
-    return new Promise((resolve) => {
-        let shuttingDown = false;
-        const shutdown = async (signal) => {
-            if (shuttingDown)
-                return;
-            shuttingDown = true;
-            supervisor.emit({ type: 'shutdown', message: `${signal} received, stopping services` });
-            await supervisor.stop();
-            resolve(0);
-        };
-        process.on('SIGINT', () => {
-            shutdown('SIGINT');
-        });
-        process.on('SIGTERM', () => {
-            shutdown('SIGTERM');
-        });
-        process.on('SIGHUP', () => {
-            shutdown('SIGHUP');
-        });
-    });
-}
-export { MIN_BACKOFF_MS, runForeground, Supervisor };

package/dist/terminal-font/deps.js

@@ -1,83 +0,0 @@
-// What font detection reads the world through, injectable for tests, and the
-// unit conversions every reader shares.
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-/** Terminals size fonts in points; CSS pixels are 1/96 inch. */
-const PX_PER_PT = 96 / 72;
-const COMMAND_TIMEOUT_MS = 3000;
-/** Names a terminal accepts in place of a real family. */
-export const GENERIC_FAMILIES = new Set([
-    'monospace',
-    'mono',
-    'sans',
-    'sans-serif',
-    'serif',
-    'system-ui',
-    'ui-monospace',
-]);
-export function defaultRun(command, args) {
-    try {
-        const result = spawnSync(command, args, {
-            encoding: 'utf8',
-            timeout: COMMAND_TIMEOUT_MS,
-            windowsHide: true,
-        });
-        return { status: result.status, stdout: result.stdout || '' };
-    }
-    catch {
-        return { status: null, stdout: '' };
-    }
-}
-function defaultReadFile(filePath) {
-    try {
-        return fs.readFileSync(filePath, 'utf8');
-    }
-    catch {
-        return null;
-    }
-}
-function defaultReadBuffer(filePath) {
-    try {
-        return fs.readFileSync(filePath);
-    }
-    catch {
-        return null;
-    }
-}
-export function withDefaults(deps = {}) {
-    const env = deps.env || process.env;
-    return {
-        env,
-        platform: deps.platform || process.platform,
-        home: deps.home || env.HOME || os.homedir(),
-        run: deps.run || defaultRun,
-        readFile: deps.readFile || defaultReadFile,
-        readBuffer: deps.readBuffer || defaultReadBuffer,
-        terminalArgs: deps.terminalArgs || [],
-    };
-}
-export function configHome(deps) {
-    return deps.env.XDG_CONFIG_HOME || path.join(deps.home, '.config');
-}
-export function dataHome(deps) {
-    return deps.env.XDG_DATA_HOME || path.join(deps.home, '.local', 'share');
-}
-export function localAppData(deps) {
-    return deps.env.LOCALAPPDATA || path.join(deps.home, 'AppData', 'Local');
-}
-export function roamingAppData(deps) {
-    return deps.env.APPDATA || path.join(deps.home, 'AppData', 'Roaming');
-}
-export function expandHome(filePath, deps) {
-    return filePath.startsWith('~/') ? path.join(deps.home, filePath.slice(2)) : filePath;
-}
-export function pointsToPx(points) {
-    const value = Number(points);
-    return Number.isFinite(value) && value > 0 ? Math.round(value * PX_PER_PT * 10) / 10 : undefined;
-}
-export function positiveNumber(value) {
-    const number = Number(value);
-    return Number.isFinite(number) && number > 0 ? number : undefined;
-}