herdr-remote 0.2.38 → 0.3.31

package/dist/connector/admin-shell.js

@@ -1,67 +0,0 @@
-// `herdr-remote admin-shell`: the administrator terminal inside a Herdr tab.
-//
-// This process runs in the tab's pane with the pane's standard rights and
-// relays its console to an elevated PowerShell that the admin broker runs. On
-// Windows, Node's raw mode reads keys as VT input and writes VT output through
-// unchanged, so the relay is byte for byte.
-import { requestHerdr } from '../herdr-api.js';
-import { ADMIN_TAB_ENV } from './admin-tab.js';
-import { ElevatedPty } from './elevatedPty.js';
-const BROKER_UNAVAILABLE_CODES = ['ENOENT', 'ECONNREFUSED', 'ETIMEDOUT'];
-/** Close the pane this runs in, which closes the tab `openAdminTab` made for it. */
-async function closeOwnPane() {
-    const socketPath = process.env.HERDR_SOCKET_PATH;
-    const paneId = process.env.HERDR_PANE_ID;
-    if (process.env[ADMIN_TAB_ENV] !== '1' || !socketPath || !paneId)
-        return;
-    try {
-        await requestHerdr(socketPath, 'pane.close', { pane_id: paneId });
-    }
-    catch {
-        // The shell's prompt comes back instead; the user can close the tab.
-    }
-}
-export async function runAdminShell(t, { stdin = process.stdin, stdout = process.stdout, platform = process.platform, } = {}) {
-    if (platform !== 'win32')
-        throw new Error(t('adminBroker.windowsOnly'));
-    if (!stdin.isTTY || !stdout.isTTY)
-        throw new Error(t('adminShell.needsTerminal'));
-    const pty = new ElevatedPty({
-        command: 'powershell.exe',
-        args: ['-NoLogo', '-NoProfile'],
-        cwd: process.cwd(),
-    });
-    const relayInput = (data) => pty.write(data);
-    const relayResize = () => pty.resize(stdout.columns, stdout.rows);
-    stdin.setRawMode(true);
-    stdin.on('data', relayInput);
-    // The CLI's Windows color probe pauses stdin before any command runs, and a
-    // paused stream ignores a new 'data' listener: no key would reach PowerShell.
-    stdin.resume();
-    stdout.on('resize', relayResize);
-    try {
-        const exitCode = await new Promise((resolve, reject) => {
-            pty.start({
-                cols: stdout.columns,
-                rows: stdout.rows,
-                onData: (data) => stdout.write(data),
-                onExit: (event) => resolve(event.exitCode),
-                onError: reject,
-            });
-        });
-        await closeOwnPane();
-        return exitCode;
-    }
-    catch (error) {
-        const { code } = error;
-        if (code && BROKER_UNAVAILABLE_CODES.includes(code))
-            throw new Error(t('adminShell.brokerUnavailable'));
-        throw error;
-    }
-    finally {
-        stdin.off('data', relayInput);
-        stdout.off('resize', relayResize);
-        stdin.setRawMode(false);
-        stdin.pause();
-    }
-}

package/dist/connector/admin-tab.js

