@bivy/bivy 0.6.0-staging.82 → 0.6.0-staging.83

package/dist/server.js

@@ -535,7 +535,9 @@ if (sessionRunPolicy) {
     console.log(`[policy] in-session model reroute enabled: ${process.env.BIVY_SESSION_MODEL_FALLBACK}`);
 }
 let lastUpdateCheckAt = 0;
-let updateNoticeSentFor = "";
+// The most recent "this node is behind" finding, so a client that connects after
+// the check already ran still gets the banner (replayed on connect below).
+let pendingBivyUpdate = null;
 function runtimeSummary(rt) {
     return runtimeHost.summary(rt);
 }
@@ -625,11 +627,11 @@ function readJsonFile(file) {
         return undefined;
     }
 }
-async function maybeNotifyBivyUpdate(record) {
-    // The daemon creates an initial session during startup before any UI is
-    // connected. Don't consume the once-per-version notice until someone can see it.
-    if (clients.size === 0 && !relay)
-        return;
+// Poll npm for a newer release (throttled to every 6h). On finding one, remember
+// it and push a dedicated `node.update` event so every connected app can show a
+// banner with a one-tap "Update this node" button (see runBivyUpdate). Safe to
+// call from anywhere — never throws, never interrupts a session.
+async function checkBivyUpdate() {
     const now = Date.now();
     if (now - lastUpdateCheckAt < 6 * 60 * 60 * 1000)
         return;
@@ -641,25 +643,48 @@ async function maybeNotifyBivyUpdate(record) {
         const res = await fetch(updateRegistryUrl, { signal: AbortSignal.timeout(5000) });
         if (!res.ok)
             return;
-        const latestVersion = (await res.json()).version;
-        if (!latestVersion || !isNewerVersion(latestVersion, current))
+        const latest = (await res.json()).version;
+        if (!latest || !isNewerVersion(latest, current))
             return;
-        if (updateNoticeSentFor === latestVersion)
-            return;
-        updateNoticeSentFor = latestVersion;
-        const label = ` ${latestVersion}`;
-        broadcast({
-            type: "session.notice",
-            sessionId: record.id,
-            level: "info",
-            message: `A newer Bivy version${label} is available. Run \`bivy update\` in your terminal to update.`,
-            action: "bivy update",
-        });
+        pendingBivyUpdate = { current, latest };
+        broadcast({ type: "node.update", current, latest });
     }
     catch {
         // Best-effort update checks should never interrupt a session.
     }
 }
+async function maybeNotifyBivyUpdate() {
+    // The daemon creates an initial session during startup before any UI is
+    // connected. Don't spend a check until someone can see the banner.
+    if (clients.size === 0 && !relay)
+        return;
+    await checkBivyUpdate();
+}
+// Run `bivy update` on this node, the same command a user would type. The CLI
+// re-spawns itself detached, waits for any in-flight turn, updates, and restarts
+// the service (logging to update.log), so we just fire-and-forget it here. The
+// bin ships next to this server bundle in both the git checkout (src/server.ts)
+// and the published package (dist/server.js), so repoRoot/bin/bivy.mjs resolves
+// in both. Returns a friendly error instead of throwing when it can't be found
+// (e.g. an unusual layout), so the banner can fall back to the manual command.
+function runBivyUpdate() {
+    const script = path.join(repoRoot, "bin", "bivy.mjs");
+    if (!fs.existsSync(script)) {
+        return { ok: false, error: "Could not locate the bivy CLI on this node — run `bivy update` in a terminal." };
+    }
+    try {
+        const child = spawn(process.execPath, [script, "update"], {
+            detached: true,
+            stdio: "ignore",
+            env: process.env,
+        });
+        child.unref();
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
 function runtimeInstallSpec(requested) {
     let id = String(requested ?? "").trim().toLowerCase();
     // Normalize a few historical aliases to their canonical runtime id.
@@ -2597,6 +2622,14 @@ const RELAY_COMMANDS = {
     ping(msg, ctx) {
         ctx.reply({ type: "pong", requestId: typeof msg.requestId === "string" ? msg.requestId : undefined });
     },
+    // Kick off `bivy update` on this node from the app's version-mismatch banner
+    // (see runBivyUpdate). The node restarts itself when the update lands, so the
+    // client just sees the socket reconnect on the new build; a failure to even
+    // start reports back so the banner can show the manual command.
+    "node.update"(_msg, ctx) {
+        const result = runBivyUpdate();
+        ctx.reply({ type: "node.update.result", ok: result.ok, error: result.error });
+    },
     // Fetch a stored attachment's bytes by content hash. The relay client (a phone
     // not on the LAN) can't reach the GET /api/attachment endpoint, so it fetches
     // over the encrypted tunnel instead; the relay framing chunks the base64 payload
@@ -7640,7 +7673,7 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
         if (makeActive)
             active = existing;
         broadcast({ type: "session.created", sessionId: existing.id, name: existing.session.getName(), workspace: existing.workspace, sessionFile: existing.sessionFile, source: existing.source, branch: existing.worktree?.branch, prUrl: existing.prUrl, runtimeId: existing.runtimeId, agentName: getRuntime(existing.runtimeId).displayName, bivySession: bivySessionEnvelope(existing), capabilities: capabilitiesWithCommands(existing.runtimeId, existing.session) });
-        void maybeNotifyBivyUpdate(existing);
+        void maybeNotifyBivyUpdate();
         return existing;
     }
     // Pick the agent for this session (fixed for its life). Resuming a tagged
@@ -7829,7 +7862,7 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     if (makeActive)
         active = record;
     broadcast({ type: "session.created", sessionId, name: record.session.getName(), workspace: sessionWorkspace, sessionFile: record.sessionFile, source: record.source, branch: worktree?.branch, prUrl: record.prUrl, runtimeId: rt.id, agentName: rt.displayName, modelFallbackMessage, bivySession: bivySessionEnvelope(record), capabilities: capabilitiesWithCommands(rt.id, record.session) });
-    void maybeNotifyBivyUpdate(record);
+    void maybeNotifyBivyUpdate();
     scheduleAdvertise();
     return record;
 }
@@ -8544,6 +8577,16 @@ app.get("/api/node/info", (_req, res) => {
         sandbox: sandboxInfo(),
     });
 });
+// One-tap "Update this node" from the app's version-mismatch banner, for
+// direct/LAN clients (the relay path uses the RELAY_COMMANDS "node.update"
+// handler). Both call the same runBivyUpdate.
+app.post("/api/node/update", (_req, res) => {
+    const result = runBivyUpdate();
+    if (result.ok)
+        res.json({ ok: true });
+    else
+        res.status(500).json({ ok: false, error: result.error });
+});
 // Build collectNodeStats() options, resolving the optional session so the panel
 // can attribute a session-scoped tier (its live agent process + workspace size).
 function nodeStatsOptsFor(sessionId) {
@@ -10444,6 +10487,14 @@ wss.on("connection", (socket, req) => {
     // sharing a PTY size it to their min (see TerminalManager.setClientSize).
     const clientTerminalId = `sock-${randomUUID()}`;
     socket.send(JSON.stringify({ type: "hello", activeSessionId: active?.id, activeSession: active ? { id: active.id, isStreaming: sessionBusy(active), lastActivity: active.lastActivity, workingStartedAt: active.workingStartedAt } : null }));
+    // Authoritative version status on every connect: `latest` set means this node
+    // is behind (banner shows); absent means up to date (banner + any "Updating…"
+    // state clear — this is how the banner disappears after an update lands and
+    // the socket reconnects on the new build). Then (re)run the throttled check so
+    // a freshly-opened app surfaces a newly-available update without waiting for a
+    // session turn.
+    socket.send(JSON.stringify({ type: "node.update", current: currentVersion() ?? "", latest: pendingBivyUpdate?.latest }));
+    void checkBivyUpdate();
     socket.on("message", (raw) => {
         let msg;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.6.0-staging.82",
+  "version": "0.6.0-staging.83",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",