baychat 0.13.1 → 0.15.0

package/dist/credential-refresh.js

@@ -0,0 +1,97 @@
+"use strict";
+// Keeping already-connected clients working across a credential renewal.
+//
+// WHY THIS EXISTS. The device credential has a hard 30-day expiry, and every
+// connected client holds a COPY of it — Codex and Cursor in their own config
+// files, Claude Code in its MCP registration. `baychat login` renewed the
+// credential in `~/.baychat/credentials.json` and updated none of them.
+//
+// Observed on 2026-08-30, in the exact shape it will hit every user: a login
+// printed `✓ Logged in as Karrrmex`, and left both Codex configs and Claude
+// Code's registration holding a token with two hours left on it. In two hours
+// every agent on that machine would have stopped working, and the one command a
+// user would reach for to fix it — `baychat login` — is the command that had
+// just claimed success.
+//
+// A renewal is not an edge case. It is the normal, scheduled state of a
+// credential with an expiry, so it has to be the case this code handles best.
+//
+// REFRESH IS NOT CONNECT. This only ever rewrites a file that ALREADY names
+// BayChat. Writing a config for a client the user never connected would
+// configure software they did not ask us to touch, on the occasion of renewing
+// something else.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staleClientConfigs = staleClientConfigs;
+exports.refreshExistingClientConfigs = refreshExistingClientConfigs;
+const client_config_writer_1 = require("./client-config-writer");
+const client_paths_1 = require("./client-paths");
+const mcp_dialects_1 = require("./mcp-dialects");
+/**
+ * Config files that name BayChat but not with this token.
+ *
+ * Used by `doctor` to report the fault, and by the refresh below to fix it. A
+ * file with no BayChat entry is not stale — it is unconnected, and reporting it
+ * would send someone to fix something that is not broken.
+ */
+function staleClientConfigs(token, io, env) {
+    const stale = [];
+    for (const path of everyKnownConfigPath(env)) {
+        const contents = io.readFile(path);
+        if (contents === null || !contents.includes("baychat"))
+            continue;
+        if (!contents.includes(token))
+            stale.push(path);
+    }
+    return stale;
+}
+/**
+ * Rewrite every already-connected client config with the current credential.
+ *
+ * @returns the paths actually updated, for the caller to report. Naming them
+ * matters: a user whose editor is open needs to know which file changed under
+ * it, and a silent rewrite of a config file is exactly the behaviour that makes
+ * people stop trusting a tool that edits their configs.
+ */
+function refreshExistingClientConfigs(endpoint, io, env) {
+    const updated = [];
+    for (const client of mcp_dialects_1.MCP_CLIENTS) {
+        for (const path of (0, client_paths_1.inspectableConfigPaths)(client, env)) {
+            const existing = io.readFile(path);
+            // Only files that already name BayChat. See the header: refresh is not
+            // connect.
+            if (existing === null || !existing.includes("baychat"))
+                continue;
+            if (existing.includes(endpoint.token))
+                continue;
+            if (rewrite(client, path, existing, endpoint, io))
+                updated.push(path);
+        }
+    }
+    return updated;
+}
+/**
+ * One file, rewritten, or `false` when it could not be.
+ *
+ * A failure here is deliberately not fatal. `mergeJsonConfig` refuses a config
+ * it cannot parse — correctly, because overwriting a file that is merely
+ * mid-edit would destroy it — and one unparseable Cursor config must not stop
+ * Codex being refreshed. A partial renewal is far better than none, and the
+ * caller reports what it managed.
+ */
+function rewrite(client, path, existing, endpoint, io) {
+    try {
+        const merged = (0, client_config_writer_1.mergeClientConfig)((0, mcp_dialects_1.buildClientConfig)(client, endpoint), existing);
+        io.copyFile(path, (0, client_config_writer_1.backupPathFor)(path));
+        io.writeFile(path, merged.content);
+        return true;
+    }
+    catch {
+        // Nothing to log here: the caller reports which files it updated, and the
+        // absence of one from that list is the report. `doctor` names the rest.
+        return false;
+    }
+}
+/** Every config location of every client this package knows how to write. */
+function everyKnownConfigPath(env) {
+    return mcp_dialects_1.MCP_CLIENTS.flatMap((client) => (0, client_paths_1.inspectableConfigPaths)(client, env));
+}

package/dist/doctor-command.js