@@ -1,90 +0,0 @@
-// An administrator terminal as a tab of the workstation's own Herdr, opened at
-// a browser's request.
-//
-// Herdr's API cannot start a tab running a command of our choosing, so the tab
-// starts with the user's shell and `herdr-remote admin-shell` is typed into it
-// once that shell is running. Nor can the API focus a tab for one client:
-// `tab.focus` moves every client attached to this Herdr, which is the price of
-// the requesting window showing the new tab at once.
-import path from 'node:path';
-import { requestHerdr } from '../herdr-api.js';
-import { createTranslator, detectLocale } from '../i18n/index.js';
-import { cliEntryPoint } from '../keepalive/environment.js';
-import { adminBrokerStatus } from './admin-broker.js';
-const SHELL_START_TIMEOUT_MS = 5_000;
-const SHELL_START_POLL_MS = 100;
-/** Marks the tab's shell, so `admin-shell` knows it may close the pane when done. */
-export const ADMIN_TAB_ENV = 'HERDR_REMOTE_ADMIN_TAB';
-function powershellQuote(value) {
-    return `'${value.replaceAll("'", "''")}'`;
-}
-function posixQuote(value) {
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
-/** The command line that starts `admin-shell`, in the syntax of the tab's shell. */
-export function adminShellCommand(shell, node, entry) {
-    const name = path.win32
-        .basename(shell)
-        .toLowerCase()
-        .replace(/\.exe$/, '');
-    if (name === 'powershell' || name === 'pwsh') {
-        return `& ${powershellQuote(node)} ${powershellQuote(entry)} admin-shell`;
-    }
-    if (name === 'cmd')
-        return `"${node}" "${entry}" admin-shell`;
-    // Git Bash and other POSIX shells: forward slashes, or C:\ reads as escapes.
-    const posix = (file) => posixQuote(file.replaceAll('\\', '/'));
-    return `${posix(node)} ${posix(entry)} admin-shell`;
-}
-/** The new tab's shell, once Herdr reports it running. */
-async function waitForShell(request, socketPath, paneId) {
-    const deadline = Date.now() + SHELL_START_TIMEOUT_MS;
-    while (true) {
-        const info = await request(socketPath, 'pane.process_info', {
-            pane_id: paneId,
-        });
-        const shell = info.process_info?.foreground_processes?.[0]?.name;
-        if (shell)
-            return shell;
-        if (Date.now() >= deadline)
-            throw new Error('The new tab did not start a shell in time.');
-        await new Promise((resolve) => setTimeout(resolve, SHELL_START_POLL_MS));
-    }
-}
-export async function openAdminTab({ socketPath, label, request = requestHerdr, brokerReady = adminBrokerStatus, }) {
-    if (!(await brokerReady())) {
-        throw Object.assign(new Error('The administrator terminal broker is not running.'), {
-            code: 'admin_broker_unavailable',
-        });
-    }
-    const created = await request(socketPath, 'tab.create', {
-        label,
-        focus: false,
-        env: { [ADMIN_TAB_ENV]: '1' },
-    });
-    const paneId = created.root_pane.pane_id;
-    await request(socketPath, 'tab.focus', { tab_id: created.tab.tab_id });
-    const shell = await waitForShell(request, socketPath, paneId);
-    await request(socketPath, 'pane.send_input', {
-        pane_id: paneId,
-        text: adminShellCommand(shell, process.execPath, cliEntryPoint()),
-        keys: ['enter'],
-    });
-}
-/** Open the tab for a browser window, and tell that window when it could not. */
-export async function openAdminTabFor(streamId, options) {
-    const t = createTranslator(detectLocale({ preference: options.language }));
-    try {
-        await openAdminTab({ socketPath: options.socketPath, label: t('adminShell.tabLabel') });
-    }
-    catch (error) {
-        const { code, message } = error;
-        process.stderr.write(`herdr-remote host connector: could not open an admin tab: ${message}\n`);
-        options.send({
-            type: 'error',
-            clientId: streamId,
-            code: code === 'admin_broker_unavailable' ? code : 'admin_tab_failed',
-            message,
-        });
-    }
-}

package/dist/connector/adminBrokerEndpoint.js

@@ -1,68 +0,0 @@
-import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
-import fs from 'node:fs';
-import net from 'node:net';
-import path from 'node:path';
-import { stateDir } from '../paths.js';
-const ADMIN_BROKER_TASK_NAME = 'HerdrRemoteAdminBroker';
-const ADMIN_BROKER_HOST = '127.0.0.1';
-export const ADMIN_BROKER_MAX_MESSAGE_BYTES = 2 * 1_024 * 1_024;
-function adminBrokerAccountId() {
-    const account = `${process.env.USERDOMAIN || ''}\\${process.env.USERNAME || process.env.USERPROFILE || 'default'}`;
-    return createHash('sha256').update(account.toLowerCase()).digest('hex').slice(0, 24);
-}
-export function adminBrokerTaskName() {
-    return `${ADMIN_BROKER_TASK_NAME}-${adminBrokerAccountId()}`;
-}
-// Not a named pipe: one created by an elevated process admits only
-// Administrators, so the connector's standard token gets EPERM, and opening it
-// to everyone would let any account add an instance of the same name and sit
-// in the middle. A loopback port cannot be taken over by another account, and
-// the token lives in the state directory, which only this account can read.
-function endpointPath() {
-    return path.join(stateDir(), 'admin-broker.json');
-}
-/** Record where the broker listens, with a fresh token callers must present. */
-export function publishAdminBrokerEndpoint(port) {
-    const token = randomBytes(32).toString('hex');
-    const file = endpointPath();
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const temporary = `${file}.${process.pid}.tmp`;
-    fs.writeFileSync(temporary, JSON.stringify({ port, token }), { mode: 0o600 });
-    fs.renameSync(temporary, file);
-    return token;
-}
-export function adminBrokerTokenMatches(expected, received) {
-    if (!expected || typeof received !== 'string')
-        return false;
-    const want = Buffer.from(expected);
-    const got = Buffer.from(received);
-    return want.length === got.length && timingSafeEqual(want, got);
-}
-function brokerUnavailable() {
-    return Object.assign(new Error('The administrator terminal broker is not running.'), {
-        code: 'ENOENT',
-    });
-}
-/** Connect to the running broker; the token goes in the first message. */
-export function connectAdminBroker() {
-    let endpoint;
-    try {
-        endpoint = JSON.parse(fs.readFileSync(endpointPath(), 'utf8'));
-    }
-    catch {
-        // Missing or half-written: either way no broker has published itself.
-        throw brokerUnavailable();
-    }
-    const { port, token } = endpoint;
-    if (!Number.isInteger(port) || typeof token !== 'string')
-        throw brokerUnavailable();
-    return { socket: net.createConnection({ host: ADMIN_BROKER_HOST, port: port }), token };
-}
-export function listenAdminBroker(server, onListening) {
-    server.listen(0, ADMIN_BROKER_HOST, () => {
-        onListening(server.address().port);
-    });
-}
-export function sendAdminBrokerMessage(socket, message) {
-    socket.write(`${JSON.stringify(message)}\n`);
-}

package/dist/connector/agent-watch.js

@@ -1,123 +0,0 @@
-// Watching what the agents on this workstation are doing, for the status bar
-// of every window attached to it.
-import { sameSummary, summarizeAgents, } from '../agent-status.js';
-import { requestHerdr, subscribeHerdr, } from '../herdr-api.js';
-/** How often the agent summary is re-read while a browser is watching. */
-const AGENT_STATUS_POLL_MS = 5_000;
-const AGENT_STATUS_EVENT_DEBOUNCE_MS = 150;
-const AGENT_STATUS_SUBSCRIPTIONS = [
-    { type: 'pane.focused' },
-    { type: 'tab.focused' },
-    { type: 'workspace.focused' },
-    { type: 'pane.agent_detected' },
-];
-/**
- * A side channel, on its own socket, alive only while a browser is attached.
- * Herdr's server can be restarted underneath a running herdr-remote — the
- * PTYs survive it — so every failure here is a retry, never anything a
- * terminal session notices.
- *
- * A long-lived subscription provides fast refreshes on pane and workspace
- * focus changes; the five-second poll still repairs missed events and a
- * restarted Herdr server. Both paths only read the side-channel snapshot, and
- * events only invalidate it: Herdr's snapshots and events share no sequence,
- * so each (re)started subscription and each event mid-read asks for a fresh
- * read rather than patching the last one.
- */
-export class AgentWatch {
-    socketPath;
-    request;
-    subscribe;
-    send;
-    pollTimer = null;
-    debounceTimer = null;
-    subscription = null;
-    pending = false;
-    stale = false;
-    lastSummary = null;
-    constructor(options, send) {
-        this.socketPath = options.socketPath;
-        this.request = options.requestHerdr || requestHerdr;
-        this.subscribe = options.subscribeHerdr || subscribeHerdr;
-        this.send = send;
-    }
-    start() {
-        if (this.pollTimer)
-            return;
-        this.pollTimer = setInterval(() => this.read(), AGENT_STATUS_POLL_MS);
-        this.pollTimer.unref?.();
-        try {
-            this.subscription = this.subscribe(this.socketPath, AGENT_STATUS_SUBSCRIPTIONS, () => this.scheduleRead(), { onStarted: () => this.scheduleRead() });
-        }
-        catch {
-            // A missing or restarting Herdr server leaves the regular poll in place.
-        }
-        this.read();
-    }
-    stop() {
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = null;
-        }
-        if (this.debounceTimer) {
-            clearTimeout(this.debounceTimer);
-            this.debounceTimer = null;
-        }
-        if (this.subscription) {
-            this.subscription.close();
-            this.subscription = null;
-        }
-        this.stale = false;
-        this.lastSummary = null;
-    }
-    scheduleRead() {
-        if (!this.pollTimer)
-            return;
-        if (this.debounceTimer)
-            clearTimeout(this.debounceTimer);
-        this.debounceTimer = setTimeout(() => {
-            this.debounceTimer = null;
-            this.read();
-        }, AGENT_STATUS_EVENT_DEBOUNCE_MS);
-        this.debounceTimer.unref?.();
-    }
-    /**
-     * Read the summary and forward it if it changed.
-     *
-     * A slow answer must not stack up behind the next tick, and a failed one
-     * leaves the last summary standing rather than blanking the browser's chip:
-     * Herdr's server not running is an ordinary state, not news.
-     */
-    async read() {
-        if (!this.pollTimer)
-            return;
-        if (this.pending) {
-            this.stale = true;
-            return;
-        }
-        this.pending = true;
-        this.stale = false;
-        let snapshot;
-        try {
-            const result = await this.request(this.socketPath, 'session.snapshot', {});
-            snapshot = result?.snapshot || result;
-        }
-        catch {
-            return;
-        }
-        finally {
-            this.pending = false;
-            // Something changed while this answer was in flight; it may predate it.
-            if (this.stale)
-                this.scheduleRead();
-        }
-        // Stopped while the answer was in flight; the browser it was for is gone.
-        if (!this.pollTimer)
-            return;
-        const summary = summarizeAgents(snapshot);
-        if (sameSummary(this.lastSummary, summary))
-            return;
-        this.lastSummary = summary;
-        this.send({ type: 'agent_status', ...summary });
-    }
-}

