herdr-remote 0.2.39 → 0.3.32

package/dist/keepalive/systemd.js

@@ -1,112 +0,0 @@
-// systemd --user: a unit that runs `herdr-remote run` and restarts it.
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { ensureDir } from 'herdr-remote-relay/state';
-import { cliEntryPoint, serviceEnvironment } from './environment.js';
-const SYSTEMD_UNIT_NAME = 'herdr-remote.service';
-function systemdUnitPath() {
-    const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
-    return path.join(configHome, 'systemd', 'user', SYSTEMD_UNIT_NAME);
-}
-/**
- * One `KEY=value` per directive. An unquoted systemd value ends at the first
- * space, and `%` starts a specifier, so a `PATH` with either in it would be
- * silently truncated or rewritten.
- */
-export function systemdEnvironmentLine(key, value) {
-    const text = String(value)
-        .replace(/[\r\n]+/g, ' ')
-        .replace(/%/g, '%%');
-    if (/^[\w@+=:,./-]*$/.test(text))
-        return `Environment=${key}=${text}`;
-    return `Environment="${key}=${text.replace(/([\\"])/g, '\\$1')}"`;
-}
-export function renderSystemdUnit({ nodePath = process.execPath, entryPoint = cliEntryPoint(), environment = {}, } = {}) {
-    const environmentLines = Object.entries(environment)
-        .map(([key, value]) => systemdEnvironmentLine(key, value))
-        .join('\n');
-    return `[Unit]
-Description=Herdr Remote (relay and host connector)
-Documentation=https://github.com/dibin666/herdr-remote
-After=default.target
-
-[Service]
-Type=simple
-ExecStart=${nodePath} ${entryPoint} run
-Restart=always
-RestartSec=3
-# Give the relay and host connector time to close sessions cleanly.
-TimeoutStopSec=15
-${environmentLines}
-
-[Install]
-WantedBy=default.target
-`;
-}
-function systemctl(args) {
-    return spawnSync('systemctl', ['--user', ...args], {
-        encoding: 'utf8',
-        stdio: 'pipe',
-        windowsHide: true,
-    });
-}
-/** Run a systemctl command that must succeed, throwing its stderr when it does not. */
-function systemctlOrThrow(args, failure) {
-    const result = systemctl(args);
-    if (result.status !== 0) {
-        throw new Error(`${failure}: ${String(result.stderr || '').trim()}`);
-    }
-}
-export const systemd = {
-    name: 'systemd',
-    status() {
-        const installed = fs.existsSync(systemdUnitPath());
-        if (!installed)
-            return { manager: 'systemd', installed: false, active: false, enabled: false };
-        const active = systemctl(['is-active', SYSTEMD_UNIT_NAME]);
-        const enabled = systemctl(['is-enabled', SYSTEMD_UNIT_NAME]);
-        const lingering = spawnSync('loginctl', ['show-user', os.userInfo().username, '--property=Linger'], { encoding: 'utf8', windowsHide: true });
-        return {
-            manager: 'systemd',
-            installed: true,
-            active: String(active.stdout || '').trim() === 'active',
-            enabled: String(enabled.stdout || '')
-                .trim()
-                .startsWith('enabled'),
-            linger: String(lingering.stdout || '').includes('Linger=yes'),
-            unitPath: systemdUnitPath(),
-            state: String(active.stdout || active.stderr || '').trim(),
-        };
-    },
-    async install() {
-        const unitPath = systemdUnitPath();
-        ensureDir(path.dirname(unitPath));
-        fs.writeFileSync(unitPath, renderSystemdUnit({ environment: serviceEnvironment() }), {
-            mode: 0o644,
-        });
-        systemctlOrThrow(['daemon-reload'], 'systemctl --user daemon-reload failed');
-        systemctlOrThrow(['enable', '--now', SYSTEMD_UNIT_NAME], 'systemctl --user enable --now failed');
-        return { ok: true, unitPath, hint: `loginctl enable-linger ${os.userInfo().username}` };
-    },
-    async uninstall() {
-        const unitPath = systemdUnitPath();
-        systemctl(['disable', '--now', SYSTEMD_UNIT_NAME]);
-        fs.rmSync(unitPath, { force: true });
-        systemctl(['daemon-reload']);
-        return { ok: true, unitPath };
-    },
-    restart() {
-        const result = systemctl(['restart', SYSTEMD_UNIT_NAME]);
-        if (result.status !== 0)
-            throw new Error(String(result.stderr || '').trim() || 'systemctl restart failed');
-        return { ok: true };
-    },
-    stop() {
-        systemctl(['stop', SYSTEMD_UNIT_NAME]);
-    },
-    logsHint() {
-        return `journalctl --user -u ${SYSTEMD_UNIT_NAME} -f`;
-    },
-};

