baychat 0.13.1 → 0.14.0

package/dist/relay/socket.js

@@ -34,11 +34,14 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.socketPath = socketPath;
+exports.unconfineRuntimeDir = unconfineRuntimeDir;
 exports.isNamedPipe = isNamedPipe;
 exports.pidFilePath = pidFilePath;
 exports.createFrameReader = createFrameReader;
 exports.writeFrame = writeFrame;
+exports.probeSocketDetailed = probeSocketDetailed;
 exports.probeSocket = probeSocket;
+exports.describeProbeFailure = describeProbeFailure;
 exports.unlinkStaleSocket = unlinkStaleSocket;
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
@@ -76,9 +79,34 @@ function socketPath() {
     }
     const runtimeDir = process.env.XDG_RUNTIME_DIR;
     if (runtimeDir)
-        return path.join(runtimeDir, "baychat-relay.sock");
+        return path.join(unconfineRuntimeDir(runtimeDir), "baychat-relay.sock");
     return path.join((0, config_1.configDir)(), "relay.sock");
 }
+/**
+ * The runtime dir the RELAY uses, as seen from inside a snap.
+ *
+ * A confined snap does not get the user's `XDG_RUNTIME_DIR`: snapd rewrites it
+ * to a private subdirectory, `/run/user/1000/snap.codex`. A snap-installed Codex
+ * therefore computes a socket path no relay has ever listened on, finds nothing,
+ * and reports "no relay is running" — while the real socket sits one level up,
+ * readable and connectable by the same uid. Verified on 2026-08-30: from inside
+ * `snap run --shell codex`, `/run/user/1000/baychat-relay.sock` connects fine;
+ * only the path was wrong.
+ *
+ * This is RECURRING_MISTAKES §24 again — "where it keeps its state" is not
+ * "where this copy reads" — and the same shape as `codexRoots`, which already
+ * has to know that a snap Codex keeps its rollouts somewhere else.
+ *
+ * Guarded on `SNAP` so an ordinary process is never second-guessed, and it only
+ * strips a segment that actually looks like snapd's, so a user whose runtime dir
+ * legitimately ends in something else is left alone.
+ */
+function unconfineRuntimeDir(runtimeDir, env = process.env) {
+    if (!env.SNAP)
+        return runtimeDir;
+    const parent = path.dirname(runtimeDir);
+    return /^snap\.[^/\\]+$/.test(path.basename(runtimeDir)) ? parent : runtimeDir;
+}
 /** A pipe name may not contain a backslash — it would read as another level of
  * the pipe namespace — and Windows usernames legally can (`DOMAIN\user` reaches
  * `os.userInfo()` that way on some setups). Everything outside the safe set is
@@ -129,31 +157,87 @@ function writeFrame(sock, frame) {
     sock.write(JSON.stringify(frame) + "\n");
 }
 /**
- * Is a daemon already listening?
+ * Probe the attach endpoint, KEEPING THE REASON IT FAILED.
+ *
+ * The boolean version of this threw the errno away, and every distinct failure
+ * arrived at the user as one sentence: "no relay is running". That sentence is
+ * true for exactly one of them. A sandboxed or differently-elevated shell that
+ * is REFUSED the pipe (EACCES/EPERM) is told the daemon does not exist, so the
+ * obvious next move is `relay start` — which spawns a SECOND daemon, and two
+ * daemons on one credential is a materially worse state than the one we were
+ * diagnosing. A wedged daemon that never accepts is likewise reported as absent.
  *
- * A socket file on disk proves nothing — a killed daemon leaves one behind. The
- * only honest test is to connect: ECONNREFUSED means the file is stale and safe
- * to unlink, which is what lets `relay start` recover from a hard kill without
- * a human deleting files.
+ * Measured on 2026-08-30: a Codex session on Windows reported "no relay is
+ * running" while a healthy relay (pid 16388) held four of its messages, and the
+ * CLI could not say which of these it had hit. Hence the reason code.
  */
