baychat 0.27.1 → 0.29.0

package/dist/channel/permission.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionRelay = exports.RELAY_OPTIONS = void 0;
+exports.composeRelayQuestion = composeRelayQuestion;
+/** Button labels, and the ONLY index that means yes. Same as `baychat approve-hook`. */
+exports.RELAY_OPTIONS = ["Allow this once", "Deny"];
+const ALLOW_INDEX = 0;
+/** One window of the server's wait; it answers "waiting" when nobody tapped yet. */
+const POLL_WAIT_SECONDS = 25;
+const MAX_CONSECUTIVE_FAILURES = 5;
+const RETRY_DELAY_MS = 3_000;
+const QUESTION_MAX = 2_000;
+const PREVIEW_MAX = 1_200;
+function clip(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+/** What the person on the phone reads. They decide from this text alone. */
+function composeRelayQuestion(req, host, session) {
+    const lines = [
+        `Claude Code (session "${session}" on ${host}) asks to use ${req.tool_name}: ${req.description}`,
+        "",
+        req.input_preview ? clip(req.input_preview, PREVIEW_MAX) : "",
+        "",
+        "The same question is open in the terminal; whichever answer comes first counts. " +
+            "Allowing runs it on that machine, now. If you did not expect this, deny.",
+    ];
+    return clip(lines.join("\n").replace(/\n{3,}/g, "\n\n").trim(), QUESTION_MAX);
+}
+class PermissionRelay {
+    deps;
+    current;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** Relay one dialog. Resolves when it is settled, superseded, or given up on. Never throws. */
+    async onRequest(req) {
+        await this.retire();
+        const target = this.deps.target();
+        if (!target)
+            return; // Nobody is listening through this channel: the terminal alone decides.
+        const pending = { claudeId: req.request_id, login: target.login, retired: false };
+        this.current = pending;
+        try {
+            let reply = await this.deps.api(target.login, "POST", "/api/device-api/approvals", {
+                session: target.session,
+                question: composeRelayQuestion(req, this.deps.host(), target.session),
+                options: [...exports.RELAY_OPTIONS],
+                // The private chat with the owner: a session is usually in a group too, and a prompt about
+                // one person's machine belongs to that person, not to the room.
+                direct: true,
+                wait: 1,
+            });
+            pending.cardId = typeof reply.requestId === "string" && reply.requestId ? reply.requestId : undefined;
+            if (!pending.cardId) {
+                this.deps.log("permission relay: BayChat returned no card id");
+                return;
+            }
+            let failures = 0;
+            for (;;) {
+                if (pending.retired) {
+                    await this.withdraw(pending);
+                    return;
+                }
+                if (reply.status === "answered") {
+                    await this.deps.verdict(req.request_id, reply.answerIndex === ALLOW_INDEX ? "allow" : "deny");
+                    return;
+                }
+                if (reply.status !== "waiting")
+                    return; // cancelled, or a status we do not know: no verdict.
+                try {
+                    reply = await this.deps.api(pending.login, "GET", `/api/device-api/approvals/${encodeURIComponent(pending.cardId)}?wait=${POLL_WAIT_SECONDS}`);
+                    failures = 0;
+                }
+                catch (err) {
+                    failures++;
+                    this.deps.log(`permission relay: waiting failed (${err instanceof Error ? err.message : String(err)}), attempt ${failures}`);
+                    if (failures >= MAX_CONSECUTIVE_FAILURES) {
+                        // Give the decision back to the terminal alone, and take the card off the phone.
+                        await this.withdraw(pending);
+                        return;
+                    }
+                    await (this.deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))))(RETRY_DELAY_MS);
+                }
+            }
+        }
+        catch (err) {
+            this.deps.log(`permission relay: could not ask BayChat (${err instanceof Error ? err.message : String(err)}); the terminal still decides`);
+        }
+        finally {
+            if (this.current === pending)
+                this.current = undefined;
+        }
+    }
+    /** The current dialog is over (a newer one opened, or shutdown): stop and withdraw its card. */
+    async retire() {
+        const pending = this.current;
+        if (!pending)
+            return;
+        pending.retired = true;
+        this.current = undefined;
+        await this.withdraw(pending);
+    }
+    async withdraw(pending) {
+        if (!pending.cardId)
+            return; // Not created yet: the create path sees `retired` and withdraws.
+        const cardId = pending.cardId;
+        pending.cardId = undefined;
+        try {
+            await this.deps.api(pending.login, "POST", `/api/device-api/approvals/${encodeURIComponent(cardId)}/withdraw`, {});
+        }
+        catch (err) {
+            // An older server (no route) or a blip: the card stays up, and a tap on it is dropped by
+            // Claude Code as an unknown id. Untidy, never unsafe.
+            this.deps.log(`permission relay: could not withdraw card ${cardId} (${err instanceof Error ? err.message : String(err)})`);
+        }
+    }
+}
+exports.PermissionRelay = PermissionRelay;

