@bubblebrain-ai/bubble 0.0.13 → 0.0.15

package/dist/update/index.js

@@ -0,0 +1,240 @@
+/**
+ * Self-update: `bubble update` / `bubble upgrade`, plus a cached startup
+ * "update available" check.
+ *
+ * Bubble ships as the npm package `@bubblebrain-ai/bubble`. Updating just means
+ * re-installing it globally with whatever package manager put it there, so we
+ * detect the install method and run the matching command.
+ */
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { realpathSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+const require = createRequire(import.meta.url);
+export const PACKAGE_NAME = "@bubblebrain-ai/bubble";
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // once a day
+export function getCurrentVersion() {
+    try {
+        const pkg = require("../../package.json");
+        return pkg.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export async function fetchLatestVersion(timeoutMs = 5000) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(REGISTRY_URL, {
+                signal: controller.signal,
+                headers: { accept: "application/json" },
+            });
+            if (!res.ok)
+                return null;
+            const data = (await res.json());
+            return data.version ?? null;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Compare two semver-ish strings. Returns 1 if a > b, -1 if a < b, 0 if equal.
+ * Handles `x.y.z` and a single pre-release tag (`x.y.z-beta.1`); a release
+ * always outranks a pre-release of the same numeric version.
+ */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const cleaned = v.trim().replace(/^v/, "");
+        const [core, pre] = cleaned.split("-", 2);
+        const nums = core.split(".").map((n) => parseInt(n, 10) || 0);
+        while (nums.length < 3)
+            nums.push(0);
+        return { nums, pre: pre ?? "" };
+    };
+    const pa = parse(a);
+    const pb = parse(b);
+    for (let i = 0; i < 3; i++) {
+        if (pa.nums[i] > pb.nums[i])
+            return 1;
+        if (pa.nums[i] < pb.nums[i])
+            return -1;
+    }
+    // Equal numeric core: no pre-release beats a pre-release.
+    if (pa.pre === pb.pre)
+        return 0;
+    if (!pa.pre)
+        return 1;
+    if (!pb.pre)
+        return -1;
+    return pa.pre > pb.pre ? 1 : -1;
+}
+/**
+ * Figure out how this copy of Bubble was installed by inspecting the real path
+ * of the package directory (two levels up from this module: dist/update -> pkg).
+ */
+export function detectInstall() {
+    const rawRoot = fileURLToPath(new URL("../../", import.meta.url));
+    let installPath = rawRoot;
+    try {
+        installPath = realpathSync(rawRoot);
+    }
+    catch {
+        // keep rawRoot
+    }
+    const lower = installPath.replace(/\\/g, "/").toLowerCase();
+    const isUnderNodeModules = lower.includes("/node_modules/");
+    // A dev/source checkout has src/ alongside dist/ and isn't under node_modules.
+    const isLocalCheckout = !isUnderNodeModules;
+    let manager = "unknown";
+    if (lower.includes("/cellar/") || lower.includes("/homebrew/")) {
+        manager = "homebrew";
+    }
+    else if (lower.includes("/.bun/") || lower.includes("/bun/install/")) {
+        manager = "bun";
+    }
+    else if (lower.includes("/pnpm/") || lower.includes("/.pnpm/")) {
+        manager = "pnpm";
+    }
+    else if (lower.includes("/.yarn/") || lower.includes("/yarn/global")) {
+        manager = "yarn";
+    }
+    else if (isUnderNodeModules) {
+        manager = "npm";
+    }
+    return { manager, isGlobal: isUnderNodeModules, isLocalCheckout, installPath };
+}
+export function upgradeCommandFor(manager) {
+    const spec = `${PACKAGE_NAME}@latest`;
+    switch (manager) {
+        case "npm":
+        case "unknown": // default to npm
+            return { cmd: "npm", args: ["install", "-g", spec] };
+        case "bun":
+            return { cmd: "bun", args: ["add", "-g", spec] };
+        case "pnpm":
+            return { cmd: "pnpm", args: ["add", "-g", spec] };
+        case "yarn":
+            return { cmd: "yarn", args: ["global", "add", spec] };
+        case "homebrew":
+            return null; // handled separately (brew upgrade)
+    }
+}
+function spawnInherit(cmd, args) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: "inherit", env: process.env });
+        child.on("error", () => resolve(127));
+        child.on("exit", (code) => resolve(code ?? 1));
+    });
+}
+/**
+ * `bubble update` entry point. Returns a process exit code.
+ */
+export async function runUpdateCommand(opts = {}) {
+    const current = getCurrentVersion();
+    process.stdout.write(`Bubble v${current}\n`);
+    process.stdout.write("Checking npm for the latest version…\n");
+    const latest = await fetchLatestVersion();
+    if (!latest) {
+        process.stderr.write("Could not reach the npm registry. Check your connection and try again.\n");
+        return 1;
+    }
+    if (compareVersions(latest, current) <= 0) {
+        process.stdout.write(`You're already on the latest version (v${current}).\n`);
+        return 0;
+    }
+    process.stdout.write(`Update available: v${current} → v${latest}\n`);
+    if (opts.checkOnly) {
+        process.stdout.write("Run `bubble update` to install it.\n");
+        return 0;
+    }
+    const info = detectInstall();
+    if (info.isLocalCheckout) {
+        process.stderr.write("This looks like a local/development checkout, not a global install.\n" +
+            "Update it with:\n  git pull && npm run build\n");
+        return 1;
+    }
+    if (info.manager === "homebrew") {
+        process.stderr.write("Bubble was installed via Homebrew. Update it with:\n  brew upgrade bubble\n");
+        return 1;
+    }
+    const command = upgradeCommandFor(info.manager);
+    if (!command) {
+        process.stderr.write(`Couldn't determine how to update automatically. Run:\n  npm install -g ${PACKAGE_NAME}@latest\n`);
+        return 1;
+    }
+    process.stdout.write(`\nUpdating via ${command.cmd}…\n\n`);
+    const code = await spawnInherit(command.cmd, command.args);
+    if (code === 0) {
+        process.stdout.write(`\n✓ Updated to v${latest}. Restart bubble to use the new version.\n`);
+        return 0;
+    }
+    process.stderr.write(`\nUpdate failed (exit ${code}). Try running it manually:\n  ${command.cmd} ${command.args.join(" ")}\n` +
+        "If this is a permissions error, you may need elevated privileges or to fix your global install prefix.\n");
+    return code;
+}
+function cacheFile() {
+    return join(getBubbleHome(), "update-check.json");
+}
+async function readCache() {
+    try {
+        const raw = await readFile(cacheFile(), "utf8");
+        const data = JSON.parse(raw);
+        if (typeof data.lastCheck === "number" && typeof data.latest === "string") {
+            return { lastCheck: data.lastCheck, latest: data.latest };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(cache) {
+    try {
+        const file = cacheFile();
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify(cache), "utf8");
+    }
+    catch {
+        // best-effort; never fail startup over a cache write
+    }
+}
+async function refreshCacheInBackground(now) {
+    const latest = await fetchLatestVersion(4000);
+    if (latest) {
+        await writeCache({ lastCheck: now, latest });
+    }
+}
+/**
+ * Returns a one-line "update available" notice if the cached latest version is
+ * newer than the running one. Reads only a local cache file (fast, no network
+ * on the hot path); a stale cache triggers a fire-and-forget refresh so the
+ * next launch is accurate. Never throws.
+ */
+export async function getStartupUpdateNotice() {
+    try {
+        const current = getCurrentVersion();
+        const now = Date.now();
+        const cache = await readCache();
+        if (!cache || now - cache.lastCheck > CHECK_INTERVAL_MS) {
+            void refreshCacheInBackground(now);
+        }
+        if (cache && compareVersions(cache.latest, current) > 0) {
+            return `Update available: v${current} → v${cache.latest} · run \`bubble update\``;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {