@bivy/bivy 0.21.1 → 0.21.2-staging.10

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";
@@ -240,9 +240,6 @@ try {
         if (process.env[key] === undefined)
             process.env[key] = value;
     }
-    if (canonicalNodeConfig.agents && process.env.BIVY_CUSTOM_AGENTS === undefined) {
-        process.env.BIVY_CUSTOM_AGENTS = JSON.stringify(Object.entries(canonicalNodeConfig.agents).map(([id, spec]) => ({ id, ...spec })));
-    }
     if (canonicalNodeConfig.automation?.checks && process.env.BIVY_AUTOMATION_CHECKS === undefined) {
         process.env.BIVY_AUTOMATION_CHECKS = JSON.stringify(canonicalNodeConfig.automation.checks);
     }
@@ -827,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) {
@@ -1081,7 +1079,7 @@ const linkedDevices = createLinkedDeviceController({
         syncPairingMetadata();
         relay?.pushRotate(deliveries);
         broadcast({ type: "devices.updated", devices });
-        void resealRetiredAutomationTemplates();
+        void checkAutomationTemplates();
     },
 });
 const accessDevices = createAccessDeviceController({
@@ -2123,11 +2121,9 @@ retireTranscriptsDir();
 const sessionNewDedupe = createSessionNewDedupe();
 const dedupeSessionNew = (requestId, create) => sessionNewDedupe.run(requestId, create);
 // Idempotency for `prompt`, keyed by the client's clientMessageId (the same
-// generic key->promise cache as above, reused for a different key) — see
-// issue #154's queued follow-ups. A client that isn't sure whether a queued
-// item's send actually reached the node before the socket dropped (see
-// FollowupCoordinator.retrySending) resends it verbatim after reconnecting;
-// this makes that safe by collapsing a retried clientMessageId onto the
+// generic key->promise cache as above, reused for a different key). A client
+// that isn't sure whether a prompt reached the node before the socket dropped
+// resends it verbatim after reconnecting; this makes that safe by collapsing a retried clientMessageId onto the
 // original broadcast + turn instead of double-prompting the runtime. The key is
 // kept for a day, not session.new's 10 minutes: a phone backgrounded mid-send
 // can reconnect long after the turn ended, and an expired key turned its
@@ -3548,7 +3544,7 @@ function startRelayIfConfigured() {
     if (config.controlPlaneUrl && config.enrollmentToken) {
         sessionAdvertiseTarget = { controlPlaneUrl: config.controlPlaneUrl, enrollmentToken: config.enrollmentToken };
         void syncModelAuthFromControlPlane();
-        void resealRetiredAutomationTemplates();
+        void checkAutomationTemplates();
         if (remoteRuntimeEnabled()) {
             // Stage 3: layer a control-plane-backed location registry UNDER the in-memory
             // one (so a lookup surviving a restart resolves from durable state), then
@@ -3678,27 +3674,36 @@ async function modelAuthFetch(pathname, init = {}) {
 }
 // A device revoke rotates the room key. Re-seal this node's stored automation
 // instructions under the new key so the node and its devices can still read
-// them, then drop the retired keys. Retried at startup until it completes.
-async function resealRetiredAutomationTemplates() {
-    const retired = pairingStore.retiredRoomKeys();
-    if (!retired.length || !sessionAdvertiseTarget)
+// them, then drop the retired keys. Instructions no key opens are flagged so the
+// automation list asks for them again. Runs at every start (retried there until
+// it completes), after a revoke, and when a run can't open its instructions.
+let automationTemplateCheck = null;
+function checkAutomationTemplates() {
+    automationTemplateCheck ??= reconcileAutomationTemplates().finally(() => { automationTemplateCheck = null; });
+    return automationTemplateCheck;
+}
+async function reconcileAutomationTemplates() {
+    if (!sessionAdvertiseTarget)
         return;
+    const retired = pairingStore.retiredRoomKeys();
     const current = pairingStore.roomKey();
     try {
         const res = await modelAuthFetch("/node/automation-templates");
         if (!res?.ok)
             throw new Error(`control plane returned ${res?.status}`);
         const { templates } = await res.json();
+        const call = async (pathname, init) => {
+            const out = await modelAuthFetch(pathname, init);
+            if (!out?.ok)
+                throw new Error(`control plane returned ${out?.status}`);
+        };
         const result = await resealAutomationTemplates({
             nodeId: identity.nodeId,
             current,
             retired,
             templates,
-            save: async (id, templateCiphertext) => {
-                const saved = await modelAuthFetch(`/node/automation-templates/${encodeURIComponent(id)}`, { method: "PUT", body: JSON.stringify({ templateCiphertext }) });
-                if (!saved?.ok)
-                    throw new Error(`control plane returned ${saved?.status}`);
-            },
+            save: (id, templateCiphertext) => call(`/node/automation-templates/${encodeURIComponent(id)}`, { method: "PUT", body: JSON.stringify({ templateCiphertext }) }),
+            markUnreadable: (id) => call(`/node/automation-templates/${encodeURIComponent(id)}/unreadable`, { method: "POST" }),
         });
         if (result.resealed)
             console.log(`[automation-reseal] re-sealed ${result.resealed} automation template(s) under the rotated room key`);
@@ -3706,8 +3711,9 @@ async function resealRetiredAutomationTemplates() {
             console.warn(`[automation-reseal] ${result.unreadable.length} automation template(s) were sealed under a key this node no longer has: ${result.unreadable.join(", ")}`);
         // Another rotation during this pass retired `current`; run again for it.
         if (!pairingStore.roomKey().equals(current))
-            return void resealRetiredAutomationTemplates();
-        pairingStore.forgetRetiredRoomKeys();
+            return reconcileAutomationTemplates();
+        if (retired.length)
+            pairingStore.forgetRetiredRoomKeys();
     }
     catch (error) {
         console.warn("[automation-reseal] will retry at next start:", error.message);
@@ -5477,6 +5483,7 @@ async function executeWorkItem(item, report, signal) {
             item = { ...item, body: template.instructions };
         }
         catch {
+            void checkAutomationTemplates();
             throw new Error("could not decrypt automation instructions on this node");
         }
     }
@@ -7004,10 +7011,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;
@@ -8447,8 +8450,8 @@ async function tryAttachLiveRemote(sessionId, options) {
     }
 }
 /** Re-open a runtime that still reports streaming shortly after a manual Stop.
- * The client is settled immediately by the abort handler; prompts arriving from
- * its follow-up queue await this promise and therefore cannot be steered into the
+ * The client is settled immediately by the abort handler; prompts arriving
+ * right after the Stop await this promise and therefore cannot be steered into the
  * stale in-process Pi turn. */
 async function recoverRecordAfterAbort(record) {
     const oldSession = record.session;
@@ -8621,20 +8624,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.1",
+  "version": "0.21.2-staging.10",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",