@platless/axom-cli 0.1.0

package/dist/workstation/channels/agent.js

@@ -0,0 +1,96 @@
+import { createHash } from 'node:crypto';
+import { connectEncryptedChannel } from '../connection/encryptedChannel.js';
+import { AGENT_WIRE_MIN_VERSION, AGENT_WIRE_RESUME_OFFER_VERSION, AGENT_WIRE_VERSION, decodeAgentFrame, encodeAgentFrame, outboundAgentFrameRejection, } from '../protocol/agent.js';
+import { bridgesForWire } from '../protocol/common.js';
+import { workstationChannelUrl } from './url.js';
+/** Binds daemon-scoped sessions only to the encrypted agent channel's sender. */
+export class AgentChannel {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async connect(ticket, signal) {
+        // Validate transport before ticket KDF work: an insecure endpoint must not even receive access
+        // to material that could become the channel encryption key.
+        const url = workstationChannelUrl(this.options.server, 'agent', this.options.allowInsecureWs);
+        const key = (this.options.deriveTicketKey ?? ((value) => createHash('sha256').update(value).digest()))(ticket);
+        const channel = await connectEncryptedChannel({
+            url, sessionKey: key,
+            encode: encodeAgentFrame, decode: decodeAgentFrame,
+            heartbeat: (seq, sentAtEpochMs) => agentHeartbeat(seq, sentAtEpochMs, this.options.agents),
+            isHeartbeatAck: (frame, seq) => frame.t === 'heartbeat_ack' && frame.seq === seq,
+            signal,
+            handshake: async (wire) => { wire.sendText(encodeAgentFrame(buildAgentHelloFrame(ticket, this.options.bridges))); return key; },
+        });
+        // Hoisted rather than inlined twice: `closeAll` compares it by identity to decide whether the
+        // binding it is being asked to drop is still this connection's. See AgentSessionManager.closeAll.
+        const send = (frame) => channel.send(frame);
+        void dispatchAgentChannelFrames(channel.messages, send, this.options.agents, () => channel.close());
+        void channel.closed.then(() => this.options.agents.closeAll(send));
+        return { closed: channel.closed, close: () => channel.close() };
+    }
+}
+/**
+ * One heartbeat, carrying this daemon's session inventory when there is one and the server can read
+ * it.
+ *
+ * **The inventory is dropped rather than sent unvalidated.** Every other outbound agent frame goes
+ * through `AgentSessionManager.emit`, which round-trips it through this side's own decoder before it
+ * reaches the socket; the heartbeat does not — it is produced inside the encrypted channel's
+ * liveness timer and sent directly. A malformed inventory would therefore reach the server as an
+ * undecodable frame, and the server's recovery classifies a frame with no top-level `sessionRef` as
+ * unattributable and counts it: eight in a row and it closes the channel. Trading liveness for an
+ * optional diagnostic would be a bad bargain, so the check runs here and a rejected inventory
+ * degrades to the bare heartbeat this client has always sent — loudly, because a rejection means a
+ * seq allocator produced something that is not a whole number, and that is worth finding.
+ */
+export function agentHeartbeat(seq, sentAtEpochMs, agents) {
+    const bare = { t: 'heartbeat', seq, sentAtEpochMs };
+    const sessions = agents.heartbeatInventory();
+    if (sessions === undefined)
+        return bare;
+    const withInventory = { t: 'heartbeat', seq, sentAtEpochMs, sessions };
+    const rejection = outboundAgentFrameRejection(withInventory);
+    if (!rejection)
+        return withInventory;
+    console.error(`[agent] heartbeat inventory dropped, sending liveness only: ${rejection}`);
+    return bare;
+}
+/** Exported so the roster this hello carries can be asserted without opening a socket. */
+export function buildAgentHelloFrame(ticket, bridges) {
+    return { t: 'agent_hello', ticket, bridges: bridgesForWire(bridges(), 'agent_hello') };
+}
+/** Negotiates one agent connection and emits exactly one reconnect offer when the server supports it. */
+export async function dispatchAgentChannelFrames(messages, send, agents, close = () => { }) {
+    let offered = false;
+    try {
+        for await (const frame of messages) {
+            if (frame.t === 'agent_ready') {
+                if (frame.agentWire < AGENT_WIRE_MIN_VERSION) {
+                    close();
+                    return;
+                }
+                const negotiated = Math.min(frame.agentWire, AGENT_WIRE_VERSION);
+                agents.bindSend(send, negotiated);
+                if (!offered && negotiated >= AGENT_WIRE_RESUME_OFFER_VERSION) {
+                    offered = true;
+                    send({ t: 'agent_resume_offer', sessions: await agents.resumeOfferSessions() });
+                }
+                continue;
+            }
+            await dispatchAgentFrame(agents, frame);
+        }
+    }
+    catch (error) {
+        console.error(`[agent] channel dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+        close();
+    }
+}
+export async function dispatchAgentFrame(agents, frame) {
+    try {
+        await agents.handleFrame(frame);
+    }
+    catch (error) {
+        console.error(`[agent] handling ${frame.t} failed: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
+    }
+}

package/dist/workstation/channels/computer.js

@@ -0,0 +1,91 @@
+import { createHash } from 'node:crypto';
+import { connectEncryptedChannel } from '../connection/encryptedChannel.js';
+import { runExec } from '../exec.js';
+import { decodeComputerFrame, encodeComputerFrame } from '../protocol/computer.js';
+import { workstationChannelUrl } from './url.js';
+import { TaskRegistry } from '../update/taskRegistry.js';
+/**
+ * Consumes computer frames without serializing long-running commands behind one another.
+ * All command failures and post-close sends are contained here because this is called detached
+ * from the socket connection loop.
+ */
+export async function dispatchComputerFrames(messages, send, execute, tasks = new TaskRegistry()) {
+    const active = new Map();
+    const safeSend = (frame) => { try {
+        send(frame);
+    }
+    catch { /* socket already closed */ } };
+    const run = (request) => {
+        if (!tasks.accepting) {
+            safeSend({ t: 'exec_exit', id: request.id, exitCode: null, stdout: '', stderr: 'Workstation is not accepting new work', timedOut: false, truncated: false });
+            return;
+        }
+        const controller = new AbortController();
+        // A duplicate id cannot own two processes: replacing it first ensures cancel is correlated to
+        // the most recently accepted request while the older promise still cleans up its own entry.
+        active.get(request.id)?.abort();
+        active.set(request.id, controller);
+        void (async () => {
+            try {
+                const exit = await tasks.withShellTask(async (shutdown) => {
+                    const onShutdown = () => controller.abort();
+                    if (shutdown.aborted)
+                        controller.abort();
+                    else
+                        shutdown.addEventListener('abort', onShutdown, { once: true });
+                    try {
+                        return await execute(request, request.streaming ? (stream, chunk) => safeSend({ t: 'exec_output', id: request.id, stream, chunk }) : undefined, controller.signal);
+                    }
+                    finally {
+                        shutdown.removeEventListener('abort', onShutdown);
+                    }
+                });
+                safeSend(exit);
+            }
+            catch (error) {
+                safeSend({ t: 'exec_exit', id: request.id, exitCode: null, stdout: '', stderr: error instanceof Error ? error.message : String(error), timedOut: false, truncated: false });
+            }
+            finally {
+                if (active.get(request.id) === controller)
+                    active.delete(request.id);
+            }
+        })();
+    };
+    try {
+        for await (const frame of messages) {
+            if (frame.t === 'exec_request')
+                run(frame);
+            else if (frame.t === 'exec_cancel')
+                active.get(frame.id)?.abort();
+        }
+    }
+    finally {
+        for (const controller of active.values())
+            controller.abort();
+    }
+}
+/** Owns only computer-use dispatch; it never sees management or agent frames. */
+export class ComputerChannel {
+    options;
+    tasks;
+    constructor(options) {
+        this.options = options;
+        this.tasks = options.taskRegistry ?? new TaskRegistry();
+    }
+    activeTaskCount() { return this.tasks.snapshot().activeShellTasks; }
+    async connect(ticket, signal) {
+        const channel = await connectEncryptedChannel({
+            url: workstationChannelUrl(this.options.server, 'computer', this.options.allowInsecureWs), sessionKey: createHash('sha256').update(ticket).digest(),
+            encode: encodeComputerFrame, decode: decodeComputerFrame,
+            heartbeat: (seq, sentAtEpochMs) => ({ t: 'heartbeat', seq, sentAtEpochMs }),
+            isHeartbeatAck: (frame, seq) => frame.t === 'heartbeat_ack' && frame.seq === seq,
+            signal,
+            handshake: async (wire) => { wire.sendText(encodeComputerFrame({ t: 'computer_hello', ticket })); return createHash('sha256').update(ticket).digest(); },
+        });
+        void this.dispatch(channel);
+        return { closed: channel.closed, close: () => channel.close() };
+    }
+    async dispatch(channel) {
+        await dispatchComputerFrames(channel.messages, (frame) => channel.send(frame), this.options.runExec ?? runExec, this.tasks);
+    }
+}

package/dist/workstation/channels/management.js

@@ -0,0 +1,231 @@
+import { deriveSessionKey, randomBytes } from '../crypto.js';
+import { connectEncryptedChannel } from '../connection/encryptedChannel.js';
+import { CLIENT_PACKAGE_NAME, CLIENT_VERSION } from '../version.js';
+import { decodeManagementFrame, encodeManagementFrame, MANAGEMENT_WIRE_DRAINING_VERSION, MANAGEMENT_WIRE_LOAD_AVERAGES_VERSION, MANAGEMENT_WIRE_METRICS_VERSION, MANAGEMENT_WIRE_MIN_VERSION, MANAGEMENT_WIRE_PRESSURE_VERSION, MANAGEMENT_WIRE_VERSION, } from '../protocol/management.js';
+import { bridgesForWire } from '../protocol/common.js';
+import { AGENT_WIRE_MIN_VERSION, AGENT_WIRE_VERSION } from '../protocol/agent.js';
+import { osInfo } from '../osinfo.js';
+import { workstationChannelUrl } from './url.js';
+const protocols = {
+    MANAGEMENT: { min: MANAGEMENT_WIRE_MIN_VERSION, max: MANAGEMENT_WIRE_VERSION },
+    COMPUTER: { min: 1, max: 1 }, AGENT: { min: AGENT_WIRE_MIN_VERSION, max: AGENT_WIRE_VERSION },
+};
+/** Exported so tests can assert the wire frame's `clientPackage` without opening a socket. */
+export function buildHelloFrame(options, clientNonce) {
+    return {
+        t: 'management_hello', workstationId: options.workstationId, workstation: options.workstation,
+        clientNonce, clientVersion: CLIENT_VERSION, protocols, bridges: helloBridges(options.bridges),
+        clientPackage: CLIENT_PACKAGE_NAME,
+    };
+}
+/**
+ * The roster this hello may carry. Nothing an agent advertises is allowed to cost the handshake —
+ * see {@link bridgesForWire} for why that is not a theoretical concern.
+ */
+function helloBridges(bridges) {
+    const roster = bridges?.();
+    return roster === undefined ? undefined : bridgesForWire(roster, 'management_hello');
+}
+/** Exported so the roster this answer carries can be asserted without driving a whole channel. */
+export function buildScanResultFrame(commandId, bridges) {
+    return {
+        t: 'external_agents_scan_result',
+        commandId,
+        bridges: bridgesForWire(bridges, 'external_agents_scan_result'),
+    };
+}
+/**
+ * A newly handled command inherits its Server-generated id. An already-running command keeps the
+ * id persisted from its original Server frame, so a Server restart cannot misattribute progress.
+ */
+export function toClientUpdateStatusFrame(command, status, serverManagementWire) {
+    const compatible = statusForManagementWire(status, serverManagementWire);
+    return { t: 'client_update_status', status: { ...compatible, commandId: compatible.commandId ?? command.commandId } };
+}
+/**
+ * Keeps the new persisted/current-client `DRAINING` state off a peer until its negotiated
+ * management wire proves it understands that enum value. Before `management_ready` there is no
+ * negotiated version yet, so the proof heartbeat uses the same legacy-safe `REQUESTED` view.
+ */
+export function statusForManagementWire(status, serverManagementWire) {
+    if (status.phase === 'DRAINING' && (serverManagementWire ?? 0) < MANAGEMENT_WIRE_DRAINING_VERSION) {
+        return { ...status, phase: 'REQUESTED' };
+    }
+    return status;
+}
+export function metricsForManagementWire(metrics, serverManagementWire) {
+    if (!metrics)
+        return metrics;
+    const selectedWire = serverManagementWire ?? 0;
+    if (selectedWire >= MANAGEMENT_WIRE_LOAD_AVERAGES_VERSION) {
+        const { cpuLoadNormalized: _cpuLoadNormalized, ...rawLoad } = metrics;
+        return rawLoad;
+    }
+    const { cpuLoad1, cpuLoad5: _cpuLoad5, cpuLoad15: _cpuLoad15, cpuLogicalCount, cpuLoadNormalized: _cpuLoadNormalized, ...withoutLoad } = metrics;
+    if (selectedWire >= MANAGEMENT_WIRE_PRESSURE_VERSION) {
+        return {
+            ...withoutLoad,
+            cpuLoadNormalized: cpuLoad1 != null && cpuLogicalCount != null && cpuLogicalCount > 0
+                ? Math.max(0, Math.min(1, cpuLoad1 / cpuLogicalCount))
+                : null,
+        };
+    }
+    const { memoryPressure: _memoryPressure, ...legacy } = withoutLoad;
+    return legacy;
+}
+/**
+ * Runs one server update command and reports its final status back over [channel] — but only as a
+ * fast path, and only if the channel is still open to carry it.
+ *
+ * Deliberately detached from the frame loop that calls it: an update runs for minutes and on macOS
+ * ends by booting the daemon's own process out of launchd, so handling it inline stalled every
+ * ticket/scan frame behind it — and by the time the final status was ready the channel had usually
+ * closed, which turned the report into an unhandled "Encrypted channel is not open" rejection. The
+ * heartbeat's persisted update state is the authoritative report; nothing is lost when this send
+ * is skipped or fails.
+ *
+ * Exported for tests; production's only caller is `routeMessages`.
+ */
+export function dispatchUpdateCommand(channel, command, onUpdate, serverManagementWire) {
+    return onUpdate(command)
+        .then((status) => {
+        if (channel.state !== 'OPEN')
+            return;
+        try {
+            channel.send(toClientUpdateStatusFrame(command, status, serverManagementWire));
+        }
+        catch { /* the next heartbeat carries it */ }
+    })
+        .catch(() => { });
+}
+/**
+ * The server nonce to derive this session's key from.
+ *
+ * Hand-rolled rather than run through {@link decodeManagementFrame}: neither frame at this point
+ * has been encrypted yet, and neither is a member of the set that decoder guards.
+ */
+export function serverNonceFromChallenge(text) {
+    const decoded = JSON.parse(text);
+    if (!decoded || typeof decoded !== 'object')
+        throw new Error('Unexpected management nonce challenge');
+    const frame = decoded;
+    // The server names a fault in the hello this client just sent, then closes. Carrying its words
+    // through means the daemon log says what is wrong instead of "closed before opening", which is
+    // all a silent close could ever produce and is indistinguishable from an unreachable server.
+    if (frame.t === 'management_rejected' && typeof frame.reason === 'string') {
+        throw new Error(`Management server refused this workstation: ${frame.reason}`);
+    }
+    if (frame.t !== 'welcome' || typeof frame.serverNonce !== 'string') {
+        throw new Error('Unexpected management nonce challenge');
+    }
+    return Buffer.from(frame.serverNonce, 'base64');
+}
+/** Authenticates the management channel and serializes its ticket requests. */
+export class ManagementChannel {
+    options;
+    /** Undefined until this connection receives management_ready; reset for every reconnect. */
+    serverManagementWire;
+    constructor(options) {
+        this.options = options;
+    }
+    async connect(signal) {
+        this.serverManagementWire = undefined;
+        const nonce = randomBytes(16);
+        let initialHeartbeat = true;
+        const channel = await connectEncryptedChannel({
+            url: workstationChannelUrl(this.options.server, 'management', this.options.allowInsecureWs),
+            signal,
+            encode: encodeManagementFrame,
+            decode: decodeManagementFrame,
+            heartbeat: (seq, sentAtEpochMs) => this.heartbeat(seq, sentAtEpochMs),
+            initialFrame: () => {
+                initialHeartbeat = false;
+                return this.heartbeat(0, Date.now());
+            },
+            isHeartbeatAck: (frame, seq) => frame.t === 'heartbeat_ack' && frame.seq === seq,
+            handshake: async (wire) => {
+                wire.sendText(encodeManagementFrame(buildHelloFrame(this.options, nonce.toString('base64'))));
+                const welcome = await wire.receive();
+                if (welcome.isBinary)
+                    throw new Error('Management server did not send a nonce challenge');
+                return deriveSessionKey(this.options.clientKey, this.options.serverPub, nonce, serverNonceFromChallenge(welcome.data.toString()));
+            },
+        });
+        // `initialFrame` exists to satisfy the server's proof-of-key requirement before Ready. Kept as
+        // a runtime guard too, so a future encrypted-channel refactor cannot silently remove it.
+        if (initialHeartbeat)
+            throw new Error('Management proof heartbeat was not sent');
+        const ready = await this.nextReady(channel);
+        this.serverManagementWire = ready.protocols.MANAGEMENT;
+        // A readiness record is evidence from this encrypted, proof-of-key management generation — it
+        // is never driven by the local browser/device-authorization flow.
+        await this.options.onReady?.({ generation: ready.generation, release: ready.release });
+        const pending = new Map();
+        void this.routeMessages(channel, pending);
+        return {
+            generation: ready.generation,
+            closed: channel.closed,
+            close: () => channel.close(),
+            ticket: (kind) => new Promise((resolve, reject) => {
+                const queue = pending.get(kind) ?? [];
+                queue.push({ resolve, reject });
+                pending.set(kind, queue);
+                try {
+                    channel.send({ t: 'channel_ticket_request', channel: kind });
+                }
+                catch (error) {
+                    queue.pop();
+                    reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            }),
+        };
+    }
+    heartbeat(seq, sentAtEpochMs) {
+        const snapshot = this.options.snapshot();
+        return {
+            t: 'heartbeat', seq, sentAtEpochMs, clientVersion: CLIENT_VERSION,
+            channels: {
+                MANAGEMENT: snapshot.channels.management,
+                COMPUTER: snapshot.channels.computer,
+                AGENT: snapshot.channels.agent,
+            },
+            activeShellTasks: snapshot.activeShellTasks, activeAgentTasks: snapshot.activeAgentTasks,
+            protocols, os: osInfo(),
+            ...(this.options.metrics && (this.serverManagementWire ?? 0) >= MANAGEMENT_WIRE_METRICS_VERSION
+                ? { metrics: metricsForManagementWire(this.options.metrics(), this.serverManagementWire) }
+                : {}),
+            ...(snapshot.update ? { update: statusForManagementWire(snapshot.update, this.serverManagementWire) } : {}),
+        };
+    }
+    async nextReady(channel) {
+        for await (const frame of channel.messages)
+            if (frame.t === 'management_ready')
+                return frame;
+        throw new Error('Management channel closed before ready');
+    }
+    async routeMessages(channel, pending) {
+        try {
+            for await (const frame of channel.messages) {
+                if (frame.t === 'channel_ticket') {
+                    const queue = pending.get(frame.channel);
+                    queue?.shift()?.resolve(frame.ticket);
+                    continue;
+                }
+                if (frame.t === 'client_update' && this.options.onUpdate) {
+                    // Deliberately not awaited — see dispatchUpdateCommand for why inline handling both
+                    // stalled this loop for the whole update and threw the final status away.
+                    void dispatchUpdateCommand(channel, frame, this.options.onUpdate, this.serverManagementWire);
+                    continue;
+                }
+                if (frame.t === 'external_agents_scan' && this.options.onExternalAgentsScan) {
+                    channel.send(buildScanResultFrame(frame.commandId, await this.options.onExternalAgentsScan()));
+                }
+            }
+        }
+        finally {
+            for (const queue of pending.values())
+                for (const request of queue)
+                    request.reject(new Error('Management channel closed before ticket response'));
+        }
+    }
+}

package/dist/workstation/channels/url.js

@@ -0,0 +1,42 @@
+const TRUSTED_PLAINTEXT_NAMES = new Set([
+    'localhost',
+    'host.docker.internal',
+    'gateway.docker.internal',
+]);
+function ipv4Octets(hostname) {
+    const parts = hostname.split('.');
+    if (parts.length !== 4 || parts.some((part) => !/^\d{1,3}$/.test(part)))
+        return null;
+    const octets = parts.map(Number);
+    return octets.every((octet) => octet <= 255) ? octets : null;
+}
+/** Deliberately classifies literal names/IPs only: DNS answers must never downgrade transport security. */
+function isTrustedPlaintextHost(rawHostname) {
+    const hostname = rawHostname.toLowerCase().replace(/^\[|\]$/g, '');
+    if (TRUSTED_PLAINTEXT_NAMES.has(hostname) || hostname.endsWith('.localhost'))
+        return true;
+    if (hostname === '::1' || hostname.startsWith('fe80:'))
+        return true;
+    const octets = ipv4Octets(hostname);
+    if (octets === null)
+        return false;
+    const [first, second] = octets;
+    return first === 10
+        || first === 127
+        || first === 169 && second === 254
+        || first === 192 && second === 168
+        || first === 172 && second >= 16 && second <= 31;
+}
+/** Builds a workstation channel URL, requiring TLS except for explicitly trusted private-network endpoints. */
+export function workstationChannelUrl(server, channel, allowInsecureWs = false) {
+    const url = new URL(server);
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new Error('Workstation server URL must use HTTP or HTTPS');
+    }
+    if (url.protocol === 'http:' && !allowInsecureWs && !isTrustedPlaintextHost(url.hostname)) {
+        throw new Error('Insecure workstation WebSocket transport is disabled; use HTTPS/WSS');
+    }
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    url.pathname = `${url.pathname.replace(/\/$/, '')}/workstation/ws/${channel}`;
+    return url;
+}

package/dist/workstation/config.js

@@ -0,0 +1,47 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import yaml from 'js-yaml';
+export function updateServiceContext(configDir = clientDir(), overrides = {}) {
+    // config.ts lives in dist/workstation/ after packaging, so two levels up is the installed package root.
+    const packageRoot = overrides.packageRoot ?? path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+    const nodePath = overrides.nodePath ?? process.execPath;
+    return {
+        configDir,
+        platform: overrides.platform ?? (process.platform === 'darwin' ? 'darwin' : 'linux'),
+        nodePath,
+        npmPath: overrides.npmPath ?? process.env.AXOM_WORKSTATION_NPM_PATH ?? path.join(path.dirname(nodePath), 'npm'),
+        // packageRoot is under lib/node_modules/@platless; climb to npm's global prefix.
+        npmPrefix: overrides.npmPrefix ?? process.env.AXOM_WORKSTATION_NPM_PREFIX ?? path.resolve(packageRoot, '../../../..'),
+        packageRoot,
+    };
+}
+/** Global per-machine client directory: ~/.axom/workstation */
+export function clientDir() {
+    // User services render the current user's config directory explicitly. Respect it so a
+    // service manager with a different HOME never creates a second workstation identity.
+    return process.env.AXOM_WORKSTATION_CONFIG_DIR ?? path.join(os.homedir(), '.axom', 'workstation');
+}
+export async function saveClientConfig(dir, cfg) {
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(path.join(dir, 'config.yml'), yaml.dump(cfg), { mode: 0o600 });
+}
+export async function loadClientConfig(dir) {
+    const raw = await fs.readFile(path.join(dir, 'config.yml'), 'utf8');
+    const parsed = yaml.load(raw);
+    if (!parsed?.server || !parsed.workstationId) {
+        throw new Error('Invalid workstation config: server and workstationId are required; run axom auth again');
+    }
+    return { server: parsed.server, workstationId: parsed.workstationId, ...(Array.isArray(parsed.workspaces) ? { workspaces: parsed.workspaces } : {}) };
+}
+export async function writeKeys(dir, clientKeyB64, serverPubB64) {
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(path.join(dir, 'client.key'), clientKeyB64, { mode: 0o600 });
+    await fs.writeFile(path.join(dir, 'server.pub'), serverPubB64);
+}
+export async function readKeys(dir) {
+    const clientKey = Buffer.from((await fs.readFile(path.join(dir, 'client.key'), 'utf8')).trim(), 'base64');
+    const serverPub = Buffer.from((await fs.readFile(path.join(dir, 'server.pub'), 'utf8')).trim(), 'base64');
+    return { clientKey, serverPub };
+}