@bivy/bivy 0.21.2-staging.7 → 0.21.2-staging.9

package/bin/archive-install.mjs

@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+/**
+ * Install and update from the self-contained GitHub release archives
+ * (scripts/release-archives.mjs). Layout under the install root
+ * (default ~/.local/share/bivy):
+ *
+ *   versions/<version>-<target>/   one extracted archive each
+ *   current -> versions/…          the active one, swapped atomically
+ *
+ * The launcher (current/bin/bivy) passes its unresolved `current` path as
+ * BIVY_ARCHIVE_ROOT, so a service unit or shim written through it keeps
+ * working after `current` moves to a new version.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+
+export const RELEASES_URL = "https://github.com/bivysh/bivy/releases";
+export const ARCHIVE_INFO = "bivy-archive.json";
+/** Versions kept on disk: the active one and the one before it, for rollback. */
+const KEEP = 2;
+
+/** "linux-x64" etc.: the archive target for this machine, or undefined. */
+export function archiveTarget(platform = process.platform, arch = process.arch) {
+  return ["linux", "darwin"].includes(platform) && ["x64", "arm64"].includes(arch) ? `${platform}-${arch}` : undefined;
+}
+
+/** Where a channel's manifest and archives live. `latest` is the newest stable release. */
+export function channelUrls(channel, base = process.env.BIVY_RELEASES_URL || RELEASES_URL) {
+  const dir = channel === "latest" ? `${base}/latest/download` : `${base}/download/${encodeURIComponent(channel)}`;
+  return {
+    manifest: `${dir}/manifest.json`,
+    // Stable archives are fetched from their own tag, so a release published
+    // mid-update can't swap the file under a manifest read a moment earlier.
+    archive: (manifest, file) => (channel === "latest" ? `${base}/download/v${manifest.version}/${file}` : `${dir}/${file}`),
+  };
+}
+
+/**
+ * The archive install this CLI runs from, or null. `archiveRoot` is the
+ * launcher's BIVY_ARCHIVE_ROOT; it only counts when it really is the install
+ * holding `appRoot`, so a value inherited into some other checkout is ignored.
+ */
+export function archiveInstall(archiveRoot, appRoot) {
+  if (!archiveRoot) return null;
+  try {
+    if (fs.realpathSync(path.join(archiveRoot, "app")) !== fs.realpathSync(appRoot)) return null;
+    const info = JSON.parse(fs.readFileSync(path.join(archiveRoot, ARCHIVE_INFO), "utf8"));
+    // Run as current/bin/bivy or as versions/<v>/bin/bivy, the install root is
+    // the same, and `current` is the path worth writing down.
+    const parent = path.dirname(archiveRoot);
+    const installRoot = path.basename(archiveRoot) === "current" ? parent : path.basename(parent) === "versions" ? path.dirname(parent) : undefined;
+    // An archive unpacked anywhere else runs, but has no install to update.
+    const current = path.join(installRoot ?? "", "current");
+    if (!installRoot || !fs.existsSync(current)) return null;
+    // Run through `current`, write `current`; a specific version (say, a new one
+    // being checked before the swap) stays itself.
+    const root = fs.realpathSync(archiveRoot) === fs.realpathSync(current) ? current : archiveRoot;
+    return { root, installRoot, version: info.version, target: info.target };
+  } catch {
+    return null;
+  }
+}
+
+export async function fetchManifest(url, fetchImpl = fetch) {
+  const res = await fetchImpl(url, { signal: AbortSignal.timeout(15_000) });
+  if (!res.ok) throw new Error(`Could not read the release manifest (${res.status} from ${url})`);
+  const manifest = await res.json();
+  if (typeof manifest?.version !== "string" || !manifest.archives) throw new Error(`${url} is not a Bivy release manifest`);
+  return manifest;
+}
+
+/**
+ * Fetch a large file with curl. Node's fetch can abort the process on an
+ * assertion when a server closes the connection while the body is paused
+ * for backpressure; curl is on every machine install.sh runs on.
+ */
+export function curlDownload(url, dest) {
+  const res = spawnSync("curl", ["-fsSL", "--retry", "2", "-o", dest, url], { encoding: "utf8" });
+  if (res.status !== 0) throw new Error(`Could not download ${url}: ${(res.stderr || "").trim() || `curl exit ${res.status}`}`);
+}
+
+/**
+ * Download, verify and extract one archive into versions/. Returns its
+ * directory. Nothing outside versions/ changes, so a failure here leaves the
+ * running install untouched.
+ */
+export async function stageArchive({ installRoot, manifest, target, archiveUrl, download = curlDownload }) {
+  const entry = manifest.archives[target];
+  if (!entry) throw new Error(`Bivy ${manifest.version} has no archive for ${target}`);
+  const versions = path.join(installRoot, "versions");
+  fs.mkdirSync(versions, { recursive: true });
+  const work = fs.mkdtempSync(path.join(versions, ".stage-"));
+  try {
+    const tarball = path.join(work, entry.file);
+    await download(archiveUrl(manifest, entry.file), tarball);
+    const sha256 = crypto.createHash("sha256").update(fs.readFileSync(tarball)).digest("hex");
+    if (sha256 !== entry.sha256) throw new Error(`${entry.file} failed verification: sha256 ${sha256}, the manifest says ${entry.sha256}`);
+
+    const tar = spawnSync("tar", ["-xzf", tarball, "-C", work], { encoding: "utf8" });
+    if (tar.status !== 0) throw new Error(`Could not extract ${entry.file}: ${tar.stderr}`);
+    const extracted = path.join(work, entry.file.replace(/\.tar\.gz$/, ""));
+    const info = JSON.parse(fs.readFileSync(path.join(extracted, ARCHIVE_INFO), "utf8"));
+    if (info.version !== manifest.version || info.target !== target) throw new Error(`${entry.file} holds ${info.version} ${info.target}, not ${manifest.version} ${target}`);
+
+    const dest = path.join(versions, `${manifest.version}-${target}`);
+    // Re-staging a version (a reinstall) must not replace the directory `current`
+    // points at while it runs; move it aside first and drop it afterwards.
+    const aside = fs.existsSync(dest) ? `${dest}.old-${process.pid}` : undefined;
+    if (aside) fs.renameSync(dest, aside);
+    fs.renameSync(extracted, dest);
+    if (aside) fs.rmSync(aside, { recursive: true, force: true });
+    return dest;
+  } finally {
+    fs.rmSync(work, { recursive: true, force: true });
+  }
+}
+
+/** The version directory `current` points at, or undefined. */
+export function activeVersion(installRoot) {
+  try {
+    return path.resolve(installRoot, fs.readlinkSync(path.join(installRoot, "current")));
+  } catch {
+    return undefined;
+  }
+}
+
+/** Point `current` at a version directory atomically. Returns what it pointed at before. */
+export function activate(installRoot, versionDir) {
+  const previous = activeVersion(installRoot);
+  const link = path.join(installRoot, "current");
+  const next = `${link}.next-${process.pid}`;
+  fs.rmSync(next, { force: true });
+  fs.symlinkSync(path.relative(installRoot, versionDir), next);
+  fs.renameSync(next, link);
+  return previous;
+}
+
+/** Remove version directories other than the newest KEEP, never the active one. */
+export function prune(installRoot, keep = []) {
+  const versions = path.join(installRoot, "versions");
+  const active = activeVersion(installRoot);
+  const kept = new Set([...new Set([active, ...keep].filter(Boolean).map((p) => path.resolve(p)))].slice(0, KEEP));
+  for (const name of fs.readdirSync(versions)) {
+    const dir = path.join(versions, name);
+    if (!kept.has(dir)) fs.rmSync(dir, { recursive: true, force: true });
+  }
+}

