@nhic-lab/srv-wrapper 0.1.0

package/dist/daemon/keychain.js

@@ -0,0 +1,46 @@
+import { spawnSync } from 'node:child_process';
+const SERVICE = 'srv-wrapper';
+function defaultExec(cmd, args) {
+    const result = spawnSync(cmd, args, { encoding: 'utf-8' });
+    return { stdout: result.stdout ?? '', status: result.status ?? 1 };
+}
+export class Keychain {
+    daemonBinaryPath;
+    exec;
+    constructor(daemonBinaryPath, exec = defaultExec) {
+        this.daemonBinaryPath = daemonBinaryPath;
+        this.exec = exec;
+    }
+    setSecret(serverId, secret) {
+        const result = this.exec('security', [
+            'add-generic-password',
+            '-a', serverId,
+            '-s', SERVICE,
+            '-w', secret,
+            '-T', this.daemonBinaryPath,
+            '-U',
+        ]);
+        if (result.status !== 0) {
+            throw new Error(`Failed to store secret for ${serverId} in Keychain (status ${result.status})`);
+        }
+    }
+    getSecret(serverId) {
+        const result = this.exec('security', [
+            'find-generic-password',
+            '-a', serverId,
+            '-s', SERVICE,
+            '-w',
+        ]);
+        if (result.status !== 0) {
+            throw new Error(`No secret found for ${serverId} in Keychain (status ${result.status})`);
+        }
+        return result.stdout.trim();
+    }
+    deleteSecret(serverId) {
+        this.exec('security', [
+            'delete-generic-password',
+            '-a', serverId,
+            '-s', SERVICE,
+        ]);
+    }
+}

package/dist/daemon/logstore.js

