clay-server 4.2.0 → 4.3.0-beta.10

package/lib/public/modules/websocket-lifecycle.js

@@ -0,0 +1,178 @@
+// websocket-lifecycle.js - bounded connection attempt and retry policy
+
+var DEFAULTS = {
+  handshakeTimeoutMs: 12000,
+  stableConnectionMs: 15000,
+  retryMinMs: 1000,
+  retryMaxMs: 15000,
+  jitterRatio: 0.2,
+  authTimeoutMs: 4000
+};
+
+function createWebSocketLifecycle(options) {
+  var config = Object.assign({}, DEFAULTS, options || {});
+  var epoch = 0;
+  var retryAttempt = 0;
+  var retryTimer = null;
+  var handshakeTimer = null;
+  var stableTimer = null;
+  var authTimer = null;
+  var authInFlight = false;
+  var authCancel = null;
+  var authGeneration = 0;
+  var stableEpoch = 0;
+  var cancelled = false;
+  var offline = false;
+
+  function clearTimer(timer) {
+    if (timer) clearTimeout(timer);
+    return null;
+  }
+
+  function clearTimers() {
+    retryTimer = clearTimer(retryTimer);
+    handshakeTimer = clearTimer(handshakeTimer);
+    stableTimer = clearTimer(stableTimer);
+    authTimer = clearTimer(authTimer);
+    stableEpoch = 0;
+    if (authCancel) authCancel();
+    authCancel = null;
+    authInFlight = false;
+  }
+
+  function current(value) {
+    return value === epoch && !cancelled;
+  }
+
+  function canProceed(value) {
+    return current(value) && !offline;
+  }
+
+  function beginAttempt() {
+    clearTimers();
+    cancelled = false;
+    epoch += 1;
+    var attemptEpoch = epoch;
+    handshakeTimer = setTimeout(function () {
+      handshakeTimer = null;
+      if (current(attemptEpoch) && config.onHandshakeTimeout) config.onHandshakeTimeout(attemptEpoch);
+    }, config.handshakeTimeoutMs);
+    return attemptEpoch;
+  }
+
+  function delayForAttempt() {
+    var base = Math.min(config.retryMaxMs, config.retryMinMs * Math.pow(1.5, retryAttempt));
+    retryAttempt += 1;
+    var jitter = base * config.jitterRatio;
+    var random = config.random || Math.random;
+    return Math.min(config.retryMaxMs, Math.max(0, Math.round(base - jitter + random() * jitter * 2)));
+  }
+
+  function schedule(reason, callback) {
+    if (cancelled || offline || retryTimer) return null;
+    var scheduledEpoch = epoch;
+    var delay = delayForAttempt();
+    retryTimer = setTimeout(function () {
+      retryTimer = null;
+      if (!canProceed(scheduledEpoch)) return;
+      callback(scheduledEpoch, reason, delay);
+    }, delay);
+    return { epoch: scheduledEpoch, delay: delay };
+  }
+
+  function clearRetry() {
+    retryTimer = clearTimer(retryTimer);
+  }
+
+  function beginAuth(authEpoch, onTimeout, onCancel) {
+    if (!canProceed(authEpoch) || authInFlight) return null;
+    authInFlight = true;
+    authGeneration += 1;
+    var authToken = { epoch: authEpoch, generation: authGeneration };
+    authCancel = onCancel || null;
+    authTimer = setTimeout(function () {
+      authTimer = null;
+      authInFlight = false;
+      authCancel = null;
+      if (canProceed(authEpoch) && onTimeout) onTimeout(authEpoch);
+    }, config.authTimeoutMs);
+    return authToken;
+  }
+
+  function finishAuth(authEpoch, authToken) {
+    if (!authInFlight || !current(authEpoch) || !authToken || authToken.epoch !== authEpoch || authToken.generation !== authGeneration) return false;
+    authInFlight = false;
+    authCancel = null;
+    authTimer = clearTimer(authTimer);
+    return true;
+  }
+
+  function markOpen(attemptEpoch) {
+    if (!current(attemptEpoch)) return false;
+    handshakeTimer = clearTimer(handshakeTimer);
+    return true;
+  }
+
+  function markLive(attemptEpoch) {
+    if (!current(attemptEpoch)) return false;
+    handshakeTimer = clearTimer(handshakeTimer);
+    if (stableEpoch === attemptEpoch) return true;
+    stableEpoch = attemptEpoch;
+    stableTimer = clearTimer(stableTimer);
+    stableTimer = setTimeout(function () {
+      stableTimer = null;
+      if (current(attemptEpoch)) retryAttempt = 0;
+    }, config.stableConnectionMs);
+    return true;
+  }
+
+  function invalidate(attemptEpoch) {
+    if (attemptEpoch !== epoch) return false;
+    epoch += 1;
+    clearTimers();
+    return true;
+  }
+
+  function cancel() {
+    cancelled = true;
+    epoch += 1;
+    clearTimers();
+  }
+
+  function setOffline(value) {
+    var nextOffline = value === true;
+    if (nextOffline === offline) return offline;
+    offline = nextOffline;
+    if (offline) {
+      epoch += 1;
+      clearTimers();
+    }
+    return offline;
+  }
+
+  function wake(callback) {
+    offline = false;
+    if (!cancelled && callback) callback();
+  }
+
+  return {
+    beginAttempt: beginAttempt,
+    beginAuth: beginAuth,
+    cancel: cancel,
+    canProceed: canProceed,
+    clearRetry: clearRetry,
+    current: current,
+    finishAuth: finishAuth,
+    invalidate: invalidate,
+    markOpen: markOpen,
+    markLive: markLive,
+    schedule: schedule,
+    setOffline: setOffline,
+    wake: wake,
+    getRetryAttempt: function () { return retryAttempt; },
+    getEpoch: function () { return epoch; },
+    isOffline: function () { return offline; }
+  };
+}
+
+export { createWebSocketLifecycle };

