clay-server 4.2.0 → 4.3.0-beta.2

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/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,