@prohost/cli 0.13.2 → 0.14.0

package/dist/codehost/host_stats.d.ts

@@ -0,0 +1,71 @@
+/**
+ * How busy this machine is — the "Machine" card on a Code thread.
+ *
+ * Sent only while Code-thread hosting is on (the owner's opt-in), in the
+ * heartbeat's `runtime_status.host` and on the relay's control socket. Every
+ * number comes from a stock tool or Node's `os` module; anything that can't be
+ * read is `null`, never 0. macOS sources: `vm_stat` (memory in use),
+ * `sysctl kern.memorystatus_vm_pressure_level` (pressure), `pmset -g batt`
+ * (battery), `sysctl machdep.cpu.brand_string` (spec). Elsewhere only the
+ * `os`-module numbers are reported.
+ */
+import os from 'node:os';
+export type MemoryPressure = 'normal' | 'elevated' | 'critical';
+export interface HostStats {
+    cpuPct: number | null;
+    memUsedGb: number | null;
+    memTotalGb: number | null;
+    memoryPressure: MemoryPressure | null;
+    batteryPct: number | null;
+    onBattery: boolean | null;
+    buildSlotsBusy: number | null;
+    buildSlotsTotal: number | null;
+    spec: string | null;
+}
+/** Bytes in use per `vm_stat`: active + wired + compressed (what Activity Monitor calls used). */
+export declare function parseVmStat(text: string): number | undefined;
+/** `kern.memorystatus_vm_pressure_level`: 1 normal, 2 warn, 4 critical. */
+export declare function pressureFromLevel(raw: string): MemoryPressure | null;
+/** `pmset -g batt`. A desktop Mac (no battery) reports AC power and no percentage. */
+export declare function parsePmset(text: string): {
+    batteryPct: number | null;
+    onBattery: boolean | null;
+};
+/** e.g. `Apple M3 Max · 64 GB`. */
+export declare function specFrom(brand: string | undefined, totalBytes: number | undefined): string | null;
+interface CpuSample {
+    idle: number;
+    total: number;
+}
+/** Busy share between two samples, 0–100; `undefined` when the clock did not move. */
+export declare function cpuPctBetween(before: CpuSample, after: CpuSample): number | undefined;
+export type CommandRunner = (file: string, args: string[]) => Promise<string | undefined>;
+export interface HostStatsSamplerOptions {
+    run?: CommandRunner;
+    platform?: NodeJS.Platform;
+    cpus?: () => os.CpuInfo[];
+    totalmem?: () => number;
+    freemem?: () => number;
+    /** Agent runs executing / allowed at once on this host. */
+    slots?: () => {
+        busy: number;
+        total: number;
+    } | undefined;
+}
+/** Samples on demand. Keeps the previous CPU sample so each call reports the interval since the last. */
+export declare class HostStatsSampler {
+    private readonly options;
+    private readonly run;
+    private readonly platform;
+    private readonly cpus;
+    private readonly totalmem;
+    private readonly freemem;
+    private previous;
+    private spec;
+    private last;
+    constructor(options?: HostStatsSamplerOptions);
+    /** The most recent sample, if one has been taken. */
+    latest(): HostStats | undefined;
+    sample(): Promise<HostStats>;
+}
+export {};

package/dist/codehost/host_stats.js