@@ -0,0 +1,202 @@
+import Database from 'better-sqlite3';
+/**
+ * Stored output is capped per run: the first HEAD_CHARS and last TAIL_CHARS are
+ * kept with an elision marker between them. A handful of `mysql`/`docker exec`
+ * dumps had grown to ~97 MB each and accounted for 96% of a 1.8 GB log.db,
+ * which made `GET /api/history` fail outright with "RangeError: Invalid string
+ * length" once the combined output passed V8's ~512 MB string ceiling.
+ *
+ * The cap also removes a quadratic write cost: `output = output || chunk`
+ * rewrites the entire column on every chunk, so a 97 MB run rewrote ~97 MB
+ * thousands of times. With the cap the column never exceeds ~256 KB.
+ */
+const HEAD_CHARS = 128 * 1024;
+const TAIL_CHARS = 128 * 1024;
+const DEFAULT_LIST_LIMIT = 500;
+function fmtBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(0)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+function elisionMarker(bytes) {
+    return `\n\n… ${fmtBytes(bytes)} of output elided by srv-wrapper (head and tail kept) …\n\n`;
+}
+export class LogStore {
+    db;
+    /** Runs whose stored output has hit the cap: we hold head/tail in memory and
+     *  stop touching the `output` column until the run finishes. */
+    capped = new Map();
+    constructor(dbPath) {
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        server_id TEXT NOT NULL,
+        agent_label TEXT NOT NULL,
+        kind TEXT NOT NULL CHECK(kind IN ('exec','session')),
+        command TEXT,
+        output TEXT NOT NULL DEFAULT '',
+        exit_code INTEGER,
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER
+      )
+    `);
+        const cols = this.db.prepare(`PRAGMA table_info(runs)`).all();
+        if (!cols.some((c) => c.name === 'output_bytes')) {
+            this.db.exec(`ALTER TABLE runs ADD COLUMN output_bytes INTEGER NOT NULL DEFAULT 0`);
+        }
+        if (!cols.some((c) => c.name === 'truncated')) {
+            this.db.exec(`ALTER TABLE runs ADD COLUMN truncated INTEGER NOT NULL DEFAULT 0`);
+        }
+        // Backfill sizes for rows written before output_bytes existed. This is
+        // keyed off user_version rather than "did we just add the column", because
+        // scripts/compact-log.mjs may have created the column first — in which case
+        // a creation-time backfill never runs and every older row reports 0 bytes.
+        // user_version guarantees this happens exactly once per database.
+        const schemaVersion = this.db.pragma('user_version', { simple: true });
+        if (schemaVersion < 1) {
+            this.db.exec(`UPDATE runs SET output_bytes = length(output) WHERE output_bytes = 0 AND length(output) > 0`);
+            this.db.pragma('user_version = 1');
+        }
+        // History is always read newest-first, and always filtered by server id on
+        // the server-detail pane; without this every read was a full table scan.
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_started_at ON runs (started_at DESC)`);
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_runs_server_started ON runs (server_id, started_at DESC)`);
+    }
+    start(input) {
+        this.db
+            .prepare(`INSERT INTO runs (id, server_id, agent_label, kind, command, output, output_bytes, truncated, exit_code, started_at, ended_at)
+         VALUES (@id, @serverId, @agentLabel, @kind, @command, '', 0, 0, NULL, @startedAt, NULL)`)
+            .run({ ...input, startedAt: Date.now() });
+    }
+    appendOutput(id, chunk) {
+        const bytes = Buffer.byteLength(chunk);
+        const cap = this.capped.get(id);
+        if (cap) {
+            // Already capped: keep a rolling tail in memory, touch only the counter.
+            cap.tail += chunk;
+            if (cap.tail.length > TAIL_CHARS) {
+                const over = cap.tail.length - TAIL_CHARS;
+                cap.elided += Buffer.byteLength(cap.tail.slice(0, over));
+                cap.tail = cap.tail.slice(over);
+            }
+            this.db.prepare('UPDATE runs SET output_bytes = output_bytes + @bytes WHERE id = @id').run({ id, bytes });
+            return;
+        }
+        this.db
+            .prepare('UPDATE runs SET output = output || @chunk, output_bytes = output_bytes + @bytes WHERE id = @id')
+            .run({ id, chunk, bytes });
+        const row = this.db.prepare('SELECT length(output) AS len FROM runs WHERE id = ?').get(id);
+        if (!row || row.len <= HEAD_CHARS + TAIL_CHARS)
+            return;
+        const full = this.db.prepare('SELECT output FROM runs WHERE id = ?').get(id).output;
+        const entry = {
+            head: full.slice(0, HEAD_CHARS),
+            tail: full.slice(full.length - TAIL_CHARS),
+            elided: Buffer.byteLength(full.slice(HEAD_CHARS, full.length - TAIL_CHARS)),
+        };
+        this.capped.set(id, entry);
+        this.db.prepare('UPDATE runs SET truncated = 1 WHERE id = ?').run(id);
+        this.flushCapped(id);
+    }
+    flushCapped(id) {
+        const cap = this.capped.get(id);
+        if (!cap)
+            return;
+        this.db
+            .prepare('UPDATE runs SET output = @output WHERE id = @id')
+            .run({ id, output: cap.head + elisionMarker(cap.elided) + cap.tail });
+    }
+    finish(id, exitCode) {
+        if (this.capped.has(id)) {
+            this.flushCapped(id);
+            this.capped.delete(id);
+        }
+        this.db
+            .prepare('UPDATE runs SET exit_code = @exitCode, ended_at = @endedAt WHERE id = @id')
+            .run({ id, exitCode, endedAt: Date.now() });
+    }
+    get(id) {
+        const row = this.db.prepare('SELECT * FROM runs WHERE id = ?').get(id);
+        if (!row)
+            return undefined;
+        return this.rowToRecord(row);
+    }
+    /**
+     * Run metadata only, newest first — deliberately without `output`. The
+     * dashboard's list pane never needs output, and sending it for every run is
+     * what broke this endpoint. Fetch a single run (with output) via `get`.
+     */
+    list(filter) {
+        let query = `SELECT id, server_id, agent_label, kind, command, exit_code, started_at, ended_at,
+                        output_bytes, truncated, length(output) AS stored_chars
+                 FROM runs`;
+        const clauses = [];
+        const params = {};
+        if (filter?.serverId) {
+            clauses.push('server_id = @serverId');
+            params.serverId = filter.serverId;
+        }
+        if (filter?.agentLabel) {
+            clauses.push('agent_label = @agentLabel');
+            params.agentLabel = filter.agentLabel;
+        }
+        if (clauses.length)
+            query += ' WHERE ' + clauses.join(' AND ');
+        query += ' ORDER BY started_at DESC LIMIT @limit OFFSET @offset';
+        params.limit = Math.max(1, Math.min(filter?.limit ?? DEFAULT_LIST_LIMIT, 5000));
+        params.offset = Math.max(0, filter?.offset ?? 0);
+        const rows = this.db.prepare(query).all(params);
+        return rows.map((r) => ({
+            id: r.id,
+            serverId: r.server_id,
+            agentLabel: r.agent_label,
+            kind: r.kind,
+            command: r.command,
+            exitCode: r.exit_code,
+            startedAt: r.started_at,
+            endedAt: r.ended_at,
+            outputBytes: r.output_bytes,
+            truncated: Boolean(r.truncated),
+            hasOutput: r.stored_chars > 0,
+        }));
+    }
+    /** Total number of runs, for "showing N of M" in the UI. */
+    count(filter) {
+        let query = 'SELECT count(*) AS n FROM runs';
+        const clauses = [];
+        const params = {};
+        if (filter?.serverId) {
+            clauses.push('server_id = @serverId');
+            params.serverId = filter.serverId;
+        }
+        if (filter?.agentLabel) {
+            clauses.push('agent_label = @agentLabel');
+            params.agentLabel = filter.agentLabel;
+        }
+        if (clauses.length)
+            query += ' WHERE ' + clauses.join(' AND ');
+        return this.db.prepare(query).get(params).n;
+    }
+    rowToRecord(row) {
+        return {
+            id: row.id,
+            serverId: row.server_id,
+            agentLabel: row.agent_label,
+            kind: row.kind,
+            command: row.command,
+            output: row.output,
+            exitCode: row.exit_code,
+            startedAt: row.started_at,
+            endedAt: row.ended_at,
+            outputBytes: row.output_bytes ?? row.output?.length ?? 0,
+            truncated: Boolean(row.truncated),
+        };
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/daemon/registry.js

@@ -0,0 +1,103 @@
+import Database from 'better-sqlite3';
+export class Registry {
+    db;
+    constructor(dbPath) {
+        this.db = new Database(dbPath);
+        this.db.pragma('journal_mode = WAL');
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS servers (
+        id TEXT PRIMARY KEY,
+        host TEXT NOT NULL,
+        port INTEGER NOT NULL,
+        username TEXT NOT NULL,
+        auth_method TEXT NOT NULL CHECK(auth_method IN ('password','key')),
+        key_path TEXT,
+        host_key_fingerprint TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+        const cols = this.db.prepare(`PRAGMA table_info(servers)`).all();
+        if (!cols.some((c) => c.name === 'host_key_fingerprint')) {
+            this.db.exec(`ALTER TABLE servers ADD COLUMN host_key_fingerprint TEXT`);
+        }
+        if (!cols.some((c) => c.name === 'jump_chain')) {
+            this.db.exec(`ALTER TABLE servers ADD COLUMN jump_chain TEXT`);
+        }
+        // Reachability is persisted so the Servers view's online/offline filter is
+        // still meaningful after a refresh or a daemon restart — with 50+ servers,
+        // re-running "Test all" just to repopulate an in-memory map is not viable.
+        if (!cols.some((c) => c.name === 'last_test_at')) {
+            this.db.exec(`ALTER TABLE servers ADD COLUMN last_test_at INTEGER`);
+        }
+        if (!cols.some((c) => c.name === 'last_test_ok')) {
+            this.db.exec(`ALTER TABLE servers ADD COLUMN last_test_ok INTEGER`);
+        }
+        if (!cols.some((c) => c.name === 'last_test_error')) {
+            this.db.exec(`ALTER TABLE servers ADD COLUMN last_test_error TEXT`);
+        }
+    }
+    upsert(record) {
+        const now = Date.now();
+        const existing = this.get(record.id);
+        const createdAt = existing?.createdAt ?? now;
+        this.db
+            .prepare(`INSERT INTO servers (id, host, port, username, auth_method, key_path, jump_chain, created_at, updated_at)
+         VALUES (@id, @host, @port, @username, @authMethod, @keyPath, @jumpChain, @createdAt, @updatedAt)
+         ON CONFLICT(id) DO UPDATE SET
+           host=excluded.host, port=excluded.port, username=excluded.username,
+           auth_method=excluded.auth_method, key_path=excluded.key_path, jump_chain=excluded.jump_chain, updated_at=excluded.updated_at`)
+            .run({
+            id: record.id,
+            host: record.host,
+            port: record.port,
+            username: record.username,
+            authMethod: record.authMethod,
+            keyPath: record.keyPath ?? null,
+            jumpChain: record.jumpChain && record.jumpChain.length > 0 ? JSON.stringify(record.jumpChain) : null,
+            createdAt,
+            updatedAt: now,
+        });
+        return this.get(record.id);
+    }
+    get(id) {
+        const row = this.db.prepare('SELECT * FROM servers WHERE id = ?').get(id);
+        if (!row)
+            return undefined;
+        return {
+            id: row.id,
+            host: row.host,
+            port: row.port,
+            username: row.username,
+            authMethod: row.auth_method,
+            keyPath: row.key_path ?? undefined,
+            hostKeyFingerprint: row.host_key_fingerprint ?? undefined,
+            jumpChain: row.jump_chain ? JSON.parse(row.jump_chain) : undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            lastTestAt: row.last_test_at ?? undefined,
+            lastTestOk: row.last_test_ok == null ? undefined : Boolean(row.last_test_ok),
+            lastTestError: row.last_test_error ?? undefined,
+        };
+    }
+    setHostKeyFingerprint(id, fingerprint) {
+        this.db.prepare('UPDATE servers SET host_key_fingerprint = ? WHERE id = ?').run(fingerprint, id);
+    }
+    /** Records the outcome of a reachability check. `error` is the already
+     *  sanitized message — never a raw ssh2/Node error (see sanitizeSshError). */
+    setTestResult(id, ok, error) {
+        this.db
+            .prepare('UPDATE servers SET last_test_at = ?, last_test_ok = ?, last_test_error = ? WHERE id = ?')
+            .run(Date.now(), ok ? 1 : 0, ok ? null : (error ?? null), id);
+    }
+    list() {
+        const rows = this.db.prepare('SELECT id FROM servers ORDER BY id').all();
+        return rows.map((r) => this.get(r.id));
+    }
+    delete(id) {
+        this.db.prepare('DELETE FROM servers WHERE id = ?').run(id);
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/daemon/socket-protocol.js

@@ -0,0 +1,19 @@
+export function encodeMessage(msg) {
+    return JSON.stringify(msg) + '\n';
+}
+export function decodeMessages(buffer) {
+    const parts = buffer.split('\n');
+    const rest = parts.pop() ?? '';
+    const messages = [];
+    for (const line of parts) {
+        if (line.length === 0)
+            continue;
+        try {
+            messages.push(JSON.parse(line));
+        }
+        catch {
+            // malformed line — skip it rather than throwing and crashing the daemon
+        }
+    }
+    return { messages, rest };
+}

package/dist/daemon/socket-server.js

@@ -0,0 +1,199 @@
+import net from 'node:net';
+import fs from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { encodeMessage, decodeMessages } from './socket-protocol.js';
+const KNOWN_SSH_ERROR_CODES = {
+    ECONNREFUSED: 'connection refused',
+    ETIMEDOUT: 'connection timed out',
+    EHOSTUNREACH: 'host unreachable',
+    ENOTFOUND: 'host not found',
+    ECONNRESET: 'connection reset',
+};
+/**
+ * SSH/Node connection-level errors routinely embed the literal host/IP and port
+ * (e.g. "connect ECONNREFUSED 10.0.0.5:22"). The CLI process must never receive
+ * host/port/credentials, so map known error codes to safe, generic messages and
+ * fall back to a fully generic message otherwise. The real error is logged
+ * server-side only.
+ */
+export function sanitizeSshError(err) {
+    const code = err?.code;
+    if (code && KNOWN_SSH_ERROR_CODES[code])
+        return `ssh error: ${KNOWN_SSH_ERROR_CODES[code]}`;
+    console.error('srvd: unclassified SSH error:', err);
+    return 'ssh error: connection failed';
+}
+export class SocketServer {
+    opts;
+    static SESSION_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+    server;
+    sessions = new Map();
+    constructor(opts) {
+        this.opts = opts;
+        this.server = net.createServer((conn) => this.handleConnection(conn));
+    }
+    async start() {
+        if (fs.existsSync(this.opts.socketPath))
+            fs.unlinkSync(this.opts.socketPath);
+        await new Promise((resolve) => this.server.listen(this.opts.socketPath, resolve));
+        fs.chmodSync(this.opts.socketPath, 0o600);
+    }
+    async stop() {
+        await new Promise((resolve) => this.server.close(() => resolve()));
+        if (fs.existsSync(this.opts.socketPath))
+            fs.unlinkSync(this.opts.socketPath);
+    }
+    handleConnection(conn) {
+        let buffer = '';
+        conn.on('data', (data) => {
+            buffer += data.toString();
+            const { messages, rest } = decodeMessages(buffer);
+            buffer = rest;
+            for (const msg of messages) {
+                this.handleMessage(conn, msg).catch((err) => {
+                    this.send(conn, {
+                        type: 'done',
+                        requestId: msg.requestId ?? 'unknown',
+                        exitCode: null,
+                        error: `internal error: ${err?.message ?? err}`,
+                    });
+                });
+            }
+        });
+    }
+    async handleMessage(conn, msg) {
+        const requestId = msg.requestId ?? randomUUID();
+        if (msg.type === 'list') {
+            const serverIds = this.opts.registry.list().map((s) => s.id);
+            this.send(conn, { type: 'list_result', requestId, serverIds });
+            return;
+        }
+        if (msg.type === 'exec') {
+            const server = this.opts.registry.get(msg.serverId);
+            if (!server) {
+                this.send(conn, { type: 'done', requestId, exitCode: null, error: `unknown server: ${msg.serverId}` });
+                return;
+            }
+            const runId = randomUUID();
+            this.opts.logStore.start({ id: runId, serverId: server.id, agentLabel: msg.agentLabel, kind: 'exec', command: msg.command });
+            try {
+                const exitCode = await this.opts.sshManager.exec(server, msg.command, (stream, chunk) => {
+                    this.opts.logStore.appendOutput(runId, chunk);
+                    const event = { type: 'stream', requestId, stream, chunk };
+                    this.send(conn, event);
+                    this.opts.onBroadcast?.({ ...event, serverId: server.id, agentLabel: msg.agentLabel, command: msg.command });
+                });
+                this.opts.logStore.finish(runId, exitCode);
+                const done = { type: 'done', requestId, exitCode };
+                this.send(conn, done);
+                this.opts.onBroadcast?.({ ...done, serverId: server.id, agentLabel: msg.agentLabel });
+            }
+            catch (err) {
+                this.opts.logStore.finish(runId, null);
+                const safe = sanitizeSshError(err);
+                this.send(conn, { type: 'done', requestId, exitCode: null, error: safe });
+                // The dashboard needs this too — without it a run that failed to
+                // connect is left streaming forever in the live view.
+                this.opts.onBroadcast?.({ type: 'done', requestId, exitCode: null, error: safe, serverId: server.id, agentLabel: msg.agentLabel });
+            }
+            return;
+        }
+        if (msg.type === 'session_start') {
+            const server = this.opts.registry.get(msg.serverId);
+            if (!server) {
+                this.send(conn, { type: 'done', requestId, exitCode: null, error: `unknown server: ${msg.serverId}` });
+                return;
+            }
+            const runId = randomUUID();
+            this.opts.logStore.start({ id: runId, serverId: server.id, agentLabel: msg.agentLabel, kind: 'session', command: null });
+            try {
+                const sessionId = await this.opts.sshManager.startSession(server, (chunk) => {
+                    this.opts.logStore.appendOutput(runId, chunk);
+                    const session = this.sessions.get(sessionId);
+                    if (session?.pendingConn && session.pendingRequestId) {
+                        this.send(session.pendingConn, { type: 'stream', requestId: session.pendingRequestId, stream: 'stdout', chunk });
+                        this.opts.onBroadcast?.({ type: 'stream', requestId: session.pendingRequestId, stream: 'stdout', chunk, serverId: server.id, agentLabel: msg.agentLabel });
+                        if (session.idleTimer)
+                            clearTimeout(session.idleTimer);
+                        session.idleTimer = setTimeout(() => this.finalizePendingSend(sessionId), 300);
+                    }
+                });
+                this.sessions.set(sessionId, {
+                    serverId: server.id, agentLabel: msg.agentLabel, runId,
+                    pendingConn: null, pendingRequestId: null, idleTimer: null,
+                    sessionTimeoutTimer: this.scheduleSessionTimeout(sessionId),
+                });
+                this.send(conn, { type: 'session_started', requestId, sessionId });
+            }
+            catch (err) {
+                this.opts.logStore.finish(runId, null);
+                this.send(conn, { type: 'done', requestId, exitCode: null, error: sanitizeSshError(err) });
+            }
+            return;
+        }
+        if (msg.type === 'session_send') {
+            const session = this.sessions.get(msg.sessionId);
+            if (!session) {
+                this.send(conn, { type: 'done', requestId, exitCode: null, error: `unknown session: ${msg.sessionId}` });
+                return;
+            }
+            session.pendingConn = conn;
+            session.pendingRequestId = requestId;
+            clearTimeout(session.sessionTimeoutTimer);
+            session.sessionTimeoutTimer = this.scheduleSessionTimeout(msg.sessionId);
+            this.opts.sshManager.sendToSession(msg.sessionId, msg.command);
+            if (session.idleTimer)
+                clearTimeout(session.idleTimer);
+            session.idleTimer = setTimeout(() => this.finalizePendingSend(msg.sessionId), 300);
+            return;
+        }
+        if (msg.type === 'session_stop') {
+            const session = this.sessions.get(msg.sessionId);
+            if (!session) {
+                this.send(conn, { type: 'done', requestId, exitCode: null, error: `unknown session: ${msg.sessionId}` });
+                return;
+            }
+            clearTimeout(session.sessionTimeoutTimer);
+            if (session.idleTimer)
+                clearTimeout(session.idleTimer);
+            this.finalizePendingSend(msg.sessionId);
+            this.opts.sshManager.stopSession(msg.sessionId);
+            this.opts.logStore.finish(session.runId, null);
+            this.sessions.delete(msg.sessionId);
+            this.send(conn, { type: 'done', requestId, exitCode: null });
+            return;
+        }
+        this.send(conn, { type: 'done', requestId, exitCode: null, error: `unsupported request type: ${msg.type}` });
+    }
+    scheduleSessionTimeout(sessionId) {
+        return setTimeout(() => {
+            const session = this.sessions.get(sessionId);
+            if (!session)
+                return;
+            if (session.idleTimer)
+                clearTimeout(session.idleTimer);
+            this.finalizePendingSend(sessionId);
+            this.opts.sshManager.stopSession(sessionId);
+            this.opts.logStore.finish(session.runId, null);
+            this.sessions.delete(sessionId);
+        }, SocketServer.SESSION_IDLE_TIMEOUT_MS);
+    }
+    finalizePendingSend(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session?.pendingConn || !session.pendingRequestId)
+            return;
+        this.send(session.pendingConn, { type: 'done', requestId: session.pendingRequestId, exitCode: null });
+        // Mirrored to the dashboard so the send's live row settles instead of
+        // streaming indefinitely.
+        this.opts.onBroadcast?.({
+            type: 'done', requestId: session.pendingRequestId, exitCode: null,
+            serverId: session.serverId, agentLabel: session.agentLabel,
+        });
+        session.pendingConn = null;
+        session.pendingRequestId = null;
+        session.idleTimer = null;
+    }
+    send(conn, event) {
+        conn.write(encodeMessage(event));
+    }
+}