package/bin/bivy.mjs

@@ -45,11 +45,16 @@ import { parseTailscaleStatus, serveConflict, serveFailureHint, serveOffArgs, se
 import { resolveAttachSessionId } from "./attach-session-id.mjs";
 import { detectInstallKind as classifyInstallKind, managedInstall, npmGlobalPrefix } from "./install-kind.mjs";
 import { hasConfiguredService as configuredServiceExists } from "./service-state.mjs";
+import { activate, activeVersion, archiveInstall, archiveTarget, channelUrls, fetchManifest, prune, stageArchive } from "./archive-install.mjs";
 import { COMMANDS, EXIT, cliError, completionWords, describeCli, describeCommand, describeTools, renderHelp, resolveCommand, subcommandTable, suggestCommands, toolArgv, wantsJson } from "./cli-commands.mjs";
 
-const selfScript = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(selfScript);
-const repoRoot = path.resolve(__dirname, "..");
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// A GitHub release archive install runs through its launcher, which names the
+// install's `current` path. Paths written to disk (service unit, shims) use it,
+// so they stay valid when an update points `current` at a new version.
+const archive = archiveInstall(process.env.BIVY_ARCHIVE_ROOT, path.resolve(__dirname, ".."));
+const repoRoot = archive ? path.join(archive.root, "app") : path.resolve(__dirname, "..");
+const selfScript = path.join(repoRoot, "bin", "bivy.mjs");
 // Mutable node state (config, relay E2E keys, sessions, logs) must live in a
 // stable, user-owned directory that survives reinstalls. Pick it by install type:
 //   - BIVY_DATA_DIR set                         -> honor it (explicit override)
@@ -77,10 +82,11 @@ process.env.BIVY_DATA_DIR = appDir;
 //   - "git"        dev checkout (has .git)
 //   - "npx"        ephemeral `npx bivy` run (repoRoot under an npm _npx cache)
 //   - "npm-global" `npm i -g @bivy/bivy` (repoRoot is below node_modules/@bivy)
+//   - "archive"    a GitHub release archive under ~/.local/share/bivy (install.sh)
 //   - "packaged"   install.sh tarball tree (user-owned, self-preserving)
 //   - "managed"    a system package (the AUR's `bivy`), updated by its manager
 function detectInstallKind() {
-  return classifyInstallKind(repoRoot);
+  return archive ? "archive" : classifyInstallKind(repoRoot);
 }
 const cliConfigPath = path.join(appDir, "cli.json");
 const canonicalConfigPath = path.join(appDir, "config.yaml");
@@ -185,7 +191,7 @@ const mcpProxyEntry = path.join(repoRoot, packaged ? "dist/harness/mcp-proxy-cli
 const mcpServeEntry = path.join(repoRoot, packaged ? "dist/harness/mcp-serve-cli.js" : "src/harness/mcp-serve-cli.ts");
 const qrEntry = path.join(repoRoot, "public", "qr.js");
 const tsxCli = packaged ? "" : path.join(repoRoot, "node_modules", "tsx", "dist", "cli.mjs");
-const nodeBin = process.execPath;
+const nodeBin = archive ? path.join(archive.root, "runtime", "bin", "node") : process.execPath;
 const nodeScriptArgs = (entry) => (tsxCli ? [tsxCli, entry] : [entry]);
 
 // Resolve the baked-in hosted endpoints (app/relay/client URLs). Imported lazily
@@ -230,7 +236,7 @@ function commandPath(extraPath = "") {
     process.env.PATH || "",
     // npm global executables normally live beside the Node binary (including
     // nvm/fnm installs). Services need this even without shell initialization.
-    path.dirname(process.execPath),
+    path.dirname(nodeBin),
   ].filter(Boolean);
   return [...new Set(parts.flatMap((part) => String(part).split(path.delimiter)).filter(Boolean))].join(path.delimiter);
 }
@@ -4065,6 +4071,7 @@ function plistContent(config) {
     PORT: String(config.port),
     BIVY_WORKSPACE: config.workspace,
     BIVY_DATA_DIR: appDir,
+    ...(archive ? { BIVY_ARCHIVE_ROOT: archive.root } : {}),
     ...config.env,
     PATH: commandPath(config.env?.PATH),
   })