@@ -0,0 +1,166 @@
+/**
+ * How busy this machine is — the "Machine" card on a Code thread.
+ *
+ * Sent only while Code-thread hosting is on (the owner's opt-in), in the
+ * heartbeat's `runtime_status.host` and on the relay's control socket. Every
+ * number comes from a stock tool or Node's `os` module; anything that can't be
+ * read is `null`, never 0. macOS sources: `vm_stat` (memory in use),
+ * `sysctl kern.memorystatus_vm_pressure_level` (pressure), `pmset -g batt`
+ * (battery), `sysctl machdep.cpu.brand_string` (spec). Elsewhere only the
+ * `os`-module numbers are reported.
+ */
+import { execFile } from 'node:child_process';
+import os from 'node:os';
+const GB = 1024 ** 3;
+const round1 = (value) => Math.round(value * 10) / 10;
+/** Bytes in use per `vm_stat`: active + wired + compressed (what Activity Monitor calls used). */
+export function parseVmStat(text) {
+    const pageSize = Number.parseInt(/page size of (\d+) bytes/.exec(text)?.[1] ?? '', 10);
+    if (!Number.isFinite(pageSize) || pageSize <= 0)
+        return undefined;
+    const pages = (label) => {
+        const match = new RegExp(`${label}:\\s+(\\d+)`).exec(text);
+        return match ? Number.parseInt(match[1], 10) : undefined;
+    };
+    const active = pages('Pages active');
+    const wired = pages('Pages wired down');
+    const compressed = pages('Pages occupied by compressor') ?? 0;
+    if (active === undefined || wired === undefined)
+        return undefined;
+    return (active + wired + compressed) * pageSize;
+}
+/** `kern.memorystatus_vm_pressure_level`: 1 normal, 2 warn, 4 critical. */
+export function pressureFromLevel(raw) {
+    const level = Number.parseInt(raw.trim(), 10);
+    if (level === 1)
+        return 'normal';
+    if (level === 2)
+        return 'elevated';
+    if (level === 4)
+        return 'critical';
+    return null;
+}
+/** `pmset -g batt`. A desktop Mac (no battery) reports AC power and no percentage. */
+export function parsePmset(text) {
+    const source = /Now drawing from '([^']+)'/.exec(text)?.[1];
+    const pct = /(\d{1,3})%/.exec(text)?.[1];
+    return {
+        batteryPct: pct === undefined ? null : Math.min(100, Number.parseInt(pct, 10)),
+        onBattery: source === undefined ? null : source === 'Battery Power',
+    };
+}
+/** e.g. `Apple M3 Max · 64 GB`. */
+export function specFrom(brand, totalBytes) {
+    const parts = [brand?.trim(), totalBytes ? `${Math.round(totalBytes / GB)} GB` : undefined].filter(Boolean);
+    return parts.length > 0 ? parts.join(' · ') : null;
+}
+function cpuSample(cpus) {
+    let idle = 0;
+    let total = 0;
+    for (const cpu of cpus) {
+        const t = cpu.times;
+        idle += t.idle;
+        total += t.user + t.nice + t.sys + t.irq + t.idle;
+    }
+    return { idle, total };
+}
+/** Busy share between two samples, 0–100; `undefined` when the clock did not move. */
+export function cpuPctBetween(before, after) {
+    const total = after.total - before.total;
+    if (total <= 0)
+        return undefined;
+    return round1(Math.min(100, Math.max(0, (1 - (after.idle - before.idle) / total) * 100)));
+}
+const defaultRun = (file, args) => new Promise((resolve) => {
+    execFile(file, args, { timeout: 2_000, maxBuffer: 256 * 1024 }, (error, stdout) => {
+        resolve(error ? undefined : String(stdout));
+    });
+});
+/** Samples on demand. Keeps the previous CPU sample so each call reports the interval since the last. */
+export class HostStatsSampler {
+    options;
+    run;
+    platform;
+    cpus;
+    totalmem;
+    freemem;
+    previous;
+    spec;
+    last;
+    constructor(options = {}) {
+        this.options = options;
+        this.run = options.run ?? defaultRun;
+        this.platform = options.platform ?? process.platform;
+        this.cpus = options.cpus ?? os.cpus;
+        this.totalmem = options.totalmem ?? os.totalmem;
+        this.freemem = options.freemem ?? os.freemem;
+        try {
+            this.previous = cpuSample(this.cpus());
+        }
+        catch {
+            this.previous = undefined;
+        }
+    }
+    /** The most recent sample, if one has been taken. */
+    latest() {
+        return this.last;
+    }
+    async sample() {
+        let cpuPct = null;
+        try {
+            const now = cpuSample(this.cpus());
+            if (this.previous)
+                cpuPct = cpuPctBetween(this.previous, now) ?? null;
+            this.previous = now;
+        }
+        catch {
+            cpuPct = null;
+        }
+        const total = safe(this.totalmem);
+        let used;
+        let memoryPressure = null;
+        let battery = { batteryPct: null, onBattery: null };
+        if (this.platform === 'darwin') {
+            const [vm, pressure, pmset] = await Promise.all([
+                this.run('vm_stat', []),
+                this.run('sysctl', ['-n', 'kern.memorystatus_vm_pressure_level']),
+                this.run('pmset', ['-g', 'batt']),
+            ]);
+            used = vm ? parseVmStat(vm) : undefined;
+            memoryPressure = pressure ? pressureFromLevel(pressure) : null;
+            if (pmset)
+                battery = parsePmset(pmset);
+            if (this.spec === undefined) {
+                const brand = (await this.run('sysctl', ['-n', 'machdep.cpu.brand_string']))?.trim();
+                this.spec = specFrom(brand || undefined, total);
+            }
+        }
+        else {
+            const free = safe(this.freemem);
+            used = total !== undefined && free !== undefined ? total - free : undefined;
+            if (this.spec === undefined)
+                this.spec = specFrom(safe(() => os.cpus()[0]?.model), total);
+        }
+        const slots = this.options.slots?.();
+        this.last = {
+            cpuPct,
+            memUsedGb: used === undefined ? null : round1(used / GB),
+            memTotalGb: total === undefined ? null : round1(total / GB),
+            memoryPressure,
+            batteryPct: battery.batteryPct,
+            onBattery: battery.onBattery,
+            buildSlotsBusy: slots ? slots.busy : null,
+            buildSlotsTotal: slots ? slots.total : null,
+            spec: this.spec ?? null,
+        };
+        return this.last;
+    }
+}
+function safe(read) {
+    try {
+        return read();
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/codehost/invocations.d.ts

@@ -0,0 +1,12 @@
+export declare const INVOCATION_PROTOCOL_ENV = "PROHOST_INVOCATION_PROTOCOL";
+/** Must finish successfully before the critical PreToolUse hook returns. */
+export declare function recordInvocation(terminalId: string, input: Record<string, unknown>, env: NodeJS.ProcessEnv): void;
+/**
+ * The held invocation is among these IDs because its successful PreToolUse completed first.
+ * Retain all same-tool IDs, including identical parallel calls; a parent agent may prompt too.
+ */
+export declare function permissionInvocationIds(terminalId: string, input: Record<string, unknown>, env: NodeJS.ProcessEnv): string[];
+/** Turn/user progress retires both waiters and the IDs from the previous turn. */
+export declare function forgetInvocations(terminalId: string, env: NodeJS.ProcessEnv): void;
+/** Failure-blocking command hooks first became a supported contract in this version. */
+export declare function supportsInvocationProtocol(version: string | undefined): boolean;

package/dist/codehost/invocations.js

@@ -0,0 +1,82 @@
+/** Invocation IDs recorded before Claude Code can ask permission; no transcript timing inference. */
+import { createHash } from 'node:crypto';
+import { readdirSync, readFileSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { codeHostDir, writePrivateJson } from './settings.js';
+import { isValidId } from './tmux.js';
+export const INVOCATION_PROTOCOL_ENV = 'PROHOST_INVOCATION_PROTOCOL';
+const hash = (value) => createHash('sha256').update(value).digest('hex');
+const opaqueId = (value) => typeof value === 'string' && value.length > 0 && value.length <= 512 && !value.includes('\0');
+const transcriptPath = (value) => typeof value === 'string' && path.isAbsolute(value) && value.endsWith('.jsonl');
+function terminalDir(terminalId, env) {
+    if (!isValidId(terminalId))
+        throw new Error('Invalid invocation terminal');
+    return path.join(codeHostDir(env), 'invocations', terminalId);
+}
+function parseInvocation(input) {
+    if (!opaqueId(input.session_id) || !opaqueId(input.tool_use_id) ||
+        !opaqueId(input.tool_name) || !transcriptPath(input.transcript_path)) {
+        throw new Error('Missing invocation identity');
+    }
+    return {
+        sessionId: input.session_id,
+        toolUseId: input.tool_use_id,
+        toolName: input.tool_name,
+        transcript: path.normalize(input.transcript_path),
+    };
+}
+/** Must finish successfully before the critical PreToolUse hook returns. */
+export function recordInvocation(terminalId, input, env) {
+    const invocation = parseInvocation(input);
+    // Child results may live outside transcript_path; their permission waiters require turn progress.
+    if (input.agent_id !== undefined)
+        return;
+    const file = path.join(terminalDir(terminalId, env), hash(invocation.sessionId), `${hash(invocation.toolUseId)}.json`);
+    writePrivateJson(file, invocation);
+}
+/**
+ * The held invocation is among these IDs because its successful PreToolUse completed first.
+ * Retain all same-tool IDs, including identical parallel calls; a parent agent may prompt too.
+ */
+export function permissionInvocationIds(terminalId, input, env) {
+    if (!opaqueId(input.session_id) || !opaqueId(input.tool_name) || !transcriptPath(input.transcript_path)) {
+        throw new Error('Missing permission invocation scope');
+    }
+    const dir = path.join(terminalDir(terminalId, env), hash(input.session_id));
+    const transcript = path.normalize(input.transcript_path);
+    const ids = [];
+    for (const filename of readdirSync(dir)) {
+        if (!filename.endsWith('.json'))
+            continue;
+        const raw = JSON.parse(readFileSync(path.join(dir, filename), 'utf8'));
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            throw new Error('Invalid invocation record');
+        const value = raw;
+        const invocation = parseInvocation({
+            session_id: value.sessionId, tool_use_id: value.toolUseId,
+            tool_name: value.toolName, transcript_path: value.transcript,
+        });
+        if (invocation.sessionId !== input.session_id || filename !== `${hash(invocation.toolUseId)}.json`) {
+            throw new Error('Invocation scope mismatch');
+        }
+        if (invocation.transcript === transcript &&
+            (invocation.toolName === input.tool_name || ['Task', 'Agent'].includes(invocation.toolName))) {
+            ids.push(invocation.toolUseId);
+        }
+    }
+    if (ids.length === 0)
+        throw new Error('No recorded permission invocation');
+    return ids.sort();
+}
+/** Turn/user progress retires both waiters and the IDs from the previous turn. */
+export function forgetInvocations(terminalId, env) {
+    rmSync(terminalDir(terminalId, env), { recursive: true, force: true });
+}
+/** Failure-blocking command hooks first became a supported contract in this version. */
+export function supportsInvocationProtocol(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:\s|$)/.exec(version?.trim() ?? '');
+    if (!match)
+        return false;
+    const [major, minor, patch] = match.slice(1).map(Number);
+    return major > 2 || (major === 2 && (minor > 1 || (minor === 1 && patch >= 295)));
+}

package/dist/codehost/ledger.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Deliveries of `code_thread.input_requested` / `.approval_decided` this
+ * machine has acted on, kept across restarts.
+ *
+ * Typing into a pane is not idempotent: a reply whose ack was lost in a
+ * reconnect is redelivered under the same `delivery_id`, and acting on it again
+ * would submit it twice — or press a stale approval's keys on a later prompt.
+ * So a delivery is recorded *before* its keys are sent (at most once: a crash
+ * in between loses one reply, which the person can resend, rather than typing
+ * it twice), and a recorded one is acknowledged without acting.
+ */
+/** Plenty for any redelivery window; old ids fall off the front. */
+export declare const MAX_REMEMBERED_DELIVERIES = 1000;
+export declare function deliveryLedgerPath(env?: NodeJS.ProcessEnv): string;
+export declare class DeliveryLedger {
+    private readonly env;
+    private ids;
+    private readonly known;
+    /** Claimed deliveries that ended in a refusal the server hands back, by id: a repeat says it again. */
+    private readonly refused;
+    constructor(env?: NodeJS.ProcessEnv);
+    /** Whether a prior attempt has an outcome to replay, without claiming a fresh delivery. */
+    has(deliveryId: string): boolean;
+    /** True the first time `deliveryId` is claimed (and records it); false for a repeat. */
+    claim(deliveryId: string): boolean;
+    /**
+     * Forget a claim that typed nothing (refused before any key): a redelivery is
+     * judged afresh, so a refusal whose ack was lost is never answered "done".
+     */
+    release(deliveryId: string): void;
+    /** A claimed delivery that may have typed something and was then refused: a repeat refuses it the same way. */
+    refuse(deliveryId: string, reason: string): void;
+    refusalFor(deliveryId: string): string | undefined;
+    private save;
+}

package/dist/codehost/ledger.js

@@ -0,0 +1,91 @@
+/**
+ * Deliveries of `code_thread.input_requested` / `.approval_decided` this
+ * machine has acted on, kept across restarts.
+ *
+ * Typing into a pane is not idempotent: a reply whose ack was lost in a
+ * reconnect is redelivered under the same `delivery_id`, and acting on it again
+ * would submit it twice — or press a stale approval's keys on a later prompt.
+ * So a delivery is recorded *before* its keys are sent (at most once: a crash
+ * in between loses one reply, which the person can resend, rather than typing
+ * it twice), and a recorded one is acknowledged without acting.
+ */
+import path from 'node:path';
+import { codeHostDir, readJsonObject, writePrivateJson } from './settings.js';
+/** Plenty for any redelivery window; old ids fall off the front. */
+export const MAX_REMEMBERED_DELIVERIES = 1_000;
+export function deliveryLedgerPath(env = process.env) {
+    return path.join(codeHostDir(env), 'state', 'deliveries.json');
+}
+export class DeliveryLedger {
+    env;
+    ids;
+    known;
+    /** Claimed deliveries that ended in a refusal the server hands back, by id: a repeat says it again. */
+    refused = new Map();
+    constructor(env = process.env) {
+        this.env = env;
+        const file = readJsonObject(deliveryLedgerPath(env));
+        const raw = file?.ids;
+        this.ids = Array.isArray(raw) ? raw.filter((id) => typeof id === 'string') : [];
+        this.known = new Set(this.ids);
+        const refused = file?.refused;
+        if (refused && typeof refused === 'object') {
+            for (const [id, reason] of Object.entries(refused)) {
+                if (this.known.has(id) && typeof reason === 'string')
+                    this.refused.set(id, reason);
+            }
+        }
+    }
+    /** Whether a prior attempt has an outcome to replay, without claiming a fresh delivery. */
+    has(deliveryId) {
+        return this.known.has(deliveryId);
+    }
+    /** True the first time `deliveryId` is claimed (and records it); false for a repeat. */
+    claim(deliveryId) {
+        if (!deliveryId || this.known.has(deliveryId))
+            return false;
+        this.known.add(deliveryId);
+        this.ids.push(deliveryId);
+        if (this.ids.length > MAX_REMEMBERED_DELIVERIES) {
+            for (const dropped of this.ids.splice(0, this.ids.length - MAX_REMEMBERED_DELIVERIES)) {
+                this.known.delete(dropped);
+                this.refused.delete(dropped);
+            }
+        }
+        this.save();
+        return true;
+    }
+    /**
+     * Forget a claim that typed nothing (refused before any key): a redelivery is
+     * judged afresh, so a refusal whose ack was lost is never answered "done".
+     */
+    release(deliveryId) {
+        if (!this.known.delete(deliveryId))
+            return;
+        this.ids = this.ids.filter((id) => id !== deliveryId);
+        this.refused.delete(deliveryId);
+        this.save();
+    }
+    /** A claimed delivery that may have typed something and was then refused: a repeat refuses it the same way. */
+    refuse(deliveryId, reason) {
+        if (!this.known.has(deliveryId))
+            return;
+        this.refused.set(deliveryId, reason);
+        this.save();
+    }
+    refusalFor(deliveryId) {
+        return this.refused.get(deliveryId);
+    }
+    save() {
+        try {
+            writePrivateJson(deliveryLedgerPath(this.env), {
+                version: 1,
+                ids: this.ids,
+                refused: Object.fromEntries(this.refused),
+            });
+        }
+        catch {
+            /* in memory it still dedupes for this process */
+        }
+    }
+}

package/dist/codehost/local_server.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The desktop app's fast path to this machine's Code-thread terminals.
+ *
+ * The ProhostAI desktop app runs this CLI with its own `$PROHOST_HOME`, so it
+ * can read `code-host/local.json` and attach over loopback instead of a round
+ * trip through the relay. Served whenever this Mac hosts Code threads, with the
+ * remote switch on or off — the desktop app on this Mac is how its owner opens
+ * the terminals here at all. What the switch decides is which attaches it
+ * admits:
+ *
+ * - **Remote on:** any attach whose viewer token the relay vouches for.
+ * - **Remote off:** only one the relay vouches for as `local: true` — a token
+ *   minted for this Mac's own desktop app (`loc`), which the relay refuses for
+ *   any relayed attach. A verdict without `local` (an older server) is not
+ *   local. Turning the switch off ends every viewer admitted as remote.
+ *
+ * Who can connect:
+ *
+ * - **Loopback only** (`127.0.0.1`, ephemeral port), and the `Host` header must
+ *   name it — a DNS-rebinding page can't pass for it.
+ * - **Never a browser:** any request carrying an `Origin` header is refused.
+ *   Browsers always send one on a WebSocket handshake; Electron's main
+ *   process (Node's WebSocket) sends none.
+ * - **The token in `local.json`** (0600, owner-only, new every start), in the
+ *   first frame, compared in constant time.
+ *
+ * After `ready` it speaks the relay's viewer protocol: binary frames both
+ * ways, `{"type":"input"}`, `{"type":"resize"}`, ping/pong, and who sizes the
+ * window (`{"type":"hello"}` / `{"type":"claim"}` in, `{"type":"sizer"}` out to
+ * a viewer that said hello; `sizing.ts`).
+ */
+import http from 'node:http';
+import type { Duplex } from 'node:stream';
+import type { ViewerVerdict } from './relay.js';
+import type { CodeHostSettings } from './settings.js';
+import type { CodeTerminals } from './terminals.js';
+import type { TerminalWindow } from './tmux.js';
+export declare const LOCAL_TERMINAL_PATH = "/code-host/terminal";
+export declare const LOCAL_TERMINALS_PATH = "/code-host/terminals";
+export declare function localConfigPath(env?: NodeJS.ProcessEnv): string;
+export declare function tokensMatch(expected: string, given: unknown): boolean;
+/** Why a handshake must be refused, or `undefined` to accept it. */
+export declare function refuseHandshake(headers: http.IncomingHttpHeaders, url: string | undefined, port: number): {
+    status: number;
+    reason: string;
+} | undefined;
+export interface LocalAuth {
+    terminalId: string;
+    window: TerminalWindow;
+    cols: number;
+    rows: number;
+    /** The short-lived relay viewer token the page holds; verified through the relay, never trusted as-is. */
+    viewerToken: string;
+}
+export declare function parseLocalAuth(text: string, token: string): LocalAuth | {
+    error: string;
+};
+export interface LocalServerOptions {
+    env?: NodeJS.ProcessEnv;
+    /**
+     * The workspace this machine is paired with, written to `local.json`: the
+     * desktop app attaches only while it is signed in to that same workspace.
+     */
+    accountId: string;
+    /** The pairing's owner, written beside it: only that user's app window attaches. */
+    ownerUserId: string;
+    settings: () => CodeHostSettings;
+    terminals: Pick<CodeTerminals, 'attach' | 'list'>;
+    /**
+     * Who the attach is for, as the relay vouches for it (`CodeHostRelay.verifyViewer`):
+     * the same owner-only, flag-gated check a relay viewer gets.
+     */
+    verifyViewer: (token: string) => Promise<ViewerVerdict>;
+    log?: (line: string) => void;
+}
+export declare class LocalTerminalServer {
+    private readonly options;
+    private server;
+    private wss;
+    private token;
+    private port;
+    private readonly env;
+    /** Viewers admitted on a verdict that was not `local`: the ones `remote off` ends. */
+    private readonly remoteClients;
+    constructor(options: LocalServerOptions);
+    /** The bound port, once listening. */
+    boundPort(): number;
+    /** The current token. Exposed for tests; never logged. */
+    currentToken(): string;
+    start(): Promise<void>;
+    /** End every attached desktop viewer now (the pairing refused, the host stopping). */
+    dropClients(): void;
+    /** End every viewer admitted as remote (the remote switch turned off); local ones stay. */
+    dropRemoteClients(): void;
+    /** Whether `verdict` may attach now: the remote switch, or a token the relay vouched for as local. */
+    private admits;
+    stop(): Promise<void>;
+    /** Every WebSocket handshake comes through here; a refused one never reaches `ws`. */
+    onUpgrade(req: Pick<http.IncomingMessage, 'headers' | 'url'>, socket: Pick<Duplex, 'write' | 'destroy'>, head: Buffer): void;
+    private onRequest;
+    private onSocket;
+    /** Hand a verified attach to its socket, re-checking what may have changed while it opened. */
+    private serve;
+    /** Same heartbeat as the relay: a ping every 30 s, closed after 60 s without a pong. */
+    private heartbeat;
+}