package/dist/channel/plugin.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_MARKETPLACE_NAME = exports.PLUGIN_MARKETPLACE_URL = void 0;
+exports.realPluginFiles = realPluginFiles;
+exports.claudeUserSettingsPath = claudeUserSettingsPath;
+exports.pluginEnabled = pluginEnabled;
+exports.baychatMarketplace = baychatMarketplace;
+exports.installedPlugin = installedPlugin;
+exports.pluginChannelReady = pluginChannelReady;
+exports.installPluginWithClaude = installPluginWithClaude;
+/**
+ * BayChat as a Claude Code plugin: installing it, and reading what Claude Code actually installed.
+ *
+ * The plugin is the `baychat` npm package itself (`.claude-plugin/plugin.json` declares the
+ * channel), listed in a catalog served at baychat.io. `launch.ts` decides how a session is started
+ * with whichever form of the channel is installed; this file owns the plugin form.
+ *
+ * SUCCESS IS READ FROM WHAT IS INSTALLED, NEVER FROM EXIT CODES. `claude plugin marketplace add`
+ * and `claude plugin install` both answer "already" for ANY marketplace or plugin of that name.
+ * Computers set up with BayChat before the channel existed carry a marketplace that is ALSO named
+ * `baychat` — GitHub `SeaQuestdev/baychat-plugins`, whose `baychat` plugin is skill-only (no
+ * `mcpServers`, no `channels`). On those both steps said "already", connect removed the
+ * hand-registered `baychat_channel`, and the channel existed nowhere while setup reported success
+ * (2026-10-03, a laptop upgraded from 0.24.0 to 0.28.0). So the installed plugin's own manifest is
+ * the evidence, here and in `doctor`.
+ *
+ * Every reader takes `PluginFiles`, so the decisions are testable against any machine's files.
+ * Claude Code's file layout is not a published contract: anything unreadable or unexpected reads
+ * as "not installed", which sends the installer to its safe fallback (the hand-registered server).
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const detect_1 = require("./detect");
+/** Where `claude plugin marketplace add` finds BayChat's plugin catalog (served by the web app). */
+exports.PLUGIN_MARKETPLACE_URL = "https://baychat.io/claude/marketplace.json";
+/** The catalog's name, the part of `PLUGIN_ID` after the `@`. */
+exports.PLUGIN_MARKETPLACE_NAME = detect_1.PLUGIN_ID.slice(detect_1.PLUGIN_ID.indexOf("@") + 1);
+function realPluginFiles(home = os.homedir()) {
+    return {
+        home,
+        read: (file) => {
+            try {
+                return fs.readFileSync(file, "utf8");
+            }
+            catch {
+                return null; // Absent or unreadable: the readers below turn that into "not installed".
+            }
+        },
+    };
+}
+/** Claude Code's user settings, where installed plugins are switched on. */
+function claudeUserSettingsPath(home = os.homedir()) {
+    return path.join(home, ".claude", "settings.json");
+}
+/** Is BayChat's plugin installed and switched on for this user? Unreadable counts as no. */
+function pluginEnabled(files = realPluginFiles()) {
+    const settings = readJson(files, claudeUserSettingsPath(files.home));
+    return settings?.enabledPlugins?.[detect_1.PLUGIN_ID] === true;
+}
+/** Read from `~/.claude/plugins/known_marketplaces.json`. Unreadable counts as absent. */
+function baychatMarketplace(files) {
+    const known = readJson(files, path.join(pluginsDir(files.home), "known_marketplaces.json"));
+    const source = known?.[exports.PLUGIN_MARKETPLACE_NAME]?.source;
+    if (!source || typeof source !== "object")
+        return { kind: "absent" };
+    if (source.source === "url" && source.url === exports.PLUGIN_MARKETPLACE_URL)
+        return { kind: "ours" };
+    const where = [source.repo, source.url, source.path].find((v) => typeof v === "string");
+    return { kind: "foreign", source: [source.source, where].filter((v) => typeof v === "string").join(" ") || "unknown source" };
+}
+/**
+ * Read `installed_plugins.json` (the user-scope entry; `connect` installs at user scope), then that
+ * install's `.claude-plugin/plugin.json`. Only a manifest with a non-empty `channels` counts.
+ */
+function installedPlugin(files) {
+    const record = readJson(files, path.join(pluginsDir(files.home), "installed_plugins.json"));
+    const entries = record?.plugins?.[detect_1.PLUGIN_ID];
+    // Version 2 of the file keeps a list per plugin (one per scope); version 1 kept one object.
+    const list = (Array.isArray(entries) ? entries : entries ? [entries] : []);
+    const entry = list.find((e) => e?.scope === "user") ?? list.find((e) => e?.scope === undefined);
+    if (!entry || typeof entry.installPath !== "string")
+        return { state: "absent" };
+    const version = typeof entry.version === "string" ? entry.version : "unknown";
+    const manifestPath = path.join(entry.installPath, ".claude-plugin", "plugin.json");
+    const manifest = readJson(files, manifestPath);
+    if (!manifest)
+        return { state: "no-channel", version, why: `its manifest (${manifestPath}) could not be read` };
+    if (!Array.isArray(manifest.channels) || manifest.channels.length === 0) {
+        return { state: "no-channel", version, why: "its manifest declares no channel" };
+    }
+    return { state: "channel", version };
+}
+/** The one condition under which the plugin delivers the channel: switched on, and declaring it. */
+function pluginChannelReady(files) {
+    return pluginEnabled(files) && installedPlugin(files).state === "channel";
+}
+/**
+ * Install BayChat as a Claude Code plugin, and say whether the channel is now there.
+ *
+ * 1. A `baychat` marketplace from anywhere but baychat.io is removed first — otherwise "add"
+ *    answers "already" and the old catalog stays.
+ * 2. Add the catalog from baychat.io and install from it (the plugin is fetched from the `baychat`
+ *    npm package).
+ * 3. Read what is installed. "Already installed" can be a plugin from before — the old skill-only
+ *    one, or one switched off — so a plugin without the channel is reinstalled once.
+ * 4. Only then remove the hand-registered server, which would otherwise hide the plugin's.
+ *
+ * True ONLY when the installed plugin is switched on and declares the channel. False at the first
+ * step that fails, with the hand-registered server untouched — the caller then registers it by
+ * hand, and a session started with both named keeps working either way.
+ */
+function installPluginWithClaude(run, files = realPluginFiles()) {
+    if (baychatMarketplace(files).kind === "foreign") {
+        if (run(["plugin", "marketplace", "remove", exports.PLUGIN_MARKETPLACE_NAME]).status !== 0)
+            return false;
+    }
+    const added = run(["plugin", "marketplace", "add", exports.PLUGIN_MARKETPLACE_URL]);
+    if (added.status !== 0 && !/already/i.test(added.stderr))
+        return false;
+    if (!installFromCatalog(run))
+        return false;
+    if (!pluginChannelReady(files)) {
+        run(["plugin", "uninstall", detect_1.PLUGIN_ID]); // Absent is fine: the install below decides.
+        if (!installFromCatalog(run) || !pluginChannelReady(files))
+            return false;
+    }
+    run(["mcp", "remove", "--scope", "user", detect_1.CHANNEL_MCP_ENTRY]); // Absent is fine.
+    return true;
+}
+function installFromCatalog(run) {
+    const installed = run(["plugin", "install", detect_1.PLUGIN_ID]);
+    return installed.status === 0 || /already installed/i.test(installed.stderr);
+}
+function pluginsDir(home) {
+    return path.join(home, ".claude", "plugins");
+}
+/** Parsed JSON, or undefined when the file is absent, unreadable or not JSON. */
+function readJson(files, file) {
+    const text = files.read(file);
+    if (text === null)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/channel/relay-link.js

@@ -0,0 +1,257 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelayLink = void 0;
+exports.describeCommandReach = describeCommandReach;
+/**
+ * The channel's link to this computer's relay: how a channel session's `/clear` gets typed.
+ *
+ * ── WHY A CHANNEL SESSION NEEDS THE RELAY AT ALL ──────────────────────────────────────
+ *
+ * The channel delivers messages, but a `<channel>` event is a PROMPT: Claude Code never reads a
+ * slash command out of one. `/clear`, `/new`, `/compact` and the fresh start's clear work only
+ * when something TYPES them into the session's terminal, and the relay is what does that
+ * (relay/terminal-pane.ts). So after `listen` goes active, the channel server registers its
+ * session with the relay — for commands only (relay/channel-sessions.ts): the relay never wakes
+ * it, and drops its chat, because the channel already delivered it.
+ *
+ * ── WHAT IT SENDS, AND WHY IT IS READ HERE ────────────────────────────────────────────
+ *
+ * The pane (`$TMUX`/`$TMUX_PANE`, or screen's `$STY`/`$WINDOW`) and the Claude Code process.
+ * Both are read in THIS process, which Claude Code started and whose environment it inherited —
+ * the same rule `relay attach` follows: the process inside the session answers, the relay never
+ * guesses where to send keystrokes.
+ *
+ * ── WHY THE SOCKET STAYS OPEN ─────────────────────────────────────────────────────────
+ *
+ * Its close tells the relay the session is gone (Claude Code exiting closes this process's
+ * stdin, and the process exits), so a pane a later shell occupies is never typed into on this
+ * registration's word. And it carries the fresh start's note request back (`handoff-note`). A
+ * relay that is not running, or restarts, is retried with backoff for as long as the channel
+ * lives; `onChange` says when the relay starts or stops running this session's commands.
+ */
+const net = __importStar(require("node:net"));
+const socket_1 = require("../relay/socket");
+const channel_sessions_1 = require("../relay/channel-sessions");
+const feed_1 = require("./feed");
+/** How long `start` waits for the first answer before reporting "still connecting". */
+const FIRST_ANSWER_MS = 3_000;
+/** A note request is BayChat's own short instruction; anything longer is not one. */
+const MAX_NOTE_CHARS = 4_000;
+class RelayLink {
+    opts;
+    current = { kind: "connecting" };
+    socket;
+    attempt = 0;
+    retryTimer;
+    settleFirst;
+    setTimer;
+    clearTimer;
+    constructor(opts) {
+        this.opts = opts;
+        this.setTimer =
+            opts.setTimer ??
+                ((fn, ms) => {
+                    const t = setTimeout(fn, ms);
+                    // The stdio transport keeps the process alive; a retry timer must not on its own.
+                    t.unref?.();
+                    return t;
+                });
+        this.clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
+    }
+    get state() {
+        return this.current;
+    }
+    get registered() {
+        return this.current.kind === "registered";
+    }
+    /** The `listen` answer's line on whether commands from the Bay reach this session. */
+    describeReach() {
+        return describeCommandReach(this.current, this.opts.pane);
+    }
+    /**
+     * Connect and register, resolving with the first answer (or "connecting" after a short wait,
+     * so a wedged relay never holds up `listen`). Never throws: no relay is an ordinary state.
+     */
+    start(firstAnswerMs = FIRST_ANSWER_MS) {
+        return new Promise((resolve) => {
+            const timer = this.setTimer(() => this.settle(), firstAnswerMs);
+            this.settleFirst = () => {
+                this.settleFirst = undefined;
+                this.clearTimer(timer);
+                resolve(this.current);
+            };
+            this.connect();
+        });
+    }
+    /** Stop for good: the relay sees the socket close and stops running this session's commands. */
+    close() {
+        const was = this.registered;
+        this.current = { kind: "closed" };
+        if (this.retryTimer !== undefined)
+            this.clearTimer(this.retryTimer);
+        this.retryTimer = undefined;
+        const socket = this.socket;
+        this.socket = undefined;
+        socket?.destroy();
+        this.settle();
+        if (was)
+            this.opts.onChange?.(false);
+    }
+    settle() {
+        this.settleFirst?.();
+    }
+    connect() {
+        if (this.finished())
+            return;
+        let socket;
+        try {
+            socket = (this.opts.connect ?? ((p) => net.createConnection(p)))(this.opts.socketPath);
+        }
+        catch (err) {
+            this.lost(errText(err));
+            return;
+        }
+        this.socket = socket;
+        const mine = () => this.socket === socket && !this.finished();
+        socket.on("connect", () => {
+            if (!mine())
+                return;
+            const frame = {
+                type: "channel-register",
+                session: this.opts.session,
+                runtime: "claude",
+                ...(this.opts.pane ? { pane: this.opts.pane } : {}),
+                ...(this.opts.ownerPid !== undefined ? { ownerPid: this.opts.ownerPid } : {}),
+            };
+            (0, socket_1.writeFrame)(socket, frame);
+        });
+        socket.on("data", (0, socket_1.createFrameReader)((frame) => {
+            if (!mine())
+                return;
+            this.onFrame(frame);
+        }));
+        // `error` is followed by `close`; the reason is kept for the state the close reports.
+        let failure;
+        socket.on("error", (err) => {
+            failure = describeConnectError(err);
+        });
+        socket.on("close", () => {
+            if (!mine())
+                return;
+            this.socket = undefined;
+            this.lost(failure ?? "the relay closed the connection");
+        });
+    }
+    onFrame(frame) {
+        if (frame.type === "attached" && frame.delivery === "channel") {
+            this.attempt = 0;
+            this.current = { kind: "registered" };
+            this.opts.log?.(`relay runs the commands of session "${this.opts.session}"`);
+            this.settle();
+            this.opts.onChange?.(true);
+            return;
+        }
+        if (frame.type === "handoff-note") {
+            if (typeof frame.handoffId !== "string" || typeof frame.content !== "string" || frame.content.length > MAX_NOTE_CHARS)
+                return;
+            this.opts.onHandoffNote({ conversationId: frame.conversationId, handoffId: frame.handoffId, content: frame.content });
+            return;
+        }
+        if (frame.type === "error") {
+            // A refusal is the relay's considered answer (a relay-run session of that name, or a
+            // newer channel for it): retrying would only fight it.
+            const was = this.registered;
+            this.current = { kind: "refused", reason: frame.message === channel_sessions_1.CHANNEL_REPLACED ? channel_sessions_1.CHANNEL_REPLACED : `the relay refused it: ${frame.message}` };
+            const socket = this.socket;
+            this.socket = undefined;
+            socket?.destroy();
+            this.opts.log?.(`relay link for "${this.opts.session}" ended: ${this.current.reason}`);
+            this.settle();
+            if (was)
+                this.opts.onChange?.(false);
+        }
+    }
+    /** The connection failed or dropped: say so, and try again later. */
+    lost(reason) {
+        if (this.finished())
+            return;
+        const was = this.registered;
+        this.current = { kind: "waiting", reason };
+        this.settle();
+        if (was)
+            this.opts.onChange?.(false);
+        const delay = feed_1.BACKOFF_MS[Math.min(this.attempt, feed_1.BACKOFF_MS.length - 1)];
+        this.attempt++;
+        if (this.retryTimer !== undefined)
+            this.clearTimer(this.retryTimer);
+        this.retryTimer = this.setTimer(() => {
+            this.retryTimer = undefined;
+            this.connect();
+        }, delay);
+    }
+    finished() {
+        return this.current.kind === "closed" || this.current.kind === "refused";
+    }
+}
+exports.RelayLink = RelayLink;
+/**
+ * One line for the session (the `listen` answer) on whether its commands from the Bay work, and
+ * what to do when they do not. `pane` is what this process inherited.
+ */
+function describeCommandReach(state, pane) {
+    if (state.kind === "registered") {
+        if (!pane) {
+            return "Commands from the Bay: /status and /help answer, but /clear, /new and /compact cannot reach this session — it is not inside tmux or screen (start it with `baychat claude` next time).";
+        }
+        return "Commands from the Bay (/clear, /new, /compact, Fresh start): ready — this computer's relay types them into this session's terminal.";
+    }
+    if (state.kind === "connecting")
+        return "Commands from the Bay: still connecting to this computer's relay.";
+    if (state.kind === "closed")
+        return "Commands from the Bay: off.";
+    return `Commands from the Bay (/clear, /new, /compact): not available — ${state.reason}.${state.kind === "waiting" ? " Retrying in the background." : ""}`;
+}
+function describeConnectError(err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ECONNREFUSED")
+        return "no BayChat relay is running on this computer (start it with `baychat relay start`)";
+    if (code === "EACCES" || code === "EPERM")
+        return "this process may not open the relay's socket";
+    return `could not reach the relay (${code ?? err.message})`;
+}
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}