herdr-remote 0.2.39 → 0.3.32

package/dist/service.js

@@ -1,267 +0,0 @@
-// The processes that make up a running herdr-remote — the local relay and the
-// host connector — and starting, stopping and describing them.
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { ensureDir } from 'herdr-remote-relay/state';
-import { loadConfig } from './config.js';
-import { findHerdrCommand, herdrVersion, MIN_HERDR_VERSION, resolveHerdrCommand, } from './herdr-command.js';
-import { preferredLanAddress } from './net-interfaces.js';
-import { logPath, PACKAGE_ROOT, stateDir } from './paths.js';
-import { healthUrl, hostHeaders, requestJson, waitForHost, waitForRelay } from './relay-client.js';
-import { bindAddress, resolveAdminOrigin, resolveHostRelayUrl, resolvePublicUrl, runsLocalRelay, } from './relay-urls.js';
-import { ensureRuntime, managedPids, readRuntime, recordManagedPid, updateRuntime, writeRuntime, } from './runtime.js';
-import { resolveSocketPath } from './socket-discovery.js';
-import { resolveHostFont } from './terminal-font/index.js';
-import { hostTerminalPalette } from './terminal-palette.js';
-export function relayBinPath() {
-    // Resolved rather than hard-coded: the relay is a separate npm package, so
-    // its location depends on how npm hoisted it.
-    const manifest = createRequire(import.meta.url).resolve('herdr-remote-relay/package.json');
-    return path.join(path.dirname(manifest), 'bin', 'herdr-remote-relay.js');
-}
-function relayAuthStatePath() {
-    return path.join(stateDir(), 'relay-auth.json');
-}
-/**
- * The processes that make up a running herdr-remote, as declarative specs.
- *
- * Both the detached starter and the foreground supervisor build their children
- * from this one list so the two paths cannot drift in how they configure the
- * relay or the host connector.
- */
-export function serviceSpecs(config = loadConfig(), state = ensureRuntime()) {
-    const specs = [];
-    const publicUrl = resolvePublicUrl(config, preferredLanAddress());
-    if (runsLocalRelay(config)) {
-        specs.push({
-            name: 'relay',
-            command: process.execPath,
-            args: [relayBinPath()],
-            cwd: stateDir(),
-            env: {
-                // Let the shared web UI tell a private workstation relay apart from
-                // the operator-facing self-hosted relay. Standalone relay installs
-                // default to remote mode.
-                RELAY_DEPLOYMENT_MODE: 'local',
-                RELAY_BIND: bindAddress(config),
-                RELAY_PORT: String(config.relay.port),
-                RELAY_PUBLIC_URL: publicUrl,
-                // A relay we start ourselves is closed to everything but this
-                // workstation: reusing the host token as its password costs nothing and
-                // stops another machine on the LAN from enrolling into it.
-                RELAY_PASSWORD: state.hostToken,
-                RELAY_AUTH_STATE_FILE: relayAuthStatePath(),
-                RELAY_ALLOWED_ORIGINS: (config.relay.allowedOrigins || []).join(','),
-                RELAY_MAX_CLIENTS_PER_HOST: String(config.relay.maxClientsPerHost),
-                RELAY_MAX_HOSTS: String(config.relay.maxHosts),
-                RELAY_MAX_PENDING_HANDSHAKES: String(config.relay.maxPendingHandshakes),
-                RELAY_MAX_BUFFERED_BYTES_PER_CLIENT: String(config.relay.maxBufferedBytesPerClient),
-                RELAY_HOST_RECONNECT_GRACE_MS: String(config.relay.hostReconnectGraceMs),
-            },
-        });
-    }
-    const terminalPalette = hostTerminalPalette();
-    // What this command detected at its entry point, else what an earlier start
-    // with a terminal wrote down. Only the family, size and terminal travel here;
-    // the connector finds the files itself, on the machine that has them.
-    const terminalFont = resolveHostFont();
-    specs.push({
-        name: 'host',
-        command: process.execPath,
-        args: [path.join(PACKAGE_ROOT, 'dist', 'connector', 'main.js')],
-        cwd: stateDir(),
-        env: {
-            // Captured here, where a terminal may still be attached, because the
-            // connector itself usually runs detached with no terminal to ask.
-            ...(terminalPalette ? { HERDR_TERM_PALETTE_JSON: JSON.stringify(terminalPalette) } : {}),
-            ...(terminalFont ? { HERDR_TERM_FONT_JSON: JSON.stringify(terminalFont) } : {}),
-            RELAY_URL: resolveHostRelayUrl(config),
-            RELAY_HOST_ID: state.hostId,
-            RELAY_HOST_TOKEN: state.hostToken,
-            RELAY_PASSWORD: runsLocalRelay(config) ? state.hostToken : state.relayPassword || '',
-            HERDR_SOCKET_PATH: resolveSocketPath(config.herdr.socketPath),
-            HERDR_ARGS_JSON: JSON.stringify(config.herdr.args),
-            HERDR_CWD: config.herdr.cwd,
-            HERDR_BIN_PATH: resolveHerdrCommand(),
-        },
-    });
-    return specs;
-}
-export function baseEnvironment() {
-    return { ...process.env, HERDR_REMOTE_SERVICE: '1' };
-}
-function spawnDetached(spec) {
-    ensureDir(stateDir());
-    const logFd = fs.openSync(logPath(spec.name), 'a');
-    try {
-        const child = spawn(spec.command, spec.args, {
-            cwd: spec.cwd,
-            env: { ...baseEnvironment(), ...spec.env },
-            detached: true,
-            // A detached console program can open a visible window from a console-less Windows parent.
-            windowsHide: true,
-            stdio: ['ignore', logFd, logFd],
-        });
-        child.unref();
-        return child.pid;
-    }
-    finally {
-        fs.closeSync(logFd);
-    }
-}
-/** Where each service's pid is kept in runtime.json. */
-const PID_FIELDS = { relay: 'relayPid', host: 'hostPid' };
-export function startServices() {
-    const config = loadConfig();
-    const state = ensureRuntime();
-    const next = { ...state };
-    const specs = serviceSpecs(config, state);
-    const running = managedPids(next);
-    const isRunning = (pid) => running.some((entry) => entry.pid === pid);
-    for (const spec of specs) {
-        const field = PID_FIELDS[spec.name];
-        if (isRunning(next[field]))
-            continue;
-        next[field] = spawnDetached(spec) ?? null;
-        recordManagedPid(next, spec.name, next[field]);
-    }
-    // A relay that is no longer part of the plan (switched to remote mode) must
-    // not be left running on the old port.
-    if (!specs.some((spec) => spec.name === 'relay') && isRunning(next.relayPid)) {
-        try {
-            process.kill(next.relayPid, 'SIGTERM');
-        }
-        catch {
-            // Exited between the check and the signal: the port is free either way.
-        }
-        next.relayPid = null;
-    }
-    next.startedAt = next.startedAt || new Date().toISOString();
-    next.mode = config.relay.mode;
-    writeRuntime(next);
-    const live = managedPids(next);
-    return {
-        ok: true,
-        mode: config.relay.mode,
-        relay: {
-            local: runsLocalRelay(config),
-            pid: next.relayPid || null,
-            alive: live.some(({ pid }) => pid === next.relayPid),
-            bind: runsLocalRelay(config) ? bindAddress(config) : null,
-            port: config.relay.port,
-            remoteUrl: config.relay.remoteUrl || null,
-        },
-        host: {
-            pid: next.hostPid || null,
-            alive: live.some(({ pid }) => pid === next.hostPid),
-            socketPath: resolveSocketPath(config.herdr.socketPath),
-        },
-        publicUrl: resolvePublicUrl(config, preferredLanAddress()),
-    };
-}
-export function stopServices() {
-    const stopped = [];
-    ensureDir(stateDir());
-    updateRuntime((state) => {
-        // Supervisor first: it would otherwise see its children die and restart
-        // them faster than we can kill them.
-        const targets = managedPids(state).sort((a, b) => (a.name === 'supervisor' ? 0 : 1) - (b.name === 'supervisor' ? 0 : 1));
-        for (const { pid, name } of targets) {
-            try {
-                process.kill(pid, 'SIGTERM');
-                stopped.push({ name, pid });
-            }
-            catch (error) {
-                process.stderr.write(`herdr-remote: could not stop ${name} (pid ${pid}): ${error.message}\n`);
-            }
-        }
-        state.hostPid = null;
-        state.relayPid = null;
-        state.supervisorPid = null;
-        state.managedPids = [];
-        state.startedAt = null;
-    });
-    return { ok: true, stopped };
-}
-export function restartServices() {
-    stopServices();
-    return startServices();
-}
-export async function statusServices() {
-    const config = loadConfig();
-    const state = readRuntime();
-    const live = managedPids(state);
-    const lanAddress = preferredLanAddress();
-    let health;
-    try {
-        health = await requestJson(healthUrl(config), { timeout: 1200 });
-    }
-    catch (error) {
-        health = { ok: false, message: error.message };
-    }
-    const socketPath = resolveSocketPath(config.herdr.socketPath);
-    // Where Herdr was found, and whether it was found at all: under a service
-    // manager this is the first thing to check when sessions will not start.
-    const herdr = findHerdrCommand();
-    // Only worth spawning when there is something to spawn; an unresolved command
-    // has already answered the question the version would.
-    const installed = herdr.found
-        ? herdrVersion({ command: herdr.command })
-        : { version: null, supported: true };
-    return {
-        ok: true,
-        mode: config.relay.mode,
-        relay: {
-            local: runsLocalRelay(config),
-            pid: state.relayPid || null,
-            alive: runsLocalRelay(config) ? live.some(({ pid }) => pid === state.relayPid) : null,
-            bind: runsLocalRelay(config) ? bindAddress(config) : null,
-            port: config.relay.port,
-            remoteUrl: config.relay.remoteUrl || null,
-            health,
-        },
-        host: {
-            pid: state.hostPid || null,
-            alive: live.some(({ pid }) => pid === state.hostPid),
-            hostId: state.hostId || null,
-            socketPath,
-            socketExists: Boolean(socketPath) && fs.existsSync(socketPath),
-            herdrCommand: herdr.command,
-            herdrCommandFound: herdr.found,
-            herdrCommandSource: herdr.source,
-            herdrVersion: installed.version,
-            herdrVersionSupported: installed.supported,
-            herdrVersionMinimum: MIN_HERDR_VERSION,
-        },
-        publicUrl: resolvePublicUrl(config, lanAddress),
-        startedAt: state.startedAt || null,
-    };
-}
-/** Start what pairing needs, then ask the relay for a code. */
-export async function pair() {
-    const config = loadConfig();
-    if (runsLocalRelay(config))
-        startServices();
-    await waitForRelay(config);
-    await waitForHost(config);
-    // Authenticated with this workstation's own host token: on a shared relay
-    // that is what proves the pairing code is being minted for our terminal and
-    // nobody else's.
-    return requestJson(`${resolveAdminOrigin(config)}/api/pair/start`, {
-        method: 'POST',
-        headers: hostHeaders(),
-        timeout: 5000,
-    });
-}
-export function readLogTail(name, lines = 40) {
-    try {
-        const content = fs.readFileSync(logPath(name), 'utf8');
-        return content.split('\n').filter(Boolean).slice(-lines);
-    }
-    catch {
-        // No log yet: the service has never run.
-        return [];
-    }
-}