@@ -4109,6 +4116,7 @@ function systemdContent(config) {
     PORT: String(config.port),
     BIVY_WORKSPACE: config.workspace,
     BIVY_DATA_DIR: appDir,
+    ...(archive ? { BIVY_ARCHIVE_ROOT: archive.root } : {}),
     ...config.env,
     PATH: commandPath(config.env?.PATH),
   })
@@ -5515,6 +5523,49 @@ async function cmdUpdate(args = []) {
   await runUpdate(args);
 }
 
+/**
+ * Update a GitHub release archive install: stage the channel's archive beside
+ * the running one, point `current` at it, restart, and point `current` back if
+ * the node doesn't come up. The version before stays on disk for that.
+ */
+async function updateArchiveInstall(channel, { skipWait, force }) {
+  const urls = channelUrls(channel);
+  const target = archiveTarget();
+  console.log(c.dim(`Checking ${urls.manifest} (channel: ${channel})…`));
+  const manifest = await fetchManifest(urls.manifest);
+  if (manifest.version === archive.version && !force) {
+    console.log(c.green(`Bivy ${archive.version} is the newest on ${channel}.`));
+    return;
+  }
+  console.log(c.dim(`Downloading Bivy ${manifest.version} for ${target}…`));
+  const staged = await stageArchive({ installRoot: archive.installRoot, manifest, target, archiveUrl: urls.archive });
+  const probe = runQuiet(path.join(staged, "bin", "bivy"), ["--version"]);
+  if (probe.code !== 0 || probe.stdout.trim() !== manifest.version) {
+    throw new Error(`The downloaded Bivy ${manifest.version} does not run here (${(probe.stderr || probe.stdout).trim() || `exit ${probe.code}`}); kept ${archive.version}.`);
+  }
+  const config = loadConfig();
+  await waitForIdleSessions(config, { skip: skipWait });
+  const previous = activate(archive.installRoot, staged);
+  if (!hasConfiguredService(config)) {
+    prune(archive.installRoot, [staged, previous]);
+    console.log(c.green(`Updated to ${manifest.version}. Run 'bivy start' to use it.`));
+    return;
+  }
+  if ((await restartServiceReconciled(config)) && (await verifyNodeCameUp(config))) {
+    prune(archive.installRoot, [staged, previous]);
+    console.log(c.green(`Updated ${archive.version} → ${manifest.version} and restarted the background service.`));
+    return;
+  }
+  if (previous && previous !== activeVersion(archive.installRoot)) {
+    activate(archive.installRoot, previous);
+    await restartServiceReconciled(config);
+    console.log(c.red(`⚠ Bivy ${manifest.version} did not come up, so ${archive.version} is back in place.`));
+  } else {
+    reportNodeDidNotStart();
+  }
+  process.exitCode = 1;
+}
+
 async function runUpdate(args = []) {
   const skipWait = args.includes("--force") || args.includes("--no-wait");
   const kind = detectInstallKind();
@@ -5564,6 +5615,12 @@ async function runUpdate(args = []) {
     return;
   }
 
+  if (kind === "archive") {
+    await updateArchiveInstall(channel, { skipWait, force: args.includes("--force") });
+    console.log(c.dim(`=== bivy update finished ${new Date().toISOString()} ===`));
+    return;
+  }
+
   if (kind === "packaged") {
     console.log(c.dim(`Updating packaged Bivy install (channel: ${channel})…`));
     // The actual restart happens inside install.sh, which shells out to

package/dist/node-update.js

@@ -18,7 +18,28 @@ export function managedInstall(packageRoot) {
     }
     return null;
 }
-export function updateRegistryUrl(appDir, override) {
+/**
+ * True when this daemon runs from a GitHub release archive install: the
+ * launcher's BIVY_ARCHIVE_ROOT names the install holding `packageRoot` (the
+ * same check bin/archive-install.mjs makes for the CLI).
+ */
+export function isArchiveInstall(packageRoot, archiveRoot = process.env.BIVY_ARCHIVE_ROOT) {
+    if (!archiveRoot)
+        return false;
+    try {
+        return fs.realpathSync(path.join(archiveRoot, "app")) === fs.realpathSync(packageRoot)
+            && fs.existsSync(path.join(archiveRoot, "bivy-archive.json"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Where to look for a newer version on the install's recorded channel: the npm
+ * registry, or for an archive install the channel's GitHub release manifest
+ * (URLs as in bin/archive-install.mjs). Both answer with `{ version }`.
+ */
+export function updateRegistryUrl(appDir, override, archive = false) {
     if (override)
         return override;
     let channel = "latest";
@@ -28,6 +49,10 @@ export function updateRegistryUrl(appDir, override) {
             channel = recorded;
     }
     catch { /* Existing installs track stable. */ }
+    if (archive) {
+        const releases = process.env.BIVY_RELEASES_URL || "https://github.com/bivysh/bivy/releases";
+        return channel === "latest" ? `${releases}/latest/download/manifest.json` : `${releases}/download/${encodeURIComponent(channel)}/manifest.json`;
+    }
     return `https://registry.npmjs.org/%40bivy%2Fbivy/${encodeURIComponent(channel)}`;
 }
 /** Running version is fixed for this process, never re-read after an install. */

package/dist/server.js

@@ -3,7 +3,7 @@
 // First: drop agent-session markers the node inherited before anything reads them.
 import "./node-env.js";
 import fs from "node:fs";
-import { createNodeUpdateChecker, managedInstall, updateRegistryUrl } from "./node-update.js";
+import { createNodeUpdateChecker, isArchiveInstall, managedInstall, updateRegistryUrl } from "./node-update.js";
 import { createRemoteSessionAdmission, RemoteSessionAdmissionError } from "./session/remote-session-admission.js";
 import { requiresExistingSession, resolveTargetSession } from "./session/target-session.js";
 import path from "node:path";
@@ -114,7 +114,7 @@ import { SessionAllowRules } from "./policy/session-allow.js";
 import { TerminalManager } from "./terminal.js";
 import { launchCommand } from "./command-launch.js";
 import { listMultiplexerSessions } from "./multiplexer.js";
-import { createWorktree, removeWorktree, gitRepoRoot } from "./worktree.js";
+import { createWorktree, removeWorktree, gitRepoRoot, isManagedWorktreePath, reapedWorktreeBranch } from "./worktree.js";
 import { HarnessManager } from "./harness/manager.js";
 import { startEgressProxyIfEnabled, applySessionSandboxEgress, stopSessionEgress } from "./harness/egress.js";
 import { initSharedDepCache, sharedDepCacheRoot } from "./harness/dep-cache.js";
@@ -824,9 +824,10 @@ const sessionRunPolicy = {
 if (process.env.BIVY_SESSION_MODEL_FALLBACK) {
     console.log(`[policy] in-session model reroute enabled: ${process.env.BIVY_SESSION_MODEL_FALLBACK}`);
 }
+const archiveInstalled = isArchiveInstall(repoRoot);
 const nodeUpdates = createNodeUpdateChecker({
     current: currentVersion() ?? "",
-    registryUrl: () => updateRegistryUrl(appDir, process.env.BIVY_UPDATE_REGISTRY_URL),
+    registryUrl: () => updateRegistryUrl(appDir, process.env.BIVY_UPDATE_REGISTRY_URL, archiveInstalled),
     publish: (state) => broadcast(state),
 });
 function runtimeSummary(rt) {
@@ -7012,10 +7013,6 @@ function closeIdleSessions() {
             closeSessionRecord(record, "idle-timeout");
     }
 }
-function isManagedWorktreePath(wtPath) {
-    const parts = path.resolve(wtPath).split(path.sep);
-    return parts.length >= 3 && parts[parts.length - 3] === ".bivy" && parts[parts.length - 2] === "worktrees";
-}
 function sessionTimestampMs(value) {
     const ms = value ? new Date(value).getTime() : NaN;
     return Number.isFinite(ms) ? ms : 0;
@@ -8629,20 +8626,21 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     // or branch is gone, we leave it to the invariant to fail safe rather than
     // corrupt a neighbour. The clone root is reconstructed from `source`
     // (`repo:owner/repo`) because stored `workspace` is the old worktree path.
-    if (requestedSessionFile && !worktree && storedMeta?.worktree && storedMeta?.branch) {
-        const parsedSource = parseRepoSource(storedMeta.source);
+    const reapedBranch = requestedSessionFile && !worktree ? reapedWorktreeBranch(storedMeta) : undefined;
+    if (reapedBranch) {
+        const parsedSource = parseRepoSource(storedMeta?.source);
         if (parsedSource) {
             const repoDir = path.join(reposRoot, `${parsedSource.owner}__${parsedSource.repo}`);
             try {
                 // Clear any stale registration left by a dir that was rm'd out from under
                 // git, so re-adding the branch's worktree doesn't hit "already checked out".
                 runGit(["worktree", "prune"], repoDir);
-                const reprovisioned = await createWorktree({ repoDir, id: storedMeta.branch, branch: storedMeta.branch });
+                const reprovisioned = await createWorktree({ repoDir, id: reapedBranch, branch: reapedBranch });
                 worktree = reprovisioned;
                 runtimeWorkspace = reprovisioned.path;
             }
             catch (error) {
-                console.warn(`Could not re-provision worktree for resumed session on ${storedMeta.branch}: ${error instanceof Error ? error.message : String(error)}`);
+                console.warn(`Could not re-provision worktree for resumed session on ${reapedBranch}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
     }

package/dist/worktree.js

@@ -19,6 +19,23 @@ export function branchSlug(input) {
         .replace(/^[-.]+|[-.]+$/g, "")
         .slice(0, 60) || "task");
 }
+/** A Bivy-managed worktree lives at `<repo>/.bivy/worktrees/<name>`. */
+export function isManagedWorktreePath(wtPath) {
+    const parts = path.resolve(wtPath).split(path.sep);
+    return parts.length >= 3 && parts[parts.length - 3] === ".bivy" && parts[parts.length - 2] === "worktrees";
+}
+/**
+ * The branch to re-provision when a worktree session is reopened after its
+ * directory was removed, else undefined. Worktree cleanup clears `worktree` but
+ * leaves `workspace` on the old managed path, so either one marks the session
+ * as having run in a worktree.
+ */
+export function reapedWorktreeBranch(meta) {
+    if (!meta?.branch)
+        return undefined;
+    const wtPath = meta.worktree ?? (meta.workspace && isManagedWorktreePath(meta.workspace) ? meta.workspace : undefined);
+    return wtPath && !fs.existsSync(wtPath) ? meta.branch : undefined;
+}
 /** The toplevel of the git repo containing `dir`, or undefined if not a repo. */
 export async function gitRepoRoot(dir) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.21.2-staging.7",
+  "version": "0.21.2-staging.9",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",