-function probeSocket(sockPath, timeoutMs = 1_000) {
+function probeSocketDetailed(sockPath, timeoutMs = 1_000) {
     return new Promise((resolve) => {
         // The existence check is a cheap way to skip a connect that cannot succeed —
         // but a named pipe has no directory entry, so on Windows it answers "false"
         // for a perfectly healthy daemon. Skipped there; the connect below is the
         // honest test on every platform anyway.
-        if (!isNamedPipe(sockPath) && !fs.existsSync(sockPath))
-            return resolve(false);
+        if (!isNamedPipe(sockPath)) {
+            // `fs.existsSync` cannot be used here: it answers false for BOTH "there is
+            // nothing at this path" and "you may not look at this path", which is the
+            // very conflation this function exists to end. `statSync` throws an errno
+            // that separates them.
+            try {
+                fs.statSync(sockPath);
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === "ENOENT")
+                    return resolve({ alive: false, reason: "absent" });
+                const reason = code === "EACCES" || code === "EPERM" ? "denied" : "error";
+                return resolve({ alive: false, reason, code, detail: err.message });
+            }
+        }
         const sock = net.createConnection(sockPath);
-        const done = (alive) => {
+        const done = (result) => {
             sock.destroy();
-            resolve(alive);
+            resolve(result);
         };
-        sock.setTimeout(timeoutMs, () => done(false));
-        sock.on("connect", () => done(true));
-        sock.on("error", () => done(false));
+        sock.setTimeout(timeoutMs, () => done({ alive: false, reason: "timeout" }));
+        sock.on("connect", () => done({ alive: true }));
+        sock.on("error", (err) => {
+            const code = err.code;
+            // ENOENT/ECONNREFUSED genuinely mean nothing is listening. EACCES/EPERM
+            // mean something IS there and we were refused — the opposite diagnosis.
+            const reason = code === "ENOENT" || code === "ECONNREFUSED" ? "absent" : code === "EACCES" || code === "EPERM" ? "denied" : "error";
+            done({ alive: false, reason, code, detail: err.message });
+        });
     });
 }
+function probeSocket(sockPath, timeoutMs = 1_000) {
+    return probeSocketDetailed(sockPath, timeoutMs).then((r) => r.alive);
+}
+/**
+ * Turn a failed probe into a sentence that names the ACTUAL obstacle.
+ *
+ * Only `absent` may suggest `relay start`; the others must not, because
+ * starting a second daemon is the wrong move for all of them.
+ */
+function describeProbeFailure(sockPath, result) {
+    if (result.alive)
+        return "";
+    switch (result.reason) {
+        case "absent":
+            return "no relay is running — start one with `baychat relay start`";
+        case "denied":
+            return (`a relay endpoint exists at ${sockPath} but this process was refused it (${result.code}). ` +
+                `That is a permission boundary, not a missing daemon — do NOT run \`relay start\`, which would ` +
+                `create a second one. It usually means this shell runs under a different token than the relay ` +
+                `(an elevated or sandboxed shell), so run from a normal shell as the same user, or restart the ` +
+                `relay from this shell.`);
+        case "timeout":
+            return (`a relay is listening at ${sockPath} but did not accept a connection within ${1_000}ms — it is ` +
+                `probably wedged rather than absent. Check \`relay status\` from the shell that started it, and ` +
+                `stop that daemon before starting another.`);
+        default:
+            return `could not reach the relay at ${sockPath}: ${result.code ?? "unknown error"}${result.detail ? ` (${result.detail})` : ""}`;
+    }
+}
 /** Remove a socket file we have already proven dead.
  *
  * A no-op for a named pipe, which has nothing on disk to remove: Windows tears

package/dist/relay/spawn-env.js

@@ -0,0 +1,69 @@
+"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.headlessSpawnEnv = headlessSpawnEnv;
+const path = __importStar(require("path"));
+/**
+ * The environment a headless turn is spawned with.
+ *
+ * WHY THIS EXISTS. A runtime installed by npm is a JavaScript file with a
+ * `#!/usr/bin/env node` shebang, so running it asks the SPAWNING process's PATH
+ * to find `node`. The relay daemon runs under systemd, whose PATH is a minimal
+ * system one — it does not contain nvm's node, or any node at all on a machine
+ * where node was never installed system-wide.
+ *
+ * Measured 2026-08-31 00:06: the headless rung became reachable for the first
+ * time and every wake died instantly with
+ * `/usr/bin/env: 'node': No such file or directory`, exit 127. The binary was
+ * correct and present; nothing could run it.
+ *
+ * This is `SessionTarget.runtimeBin` one layer down. That rule says the session
+ * identifies its own binary because only it can; this says the daemon must also
+ * hand that binary an environment it can actually start in — and the daemon is
+ * the only process that knows where its own node lives (`process.execPath`,
+ * which is exactly the interpreter a shebang is looking for).
+ *
+ * PREPENDED, not replaced: a runtime may legitimately need the rest of the
+ * inherited PATH to find its own helpers, and clobbering it would trade this
+ * failure for a subtler one.
+ */
+function headlessSpawnEnv(env = process.env, execPath = process.execPath) {
+    const nodeDir = path.dirname(execPath);
+    const current = env.PATH ?? "";
+    const parts = current.split(path.delimiter).filter(Boolean);
+    if (parts.includes(nodeDir))
+        return env;
+    return { ...env, PATH: [nodeDir, ...parts].join(path.delimiter) };
+}

package/dist/runtime-binary.js

@@ -0,0 +1,269 @@
+"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.resolveRuntimeBinary = resolveRuntimeBinary;
+exports.describeResolution = describeResolution;
+exports.spawnPlanFor = spawnPlanFor;
+exports.summarizeProbe = summarizeProbe;
+exports.currentBinaryEnv = currentBinaryEnv;
+exports.summarizeResolutionFailure = summarizeResolutionFailure;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+/**
+ * Resolve a runtime's executable, proving each candidate before accepting it.
+ *
+ * Precedence: explicit override (exclusively), then native PATH entries in
+ * order, then foreign-filesystem PATH entries. Foreign entries are demoted
+ * rather than excluded — a user genuinely running the Windows build through WSL
+ * interop must still be able to work — but they never beat a native binary that
+ * runs, because spawning across the interop boundary means a different
+ * filesystem and a different home than the session it is answering for.
+ */
+function resolveRuntimeBinary(name, env) {
+    if (env.override !== undefined && env.override.trim() !== "") {
+        return resolveOverride(env.override, env);
+    }
+    const candidates = pathCandidates(name, env);
+    if (candidates.length === 0) {
+        return {
+            reason: `${name} not found on PATH (${env.pathEntries.length} entries searched)`,
+            rejected: [],
+            ok: false,
+        };
+    }
+    const rejected = [];
+    for (const candidate of candidates) {
+        const probed = env.probe(candidate.path);
+        if (probed.ok) {
+            return { ok: true, path: candidate.path, version: probed.version, source: candidate.source };
+        }
+        rejected.push({ path: candidate.path, reason: probed.detail });
+    }
+    return { ok: false, reason: `no working ${name} binary on this machine`, rejected };
+}
+/** Render a resolution for a human — one line on success, a full account on failure. */
+function describeResolution(name, resolution) {
+    if (resolution.ok)
+        return [`${resolution.path} (${resolution.version})`];
+    const lines = [resolution.reason];
+    for (const candidate of resolution.rejected) {
+        lines.push(`  tried ${candidate.path}`);
+        lines.push(`    → ${candidate.reason}`);
+    }
+    return lines;
+}
+/**
+ * An override is considered alone, and its failure is the answer.
+ *
+ * Falling through to PATH would mean the CLI used a binary the user did not name
+ * while their explicit setting sat broken and unreported.
+ */
+function resolveOverride(override, env) {
+    if (!env.isExecutable(override)) {
+        return {
+            ok: false,
+            reason: `configured override ${override} is not an executable file`,
+            rejected: [],
+        };
+    }
+    const probed = env.probe(override);
+    if (probed.ok)
+        return { ok: true, path: override, version: probed.version, source: "override" };
+    return {
+        ok: false,
+        reason: `configured override ${override} does not run`,
+        rejected: [{ path: override, reason: probed.detail }],
+    };
+}
+/**
+ * Every executable candidate on PATH, native entries first.
+ *
+ * Deduplicated by path: WSL routinely lists the same Windows npm directory
+ * twice, and probing spawns a process, so a duplicate entry would double the
+ * cost of resolution for no new information.
+ */
+function pathCandidates(name, env) {
+    const native = [];
+    const foreign = [];
+    const seen = new Set();
+    for (const entry of env.pathEntries) {
+        if (entry.trim() === "")
+            continue;
+        const source = isForeignMount(entry, env.platform) ? "foreign-path" : "path";
+        for (const fileName of executableNames(name, env.platform)) {
+            const candidate = joinPath(entry, fileName, env.platform);
+            if (seen.has(candidate))
+                continue;
+            seen.add(candidate);
+            if (!env.isExecutable(candidate))
+                continue;
+            (source === "path" ? native : foreign).push({ path: candidate, source });
+        }
+    }
+    return [...native, ...foreign];
+}
+/**
+ * Whether a PATH entry lives on a Windows drive mounted into Linux.
+ *
+ * Deliberately narrow: only `/mnt/<single letter>/…` counts. `/mnt/data` is an
+ * ordinary Linux mount and demoting it would be wrong.
+ */
+function isForeignMount(entry, platform) {
+    if (platform !== "linux")
+        return false;
+    return /^\/mnt\/[a-z]\//i.test(entry);
+}
+/**
+ * The file names a runtime may have on this platform.
+ *
+ * Windows resolves an unqualified command against PATHEXT; an npm-installed CLI
+ * is typically a `.cmd` shim, so omitting the extensions would find nothing at
+ * all there.
+ */
+function executableNames(name, platform) {
+    if (platform !== "win32")
+        return [name];
+    return [`${name}.exe`, `${name}.cmd`, `${name}.bat`, name];
+}
+/**
+ * Join a directory and a file name for the TARGET platform.
+ *
+ * Node's `path.join` follows the host, not the injected platform, so using it
+ * would make every Windows case untestable from Linux CI.
+ */
+function joinPath(dir, file, platform) {
+    const separator = platform === "win32" ? "\\" : "/";
+    const trimmed = dir.endsWith(separator) ? dir.slice(0, -separator.length) : dir;
+    return `${trimmed}${separator}${file}`;
+}
+/**
+ * @param candidate an executable path already resolved by `resolveRuntimeBinary`
+ * @returns file + prefix args to spawn it with, always `shell: false`
+ */
+function spawnPlanFor(candidate, platform) {
+    const needsInterpreter = platform === "win32" && /\.(cmd|bat)$/i.test(candidate);
+    if (!needsInterpreter)
+        return { file: candidate, prefixArgs: [] };
+    return { file: "cmd.exe", prefixArgs: ["/d", "/s", "/c", candidate] };
+}
+/** How long a `--version` probe may run before it is treated as broken. */
+const PROBE_TIMEOUT_MS = 5_000;
+/** The most stderr worth quoting back to a user in a rejection reason. */
+const PROBE_DETAIL_LIMIT = 200;
+/**
+ * Turn a finished `--version` run into a probe result.
+ *
+ * Split out from the spawn so the interesting half — deciding what counts as
+ * working, and what to quote when it does not — is testable without a process.
+ */
+function summarizeProbe(outcome) {
+    if (outcome.error)
+        return { ok: false, detail: outcome.error.message };
+    if (outcome.status !== 0) {
+        // Prefer stderr: a failing CLI puts its diagnosis there, and it is what
+        // names the actual fault (e.g. the missing optional dependency).
+        const said = firstMeaningfulLine(outcome.stderr) || firstMeaningfulLine(outcome.stdout);
+        const exited = `exits ${outcome.status ?? "on a signal"}`;
+        return { ok: false, detail: said ? `${exited}: ${said}` : exited };
+    }
+    const version = firstMeaningfulLine(outcome.stdout) || firstMeaningfulLine(outcome.stderr);
+    // Exit 0 is the contract. A binary that runs but prints nothing recognisable
+    // still runs, so it is accepted with an honest placeholder rather than
+    // rejected for a cosmetic reason.
+    return { ok: true, version: version || "version not reported" };
+}
+function firstMeaningfulLine(text) {
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed !== "")
+            return trimmed.slice(0, PROBE_DETAIL_LIMIT);
+    }
+    return "";
+}
+/**
+ * Read the binary environment from this process.
+ *
+ * `shell: false` throughout: nothing here is ever concatenated into a command
+ * line, and a PATH entry is attacker-adjacent data on a shared machine.
+ */
+function currentBinaryEnv(override) {
+    const delimiter = process.platform === "win32" ? ";" : ":";
+    return {
+        platform: process.platform,
+        pathEntries: (process.env.PATH ?? "").split(delimiter),
+        override,
+        isExecutable(candidate) {
+            try {
+                return fs.statSync(candidate).isFile();
+            }
+            catch {
+                // Absent, unreadable, or a dangling symlink — all mean "not a candidate".
+                // There is nothing to log: most PATH entries do not contain most binaries.
+                return false;
+            }
+        },
+        probe(candidate) {
+            const plan = spawnPlanFor(candidate, process.platform);
+            const run = (0, child_process_1.spawnSync)(plan.file, [...plan.prefixArgs, "--version"], {
+                timeout: PROBE_TIMEOUT_MS,
+                encoding: "utf8",
+                shell: false,
+            });
+            return summarizeProbe({
+                status: run.status,
+                stdout: run.stdout ?? "",
+                stderr: run.stderr ?? "",
+                error: run.error,
+            });
+        },
+    };
+}
+/**
+ * One line naming the failure and the best evidence for it.
+ *
+ * `describeResolution` is shaped for a report a human is reading deliberately;
+ * this is for a place that has room for a sentence — a `DELIVERY PENDING`
+ * reason in `relay status`, a log line — where a multi-line block would wrap
+ * into noise. It names the first rejected candidate because that is the one
+ * PATH would have chosen, and therefore the one the user believes is in use.
+ */
+function summarizeResolutionFailure(resolution) {
+    if (resolution.ok)
+        return "";
+    const first = resolution.rejected[0];
+    if (!first)
+        return resolution.reason;
+    return `${resolution.reason} (tried ${first.path}: ${first.reason})`;
+}