@bivy/bivy 0.3.0-staging.43 → 0.3.0-staging.45

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 });
@@ -3597,6 +3600,14 @@ async function syncModelAuthFromControlPlane() {
             vaultKeyB64 = pairingStore.unwrapFromNodePublicKey(data.wrappedKey.wrappedByPublicKey, data.wrappedKey.wrappedKey);
             writeLocalModelAuthVaultKey(vaultKeyB64);
         }
+        // Node-less inheritance: a lone HOSTED ephemeral (no peer to wrap the key)
+        // adopts the vault key the control plane escrowed for this hosted account, so
+        // it can decrypt the synced vault (incl. subscription OAuth) on cold start. The
+        // control plane serves `hostedKey` only for hosted-provisioning accounts.
+        if (!vaultKeyB64 && data.hostedKey && Buffer.from(data.hostedKey, "base64").length === 32) {
+            vaultKeyB64 = data.hostedKey;
+            writeLocalModelAuthVaultKey(vaultKeyB64);
+        }
         if (data.vault?.ciphertext && vaultKeyB64) {
             const { providers, localModels } = decryptModelAuthEnvelope(data.vault.ciphertext, vaultKeyB64);
             await importProviderAuth(credsDir, providers);
@@ -3663,6 +3674,13 @@ async function pushModelAuthToControlPlane() {
             method: "PUT",
             body: JSON.stringify({ targetNodeId: identity.nodeId, wrappedByPublicKey: pairingStore.nodePublicKeyB64(), wrappedKey: pairingStore.wrapForNodePublicKey(pairingStore.nodePublicKeyB64(), vaultKeyB64) }),
         });
+        // Node-less inheritance: a HOSTED node also escrows the vault key to the control
+        // plane (sealed at rest, hosted-only) so the account's NEXT hosted ephemeral —
+        // possibly the only node — can decrypt this vault without a peer to wrap the key.
+        // Gated to hosted nodes; the CP double-checks the account is hosted. Best effort.
+        if (process.env.BIVY_GITHUB_HOSTED_TASKS) {
+            await modelAuthFetch("/node/model-auth-key/hosted-escrow", { method: "PUT", body: JSON.stringify({ vaultKeyB64 }) }).catch(() => { });
+        }
         lastPushedModelAuthCiphertext = ciphertext;
     }
     catch (error) {
@@ -4797,6 +4815,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.43",
+  "version": "0.3.0-staging.45",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",