baychat 0.25.0 → 0.25.2

package/dist/commands.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.realConfigIo = exports.CATCHUP_UNTRUSTED_REMINDER = void 0;
+exports.realConfigIo = exports.WINDOWS_UNSAFE = exports.CATCHUP_UNTRUSTED_REMINDER = void 0;
 exports.requireCredentials = requireCredentials;
 exports.cmdPair = cmdPair;
 exports.cmdWhoami = cmdWhoami;
@@ -18,6 +18,7 @@ exports.resetSessionState = resetSessionState;
 exports.cmdCheck = cmdCheck;
 exports.cmdWatch = cmdWatch;
 exports.cmdLink = cmdLink;
+exports.quoteForCmd = quoteForCmd;
 exports.claudeMcpAddSpawn = claudeMcpAddSpawn;
 exports.registerWithClaude = registerWithClaude;
 exports.cmdLogin = cmdLogin;
@@ -583,7 +584,7 @@ function quoteForCmd(arg) {
  * quoted, and `!` only expands under delayed expansion, which `cmd /d /s /c` —
  * what Node's `shell: true` invokes — does not enable.
  */
-const WINDOWS_UNSAFE = /["%\u0000-\u001f\u007f]/;
+exports.WINDOWS_UNSAFE = /["%\u0000-\u001f\u007f]/;
 /**
  * The spawn recipe for `claude mcp add`, or null when it cannot be run safely.
  *
@@ -620,7 +621,7 @@ function claudeMcpAddSpawn(platform, baseUrl, token) {
     ];
     if (platform !== "win32")
         return { command: "claude", args, shell: false };
-    if (args.some((a) => WINDOWS_UNSAFE.test(a)))
+    if (args.some((a) => exports.WINDOWS_UNSAFE.test(a)))
         return null;
     return { command: "claude", args: args.map(quoteForCmd), shell: true };
 }

package/dist/main.js

@@ -217,7 +217,8 @@ async function main() {
         case "start":
             return (0, start_command_1.cmdStart)(args);
         case "update":
-            return (0, update_command_1.cmdUpdate)();
+            // `--quiet` is how an old version hands a `start`-driven update to the new one.
+            return (0, update_command_1.cmdUpdate)({ quiet: args.includes("--quiet") });
         case "skill": {
             const runtime = args[1];
             if (args.length !== 2 ||

package/dist/self-upgrade.js

@@ -0,0 +1,232 @@
+"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.resolveEntry = resolveEntry;
+exports.currentEntry = currentEntry;
+exports.classifyInstall = classifyInstall;
+exports.compareVersions = compareVersions;
+exports.upgradePackage = upgradePackage;
+exports.describeOutcome = describeOutcome;
+exports.realNpm = realNpm;
+exports.readPackageVersion = readPackageVersion;
+exports.packageEntry = packageEntry;
+exports.ownVersion = ownVersion;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const commands_1 = require("./commands");
+/** A path as the filesystem sees it: every symlink on the way resolved. */
+function resolveEntry(file) {
+    try {
+        return fs.realpathSync(file);
+    }
+    catch {
+        // Unresolvable (deleted under us, a permission on a parent). The path as given is still
+        // the best evidence there is, and classifying it honestly beats throwing mid-update.
+        return file;
+    }
+}
+/**
+ * The entry file of THIS running CLI. `__dirname` rather than argv: it is where the executing
+ * code actually lives, and Node has already resolved symlinks to get it (resolved again here
+ * for `--preserve-symlinks`).
+ */
+function currentEntry() {
+    return resolveEntry(path.join(__dirname, "index.js"));
+}
+function classifyInstall(entry, platform = process.platform) {
+    const p = platform === "win32" ? path.win32 : path.posix;
+    const parts = entry.split(/[\\/]+/);
+    if (parts.includes("_npx"))
+        return { kind: "npx", entry };
+    const at = parts.lastIndexOf("node_modules");
+    if (at < 0 || parts[at + 1] !== "baychat")
+        return { kind: "source", entry };
+    const modules = parts.slice(0, at + 1).join(p.sep);
+    const packageRoot = p.join(modules, "baychat");
+    if (platform === "win32") {
+        return { kind: "global", entry, packageRoot, prefix: p.dirname(modules) };
+    }
+    const lib = p.dirname(modules);
+    if (p.basename(lib) === "lib")
+        return { kind: "global", entry, packageRoot, prefix: p.dirname(lib) };
+    return { kind: "local", entry, packageRoot };
+}
+/** -1, 0, 1 for dotted numeric versions; undefined when either will not parse. */
+function compareVersions(a, b) {
+    const parse = (v) => (/^\d+(\.\d+)*$/.test(v) ? v.split(".").map(Number) : undefined);
+    const x = parse(a);
+    const y = parse(b);
+    if (!x || !y)
+        return undefined;
+    for (let i = 0; i < Math.max(x.length, y.length); i++) {
+        const d = (x[i] ?? 0) - (y[i] ?? 0);
+        if (d !== 0)
+            return d < 0 ? -1 : 1;
+    }
+    return 0;
+}
+const VIEW_TIMEOUT_MS = 30_000;
+const INSTALL_TIMEOUT_MS = 180_000;
+/** Upgrade the running package where it can be upgraded, and say exactly what happened. */
+function upgradePackage(deps) {
+    const { install, current } = deps;
+    if (install.kind === "npx")
+        return { outcome: "npx", current };
+    if (install.kind === "local")
+        return { outcome: "local", current, packageRoot: install.packageRoot };
+    if (install.kind === "source")
+        return { outcome: "source", current, entry: install.entry };
+    // Ask first, install only when there is something newer. Besides saving a slow npm run a
+    // day, this is what lets a machine whose global folder needs sudo finish `baychat update`
+    // after the one `sudo npm i -g` — otherwise every run would retry the write and fail.
+    const view = deps.npm(["view", "baychat", "version"], VIEW_TIMEOUT_MS);
+    const latest = view.stdout.trim();
+    if (view.error || view.status !== 0 || !/^\d+\.\d+\.\d+$/.test(latest)) {
+        return { outcome: "unchecked", current, reason: npmFailure(view) };
+    }
+    const order = compareVersions(current, latest);
+    if (order === 0 || order === 1)
+        return { outcome: "current", current };
+    // `--prefer-online`: `npm view` above always revalidates, but `install` trusts a cached
+    // packument for its max-age (~5 minutes). Straight after a publish — exactly when people run
+    // `update` — that cache can predate the version view just named, and install dies ETARGET.
+    const result = deps.npm(["install", "--global", "--prefer-online", "--prefix", install.prefix, `baychat@${latest}`], INSTALL_TIMEOUT_MS);
+    if (result.error || result.status !== 0) {
+        const denied = /\b(EACCES|EPERM)\b/.test(`${result.stderr}\n${result.error?.message ?? ""}`);
+        const reason = denied
+            ? `npm is not allowed to write to ${install.prefix}. Run \`${sudoHint(deps, install.prefix)}\` ` +
+                "(or give npm a folder you own: https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally), " +
+                "then `baychat update` again."
+            : npmFailure(result);
+        return { outcome: "failed", current, reason };
+    }
+    // npm said yes. Believe the file on disk, not the exit code: this is the very step that
+    // used to report success over an unchanged install.
+    const onDisk = deps.readVersion(install.packageRoot);
+    if (onDisk !== latest) {
+        return {
+            outcome: "failed",
+            current,
+            reason: `npm reported success, but ${install.packageRoot} holds ${onDisk ?? "no readable package.json"}, not ${latest}.`,
+        };
+    }
+    return { outcome: "upgraded", from: current, to: onDisk, packageRoot: install.packageRoot };
+}
+/** What a person reads for each outcome. `ok: false` means: do not claim this machine is updated. */
+function describeOutcome(o) {
+    switch (o.outcome) {
+        case "npx":
+            return {
+                ok: true,
+                note: `This is an npx copy of baychat ${o.current}, and npx can keep running a cached older one. Use \`npx baychat@latest\` (or install it once with \`npm i -g baychat\`) so updates land.`,
+            };
+        case "local":
+            return {
+                ok: true,
+                note: `baychat ${o.current} is installed inside a project (${o.packageRoot}), so update it there with \`npm i baychat@latest\`. The package was left alone.`,
+            };
+        case "source":
+            return {
+                ok: true,
+                note: `baychat ${o.current} is running from ${o.entry}, not from an npm install, so the package was left alone. Rebuild that checkout to update it.`,
+            };
+        case "unchecked":
+            return { ok: true, note: `Could not ask npm for the latest baychat (${o.reason}). The package stays at ${o.current}.` };
+        case "current":
+            return { ok: true, done: `baychat ${o.current} is the latest` };
+        case "upgraded":
+            return { ok: true, done: `upgraded baychat ${o.from} → ${o.to}` };
+        case "failed":
+            return {
+                ok: false,
+                note: `Could not upgrade baychat ${o.current}: ${o.reason}\nNothing else was changed, and the relay was NOT upgraded: it is still running ${o.current}.`,
+            };
+    }
+}
+function sudoHint(deps, prefix) {
+    // Plain `sudo npm i -g` is only right when npm's own global prefix IS this install's.
+    const own = deps.npm(["prefix", "--global"], VIEW_TIMEOUT_MS);
+    const ownPrefix = !own.error && own.status === 0 ? own.stdout.trim() : "";
+    return ownPrefix && resolveEntry(ownPrefix) === resolveEntry(prefix)
+        ? "sudo npm i -g baychat@latest"
+        : `sudo npm i -g --prefix ${prefix} baychat@latest`;
+}
+function npmFailure(r) {
+    if (r.error) {
+        return r.error.code === "ENOENT" ? "npm was not found on PATH" : r.error.message;
+    }
+    const lines = r.stderr.split("\n").map((l) => l.trim()).filter(Boolean);
+    return lines.slice(-3).join(" ") || `npm exited with ${r.status}`;
+}
+/** Run npm for real. Windows' npm is a `.cmd` shim, which Node will only start through a shell. */
+function realNpm(args, timeoutMs) {
+    const windows = process.platform === "win32";
+    if (windows && args.some((a) => commands_1.WINDOWS_UNSAFE.test(a))) {
+        return { status: null, stdout: "", stderr: "", error: new Error("a path npm needs cannot be passed safely through cmd.exe") };
+    }
+    const r = (0, child_process_1.spawnSync)("npm", windows ? args.map(commands_1.quoteForCmd) : args, {
+        encoding: "utf8",
+        timeout: timeoutMs,
+        shell: windows,
+    });
+    return { status: r.status, stdout: r.stdout ?? "", stderr: r.stderr ?? "", error: r.error };
+}
+function readPackageVersion(packageRoot) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The CLI entry a package root declares, for handing the rest of `update` to the new code. */
+function packageEntry(packageRoot) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+        const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.baychat;
+        if (typeof bin === "string")
+            return path.join(packageRoot, bin);
+    }
+    catch {
+        // Fall through to the layout every published version has had.
+    }
+    return path.join(packageRoot, "dist", "index.js");
+}
+/** The version of the code that is executing right now. */
+function ownVersion() {
+    return require("../package.json").version;
+}

package/dist/update-command.js

@@ -43,6 +43,7 @@ const credential_refresh_1 = require("./credential-refresh");
 const commands_1 = require("./commands");
 const client_paths_1 = require("./client-paths");
 const commands_2 = require("./relay/commands");
+const self_upgrade_1 = require("./self-upgrade");
 /**
  * `baychat update` — bring this whole machine onto the current version, in one word.
  *
@@ -85,11 +86,42 @@ async function cmdUpdate(opts = {}) {
         return 1;
     }
     const done = [];
-    // 1. THE PACKAGE. Only a global install can be upgraded in place; an npx run already
-    //    fetched whatever npx had cached, and the honest advice there is `@latest`.
-    const packageStep = updatePackage();
-    if (packageStep)
-        done.push(packageStep);
+    // 1. THE PACKAGE, and it goes first because everything after it should run on the NEW code.
+    const upgradedFrom = takeUpgradedFrom();
+    if (upgradedFrom) {
+        // We are the new version, started by the old one straight after it installed us.
+        done.push(`upgraded baychat ${upgradedFrom} → ${(0, self_upgrade_1.ownVersion)()}`);
+    }
+    else {
+        const outcome = (0, self_upgrade_1.upgradePackage)({
+            install: (0, self_upgrade_1.classifyInstall)((0, self_upgrade_1.currentEntry)()),
+            current: (0, self_upgrade_1.ownVersion)(),
+            npm: self_upgrade_1.realNpm,
+            readVersion: self_upgrade_1.readPackageVersion,
+        });
+        const told = (0, self_upgrade_1.describeOutcome)(outcome);
+        if (!told.ok) {
+            // Never "Updated this machine" over a package that did not move. Stop before the relay
+            // restart too: restarting it would only relaunch the same old code and look like progress.
+            console.error(told.note);
+            writeStamp(); // a daily retry from `start`, not one on every start
+            return 1;
+        }
+        if (told.note)
+            say(told.note);
+        if (outcome.outcome === "upgraded") {
+            // THIS process is still the old code, loaded before npm replaced the files. Hand the
+            // rest of the update — client configs, Claude registration, the relay unit and restart
+            // — to the version just installed, so each is written by the code that will run it.
+            const handedOff = runOnNewCode(outcome.packageRoot, outcome.from, !!opts.quiet);
+            if (handedOff !== undefined)
+                return handedOff;
+            // Could not start it. The relay is still restarted below from the same path, which
+            // now holds the new files, so the upgrade itself still lands.
+        }
+        if (told.done)
+            done.push(told.done);
+    }
     // 2. EVERY CONNECTED CLIENT's copy of the credential and endpoint.
     try {
         const updated = (0, credential_refresh_1.refreshExistingClientConfigs)({ url: `${device.baseUrl}/api/mcp`, token: device.token }, commands_1.realConfigIo, (0, client_paths_1.currentPathEnv)());
@@ -163,34 +195,27 @@ function writeStamp() {
     }
 }
 /**
- * Upgrade the package itself, where that is a thing this process can do.
- *
- * ⚠️ AN `npx` RUN CANNOT UPGRADE ITSELF, and pretending otherwise is worse than saying so:
- * npx resolves from its own cache, so `npx baychat` can keep running a version from weeks
- * ago while reporting success at every step. The honest output there is the one flag that
- * fixes it.
+ * Set by the OLD version when it hands the rest of `update` to the version it just installed:
+ * the version it upgraded from, for the report. Read once and cleared, so nothing this process
+ * starts afterwards inherits it.
  */
-function updatePackage() {
-    const globalInstall = isGlobalInstall();
-    if (!globalInstall) {
-        console.log("Tip: `npx baychat` can run a cached older copy. Use `npx baychat@latest` (or install it once with `npm i -g baychat`) so updates land.");
-        return undefined;
-    }
-    const result = (0, child_process_1.spawnSync)("npm", ["install", "-g", "baychat@latest"], {
-        encoding: "utf8",
-        timeout: 120_000,
+const UPGRADED_FROM_ENV = "BAYCHAT_UPGRADED_FROM";
+function takeUpgradedFrom() {
+    const value = process.env[UPGRADED_FROM_ENV];
+    delete process.env[UPGRADED_FROM_ENV];
+    return value && /^\d+\.\d+\.\d+$/.test(value) ? value : undefined;
+}
+/** Finish `update` in the newly installed version. Its exit status, or undefined if it never ran. */
+function runOnNewCode(packageRoot, from, quiet) {
+    const child = (0, child_process_1.spawnSync)(process.execPath, [(0, self_upgrade_1.packageEntry)(packageRoot), "update", ...(quiet ? ["--quiet"] : [])], {
+        stdio: "inherit",
+        env: { ...process.env, [UPGRADED_FROM_ENV]: from },
     });
-    if (result.status !== 0) {
-        console.log(`  Could not upgrade the package: ${result.stderr?.trim() || "npm failed"}`);
+    if (child.error) {
+        console.log(`  Could not start the new version (${errText(child.error)}); finishing the update from this one.`);
         return undefined;
     }
-    return "upgraded the baychat package";
-}
-/** Is this process running from a global npm install, rather than an npx cache? */
-function isGlobalInstall() {
-    const self = process.argv[1] ?? "";
-    // npx unpacks into `_npx` inside the npm cache; a global install never does.
-    return self.includes("node_modules") && !self.includes("_npx");
+    return child.status ?? 1;
 }
 function hasBinary(name) {
     const probe = (0, child_process_1.spawnSync)(name, ["--version"], { stdio: "ignore", timeout: 15_000 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.25.0",
+  "version": "0.25.2",
   "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"