package/lib/public/modules/websocket-watchdog.js

@@ -0,0 +1,126 @@
+// websocket-watchdog.js - suspendable liveness timers for the browser socket
+
+function createWebSocketWatchdog(options) {
+  var suspended = false;
+  var heartbeatTimer = null;
+  var heartbeatDeadlineTimer = null;
+  var heartbeatSocket = null;
+  var heartbeatEpoch = 0;
+  var heartbeatGeneration = 0;
+  var deadlineGeneration = 0;
+  var probeTimer = null;
+  var probeSocket = null;
+  var probeEpoch = 0;
+  var probeStartedAt = 0;
+  var probeGeneration = 0;
+
+  function clearHeartbeatDeadline() {
+    deadlineGeneration += 1;
+    if (heartbeatDeadlineTimer) clearTimeout(heartbeatDeadlineTimer);
+    heartbeatDeadlineTimer = null;
+  }
+
+  function stopHeartbeat() {
+    heartbeatGeneration += 1;
+    clearHeartbeatDeadline();
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+    heartbeatSocket = null;
+    heartbeatEpoch = 0;
+  }
+
+  function clearProbe() {
+    probeGeneration += 1;
+    if (probeTimer) clearTimeout(probeTimer);
+    probeTimer = null;
+    probeSocket = null;
+    probeEpoch = 0;
+    probeStartedAt = 0;
+  }
+
+  function suspend() {
+    suspended = true;
+    stopHeartbeat();
+    clearProbe();
+  }
+
+  function resume() {
+    var changed = suspended;
+    suspended = false;
+    return changed;
+  }
+
+  function startHeartbeat(socket, epoch) {
+    stopHeartbeat();
+    if (suspended || !socket) return false;
+    heartbeatSocket = socket;
+    heartbeatEpoch = epoch;
+    var generation = heartbeatGeneration;
+    heartbeatTimer = setInterval(function () {
+      if (suspended || generation !== heartbeatGeneration) return;
+      if (!options.isCurrent(socket, epoch)) {
+        stopHeartbeat();
+        return;
+      }
+      clearHeartbeatDeadline();
+      var currentDeadlineGeneration = deadlineGeneration;
+      heartbeatDeadlineTimer = setTimeout(function () {
+        if (suspended || currentDeadlineGeneration !== deadlineGeneration) return;
+        heartbeatDeadlineTimer = null;
+        if (heartbeatSocket === socket && heartbeatEpoch === epoch && options.isCurrent(socket, epoch)) {
+          options.onFailure("heartbeat_timeout", epoch, null);
+        }
+      }, options.heartbeatDeadlineMs);
+      try {
+        options.sendPing(socket);
+      } catch (e) {
+        options.onFailure("heartbeat_error", epoch, null);
+      }
+    }, options.heartbeatIntervalMs);
+    return true;
+  }
+
+  function probe(socket, epoch) {
+    if (suspended) return "suspended";
+    if (probeTimer) return "pending";
+    probeSocket = socket;
+    probeEpoch = epoch;
+    probeStartedAt = options.now();
+    probeGeneration += 1;
+    var generation = probeGeneration;
+    probeTimer = setTimeout(function () {
+      if (suspended || generation !== probeGeneration) return;
+      probeTimer = null;
+      if (probeSocket === socket && probeEpoch === epoch && options.isCurrent(socket, epoch)) {
+        options.onFailure("probe_timeout", epoch, options.now() - probeStartedAt);
+      }
+    }, options.probeTimeoutMs);
+    try {
+      options.sendPing(socket);
+    } catch (e) {
+      if (generation !== probeGeneration) return "cleared";
+      var latency = options.now() - probeStartedAt;
+      clearProbe();
+      options.onFailure("probe_error", epoch, latency);
+      return "failed";
+    }
+    return "started";
+  }
+
+  function acceptPong(socket, epoch) {
+    if (heartbeatSocket === socket && heartbeatEpoch === epoch) clearHeartbeatDeadline();
+    if (probeSocket === socket && probeEpoch === epoch) clearProbe();
+  }
+
+  return {
+    acceptPong: acceptPong,
+    clearProbe: clearProbe,
+    probe: probe,
+    resume: resume,
+    startHeartbeat: startHeartbeat,
+    stopHeartbeat: stopHeartbeat,
+    suspend: suspend
+  };
+}
+
+export { createWebSocketWatchdog };