package/dist/connector/elevatedPty.js

@@ -1,141 +0,0 @@
-import { ADMIN_BROKER_MAX_MESSAGE_BYTES, connectAdminBroker, sendAdminBrokerMessage, } from './adminBrokerEndpoint.js';
-const BROKER_CONNECT_TIMEOUT_MS = 5_000;
-/** A PTY the admin broker runs elevated, driven over its loopback socket. */
-export class ElevatedPty {
-    socket = null;
-    input = '';
-    connected = false;
-    started = false;
-    finished = false;
-    killed = false;
-    /** Keystrokes typed while the elevated shell was still starting. */
-    early = [];
-    dataListener = null;
-    exitListener = null;
-    errorListener = null;
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    start({ cols, rows, onData, onExit, onError }) {
-        this.dataListener = onData;
-        this.exitListener = onExit;
-        this.errorListener = onError;
-        let broker;
-        try {
-            broker = connectAdminBroker();
-        }
-        catch (error) {
-            this.fail(error);
-            return;
-        }
-        const { socket, token } = broker;
-        this.socket = socket;
-        socket.setEncoding('utf8');
-        socket.setTimeout(BROKER_CONNECT_TIMEOUT_MS, () => {
-            socket.destroy(Object.assign(new Error('Administrator terminal broker connection timed out'), {
-                code: 'ETIMEDOUT',
-            }));
-        });
-        socket.on('connect', () => {
-            this.connected = true;
-            socket.setTimeout(0);
-            sendAdminBrokerMessage(socket, { type: 'start', token, ...this.options, cols, rows });
-        });
-        socket.on('data', (chunk) => this.receive(chunk));
-        socket.on('error', (error) => this.fail(error));
-        socket.on('close', () => {
-            if (this.started && !this.finished && !this.killed) {
-                this.finished = true;
-                this.exitListener?.({ exitCode: 1 });
-            }
-        });
-    }
-    write(data) {
-        if (this.finished)
-            return;
-        if (!this.started) {
-            this.early.push(Buffer.from(data));
-            return;
-        }
-        if (this.socket?.writable) {
-            sendAdminBrokerMessage(this.socket, {
-                type: 'input',
-                dataBase64: Buffer.from(data).toString('base64'),
-            });
-        }
-    }
-    resize(cols, rows) {
-        if (this.started && this.socket?.writable) {
-            sendAdminBrokerMessage(this.socket, { type: 'resize', cols, rows });
-        }
-    }
-    kill() {
-        this.killed = true;
-        if (!this.socket)
-            return;
-        if (this.connected && this.socket.writable) {
-            sendAdminBrokerMessage(this.socket, { type: 'kill' });
-            this.socket.end();
-        }
-        else {
-            this.socket.destroy();
-        }
-    }
-    receive(chunk) {
-        this.input += chunk;
-        if (Buffer.byteLength(this.input, 'utf8') > ADMIN_BROKER_MAX_MESSAGE_BYTES) {
-            this.socket?.destroy(new Error('Administrator terminal broker message exceeded the limit'));
-            return;
-        }
-        while (true) {
-            const newline = this.input.indexOf('\n');
-            if (newline < 0)
-                return;
-            const line = this.input.slice(0, newline);
-            this.input = this.input.slice(newline + 1);
-            let message;
-            try {
-                message = JSON.parse(line);
-            }
-            catch {
-                this.socket?.destroy(new Error('Administrator terminal broker sent invalid JSON'));
-                return;
-            }
-            if (message.type === 'started') {
-                this.started = true;
-                const early = Buffer.concat(this.early);
-                this.early = [];
-                if (early.length > 0)
-                    this.write(early);
-            }
-            else if (message.type === 'data' && typeof message.dataBase64 === 'string') {
-                this.dataListener?.(Buffer.from(message.dataBase64, 'base64').toString('utf8'));
-            }
-            else if (message.type === 'exit') {
-                this.finished = true;
-                this.exitListener?.({
-                    exitCode: Number(message.exitCode) || 0,
-                    ...(typeof message.signal === 'number' ? { signal: message.signal } : {}),
-                });
-                this.socket?.end();
-            }
-            else if (message.type === 'error') {
-                this.fail(new Error(typeof message.message === 'string' ? message.message : 'Admin PTY failed'));
-            }
-        }
-    }
-    fail(error) {
-        if (this.started) {
-            if (!this.finished && !this.killed) {
-                this.finished = true;
-                this.exitListener?.({ exitCode: 1 });
-            }
-            return;
-        }
-        if (this.finished || this.killed)
-            return;
-        this.finished = true;
-        this.errorListener?.(error);
-    }
-}

