herdr-remote 0.2.32 → 0.2.34

package/dist/relay-updater.js

@@ -1,81 +0,0 @@
-// Updating the relay a local or LAN workstation runs, on its own.
-//
-// The relay is a package of its own that herdr-remote installs. A release of
-// the relay alone leaves herdr-remote's version where it was, so the update
-// check for herdr-remote says "up to date" while the relay on disk falls
-// behind. This checks the relay by itself, and installs the newest relay that
-// this herdr-remote's dependency range allows.
-import fs from 'node:fs';
-import path from 'node:path';
-import { createRequire } from 'node:module';
-import { PACKAGE_ROOT } from './paths.js';
-import { checkForUpdate, compareVersions, currentVersion, performUpdate, } from './updater.js';
-const RELAY_PACKAGE = 'herdr-remote-relay';
-/** The relay installed under this herdr-remote, read from disk: an update moves it. */
-export function installedRelayVersion() {
-    try {
-        const manifest = createRequire(import.meta.url).resolve(`${RELAY_PACKAGE}/package.json`);
-        return JSON.parse(fs.readFileSync(manifest, 'utf8')).version;
-    }
-    catch {
-        return null;
-    }
-}
-/** The relay versions this herdr-remote declares it works with, e.g. `^0.3.9`. */
-function relayRange() {
-    try {
-        const manifest = JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf8'));
-        return manifest.dependencies?.[RELAY_PACKAGE] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Whether `version` is inside a caret range, the only kind herdr-remote
- * declares. Below 1.0 a caret holds the minor version (`^0.3.9` is `0.3.x`
- * from `0.3.9`), which is exactly the line a relay must not cross alone.
- */
-export function withinCaretRange(version, range) {
-    const match = /^\^(\d+)\.(\d+)\.(\d+)$/.exec(range.trim());
-    if (!match)
-        return false;
-    const floor = `${match[1]}.${match[2]}.${match[3]}`;
-    const [major, minor] = version.split('.').map((part) => Number.parseInt(part, 10));
-    const [floorMajor, floorMinor] = [Number(match[1]), Number(match[2])];
-    if (compareVersions(version, floor) < 0 || major !== floorMajor)
-        return false;
-    return floorMajor > 0 || minor === floorMinor;
-}
-/** Whether a newer relay than the installed one is out, and whether this herdr-remote can take it. */
-export async function checkForRelayUpdate(options = {}) {
-    const installed = installedRelayVersion();
-    const result = await checkForUpdate({
-        ...options,
-        packageName: RELAY_PACKAGE,
-        current: installed ?? '0.0.0',
-    });
-    if (!result.ok || !result.updateAvailable || !result.latest)
-        return result;
-    const range = relayRange();
-    if (range && !withinCaretRange(result.latest, range)) {
-        return { ...result, updateAvailable: false, needsNewerCli: true };
-    }
-    return result;
-}
-/**
- * Install the newest relay this herdr-remote allows: the same herdr-remote,
- * reinstalled, which npm resolves afresh, relay included. The installed
- * herdr-remote does not change, and neither does anything it was tested with
- * but the relay. Success is the relay on disk, not npm's exit code.
- */
-export async function performRelayUpdate({ relayVersion, readRelayVersion = installedRelayVersion, ...options }) {
-    const result = await performUpdate({ ...options, version: currentVersion() });
-    if (!result.ok)
-        return result;
-    const installed = readRelayVersion();
-    if (!installed || compareVersions(installed, relayVersion) < 0) {
-        return { ok: false, errorKey: 'relayUpdate.errorNotApplied', installed, output: result.output };
-    }
-    return { ...result, installed };
-}

package/dist/tui/screens/useRelayUpdate.js

@@ -1,122 +0,0 @@
-// The relay row on the About tab: check for, install and switch to a newer
-// relay. Only a machine that runs its own relay has one to update.
-import { useEffect, useState } from 'react';
-import { canSelfUpdate, checkForRelayUpdate, compareVersions, currentVersion, installKind, installedRelayVersion, performRelayUpdate, restartAll, runsLocalRelay, whileServicesStopped, } from '../api.js';
-export function useRelayUpdate(ctx) {
-    const { t } = ctx;
-    const [state, setState] = useState({ phase: 'idle' });
-    const [source, setSource] = useState({
-        registry: '',
-        sources: [],
-    });
-    const visible = runsLocalRelay(ctx.config);
-    const installed = installedRelayVersion();
-    const health = ctx.status?.relay.health;
-    const running = typeof health?.version === 'string' ? health.version : null;
-    const busy = state.phase === 'checking' || state.phase === 'updating';
-    // Installed but not yet running: an update from here, or from npm by hand.
-    const restartNeeded = !busy &&
-        state.phase !== 'restarting' &&
-        !!installed &&
-        !!running &&
-        compareVersions(installed, running) > 0;
-    const applyCheck = (result) => {
-        setSource({ registry: result.registry ?? '', sources: result.sources ?? [] });
-        const latest = result.latest;
-        if (result.needsNewerCli)
-            setState({ phase: 'needsCli', latest });
-        else if (result.updateAvailable)
-            setState({ phase: 'available', latest });
-        else
-            setState({ phase: 'current', version: result.current });
-    };
-    // The TUI asked when it opened; start from that answer.
-    // biome-ignore lint/correctness/useExhaustiveDependencies: only a new answer from the opening check matters, not each render's applyCheck or phase
-    useEffect(() => {
-        if (ctx.relayUpdateCheck?.ok && state.phase === 'idle')
-            applyCheck(ctx.relayUpdateCheck);
-    }, [ctx.relayUpdateCheck]);
-    const check = async () => {
-        setState({ phase: 'checking' });
-        const result = await checkForRelayUpdate();
-        if (!result.ok) {
-            setState({ phase: 'error', messageKey: result.errorKey ?? 'update.errorNetwork' });
-            const { message } = result;
-            if (message)
-                ctx.notify((t) => t('update.errorNetworkDetail', { message }), 'error');
-            return;
-        }
-        ctx.setRelayUpdateCheck(result);
-        applyCheck(result);
-    };
-    const install = async (latest) => {
-        setState({ phase: 'updating', latest, attempt: 1 });
-        const result = await whileServicesStopped(ctx.config, () => performRelayUpdate({
-            ...source,
-            relayVersion: latest,
-            onAttempt: ({ attempt }) => setState({ phase: 'updating', latest, attempt }),
-        }));
-        if (!result.ok) {
-            const params = { version: currentVersion(), installed: result.installed ?? '' };
-            const messageKey = result.errorKey ?? 'update.errorFailed';
-            setState({ phase: 'error', messageKey, params });
-            const { summary } = result;
-            ctx.notify((t) => summary ? t('update.errorFailedDetail', { message: summary }) : t(messageKey, params), 'error');
-            return;
-        }
-        ctx.setRelayUpdateCheck(null);
-        setState({ phase: 'current', version: latest });
-    };
-    const restart = () => {
-        setState({ phase: 'restarting' });
-        ctx.run(() => {
-            restartAll(ctx.config);
-            const version = installed ?? '';
-            setState({ phase: 'current', version });
-            ctx.notify((t) => t('relayUpdate.restarted', { version }), 'success');
-        });
-    };
-    /** One row: restart onto a relay already installed, install one found, or check. */
-    const activate = () => {
-        if (busy || state.phase === 'restarting')
-            return;
-        if (restartNeeded) {
-            restart();
-            return;
-        }
-        if (state.phase === 'available') {
-            if (!canSelfUpdate()) {
-                setState({ phase: 'error', messageKey: `update.cannot.${installKind()}` });
-                return;
-            }
-            void install(state.latest);
-            return;
-        }
-        void check();
-    };
-    const label = (() => {
-        if (restartNeeded)
-            return t('relayUpdate.restart', { version: installed ?? '', running: running ?? '' });
-        switch (state.phase) {
-            case 'checking':
-                return t('relayUpdate.checking');
-            case 'current':
-                return t('relayUpdate.upToDate', { version: state.version });
-            case 'available':
-                return t('relayUpdate.available', { latest: state.latest, installed: installed ?? '?' });
-            case 'needsCli':
-                return t('relayUpdate.needsCli', { latest: state.latest });
-            case 'updating':
-                return state.attempt > 1
-                    ? t('relayUpdate.updatingRetry', { version: state.latest, attempt: state.attempt })
-                    : t('relayUpdate.updating', { version: state.latest });
-            case 'restarting':
-                return t('relayUpdate.restarting');
-            case 'error':
-                return t(state.messageKey, state.params);
-            default:
-                return t('relayUpdate.check', { version: installed ?? '?' });
-        }
-    })();
-    return { visible, installed, label, activate };
-}