package/lib/public/modules/worker-pane-lock.js

@@ -27,6 +27,18 @@ import { store } from './store.js';
 var STATUS_ID = "worker-pane-status";
 var LOCK_CLASS = "worker-pane-locked";
 
+function configuredWorkerIds(group) {
+  if (!group || !group.pair || !Array.isArray(group.members)) return [];
+  var pair = group.pair;
+  var ids = Array.isArray(pair.workerIds) ? pair.workerIds :
+    (pair.workerId !== undefined ? [pair.workerId] : []);
+  if (pair.driverId === undefined || ids.length < 1 || ids.length > 2 || group.members.indexOf(pair.driverId) === -1) return [];
+  for (var i = 0; i < ids.length; i++) {
+    if (ids[i] === pair.driverId || group.members.indexOf(ids[i]) === -1) return [];
+  }
+  return ids;
+}
+
 // Every interactive composer affordance. Queried lazily: a pane iframe and the
 // main window share this markup, and some ids are mobile-only.
 var LOCKED_CONTROL_IDS = [
@@ -64,9 +76,7 @@ export function isDriverOperatedView(state) {
   if (!sessionId) return false;
   var groups = snapshot.splitGroups || [];
   for (var i = 0; i < groups.length; i++) {
-    var pair = groups[i] && groups[i].pair;
-    if (!pair) continue;
-    if (pair.workerId === sessionId) return true;
+    if (configuredWorkerIds(groups[i]).indexOf(sessionId) !== -1) return true;
   }
   return false;
 }

package/lib/public/style.css

@@ -26,6 +26,7 @@
 @import url("css/loop.css");
 @import url("css/scheduler.css");
 @import url("css/project-logs.css");
+@import url("css/driver-continuation.css");
 @import url("css/scheduled-tasks.css");
 @import url("css/scheduler-modal.css");
 @import url("css/home-hub.css");

package/lib/sdk-bridge.js

@@ -603,6 +603,10 @@ function createSDKBridge(opts) {
       return { behavior: "allow", updatedInput: input };
     }
 
+    if (toolName === "propose_driver_continuation" || toolName === "mcp__clay-continuation__propose_driver_continuation") {
+      return { behavior: "allow", updatedInput: input };
+    }
+
     var safeCapsuleTools = {
       clay_tool_list: true,
       clay_tool_snapshot: true,
@@ -1004,6 +1008,26 @@ function createSDKBridge(opts) {
       mode: session.permissionMode || sm.currentPermissionMode || "default", effectivePermissionMode: message.permissionMode,
       permissionCapabilities: session.permissionCapabilities || { auto: false, mcpOverride: false },
       mcpPermissionModeOverrides: session.mcpPermissionModeOverrides || {} });
+    if (typeof sm.broadcastSessionList === "function") sm.broadcastSessionList();
+    return true;
+  }
+
+  function settleContinuationStartup(session, queryInstance, queryGeneration, accepted, reason) {
+    var probe = session._continuationStartupProbe;
+    if (!probe || probe.queryInstance !== queryInstance || probe.queryGeneration !== queryGeneration) return false;
+    if (!ownsQueryRuntime(session, queryInstance, queryGeneration)) return false;
+    delete session._continuationStartupProbe;
+    clearTimeout(probe.timer);
+    if (probe.timedOut) {
+      if (typeof probe.onLateStartup === "function") probe.onLateStartup({
+        accepted: accepted === true,
+        queryAlive: session.queryInstance === queryInstance,
+        queryGeneration: queryGeneration,
+        reason: reason || null,
+      });
+      return true;
+    }
+    probe.resolve({ accepted: accepted === true, reason: reason || null });
     return true;
   }
 