package/dist/connector/font-server.js

@@ -1,165 +0,0 @@
-// Serving the workstation's terminal font to browser windows: its public
-// description, its files a chunk at a time, and characters cut out of large
-// (CJK) fonts on demand.
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import { TERMINAL_FONT_CHUNK_BYTES } from 'herdr-remote-relay/protocol';
-import { FontSubsetter } from '../font-subset.js';
-import { loadHostTerminalFont, publicTerminalFont, readFontChunk, } from '../terminal-font/index.js';
-/** Cut fonts kept for the slices a browser has yet to fetch, by total size. */
-const FONT_SUBSET_CACHE_BYTES = 48 * 1024 * 1024;
-const FONT_CHANGED = 'The terminal font changed or is no longer on this workstation';
-/**
- * Only the family, size and file hashes leave this process; a browser that
- * lacks the font fetches the files by hash, one chunk at a time.
- */
-export class FontServer {
-    font;
-    load;
-    subsetter;
-    /** Subsets too large for one message, by hash, until fetched. */
-    subsets = new Map();
-    send;
-    constructor(options, send) {
-        this.load = options.loadTerminalFont || loadHostTerminalFont;
-        this.font = options.terminalFont !== undefined ? options.terminalFont : this.load();
-        this.subsetter = options.fontSubsetter || new FontSubsetter();
-        this.send = send;
-    }
-    /** What may leave this machine: the record without its file paths. */
-    publicFont() {
-        return publicTerminalFont(this.font);
-    }
-    /**
-     * A service started at boot runs before anything has seen a terminal, so it
-     * starts with no font. The first `herdr-remote start` from a terminal (or
-     * from Herdr's plugin hook) writes one down; the next window to open picks
-     * it up here instead of waiting for a restart.
-     */
-    pickUp() {
-        if (this.font)
-            return;
-        let next = null;
-        try {
-            next = this.load();
-        }
-        catch {
-            // Unreadable now; the next window to open asks again.
-            return;
-        }
-        if (!next)
-            return;
-        this.font = next;
-        this.send({ type: 'terminal_font', terminalFont: publicTerminalFont(next) });
-    }
-    /**
-     * Read the terminal's font settings again, at a browser's request. Every
-     * window of this workstation hears the answer, since they all draw with it.
-     */
-    refresh() {
-        try {
-            const next = this.load({ refresh: true });
-            if (next)
-                this.font = next;
-        }
-        catch (error) {
-            process.stderr.write(`herdr-remote host connector: could not read the terminal font: ${error.message}\n`);
-        }
-        this.send({ type: 'terminal_font', terminalFont: this.publicFont() });
-    }
-    /** One slice of a terminal font file, for the window that asked for it. */
-    sendChunk(streamId, request) {
-        const chunk = this.subsetChunk(request.sha256, request.index) ||
-            readFontChunk(this.font, request.sha256, request.index);
-        if (!chunk) {
-            this.send({
-                type: 'error',
-                clientId: streamId,
-                code: 'host_font_unavailable',
-                message: FONT_CHANGED,
-            });
-            return;
-        }
-        this.send({
-            type: 'host_font_chunk',
-            clientId: streamId,
-            sha256: request.sha256,
-            index: request.index,
-            total: chunk.total,
-            dataBase64: chunk.data.toString('base64'),
-        });
-    }
-    /**
-     * The characters a window is about to draw, cut out of a large font (CJK).
-     * A small result travels in the answer itself; a large one (the common
-     * characters fetched up front) is held here and pulled in slices.
-     */
-    sendSubset(streamId, request) {
-        const fail = (code, text) => this.send({ type: 'error', clientId: streamId, code, message: text });
-        const source = this.font?.subsets?.find((candidate) => candidate.sha256 === request.sha256);
-        if (!source || !this.unchanged(source)) {
-            fail('host_font_unavailable', FONT_CHANGED);
-            return;
-        }
-        const codepoints = [
-            ...new Set(Array.from(String(request.text || ''), (char) => char.codePointAt(0))),
-        ];
-        let data;
-        try {
-            data = this.subsetter.subset(source, codepoints);
-        }
-        catch (error) {
-            fail('host_font_subset_failed', error.message || 'The font could not be subset');
-            return;
-        }
-        const subsetSha = crypto.createHash('sha256').update(data).digest('hex');
-        const answer = {
-            type: 'host_font_subset_ready',
-            clientId: streamId,
-            requestId: request.requestId,
-            sha256: source.sha256,
-            subsetSha,
-            bytes: data.length,
-        };
-        if (data.length <= TERMINAL_FONT_CHUNK_BYTES) {
-            answer.dataBase64 = data.toString('base64');
-        }
-        else {
-            this.hold(subsetSha, data);
-        }
-        this.send(answer);
-    }
-    /** Whether the file behind `source` is still the one that was announced. */
-    unchanged(source) {
-        try {
-            const stat = fs.statSync(source.path);
-            return stat.size === source.bytes && stat.mtimeMs === source.mtimeMs;
-        }
-        catch {
-            return false;
-        }
-    }
-    /** Keep a cut font for its slices, dropping the oldest beyond the cache size. */
-    hold(subsetSha, data) {
-        this.subsets.delete(subsetSha);
-        this.subsets.set(subsetSha, data);
-        let held = [...this.subsets.values()].reduce((sum, item) => sum + item.length, 0);
-        for (const [key, item] of this.subsets) {
-            if (held <= FONT_SUBSET_CACHE_BYTES || key === subsetSha)
-                break;
-            this.subsets.delete(key);
-            held -= item.length;
-        }
-    }
-    /** A slice of a cut font still held for the browser that asked for it. */
-    subsetChunk(sha256, index) {
-        const data = this.subsets.get(sha256);
-        if (!data)
-            return null;
-        const total = Math.ceil(data.length / TERMINAL_FONT_CHUNK_BYTES);
-        if (!Number.isInteger(index) || index < 0 || index >= total)
-            return null;
-        const start = index * TERMINAL_FONT_CHUNK_BYTES;
-        return { data: data.subarray(start, start + TERMINAL_FONT_CHUNK_BYTES), total };
-    }
-}

