@bivy/bivy 0.3.0-staging.42 → 0.3.0-staging.44

package/dist/device-registry.js

@@ -6,6 +6,26 @@ import { randomUUID } from "node:crypto";
 import { generatePairingKeypair, generateRoomKey, generatePairSecret, deriveWrapKey, verifyPairingProof, wrapRoomKey, } from "./pairing-crypto.js";
 import { seal, open } from "./e2e.js";
 const DEFAULT_PAIR_TTL_MS = 5 * 60_000;
+const ROOM_KEY_BYTES = 32;
+/**
+ * Validate + canonicalize a pre-shared room-key seed. Returns the canonical
+ * base64 of a well-formed 32-byte key, or undefined for anything malformed
+ * (missing, wrong length, non-base64) so the caller falls back to a fresh key
+ * rather than adopting a bad seed that would make every device unable to decrypt.
+ */
+function normalizeSeedRoomKey(seedRoomKeyB64) {
+    if (!seedRoomKeyB64)
+        return undefined;
+    try {
+        const buf = Buffer.from(seedRoomKeyB64, "base64");
+        if (buf.length !== ROOM_KEY_BYTES)
+            return undefined;
+        return buf.toString("base64");
+    }
+    catch {
+        return undefined;
+    }
+}
 export class PairingStore {
     filePath;
     data;
@@ -18,8 +38,17 @@ export class PairingStore {
      * Load (or create) the pairing state. A fresh state gets a randomly generated
      * room key; devices receive it (and every later rotation) over the X25519
      * pairing handshake, so there is no static seed to carry forward.
+     *
+     * `seedRoomKeyB64` (base64 32-byte key) is the ONE exception: an ephemeral
+     * REBUILD reuses a torn-down session's node id and must decrypt a snapshot
+     * sealed under that session's original room key. The launching device/CP bakes
+     * that key into relay.json (`e2eKey`) and the daemon passes it here, so a
+     * brand-new pairing state adopts it instead of minting a fresh one. It is used
+     * ONLY when there is no existing pairing.json — an already-paired node never
+     * has its room key overwritten. An absent/malformed seed falls back to a fresh
+     * random key (the ordinary first-run path).
      */
-    static load(appDir) {
+    static load(appDir, seedRoomKeyB64) {
         const filePath = path.join(appDir, "pairing.json");
         let raw;
         try {
@@ -55,9 +84,12 @@ export class PairingStore {
                 devices: Array.isArray(parsed.devices) ? parsed.devices : [],
             });
         }
+        // No pairing.json yet — first run. Adopt a valid pre-shared seed (ephemeral
+        // rebuild) if one was supplied; otherwise mint a fresh random room key.
+        const seededRoomKey = normalizeSeedRoomKey(seedRoomKeyB64);
         const data = {
             nodeKeypair: generatePairingKeypair(),
-            roomKeyB64: generateRoomKey().toString("base64"),
+            roomKeyB64: seededRoomKey ?? generateRoomKey().toString("base64"),
             devices: [],
         };
         const store = new PairingStore(filePath, data);

package/dist/relay-client.js

@@ -26,7 +26,8 @@ export function loadRelayConfig(appDir) {
         return null;
     const controlPlaneUrl = process.env.BIVY_CONTROL_PLANE_URL ?? raw.controlPlaneUrl;
     const clientBaseUrl = process.env.BIVY_CLIENT_BASE_URL ?? raw.clientBaseUrl ?? controlPlaneUrl;
-    return { url, enrollmentToken, controlPlaneUrl, clientBaseUrl };
+    const e2eKey = process.env.BIVY_ROOM_KEY ?? raw.e2eKey;
+    return { url, enrollmentToken, controlPlaneUrl, clientBaseUrl, e2eKey };
 }
 // Application-level keepalive. On flaky/mobile links the node→relay TCP socket
 // can half-open silently: the node still thinks it is connected and buffers

package/dist/server.js

@@ -740,8 +740,11 @@ function getRuntime(requested, sandbox) {
 }
 // Holds the node's X25519 identity key, the rotating room key, and the linked
 // device registry. The room key is generated fresh on first load and delivered
-// to devices via the X25519 pairing handshake — there is no static seed.
-const pairingStore = PairingStore.load(appDir);
+// to devices via the X25519 pairing handshake — there is no static seed, EXCEPT
+// on an ephemeral rebuild: relay.json carries the reused session's room key
+// (`e2eKey`) so a brand-new pairing state adopts it and can decrypt the restored
+// snapshot. Only seeds a first-run node; an existing pairing.json always wins.
+const pairingStore = PairingStore.load(appDir, loadRelayConfig(appDir)?.e2eKey);
 function syncPairingMetadata() {
     for (const device of pairingStore.listDevices()) {
         metadata.upsertDevice({ id: device.id, label: device.label, publicKeyB64: device.publicKeyB64, firstSeenAt: device.createdAt, lastSeenAt: device.lastSeenAt ?? undefined });
@@ -3420,7 +3423,14 @@ function startRelayIfConfigured() {
     terminals.dropClient(RELAY_CLIENT_ID);
     relay = new RelayConnector(config, (msg) => void handleRelayMessage(msg), {
         pairing: pairingStore,
-        onWorkAvailable: () => controlPlanePoller?.poke(),
+        onWorkAvailable: () => {
+            controlPlanePoller?.poke();
+            // A relay wake also means "something changed for this account" — kick a
+            // (debounced) model-auth sync so a peer node answers any pending vault-key
+            // request from a freshly-launched ephemeral runner without waiting for its
+            // 30s poll. Cheap and idempotent; coalesced to at most one sync per burst.
+            triggerModelAuthSyncSoon();
+        },
     });
     relay.start();
     if (config.controlPlaneUrl && config.enrollmentToken) {
@@ -3520,6 +3530,62 @@ async function modelAuthFetch(pathname, init = {}) {
         headers.set("content-type", "application/json");
     return fetch(`${sessionAdvertiseTarget.controlPlaneUrl.replace(/\/$/, "")}${pathname}`, { ...init, headers });
 }
+// Debounced model-auth sync trigger. A relay wake (`work.available`) fires this
+// so peers answer a new node's vault-key request promptly (event-driven) instead
+// of on the steady 30s poll. Coalesces a burst of wakes into one sync.
+let modelAuthSyncSoonTimer;
+function triggerModelAuthSyncSoon() {
+    if (modelAuthSyncSoonTimer)
+        return;
+    modelAuthSyncSoonTimer = setTimeout(() => {
+        modelAuthSyncSoonTimer = undefined;
+        void syncModelAuthFromControlPlane();
+    }, 250);
+    modelAuthSyncSoonTimer.unref?.();
+}
+// Cold-start fast-retry. A freshly-launched node (typically a short-lived
+// ephemeral runner) that holds vault ciphertext but no wrapped key yet must wait
+// for a peer node to answer its key request. The 30s steady poll is too slow for
+// a machine that may only live a minute, so once we've requested the key we
+// re-sync on a brief bounded cadence until the wrapped key arrives (a peer
+// answered) or we give up and let the steady poll continue. Peer-only by design:
+// the key is always answered by another node over the E2E wrap — nothing ever
+// transits the device or control plane in the clear.
+const MODEL_AUTH_COLDSTART_INTERVAL_MS = 2_000;
+const MODEL_AUTH_COLDSTART_MAX_ATTEMPTS = 30; // ~60s bounded
+let modelAuthColdStartActive = false;
+let modelAuthColdStartAttempts = 0;
+let modelAuthColdStartTimer;
+function stopModelAuthColdStart() {
+    modelAuthColdStartActive = false;
+    modelAuthColdStartAttempts = 0;
+    if (modelAuthColdStartTimer) {
+        clearTimeout(modelAuthColdStartTimer);
+        modelAuthColdStartTimer = undefined;
+    }
+}
+function ensureModelAuthColdStart() {
+    if (modelAuthColdStartActive)
+        return; // already retrying
+    modelAuthColdStartActive = true;
+    modelAuthColdStartAttempts = 0;
+    const tick = () => {
+        modelAuthColdStartTimer = undefined;
+        if (!modelAuthColdStartActive)
+            return;
+        // A concurrent sync may have already landed the key — stop as soon as we have it.
+        if (readLocalModelAuthVaultKey() || modelAuthColdStartAttempts >= MODEL_AUTH_COLDSTART_MAX_ATTEMPTS) {
+            stopModelAuthColdStart();
+            return;
+        }
+        modelAuthColdStartAttempts++;
+        void syncModelAuthFromControlPlane();
+        modelAuthColdStartTimer = setTimeout(tick, MODEL_AUTH_COLDSTART_INTERVAL_MS);
+        modelAuthColdStartTimer.unref?.();
+    };
+    modelAuthColdStartTimer = setTimeout(tick, MODEL_AUTH_COLDSTART_INTERVAL_MS);
+    modelAuthColdStartTimer.unref?.();
+}
 async function syncModelAuthFromControlPlane() {
     if (!sessionAdvertiseTarget)
         return;
@@ -3543,10 +3609,17 @@ async function syncModelAuthFromControlPlane() {
             await writePiModelsProjection();
             await broadcastLocalModels();
             lastPushedModelAuthCiphertext = data.vault.ciphertext;
+            // Got the key and imported the vault (incl. any subscription-OAuth logins) —
+            // the cold-start race is over.
+            stopModelAuthColdStart();
             broadcast({ type: "providers.list", providers: await listProvidersUnified() });
         }
         else if (data.vault?.ciphertext && !vaultKeyB64) {
             await modelAuthFetch("/node/model-auth-key/request", { method: "POST", body: JSON.stringify({ publicKey: pairingStore.nodePublicKeyB64() }) });
+            // No peer has wrapped our key yet. Fast-retry (bounded) so a short-lived
+            // ephemeral runner picks up the key within seconds of a peer answering,
+            // rather than waiting for its next 30s poll.
+            ensureModelAuthColdStart();
         }
         else if (Object.keys(await exportProviderAuth(credsDir)).length > 0 ||
             Object.keys(exportLocalModels(localModelsDir)).length > 0) {
@@ -4727,6 +4800,19 @@ async function runWorkItem(item, report) {
             if (item.url)
                 issue.url = item.url;
         }
+        // Case B: the control plane asked us to CONTINUE an existing session for this
+        // issue (an inbound comment/issue on a thread that already has one). If that
+        // session isn't live on this node — e.g. its ephemeral machine was torn down —
+        // best-effort restore its snapshot first so its transcript + branch state are
+        // rebuilt and the work continues the thread instead of starting cold. On
+        // failure we fall through to the normal idempotent, remote-branch-adopting
+        // pickup, so this can only help, never break.
+        const issueSource = `issue:${parsed.owner}/${parsed.repo}#${item.issueNumber}`;
+        if (item.targetKind === "existing_session" && item.targetSessionId && !findIssueSession(issueSource)) {
+            await restoreSessionFromSnapshot(item.targetSessionId).catch((e) => {
+                console.warn(`[case-b] snapshot restore for ${item.targetSessionId} failed:`, e.message);
+            });
+        }
         await runIssueTask(cfg, issue, { runtimeId: item.runtimeId, model: item.model, onEvidence: report });
         return;
     }

package/package.json

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