package/dist/keepalive/types.js

@@ -1 +0,0 @@
-export {};

package/dist/keepalive/windows-service-setup.js

@@ -1,138 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import { classifyStartResult, currentServiceAccount, encodePowerShellCommand, escapePowerShellSingleQuoted, startService, waitForState, windowsServicePaths, serviceState, windowsService, } from './windows-service.js';
-const MAX_PASSWORD_ATTEMPTS = 3;
-export function renderSetServiceAccountScript({ id, account }) {
-    const safeId = escapePowerShellSingleQuoted(id);
-    const safeAccount = escapePowerShellSingleQuoted(account);
-    return `$ErrorActionPreference = 'Stop'
-$password = [Console]::In.ReadLine()
-$service = Get-CimInstance -ClassName Win32_Service -Filter "Name='${safeId}'"
-$result = Invoke-CimMethod -InputObject $service -MethodName Change -Arguments @{ StartName = '${safeAccount}'; StartPassword = $password }
-exit [int]$result.ReturnValue`;
-}
-function setServiceAccount(id, account, password) {
-    const script = renderSetServiceAccountScript({ id, account });
-    // The password travels through stdin only; it is not part of PowerShell arguments or a file.
-    return spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encodePowerShellCommand(script)], { input: `${password}\n`, encoding: 'utf8', windowsHide: true });
-}
-/** Read a password with `*` feedback and remove ESC sequences such as arrow keys. */
-function promptSecret(prompt) {
-    const input = process.stdin;
-    process.stdout.write(prompt);
-    input.setRawMode(true);
-    input.resume();
-    return new Promise((resolve) => {
-        let password = '';
-        const finish = (value) => {
-            input.removeListener('data', onData);
-            input.setRawMode(false);
-            input.pause();
-            process.stdout.write('\n');
-            resolve(value);
-        };
-        const onData = (chunk) => {
-            const clean = String(chunk).replace(/\x1b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)|O.|.)/g, '');
-            for (const character of clean) {
-                if (character === '\r' || character === '\n')
-                    return finish(password);
-                if (character === '\u0003')
-                    return finish(null);
-                if (character === '\u007f' || character === '\b') {
-                    if (password.length > 0) {
-                        password = Array.from(password).slice(0, -1).join('');
-                        process.stdout.write('\b \b');
-                    }
-                    continue;
-                }
-                const code = character.codePointAt(0) || 0;
-                if (code < 0x20 || (code >= 0x7f && code <= 0x9f))
-                    continue;
-                password += character;
-                process.stdout.write('*');
-            }
-        };
-        input.on('data', onData);
-    });
-}
-function failure(label, result) {
-    const output = String(result.stdout || result.stderr || '').trim();
-    return new Error(`${label} failed (${String(result.status)}): ${output}`);
-}
-export async function configureAndStartServiceAccount(id, account, t, dependencies = {}) {
-    const setAccount = dependencies.setAccount || setServiceAccount;
-    const start = dependencies.start || startService;
-    const prompt = dependencies.prompt ||
-        ((name) => promptSecret(t('keepalive.passwordPrompt', { account: name })));
-    const write = dependencies.write || ((message) => process.stdout.write(message));
-    for (let attempt = 0; attempt <= MAX_PASSWORD_ATTEMPTS; attempt += 1) {
-        const password = attempt === 0 ? '' : await prompt(account);
-        if (password === null)
-            return false;
-        const changed = setAccount(id, account, password);
-        if (changed.error || changed.status !== 0)
-            throw failure('Setting the Windows service account', changed);
-        const started = classifyStartResult(start());
-        if (started === 'ok')
-            return true;
-        if (started !== 'logon-failed') {
-            write(`${started.message}\n`);
-            return false;
-        }
-        write(`${t('keepalive.passwordRejected')}\n`);
-    }
-    return false;
-}
-/** Complete service installation inside the elevated console. */
-export async function completeServiceInstall(t) {
-    try {
-        const paths = windowsServicePaths();
-        // A different elevated account resolves a different state directory
-        // and cannot see the XML written before elevation.
-        if (!fs.existsSync(paths.unitPath)) {
-            process.stdout.write(`${t('keepalive.wrongAccount')}\n`);
-            return 1;
-        }
-        if (serviceState() !== 'NonExistent') {
-            windowsService.stop();
-            waitForState('Stopped');
-            const removed = spawnSync(paths.exePath, ['uninstall'], {
-                encoding: 'utf8',
-                windowsHide: true,
-            });
-            if (removed.error || removed.status !== 0)
-                throw failure('WinSW uninstall', removed);
-        }
-        const installed = spawnSync(paths.exePath, ['install'], {
-            stdio: 'inherit',
-            windowsHide: true,
-        });
-        if (installed.error || installed.status !== 0)
-            throw failure('WinSW install', installed);
-        const { domain, user } = currentServiceAccount();
-        const account = `${domain}\\${user}`;
-        if (await configureAndStartServiceAccount(paths.id, account, t)) {
-            process.stdout.write(`${t('keepalive.serviceInstalled', { id: paths.id })}\n`);
-            return 0;
-        }
-        return 1;
-    }
-    catch (error) {
-        process.stdout.write(`${error.message}\n`);
-        return 1;
-    }
-    finally {
-        process.stdout.write(`${t('keepalive.pressEnter')}\n`);
-        process.stdin.resume();
-        await new Promise((resolve) => {
-            const onData = (chunk) => {
-                if (!/[\r\n]/.test(String(chunk)))
-                    return;
-                process.stdin.removeListener('data', onData);
-                process.stdin.pause();
-                resolve();
-            };
-            process.stdin.on('data', onData);
-        });
-    }
-}