@@ -0,0 +1,154 @@
+"use strict";
+// `baychat doctor` — the I/O half of the diagnosis.
+//
+// `doctor.ts` decides what is wrong from a description of a machine. This file
+// builds that description from the real one and prints the result. The split is
+// the reason the whole report is testable against fixtures, including machines
+// nobody here owns — a Mac, a Windows box, a beta user's laptop with a broken
+// Codex install.
+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.currentDoctorEnv = currentDoctorEnv;
+exports.cmdDoctor = cmdDoctor;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const config_1 = require("./config");
+const doctor_1 = require("./doctor");
+const commands_1 = require("./relay/commands");
+const credential_refresh_1 = require("./credential-refresh");
+const client_paths_1 = require("./client-paths");
+const runtime_binary_1 = require("./runtime-binary");
+/** How long `claude mcp list` may take before we treat it as unanswerable. */
+const MCP_LIST_TIMEOUT_MS = 15_000;
+/**
+ * An environment variable naming a runtime's executable explicitly, for the
+ * machine where resolution genuinely cannot work it out.
+ *
+ * Documented in the `binary` check's remedy, so a user who hits an unresolvable
+ * runtime is told the escape hatch at the moment they need it.
+ */
+function overrideFor(command) {
+    return process.env[`BAYCHAT_${command.toUpperCase()}_BIN`];
+}
+/** Where Codex is, so a snap install's own config location is checked too. */
+function codexPath() {
+    const resolved = (0, runtime_binary_1.resolveRuntimeBinary)("codex", (0, runtime_binary_1.currentBinaryEnv)(overrideFor("codex")));
+    return resolved.ok ? resolved.path : undefined;
+}
+async function currentDoctorEnv() {
+    return {
+        home: os.homedir(),
+        platform: process.platform,
+        now: Date.now(),
+        device: (0, config_1.loadDeviceCredentials)(),
+        relay: await (0, commands_1.tryRelayStatus)(),
+        readText(filePath) {
+            try {
+                return fs.readFileSync(filePath, "utf8");
+            }
+            catch {
+                // Missing, unreadable, or a directory — all mean "nothing to inspect".
+                // The checks turn that into a finding; there is nothing to log here.
+                return null;
+            }
+        },
+        staleConfigs(token) {
+            // Uses the same reader the refresh does, so "doctor says stale" and
+            // "login fixed it" can never disagree about which files count.
+            return (0, credential_refresh_1.staleClientConfigs)(token, {
+                readFile: (filePath) => {
+                    try {
+                        return fs.readFileSync(filePath, "utf8");
+                    }
+                    catch {
+                        // Absent or unreadable: nothing to compare, so nothing to report.
+                        return null;
+                    }
+                },
+                writeFile: () => undefined,
+                copyFile: () => undefined,
+                mkdirp: () => undefined,
+            }, (0, client_paths_1.currentPathEnv)());
+        },
+        resolveBinary(command) {
+            return (0, runtime_binary_1.resolveRuntimeBinary)(command, (0, runtime_binary_1.currentBinaryEnv)(overrideFor(command)));
+        },
+        mcpList(runtime) {
+            // Ask the runtime itself. Its own answer is correct wherever its config
+            // turns out to live — which, for a snap install, is not where we wrote.
+            const resolved = (0, runtime_binary_1.resolveRuntimeBinary)(runtime, (0, runtime_binary_1.currentBinaryEnv)(overrideFor(runtime)));
+            if (!resolved.ok)
+                return null;
+            // Same .cmd rule as the probe: an npm-installed CLI on Windows is a shim
+            // that cannot be spawned without a shell, and this call would otherwise
+            // throw EINVAL and be reported as "could not run `codex mcp list`".
+            const plan = (0, runtime_binary_1.spawnPlanFor)(resolved.path, process.platform);
+            try {
+                return (0, child_process_1.execFileSync)(plan.file, [...plan.prefixArgs, "mcp", "list"], {
+                    encoding: "utf8",
+                    timeout: MCP_LIST_TIMEOUT_MS,
+                    stdio: ["ignore", "pipe", "pipe"],
+                });
+            }
+            catch (err) {
+                // A non-zero exit can still carry the listing on stdout, so it is worth
+                // reading before giving up. Only a genuinely empty result becomes
+                // "could not run", which the check reports as unknown rather than as
+                // "not registered".
+                const stdout = err.stdout;
+                return stdout && stdout.trim() !== "" ? stdout : null;
+            }
+        },
+    };
+}
+/**
+ * `baychat doctor [--json]`
+ *
+ * Exit codes match `relay status`: 0 clear, 1 something is broken, 2 there is
+ * mail nobody read.
+ */
+async function cmdDoctor(argv) {
+    const report = (0, doctor_1.buildReport)(await currentDoctorEnv());
+    if (argv.includes("--json")) {
+        // The whole report as data, so a beta user can paste one blob into a
+        // support thread and it can be read without a round of questions.
+        console.log(JSON.stringify(report, null, 2));
+        return (0, doctor_1.exitCodeFor)(report);
+    }
+    for (const line of (0, doctor_1.renderReport)(report))
+        console.log(line);
+    return (0, doctor_1.exitCodeFor)(report);
+}