@@ -1054,7 +1078,16 @@ function createSDKBridge(opts) {
           }
           continue;
         }
+        var continuationIdentity = msg && (msg.yokeType === "init" || msg.yokeType === "session_started");
+        if (continuationIdentity && !ownsQueryRuntime(session, myQueryInstance, myQueryGeneration)) {
+          continue;
+        }
         processSDKMessage(session, msg);
+        if (continuationIdentity) {
+          settleContinuationStartup(session, myQueryInstance, myQueryGeneration, true, null);
+        } else if (msg && msg.yokeType === "error") {
+          settleContinuationStartup(session, myQueryInstance, myQueryGeneration, false, "The successor reported an error before initialization.");
+        }
         // SDK init/status events are the only authority for runtime-effective
         // permission state. Setter acknowledgement deliberately does not
         // change this field.
@@ -1075,6 +1108,7 @@ function createSDKBridge(opts) {
       // so the session is still marked as processing. Send interrupted feedback.
       console.log("[sdk-bridge] processQueryStream ended: isProcessing=" + session.isProcessing + " taskStopRequested=" + session.taskStopRequested);
       var stillOwnsRuntime = session.queryInstance === myQueryInstance;
+      settleContinuationStartup(session, myQueryInstance, myQueryGeneration, false, "The successor query ended before initialization.");
       if (session.isProcessing && session.taskStopRequested && stillOwnsRuntime) {
         session._lastTurnInterrupted = true;
         session.isProcessing = false;
@@ -1108,6 +1142,7 @@ function createSDKBridge(opts) {
         sm.broadcastSessionList();
       }
     } catch (err) {
+      settleContinuationStartup(session, myQueryInstance, myQueryGeneration, false, err.message || "The successor query failed before initialization.");
       if (session.isProcessing && session.queryInstance === myQueryInstance) {
         session.isProcessing = false;
         session._awaitingTurnResult = false;
@@ -1202,6 +1237,7 @@ function createSDKBridge(opts) {
         sm.broadcastSessionList();
       }
     } finally {
+      settleContinuationStartup(session, myQueryInstance, myQueryGeneration, false, "The successor query closed before initialization.");
       // Close the SDK query to terminate the underlying claude child process.
       // Without this, the process stays alive indefinitely (single-user mode).
       // Only clean up if the session still references OUR resources.
@@ -1398,6 +1434,46 @@ function createSDKBridge(opts) {
     }
   }
 
+  // Continuation startup needs stronger evidence than a resolved startQuery
+  // promise: createQuery and initial delivery failures are intentionally
+  // contained inside startQuery. Return success only when the initial message
+  // was accepted and that exact query emitted its provider initialization event.
+  async function startQueryWithAcceptance(session, text, images, linuxUser, beforePush, onLateStartup) {
+    var acceptedHandle = null;
+    var acceptedGeneration = null;
+    var resolveStartup;
+    var startup = new Promise(function (resolve) { resolveStartup = resolve; });
+    var result = await startQuery(session, text, images, linuxUser, beforePush, function () {
+      acceptedHandle = session.queryInstance || null;
+      acceptedGeneration = Number(session._sdkQueryGeneration || 0);
+      session._continuationStartupProbe = {
+        queryInstance: acceptedHandle,
+        queryGeneration: acceptedGeneration,
+        resolve: resolveStartup,
+        onLateStartup: onLateStartup,
+        timedOut: false,
+      };
+      session._continuationStartupProbe.timer = setTimeout(function () {
+        var probe = session._continuationStartupProbe;
+        if (!probe || probe.queryInstance !== acceptedHandle || probe.queryGeneration !== acceptedGeneration) return;
+        probe.timedOut = true;
+        probe.resolve({ accepted: false, timedOut: true, reason: "The successor did not initialize in time." });
+      }, Number(opts.continuationStartupWaitMs || 15000));
+    });
+    var initialAccepted = result === true && !!acceptedHandle;
+    if (!initialAccepted) resolveStartup({ accepted: false, reason: "The successor did not accept its initial query." });
+    var startupResult = await startup;
+    var accepted = initialAccepted && startupResult.accepted === true;
+    return {
+      accepted: accepted,
+      initialAccepted: initialAccepted,
+      queryAlive: session.queryInstance === acceptedHandle,
+      queryGeneration: acceptedGeneration,
+      timedOut: startupResult.timedOut === true,
+      reason: accepted ? null : startupResult.reason || "The successor did not initialize its accepted query.",
+    };
+  }
+
   async function startQueryInner(session, text, images, linuxUser, beforePush, onAccepted) {
     var sessionRuntimeEnv = getRuntimeEnv(session);
     var resumedAtQueryStart = !!session.cliSessionId;
@@ -2647,6 +2723,7 @@ function createSDKBridge(opts) {
     rollbackConversation: rollbackConversation,
     forkSession: forkSessionUnified,
     startQuery: startQuery,
+    startQueryWithAcceptance: startQueryWithAcceptance,
     pushMessage: pushMessage,
     refreshSessionRuntime: refreshSessionRuntime,
     refreshEnvironmentRuntime: refreshEnvironmentRuntime,

package/lib/server.js

@@ -1336,6 +1336,7 @@ function createServer(opts) {
       worktreeMeta: worktreeMeta || null,
       mcpBridgeToken: extra.mcpBridgeToken || null,
       isMate: extra.isMate || false,
+      multiWorkerRuntimeEnabled: !extra.isMate,
       mateId: extra.mateId || (extra.isMate ? path.basename(cwd) : null),
       mateDisplayName: extra.mateDisplayName || "",
       isHostAgent: !!extra.isHostAgent,