package/dist/keepalive/windows-service.js

@@ -1,272 +0,0 @@
-import { spawn, spawnSync } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { configDir, PACKAGE_ROOT, stateDir } from '../paths.js';
-import { cliEntryPoint, serviceEnvironment } from './environment.js';
-import { escapeXml } from './launchd.js';
-const DEFAULT_STATE_TIMEOUT_MS = 20_000;
-const STATE_POLL_INTERVAL_MS = 250;
-/** The service name is machine-wide, so include the account to isolate each user's service. */
-export function serviceId(username) {
-    return `herdr-remote-${username.replace(/[^A-Za-z0-9._-]/g, '_')}`;
-}
-export function currentServiceAccount() {
-    return {
-        domain: process.env.USERDOMAIN || '',
-        user: process.env.USERNAME || os.userInfo().username,
-    };
-}
-/** Keep WinSW outside the npm package so updates do not touch a running executable. */
-export function windowsServicePaths() {
-    const id = serviceId(currentServiceAccount().user);
-    const directory = path.join(stateDir(), 'service');
-    return {
-        id,
-        directory,
-        exePath: path.join(directory, `${id}.exe`),
-        unitPath: path.join(directory, `${id}.xml`),
-    };
-}
-function lastNonemptyLine(output) {
-    return output.trim().split(/\r?\n/).pop()?.trim();
-}
-export function parseWhoamiSid(output) {
-    const sid = lastNonemptyLine(output)?.match(/"([^"]+)"\s*$/)?.[1];
-    return sid && /^S-\d(?:-\d+)+$/.test(sid) ? sid : null;
-}
-export function parseWinswState(output) {
-    const state = lastNonemptyLine(output);
-    return state === 'Started' || state === 'Stopped' || state === 'NonExistent'
-        ? state
-        : 'NonExistent';
-}
-export function windowsServiceSddl(userSid) {
-    // SYSTEM, Administrators, interactive users and service users keep the default service DACL.
-    // The last ACE lets ordinary plugin hooks and the TUI start or stop this user's service.
-    const accessEntries = [
-        '(A;;CCLCSWRPWPDTLOCRRC;;;SY)',
-        '(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;BA)',
-        '(A;;CCLCSWLOCRRC;;;IU)',
-        '(A;;CCLCSWLOCRRC;;;SU)',
-        `(A;;CCLCSWRPWPDTLOCRRC;;;${userSid})`,
-    ];
-    return 'D:' + accessEntries.join('');
-}
-export function renderWinswConfig(options) {
-    const { id, user, domain, userSid, nodePath, entryPoint, workingDirectory, environment } = options;
-    const environmentLines = Object.entries(environment).map(([key, value]) => `  <env name="${escapeXml(key)}" value="${escapeXml(value)}"/>`);
-    // Children write their own logs; WinSW captures the supervisor in supervisor.out.log.
-    return `<service>
-  <id>${escapeXml(id)}</id>
-  <name>${escapeXml(`Herdr Remote (${user})`)}</name>
-  <description>${escapeXml(`Browser access to Herdr workspaces, running as ${domain}\\${user}.`)}</description>
-  <executable>${escapeXml(nodePath)}</executable>
-  <arguments>${escapeXml(`"${entryPoint}" run --daemon`)}</arguments>
-  <workingdirectory>${escapeXml(workingDirectory)}</workingdirectory>
-  <startmode>Automatic</startmode>
-  <delayedAutoStart/>
-  <onfailure action="restart" delay="3 sec"/>
-  <resetfailure>1 hour</resetfailure>
-  <stoptimeout>15 sec</stoptimeout>
-  <logpath>${escapeXml(workingDirectory)}</logpath>
-  <logname>supervisor</logname>
-  <log mode="append"/>
-${environmentLines.join('\n')}
-  <serviceaccount>
-    <domain>${escapeXml(domain)}</domain>
-    <user>${escapeXml(user)}</user>
-    <allowservicelogon>true</allowservicelogon>
-  </serviceaccount>
-  <securityDescriptor>${escapeXml(windowsServiceSddl(userSid))}</securityDescriptor>
-</service>
-`;
-}
-export function escapePowerShellSingleQuoted(value) {
-    return value.replace(/'/g, "''");
-}
-export function renderElevationScript({ nodePath, entryPoint }) {
-    const executable = escapePowerShellSingleQuoted(nodePath);
-    const scriptPath = escapePowerShellSingleQuoted(entryPoint);
-    return `$ErrorActionPreference = 'Stop'
-try {
-  $process = Start-Process -FilePath '${executable}' -ArgumentList '"${scriptPath}" keepalive install --elevated' -Verb RunAs -Wait -PassThru
-} catch {
-  exit 1223
-}
-exit $process.ExitCode`;
-}
-export function encodePowerShellCommand(script) {
-    return Buffer.from(script, 'utf16le').toString('base64');
-}
-function text(value) {
-    return value ? String(value).trim() : '';
-}
-function runSc(command) {
-    const result = spawnSync('sc.exe', [command, windowsServicePaths().id], {
-        encoding: 'utf8',
-        windowsHide: true,
-    });
-    return { code: result.status, stdout: text(result.stdout), stderr: text(result.stderr) };
-}
-function scFailure(command, result) {
-    const output = result.stdout || result.stderr;
-    return new Error(`sc.exe ${command} failed (${result.code}): ${output}`);
-}
-/** sc.exe returns Win32 codes: 1056 means already running and 1069 means service logon failed. */
-export function classifyStartResult(result) {
-    if (result.code === 0 || result.code === 1056)
-        return 'ok';
-    if (result.code === 1069)
-        return 'logon-failed';
-    return scFailure('start', result);
-}
-export function startService() {
-    return runSc('start');
-}
-export function stopService() {
-    return runSc('stop');
-}
-export function serviceState() {
-    const { exePath } = windowsServicePaths();
-    if (!fs.existsSync(exePath))
-        return 'NonExistent';
-    const result = spawnSync(exePath, ['status'], { encoding: 'utf8', windowsHide: true });
-    return result.error || result.status !== 0 ? 'NonExistent' : parseWinswState(text(result.stdout));
-}
-export function waitForState(target, timeoutMs = DEFAULT_STATE_TIMEOUT_MS) {
-    const deadlineMs = Date.now() + timeoutMs;
-    while (serviceState() !== target) {
-        if (Date.now() >= deadlineMs)
-            throw new Error(`Windows service did not reach ${target} within ${timeoutMs} ms`);
-        // Lifecycle start/restart is synchronous, so this wait must not yield to an event loop.
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, STATE_POLL_INTERVAL_MS);
-    }
-}
-function stop() {
-    const result = stopService();
-    if (result.code !== 0 && result.code !== 1062 && result.code !== 1060)
-        throw scFailure('stop', result);
-}
-function start() {
-    const commandResult = startService();
-    const result = classifyStartResult(commandResult);
-    if (result === 'logon-failed') {
-        const output = commandResult.stdout || commandResult.stderr;
-        throw new Error(`Windows service logon failed (1069): ${output}`);
-    }
-    if (result instanceof Error)
-        throw result;
-    return { ok: true };
-}
-function sha256(filePath) {
-    return createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
-}
-async function prepare() {
-    const paths = windowsServicePaths();
-    await fs.promises.mkdir(paths.directory, { recursive: true });
-    const source = path.join(PACKAGE_ROOT, 'vendor', 'winsw', 'WinSW.NET461.exe');
-    if (!fs.existsSync(paths.exePath) || sha256(paths.exePath) !== sha256(source)) {
-        try {
-            await fs.promises.copyFile(source, paths.exePath);
-        }
-        catch (error) {
-            if (!['EBUSY', 'EPERM', 'EACCES'].includes(error.code || ''))
-                throw error;
-            throw new Error(`Could not replace ${paths.exePath}; stop the Windows service first.`, {
-                cause: error,
-            });
-        }
-    }
-    // A service may not receive reliable APPDATA, so pin both canonical directories.
-    const environment = {
-        ...serviceEnvironment(),
-        HERDR_REMOTE_CONFIG_DIR: configDir(),
-        HERDR_REMOTE_STATE_DIR: stateDir(),
-        HERDR_REMOTE_SERVICE: '1',
-    };
-    const result = spawnSync('whoami', ['/user', '/fo', 'csv', '/nh'], {
-        encoding: 'utf8',
-        windowsHide: true,
-    });
-    const userSid = !result.error && result.status === 0 ? parseWhoamiSid(text(result.stdout)) : null;
-    if (!userSid)
-        throw new Error(`Could not read the current Windows user SID: ${text(result.stderr)}`);
-    const { user, domain } = currentServiceAccount();
-    await fs.promises.writeFile(paths.unitPath, renderWinswConfig({
-        id: paths.id,
-        user,
-        domain,
-        userSid,
-        nodePath: process.execPath,
-        entryPoint: cliEntryPoint(),
-        workingDirectory: stateDir(),
-        environment,
-    }), 'utf8');
-    return paths;
-}
-function waitForChild(child) {
-    return new Promise((resolve, reject) => {
-        child.once('error', reject);
-        child.once('close', (code) => resolve(code ?? 1));
-    });
-}
-/** The password is entered only in the elevated console, so wait for that window to finish. */
-async function install() {
-    const paths = await prepare();
-    const script = renderElevationScript({ nodePath: process.execPath, entryPoint: cliEntryPoint() });
-    const child = spawn('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', encodePowerShellCommand(script)], { windowsHide: true, stdio: 'ignore' });
-    const exitCode = await waitForChild(child);
-    if (exitCode === 1223) {
-        const error = new Error('Administrator rights were not granted; nothing was installed.');
-        error.code = 'ELEVATION_CANCELLED';
-        throw error;
-    }
-    if (exitCode !== 0)
-        throw new Error(`Windows service installation did not complete (exit code ${exitCode}).`);
-    return { ok: true, unitPath: paths.unitPath, state: serviceState() };
-}
-function status() {
-    const paths = windowsServicePaths();
-    const state = serviceState();
-    const installed = state !== 'NonExistent';
-    return {
-        manager: 'windows-service',
-        installed,
-        active: state === 'Started',
-        enabled: installed,
-        unitPath: paths.unitPath,
-        state,
-    };
-}
-/** WinSW requests elevation itself, so stopping first avoids a second UAC prompt. */
-async function uninstall() {
-    const paths = windowsServicePaths();
-    stop();
-    waitForState('Stopped');
-    const result = spawnSync(paths.exePath, ['uninstall'], { windowsHide: true });
-    if (result.error || result.status !== 0)
-        throw new Error(`WinSW uninstall failed with exit code ${String(result.status)}: ${text(result.stdout)}`);
-    if (serviceState() !== 'NonExistent')
-        throw new Error(`Windows service still exists: ${paths.id}`);
-    fs.rmSync(paths.directory, { recursive: true, force: true });
-    return { ok: true, unitPath: paths.unitPath };
-}
-function restart() {
-    stop();
-    waitForState('Stopped');
-    return start();
-}
-function logsHint() {
-    return `Get-Content -Wait -Tail 40 "${path.join(stateDir(), 'supervisor.out.log')}"`;
-}
-export const windowsService = {
-    name: 'windows-service',
-    status,
-    install,
-    uninstall,
-    restart,
-    stop,
-    logsHint,
-};