@oar-sh/oar 0.9.20 → 0.9.22

package/shared/worker-runtime/worker-websocket-link.mjs

@@ -1,3 +1,5 @@
+import { buildIdsDiffer } from "../build-id.mjs";
+
 function normalizeText(value) {
   const text = String(value || "").trim();
   return text || null;
@@ -61,15 +63,23 @@ export function createWorkerWebSocketLink({
   getDeliveryHeld = null,
   // Called with the hello's reason once per connection, on the relay's first
   // server.hello: from then on the relay (possibly a restarted one that knows
-  // nothing of this worker) has the socket. Later hellos only ack the
-  // worker.hello every idle readiness refresh re-sends, and are not reported.
+  // nothing of this worker) has the socket. Later hellos only ack a later
+  // worker.hello, and are not reported.
   onServerHello = () => {},
+  // Called with "server-hello" on every server.hello and with "deliver" on
+  // every queue.deliver: the keepalive keeps its busy cadence for a while
+  // after either (worker-keepalive.mjs).
+  onRelayFrame = () => {},
   getSessionId = () => null,
   getPid = () => null,
   // The kind of worker this is ("claude", "claude-api", ...), stated in
   // every hello and ready: the relay hands a Claude chat's row only to a
   // worker of the row's billing.
   workerKind = null,
+  // The build id of the code this worker started on (shared/build-id.mjs),
+  // stated in every hello and ready next to the kind: the relay recycles a
+  // worker whose build differs from its own once the worker is idle.
+  buildId = null,
   minBackoffMs = 1000,
   maxBackoffMs = 8_000,
   jitterMs = 250,
@@ -82,8 +92,12 @@ export function createWorkerWebSocketLink({
   // Failed attempts after the first few are logged at most once per this
   // interval, with a count of the ones in between.
   failureLogIntervalMs = 60_000,
+  // The link's own readiness refresh; 0 leaves it to the caller, which then
+  // calls refreshReadiness itself (worker-keepalive.mjs does, on its beat).
   readyRefreshMs = 10_000,
-  staleConnectionMs = 30_000,
+  // Three missed idle beats (30 s each) without any word from the relay: the
+  // connection is given up and made again.
+  staleConnectionMs = 90_000,
   WebSocketImpl = globalThis.WebSocket,
   setTimeoutImpl = setTimeout,
   clearTimeoutImpl = clearTimeout,
@@ -121,6 +135,12 @@ export function createWorkerWebSocketLink({
   let lastPongAt = null;
   let lastQueueChangedAt = null;
   let lastDeliveryAt = null;
+  // The build id the relay named in its latest server.hello (null when it
+  // named none), and whether this connection has already logged that it
+  // differs from ours: the relay acks every worker.hello with another
+  // server.hello, and the log needs the news only once per connection.
+  let relayBuildId = null;
+  let buildMismatchLogged = false;
 
   function getNowMs() {
     const value = Number(now());
@@ -175,6 +195,7 @@ export function createWorkerWebSocketLink({
       sessionId: normalizeText(getSessionId()),
       pid: normalizePositiveInt(getPid()),
       ...(normalizeText(workerKind) ? { kind: normalizeText(workerKind) } : {}),
+      ...(normalizeText(buildId) ? { buildId: normalizeText(buildId) } : {}),
       ...(held ? { ready: false } : {}),
     });
     if (sent) lastHelloSentAt = getNowMs();
@@ -203,6 +224,7 @@ export function createWorkerWebSocketLink({
       sessionId: normalizeText(getSessionId()),
       pid: normalizePositiveInt(getPid()),
       ...(normalizeText(workerKind) ? { kind: normalizeText(workerKind) } : {}),
+      ...(normalizeText(buildId) ? { buildId: normalizeText(buildId) } : {}),
     });
     if (sent) lastReadySentAt = getNowMs();
     return sent;
@@ -295,19 +317,17 @@ export function createWorkerWebSocketLink({
       notifyUnready(reason);
       return true;
     }
-    if (deliveriesInFlight.size) {
-      // notifyReady gates itself: it only goes through mid-delivery when the
-      // worker is steering-ready. Hello stays an idle-only affair.
-      void notifyReady(reason);
-      return true;
-    }
-    notifyHello(reason);
+    // notifyReady gates itself: mid-delivery it only goes through when the
+    // worker is steering-ready. No hello: the socket's identity, kind and
+    // build were bound by the hello at open, and a ready carries them again;
+    // a hello would only draw a second server.hello and a second ready.
     void notifyReady(reason);
     return true;
   }
 
   function startReadyRefreshTimer() {
     clearReadyRefreshTimer();
+    if (Number(readyRefreshMs) === 0) return;
     const intervalMs = Math.max(1000, Number(readyRefreshMs) || 10_000);
     readyRefreshTimer = setIntervalImpl(() => {
       refreshReadiness("readiness-refresh");
@@ -393,6 +413,7 @@ export function createWorkerWebSocketLink({
         clearReadyRefreshTimer();
         // The next connection may reach a different (restarted) relay.
         serverCapabilities = new Set();
+        buildMismatchLogged = false;
       }
       if (stopped || !reconnect) return true;
       // A newer socket is already under way and owns the reconnect.
@@ -434,12 +455,21 @@ export function createWorkerWebSocketLink({
         return;
       }
       if (payload?.type === "queue.deliver") {
+        try { onRelayFrame("deliver"); } catch {}
         void deliverPending(payload.pending || null, String(payload.reason || "queue-deliver"))
           .finally(() => notifyReady("delivery-complete"));
         return;
       }
       if (payload?.type === "server.hello") {
+        try { onRelayFrame("server-hello"); } catch {}
         serverCapabilities = new Set(Array.isArray(payload.capabilities) ? payload.capabilities.map(String) : []);
+        relayBuildId = normalizeText(payload.buildId);
+        // Only a line in the log: the relay decides when to replace this
+        // worker, and the worker takes no action of its own on it.
+        if (!buildMismatchLogged && buildIdsDiffer(relayBuildId, normalizeText(buildId))) {
+          buildMismatchLogged = true;
+          dbg(`relay build ${relayBuildId}, mine ${normalizeText(buildId)}: the relay will recycle this worker when idle`);
+        }
         if (!serverHelloSeen) {
           serverHelloSeen = true;
           // The handshake is complete: only now does the backoff start over.
@@ -536,12 +566,16 @@ export function createWorkerWebSocketLink({
       lastPongAt,
       lastQueueChangedAt,
       lastDeliveryAt,
+      relayBuildId,
     };
   }
 
   return {
     notifyReady,
     notifyUnready,
+    refreshReadiness,
+    // A delivery in flight or a hold: the keepalive beats at its busy cadence.
+    isBusy: () => deliveriesInFlight.size > 0 || deliveryHeld(),
     serverSupports: (capability) => serverCapabilities.has(String(capability || "")),
     start,
     stop,

package/shared/worker-runtime/working-directory.mjs

@@ -16,7 +16,7 @@ import fs from 'node:fs';
 export const WORKING_DIRECTORY_MISSING_CODE = 'working-directory-missing';
 
 export const WORKING_DIRECTORY_GUIDANCE =
-  'Restore the folder, or choose another working directory for this conversation (⋯ → Change CWD), '
+  'Restore the folder, or choose another working directory for this conversation (︙ → Change CWD), '
   + 'then send the message again.';
 
 // What a failed launch says, in the words of the SDKs: Node's spawn error, the