package/dist/connector/herdr-prefix-keys.js

@@ -1,28 +0,0 @@
-// The keys that put this workstation's Herdr into prefix mode. A browser has
-// to tell a Herdr command from typed text, and only Herdr's own config file
-// says which key starts one, so the host reads it and reports it in its hello.
-import fs from 'node:fs';
-import { sanitizeHerdrPrefixKeys } from 'herdr-remote-relay/protocol';
-import { herdrConfigPath } from '../socket-discovery.js';
-import { parseTomlSubset } from '../terminal-font/formats.js';
-/** What Herdr uses when `keys.prefix` is absent or names nothing it can read. */
-const DEFAULT_PREFIX_KEYS = ['ctrl+b'];
-/**
- * `keys.prefix` from the Herdr config the connector's Herdr reads: one key or
- * a list, each a combo like `ctrl+space`. Always at least one key, because
- * Herdr itself falls back to `ctrl+b` when the file, the key or every entry
- * is unusable.
- */
-export function readHerdrPrefixKeys(env = process.env, platform = process.platform) {
-    let text;
-    try {
-        text = fs.readFileSync(herdrConfigPath(env, platform), 'utf8');
-    }
-    catch {
-        // No readable config file means Herdr runs on its defaults.
-        return [...DEFAULT_PREFIX_KEYS];
-    }
-    const configured = parseTomlSubset(text)['keys.prefix'];
-    const entries = typeof configured === 'string' ? [configured] : configured;
-    return sanitizeHerdrPrefixKeys(entries) ?? [...DEFAULT_PREFIX_KEYS];
-}