baychat 0.25.2 → 0.25.3

package/dist/relay/autostart.js

@@ -33,9 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUTOSTART_IMPLEMENTATIONS = exports.WINDOWS_RELAY_LAUNCHER = exports.LingerUnavailable = exports.SYSTEMD_UNIT_NAME = exports.SERVICE_LABEL = void 0;
+exports.AUTOSTART_IMPLEMENTATIONS = exports.WINDOWS_RELAY_LAUNCHER = exports.MAC_SEARCH_PATH = exports.LingerUnavailable = exports.SYSTEMD_UNIT_NAME = exports.SERVICE_LABEL = void 0;
+exports.launchdLogPath = launchdLogPath;
 exports.autostartForPlatform = autostartForPlatform;
 exports.relayCommand = relayCommand;
+exports.stableNodePath = stableNodePath;
 // Making the relay come back by itself, on all three platforms.
 //
 // THE BUG THIS EXISTS TO FIX. `baychat relay start` used to write a systemd user
@@ -174,7 +176,13 @@ const launchd = {
   <dict>
     <key>NODE_ENV</key>
     <string>production</string>
+    <key>PATH</key>
+    <string>${exports.MAC_SEARCH_PATH}</string>
   </dict>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(launchdLogPath())}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(launchdLogPath())}</string>
   <key>ProcessType</key>
   <string>Background</string>
 </dict>
@@ -185,6 +193,7 @@ const launchd = {
         const target = launchd.unitPath();
         fs.mkdirSync(path.dirname(target), { recursive: true });
         fs.writeFileSync(target, launchd.unit(cmd), { mode: 0o644 });
+        prepareLaunchdLog();
         const domain = `gui/${os.userInfo().uid}`;
         // Replacing an agent means removing the old one first; bootout on a label
         // that was never loaded exits non-zero, which is not a failure here.
@@ -203,6 +212,46 @@ const launchd = {
         fs.rmSync(launchd.unitPath(), { force: true });
     },
 };
+/**
+ * The PATH the relay — and every session it wakes — runs with on macOS.
+ *
+ * launchd starts an agent with `/usr/bin:/bin:/usr/sbin:/sbin` and nothing else
+ * (measured on a Mac mini, 2026-09-27), so a woken session could not find `gh`,
+ * `docker` or anything else Homebrew installed. This is the PATH a Mac Terminal has:
+ * Homebrew's two prefixes (Apple silicon), `/usr/local/bin` (Homebrew on Intel, and
+ * most installers), then the system's own. A missing directory in PATH costs nothing.
+ * Node's own directory is added again at spawn time — see ./spawn-env.ts.
+ */
+exports.MAC_SEARCH_PATH = "/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin";
+/** Past this size the log is set aside when the relay is (re)installed. */
+const LAUNCHD_LOG_MAX_BYTES = 10 * 1024 * 1024;
+/**
+ * Where the macOS relay's output goes: the per-user Logs folder, which Console.app
+ * lists under Log Reports. systemd keeps a unit's output in the journal; launchd
+ * throws it away unless the plist names a file.
+ */
+function launchdLogPath() {
+    return path.join(os.homedir(), "Library", "Logs", "BayChat", "relay.log");
+}
+/**
+ * Make sure the log's folder exists, and set a large log aside.
+ *
+ * launchd appends and never rotates. `relay start` runs at every install and every
+ * `baychat update`, so keeping one previous file here bounds the log without a
+ * rotation daemon (newsyslog needs root).
+ */
+function prepareLaunchdLog() {
+    const log = launchdLogPath();
+    fs.mkdirSync(path.dirname(log), { recursive: true });
+    try {
+        if (fs.statSync(log).size > LAUNCHD_LOG_MAX_BYTES)
+            fs.renameSync(log, `${log}.1`);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+}
 /**
  * Windows — a Task Scheduler task, triggered at logon.
  *
@@ -370,10 +419,36 @@ function relayCommand(physicalPath = (value) => fs.realpathSync.native(value)) {
     // be absent from Task Scheduler's filesystem view. Resolve the actual file
     // before handing it to a process outside that package (observed on Windows).
     return {
-        node: physicalPath(process.execPath),
+        node: stableNodePath(physicalPath(process.execPath), physicalPath),
         entry: physicalPath(path.resolve(process.argv[1] ?? "")),
     };
 }
+/** `<prefix>/Cellar/<formula>/<version>/bin/node` — one Homebrew version's own folder. */
+const HOMEBREW_CELLAR_NODE = /^(.*)\/Cellar\/([^/]+)\/[^/]+\/bin\/node$/;
+/**
+ * The same node, by a path that survives `brew upgrade`.
+ *
+ * Homebrew installs every version into its own `Cellar/<formula>/<version>` folder and
+ * deletes the old one on upgrade; `process.execPath` names that folder. A unit written
+ * with it stops starting after the next upgrade, silently, at the next login. The
+ * formula's `opt/<formula>` link always points at the installed version, so it is used —
+ * but only when it resolves to this very node now, so nothing changes about which node
+ * runs today. Any other install (system, nvm, Windows) is returned unchanged.
+ */
+function stableNodePath(node, physicalPath) {
+    const match = HOMEBREW_CELLAR_NODE.exec(node);
+    if (!match)
+        return node;
+    const [, prefix, formula] = match;
+    const opt = `${prefix}/opt/${formula}/bin/node`;
+    try {
+        return physicalPath(opt) === node ? opt : node;
+    }
+    catch {
+        // No opt link (an unusual Homebrew layout): the versioned path still works today.
+        return node;
+    }
+}
 /** Exported for tests, which need to reach a platform other than the one they
  * run on. Production code goes through {@link autostartForPlatform}. */
 exports.AUTOSTART_IMPLEMENTATIONS = {

package/dist/relay/commands.js

@@ -101,6 +101,12 @@ function request(sock, frame, timeoutMs = 5_000) {
             clearTimeout(timer);
             reject(err);
         });
+        // The relay went away without answering. Waiting out the timer would only delay
+        // the same answer; the caller decides whether gone was what it wanted.
+        sock.on("close", () => {
+            clearTimeout(timer);
+            reject(new Error("relay closed the connection without answering"));
+        });
         (0, socket_1.writeFrame)(sock, frame);
     });
 }
@@ -386,7 +392,16 @@ async function cmdRelayStop() {
         if (await (0, socket_1.probeSocket)((0, socket_1.socketPath)())) {
             // A windowless supervisor may stop without killing its child. Ask the
             // relay itself to shut down, and wait so the next start cannot reuse it.
-            await request(await connectOrFail(), { type: "stop" });
+            try {
+                await request(await connectOrFail(), { type: "stop" });
+            }
+            catch (err) {
+                // launchd's bootout above already sent the relay SIGTERM; it can accept this
+                // connection and exit before answering. A relay that is gone is what was asked
+                // for — only a relay still listening is a failure to report.
+                if (await (0, socket_1.probeSocket)((0, socket_1.socketPath)()))
+                    throw err;
+            }
             const deadline = Date.now() + 5_000;
             while (await (0, socket_1.probeSocket)((0, socket_1.socketPath)())) {
                 if (Date.now() >= deadline)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.25.2",
+  "version": "0.25.3",
   "description": "BayChat connector CLI — pair an agent session (Claude Code, Codex, Cursor) with BayChat, or have the relay run DeepSeek or the Cursor CLI for you",
   "bin": {
     "baychat": "dist/index.js"