@bivy/bivy 0.5.1-staging.63 → 0.5.1-staging.65

package/dist/server.js

@@ -409,13 +409,14 @@ const approvals = new ApprovalManager();
 const questionManager = new QuestionManager();
 questionManager.onRequest((request) => {
     scheduleAdvertise();
-    broadcast({ type: "session.question", sessionId: request.sessionId, requestId: request.id, questions: request.questions });
+    broadcast({ type: "session.question", sessionId: request.sessionId, requestId: request.id, questions: request.questions, createdAt: request.createdAt });
     // Notify unconditionally: a clarifying question always fires mid-turn (the
     // session is "working"), and it's a hard blocker the user must see to unblock
     // — matching the pre-refactor behavior.
     void sendNotificationHint({
         kind: "question_asked",
         sessionId: request.sessionId,
+        attentionId: request.id,
         title: "Bivy needs your input",
         body: `${sessionNotifyLabel(resolveSession(request.sessionId))} is asking a question — tap to answer.`,
     });
@@ -3618,6 +3619,18 @@ function startRelayIfConfigured() {
             clearInterval(advertiseResyncTimer);
         advertiseResyncTimer = setInterval(() => scheduleAdvertise(), 60_000);
         advertiseResyncTimer.unref?.();
+        // Periodic online heartbeat. The relay flips the node's `online` flag
+        // fire-and-forget on socket connect/close with no ordering guard, so a
+        // late/racing `false` can pin a genuinely-connected node offline in the
+        // registry until some later reconnect wins. Re-affirming online on a steady
+        // interval keeps `last_seen_at` fresh and self-heals a lost race (the control
+        // plane treats a recent heartbeat as online — see NODE_ONLINE_TTL_MS). Fire one
+        // immediately so a reconnect corrects a stale `false` without waiting a full tick.
+        if (nodeHeartbeatTimer)
+            clearInterval(nodeHeartbeatTimer);
+        void sendNodeHeartbeat();
+        nodeHeartbeatTimer = setInterval(() => void sendNodeHeartbeat(), NODE_HEARTBEAT_MS);
+        nodeHeartbeatTimer.unref?.();
     }
     console.log("[relay] connector enabled");
     return true;
@@ -4100,6 +4113,28 @@ function startModelAuthWatcher() {
 let sessionAdvertiseTarget;
 let advertiseTimer;
 let advertiseResyncTimer;
+// How often the node re-affirms it's online to the control plane. Kept well
+// under the control plane's NODE_ONLINE_TTL_MS (90s) so a missed beat or two
+// doesn't flap a healthy node's status.
+const NODE_HEARTBEAT_MS = 30_000;
+let nodeHeartbeatTimer;
+/** Re-affirm this node's online status so the registry self-heals a lost
+ *  relay connect/close race (see the heartbeat wiring in the relay connector
+ *  and NODE_ONLINE_TTL_MS in the control plane). Best-effort: a missed beat is
+ *  covered by the next tick and the TTL window. */
+async function sendNodeHeartbeat() {
+    if (!sessionAdvertiseTarget)
+        return;
+    try {
+        await fetch(`${sessionAdvertiseTarget.controlPlaneUrl.replace(/\/$/, "")}/node/heartbeat`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${sessionAdvertiseTarget.enrollmentToken}` },
+        });
+    }
+    catch {
+        // best effort; the next tick retries
+    }
+}
 async function advertiseNodeName(name, prevName) {
     if (!sessionAdvertiseTarget)
         return;
@@ -4286,16 +4321,37 @@ async function advertiseSessions() {
         // dropped; and with the remote flag off the map is empty, so the payload is
         // byte-identical to before.
         const agentServiceAddress = sessionAgentServiceAddress(record) ?? (record ? undefined : (await inMemorySessionLocations.lookup(s.id).catch(() => undefined))?.agentServiceAddress);
+        const approvalAttention = approvals.list()
+            .filter((a) => a.sessionId === s.id && a.status === "pending")
+            .map((a) => ({
+            id: a.id,
+            kind: "approval",
+            severity: a.risk === "critical" ? "critical" : a.risk === "high" ? "error" : "warning",
+            createdAt: new Date(a.createdAt).toISOString(),
+        }));
+        const questionAttention = questionManager.list()
+            .filter((q) => q.sessionId === s.id && q.status === "pending")
+            .map((q) => ({ id: q.id, kind: "question", severity: "warning", createdAt: new Date(q.createdAt).toISOString() }));
+        const failureAt = record?.lastFailureAt || (meta?.status === "failed" ? Date.parse(meta.updatedAt) : 0);
+        const failureAttention = failureAt
+            ? [{
+                    id: "last-failure",
+                    kind: (record?.source || meta?.source ? "automation" : "session"),
+                    severity: "error",
+                    createdAt: new Date(failureAt).toISOString(),
+                }]
+            : [];
         return {
             sessionId: s.id,
-            status: pendingApproval ? "needs_action" : (record ? (sessionBusy(record) ? "working" : "idle") : "saved"),
-            needsAction: pendingApproval,
+            status: pendingApproval || failureAttention.length ? "needs_action" : (record ? (sessionBusy(record) ? "working" : "idle") : "saved"),
+            needsAction: pendingApproval || failureAttention.length > 0,
             source: record?.source || meta?.source,
             titleEnc: name ? relay.sealString(name) : undefined,
             branch: record?.worktree?.branch || meta?.branch,
             agentServiceAddress,
             githubIssueUrl: record?.githubIssueUrl,
             prUrl: record?.prUrl,
+            attention: [...approvalAttention, ...questionAttention, ...failureAttention],
         };
     }));
     try {
@@ -6578,6 +6634,8 @@ function markSessionWorking(record, activity) {
     record.isWorking = true;
     record.lastActivity = activity;
     record.workingStartedAt ||= Date.now();
+    // A new attempt resolves the prior turn's failure condition at its source.
+    record.lastFailureAt = undefined;
     metadata.touchSession(record.id, "working");
     if (!wasWorking)
         scheduleAdvertise(); // idle → working transition
@@ -6789,6 +6847,9 @@ function attachSessionListeners(record) {
                 });
             }
             else if (turnError) {
+                record.lastFailureAt = Date.now();
+                metadata.touchSession(record.id, "failed");
+                scheduleAdvertise();
                 broadcast({ type: "session.error", sessionId: record.id, error: turnError });
                 void sendNotificationHint({
                     kind: "session_error",
@@ -7949,6 +8010,7 @@ approvals.onRequest((request) => {
         void sendNotificationHint({
             kind: "approval_requested",
             sessionId: request.sessionId,
+            attentionId: request.id,
             title: "Approval needed",
             body: `${sessionNotifyLabel(rec)} wants to run something — tap to approve or deny.`,
         });

package/package.json

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