package/dist/settings-model.js

@@ -1,298 +0,0 @@
-// Editable settings, independent of how they are rendered.
-//
-// The TUI holds a *draft* copy of the config, mutates it through these pure
-// functions and writes it out on save. Keeping the rules here (rather than in
-// the view) means they can be tested without a terminal, and the same
-// validation applies to the first-run wizard and the settings screen.
-import { ACCESS_MODES, KEEPALIVE_MANAGERS, LANGUAGES, OFFICIAL_RELAY_URL, loadConfig, } from './config.js';
-import { configDir, configPath } from './paths.js';
-import { isLoopbackHost, isUnspecifiedAddress, isUnspecifiedHost, resolvePublicUrl, } from './relay-urls.js';
-import { ensureDir, readJson, writeJsonAtomic } from 'herdr-remote-relay/state';
-import { preferredLanAddress } from './net-interfaces.js';
-function isOneOf(list, value) {
-    return list.includes(value);
-}
-/**
- * Field metadata. `kind` drives the editor the TUI shows; `visibleFor` limits a
- * field to the access modes where it means anything.
- */
-const FIELDS = [
-    { id: 'mode', kind: 'choice', choices: ACCESS_MODES, labelKey: 'field.mode' },
-    { id: 'port', kind: 'text', labelKey: 'field.port', visibleFor: ['local', 'lan'] },
-    { id: 'lanHost', kind: 'address', labelKey: 'field.lanHost', visibleFor: ['lan'] },
-    { id: 'remoteUrl', kind: 'text', labelKey: 'field.remoteUrl', visibleFor: ['remote'] },
-    { 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',
-    },
-];
-const EMPTY = '';
-/**
- * The access modes a *person* chooses between.
- *
- * The official relay is stored as `remote` with a known URL, because that is
- * exactly what it is and nothing downstream should have to learn a fourth mode.
- * It is still a separate answer to "how do I reach this workstation", though:
- * one option needs no server and no credentials, the other needs both. Keeping
- * that distinction here — rather than in whichever screen happens to draw it —
- * is what stops the official relay from being displayed as "self-hosted relay"
- * that merely happens to hold our address.
- */
-const SELECTABLE_MODES = ['local', 'lan', 'official', 'remote'];
-/** Which of `SELECTABLE_MODES` this draft represents. */
-function selectedMode(draft) {
-    if (draft.relay.mode === 'remote' && draft.relay.remoteUrl === OFFICIAL_RELAY_URL)
-        return 'official';
-    return draft.relay.mode;
-}
-/** True when the relay is the one we run, so its address and password are ours. */
-function isOfficialRelay(draft) {
-    return selectedMode(draft) === 'official';
-}
-function clone(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-function createDraft(config = loadConfig()) {
-    return clone(config);
-}
-function fieldsForMode(mode) {
-    return FIELDS.filter((field) => !field.visibleFor || field.visibleFor.includes(mode));
-}
-/** Current value of a field as an editable string. */
-function getField(draft, id) {
-    switch (id) {
-        case 'mode':
-            return draft.relay.mode;
-        case 'port':
-            return String(draft.relay.port);
-        case 'lanHost':
-            return draft.relay.lanHost || EMPTY;
-        case 'remoteUrl':
-            return draft.relay.remoteUrl || EMPTY;
-        case 'publicUrl':
-            return draft.relay.publicUrl || EMPTY;
-        case 'socketPath':
-            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':
-            return draft.keepalive.manager;
-        default:
-            return EMPTY;
-    }
-}
-/**
- * What the field shows when it is empty: the value that will actually be used.
- * Displaying the derived value beats an empty box the user cannot interpret.
- */
-function getFieldPlaceholder(draft, id) {
-    switch (id) {
-        case 'lanHost':
-            return preferredLanAddress() || '0.0.0.0';
-        case 'publicUrl':
-            return resolvePublicUrl(draft, preferredLanAddress());
-        case 'socketPath':
-            return 'placeholder.autoDiscovered';
-        case 'herdrArgs':
-            return 'placeholder.none';
-        case 'remoteUrl':
-            return 'wss://relay.example.com';
-        default:
-            return EMPTY;
-    }
-}
-function isValidUrl(value, protocols) {
-    try {
-        const url = new URL(value);
-        return protocols.includes(url.protocol);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Apply a value to a copy of the draft.
- *
- * Returns `{ draft, errorKey }`. On a validation failure the draft comes back
- * unchanged and `errorKey` names a translatable message, so callers never have
- * to guess whether the edit landed.
- */
-function setField(draft, id, rawValue) {
-    const next = clone(draft);
-    const value = typeof rawValue === 'string' ? rawValue.trim() : rawValue;
-    // Every field but the toggle is edited as text.
-    const text = value;
-    switch (id) {
-        case 'mode': {
-            if (!isOneOf(SELECTABLE_MODES, value))
-                return { draft, errorKey: 'error.invalidMode' };
-            // Picking the official relay fills in its address in the same edit: a
-            // remote mode with no URL is not a valid state, and asking for the
-            // address we already know would be asking the user to do our filing.
-            if (value === 'official') {
-                next.relay.mode = 'remote';
-                next.relay.remoteUrl = OFFICIAL_RELAY_URL;
-                next.relay.publicUrl = EMPTY;
-                break;
-            }
-            // Leaving the official relay clears its address, so the self-hosted URL
-            // field is empty and asking to be filled in rather than pre-loaded with
-            // an address that belongs to somebody else's server.
-            if (value === 'remote' && next.relay.remoteUrl === OFFICIAL_RELAY_URL) {
-                next.relay.remoteUrl = EMPTY;
-            }
-            next.relay.mode = value;
-            if (value === 'lan' &&
-                (isLoopbackHost(next.relay.lanHost) || isUnspecifiedAddress(next.relay.lanHost))) {
-                next.relay.lanHost = EMPTY;
-            }
-            // A public URL pinned for one mode is wrong for the next one; clearing it
-            // lets derivation produce the right address again.
-            next.relay.publicUrl = EMPTY;
-            break;
-        }
-        case 'port': {
-            const port = Number.parseInt(text, 10);
-            if (!Number.isInteger(port) || port < 1 || port > 65535)
-                return { draft, errorKey: 'error.invalidPort' };
-            next.relay.port = port;
-            break;
-        }
-        case 'lanHost': {
-            if (text && (isLoopbackHost(text) || isUnspecifiedAddress(text))) {
-                return { draft, errorKey: 'error.invalidLanHost' };
-            }
-            next.relay.lanHost = text || EMPTY;
-            break;
-        }
-        case 'remoteUrl': {
-            if (text && !isValidUrl(text, ['ws:', 'wss:', 'http:', 'https:'])) {
-                return { draft, errorKey: 'error.invalidRelayUrl' };
-            }
-            next.relay.remoteUrl = text.replace(/\/+$/, '');
-            break;
-        }
-        case 'publicUrl': {
-            if (text && (!isValidUrl(text, ['http:', 'https:']) || isUnspecifiedHost(text))) {
-                return { draft, errorKey: 'error.invalidPublicUrl' };
-            }
-            next.relay.publicUrl = text.replace(/\/+$/, '');
-            break;
-        }
-        case 'socketPath': {
-            next.herdr.socketPath = text || null;
-            break;
-        }
-        case 'herdrArgs': {
-            const args = text ? text.split(/\s+/).filter(Boolean) : [];
-            if (args.includes('--no-session')) {
-                return { draft, errorKey: 'error.removedHerdrArg' };
-            }
-            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 (!isOneOf(LANGUAGES, value))
-                return { draft, errorKey: 'error.invalidLanguage' };
-            next.ui.language = value;
-            break;
-        }
-        case 'keepaliveManager': {
-            if (!isOneOf(KEEPALIVE_MANAGERS, value))
-                return { draft, errorKey: 'error.invalidKeepalive' };
-            next.keepalive.manager = value;
-            break;
-        }
-        default:
-            return { draft, errorKey: 'error.unknownField' };
-    }
-    return { draft: next, errorKey: null };
-}
-/** Problems that should block saving, as translatable keys. */
-function validateDraft(draft) {
-    const problems = [];
-    if (draft.relay.mode === 'remote' && !draft.relay.remoteUrl)
-        problems.push('error.remoteUrlRequired');
-    return problems;
-}
-/**
- * Persist a draft, merging into whatever is already on disk so keys this
- * version does not know about survive the round trip.
- */
-function saveDraft(draft) {
-    const problems = validateDraft(draft);
-    if (problems.length > 0) {
-        throw Object.assign(new Error(`configuration is incomplete: ${problems.join(', ')}`), {
-            problems,
-        });
-    }
-    const current = (readJson(configPath(), {}) || {});
-    const merged = { ...current };
-    merged.ui = { ...(current.ui || {}), language: draft.ui.language };
-    const relay = {
-        ...(current.relay || {}),
-        mode: draft.relay.mode,
-        port: draft.relay.port,
-        lanHost: draft.relay.mode === 'lan' &&
-            (isLoopbackHost(draft.relay.lanHost) || isUnspecifiedAddress(draft.relay.lanHost))
-            ? EMPTY
-            : draft.relay.lanHost,
-        publicUrl: draft.relay.publicUrl,
-        remoteUrl: draft.relay.remoteUrl,
-    };
-    merged.relay = relay;
-    // Fields from the 0.1 schema would otherwise keep overriding the new ones on
-    // the next load.
-    delete relay.local;
-    delete relay.host;
-    delete relay.url;
-    // The optional Herdr source patch is gone. Nothing reads this section any
-    // more, so the next save is where a config written by an older build sheds
-    // it rather than carrying stale checksums and paths forever.
-    delete merged.patch;
-    const herdr = {
-        ...(current.herdr || {}),
-        socketPath: draft.herdr.socketPath,
-        args: draft.herdr.args,
-        autoStart: draft.herdr.autoStart === true,
-    };
-    merged.herdr = herdr;
-    if (!herdr.socketPath)
-        delete herdr.socketPath;
-    merged.keepalive = { ...(current.keepalive || {}), manager: draft.keepalive.manager };
-    ensureDir(configDir());
-    writeJsonAtomic(configPath(), merged);
-    return { ok: true, path: configPath() };
-}
-/**
- * Settings that only take effect after the services restart. Used to show a
- * "restart required" hint rather than silently doing nothing.
- */
-function requiresRestart(before, after) {
-    return (before.relay.mode !== after.relay.mode ||
-        before.relay.port !== after.relay.port ||
-        before.relay.lanHost !== after.relay.lanHost ||
-        before.relay.remoteUrl !== after.relay.remoteUrl ||
-        before.relay.publicUrl !== after.relay.publicUrl ||
-        before.herdr.socketPath !== after.herdr.socketPath ||
-        before.herdr.args.join(' ') !== after.herdr.args.join(' '));
-}
-export { createDraft, fieldsForMode, isOfficialRelay, selectedMode, getField, getFieldPlaceholder, setField, validateDraft, saveDraft, requiresRestart, };

package/dist/socket-discovery.js

@@ -1,70 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-/**
- * Herdr's own config directory, resolved as Herdr does (`XDG_CONFIG_HOME`
- * first on every platform, then the platform's home for it), so the socket
- * and `config.toml` are found wherever Herdr put them.
- */
-function herdrConfigDir(env = process.env, platform = process.platform) {
-    if (platform === 'win32') {
-        const configHome = env.XDG_CONFIG_HOME ||
-            env.APPDATA ||
-            (env.USERPROFILE && path.join(env.USERPROFILE, 'AppData', 'Roaming')) ||
-            path.join(os.homedir(), 'AppData', 'Roaming');
-        return path.join(configHome, 'herdr');
-    }
-    const configHome = env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
-    return path.join(configHome, 'herdr');
-}
-function defaultSocketPath(env = process.env, platform = process.platform) {
-    return env.HERDR_SOCKET_PATH || path.join(herdrConfigDir(env, platform), 'herdr.sock');
-}
-/** The `config.toml` Herdr reads; `HERDR_CONFIG_PATH` names it outright. */
-function herdrConfigPath(env = process.env, platform = process.platform) {
-    return env.HERDR_CONFIG_PATH || path.join(herdrConfigDir(env, platform), 'config.toml');
-}
-/**
- * On Windows, Herdr uses this path itself as the GenericNamespaced pipe name;
- * the file only contains the `pid:nanos` marker.
- */
-function herdrEndpoint(socketPath, platform = process.platform) {
-    return platform === 'win32' ? `\\\\.\\pipe\\${socketPath}` : socketPath;
-}
-function resolveSocketPath(configuredPath = null, env = process.env) {
-    return configuredPath || env.HERDR_SOCKET_PATH || defaultSocketPath(env);
-}
-function inspectSocket(socketPath, options = {}) {
-    if (typeof socketPath !== 'string' || socketPath.length === 0) {
-        return { ok: false, reason: 'socket path is empty', path: socketPath };
-    }
-    try {
-        const stat = fs.statSync(socketPath);
-        // Herdr leaves an ordinary marker file on Windows and connects through the pipe named by its path.
-        if (process.platform !== 'win32' && !stat.isSocket()) {
-            return { ok: false, reason: 'path is not a Unix socket', path: socketPath };
-        }
-        // Windows has no per-process uid to compare, so ownership checks naturally skip there.
-        if (options.requireOwner !== false &&
-            typeof process.getuid === 'function' &&
-            stat.uid !== process.getuid()) {
-            return {
-                ok: false,
-                reason: 'socket is not owned by the current user',
-                path: socketPath,
-                uid: stat.uid,
-            };
-        }
-        return { ok: true, path: socketPath, uid: stat.uid, mode: stat.mode };
-    }
-    catch (error) {
-        const { code, message } = error;
-        return {
-            ok: false,
-            missing: code === 'ENOENT',
-            reason: code === 'ENOENT' ? 'socket does not exist' : message,
-            path: socketPath,
-        };
-    }
-}
-export { defaultSocketPath, herdrConfigPath, herdrEndpoint, resolveSocketPath, inspectSocket };