clay-server 3.3.0-beta.1 → 3.3.0

package/lib/yoke/adapters/claude.js

@@ -701,12 +701,7 @@ function spawnWorker(linuxUser, workerScriptPath, cwd) {
   });
 
   worker.send = function(msg) {
-    if (!worker.connection || worker.connection.destroyed) return;
-    try {
-      worker.connection.write(JSON.stringify(serializeWorkerValue(msg)) + "\n");
-    } catch (e) {
-      console.error("[yoke/claude] Failed to send to worker:", e.message);
-    }
+    return sendWorkerMessage(worker, msg);
   };
 
   worker.onMessage = function(handler) {
@@ -732,6 +727,36 @@ function spawnWorker(linuxUser, workerScriptPath, cwd) {
   return worker;
 }
 
+function hasWritableWorkerConnection(worker) {
+  var connection = worker && worker.connection;
+  return !!connection
+    && !connection.destroyed
+    && !connection.writableEnded
+    && connection.writable !== false;
+}
+
+function sendWorkerMessage(worker, msg) {
+  if (!hasWritableWorkerConnection(worker)) return false;
+  try {
+    // A false return from socket.write means backpressure, not rejection. The
+    // bytes are still queued, so delivery is accepted unless write throws.
+    worker.connection.write(JSON.stringify(serializeWorkerValue(msg)) + "\n");
+    return true;
+  } catch (e) {
+    console.error("[yoke/claude] Failed to send to worker:", e.message);
+    return false;
+  }
+}
+
+function canReuseWorker(worker) {
+  return !!worker
+    && worker.ready
+    && worker.process
+    && !worker.process.killed
+    && worker.process.exitCode == null
+    && hasWritableWorkerConnection(worker);
+}
+
 function cleanupWorker(worker) {
   console.log("[yoke/claude] cleanupWorker() called, pid=" + (worker.process ? worker.process.pid : "?") + " stack=" + new Error().stack.split("\n").slice(1, 4).join(" | "));
   if (worker._abortTimeout) { clearTimeout(worker._abortTimeout); worker._abortTimeout = null; }
@@ -1009,12 +1034,7 @@ function createWorkerQueryHandle(worker, canUseTool, onElicitation, callMcpTool,
       }
       if (text) content.push({ type: "text", text: text });
       var userMsg = { type: "user", message: { role: "user", content: content } };
-      try {
-        worker.send({ type: "push_message", content: userMsg });
-        return true;
-      } catch (e) {
-        return false;
-      }
+      return worker.send({ type: "push_message", content: userMsg }) === true;
     },
 
     setModel: function(model) {
@@ -1498,7 +1518,8 @@ function createClaudeAdapter(opts) {
     var reusingWorker = false;
 
     // Wait for previous worker exit if needed
-    if (workerState && workerState.exitPromise && !workerState.worker) {
+    if (workerState && workerState.exitPromise
+        && (!workerState.worker || !canReuseWorker(workerState.worker))) {
       await Promise.race([
         workerState.exitPromise,
         new Promise(function(resolve) { setTimeout(resolve, 3000); }),
@@ -1506,8 +1527,7 @@ function createClaudeAdapter(opts) {
     }
 
     // Reuse existing worker if alive
-    if (workerState && workerState.worker && workerState.worker.ready &&
-        workerState.worker.process && !workerState.worker.process.killed) {
+    if (workerState && canReuseWorker(workerState.worker)) {
       worker = workerState.worker;
       reusingWorker = true;
       // Clear old message handlers so they don't fire for the new query
@@ -1564,7 +1584,7 @@ function createClaudeAdapter(opts) {
     // will push the initial message and the worker receives it via push_message.
     // Instead, we send query_start with no prompt; the worker starts a query with
     // the message queue, and the first push_message will arrive.
-    worker.send({
+    if (!worker.send({
       type: "query_start",
       prompt: null,
       options: queryOptions,
@@ -1572,7 +1592,9 @@ function createClaudeAdapter(opts) {
       originalHome: claudeOpts.originalHome || null,
       projectPath: claudeOpts.projectPath || null,
       _perfT0: claudeOpts._perfT0 || Date.now(),
-    });
+    })) {
+      throw new Error("Claude worker IPC connection closed before query start");
+    }
 
     return handle;
   }
@@ -1808,6 +1830,10 @@ module.exports = {
   contractTestKit: {
     createMessageQueue: createMessageQueue,
     createQueryHandle: createQueryHandle,
+    createWorkerQueryHandle: createWorkerQueryHandle,
+    hasWritableWorkerConnection: hasWritableWorkerConnection,
+    sendWorkerMessage: sendWorkerMessage,
+    canReuseWorker: canReuseWorker,
     normalizeEvent: flattenEvent,
   },
 };

package/lib/yoke/index.js

@@ -8,6 +8,23 @@ var createClaudeAdapter = require("./adapters/claude").createClaudeAdapter;
 var createCodexAdapter = require("./adapters/codex").createCodexAdapter;
 var createKiroAdapter = require("./adapters/kiro").createKiroAdapter;
 
+// Keep the first session in a new project predictable. This order is also
+// used by the UI when a project has no remembered vendor yet.
+var DEFAULT_VENDOR_ORDER = ["claude", "codex", "kiro"];
+
+function resolveDefaultVendor(availableVendors) {
+  availableVendors = availableVendors || {};
+  for (var i = 0; i < DEFAULT_VENDOR_ORDER.length; i++) {
+    var vendor = DEFAULT_VENDOR_ORDER[i];
+    if (Array.isArray(availableVendors)) {
+      if (availableVendors.indexOf(vendor) !== -1) return vendor;
+    } else if (availableVendors[vendor]) {
+      return vendor;
+    }
+  }
+  return "claude";
+}
+
 /**
  * Wrap adapter.createQuery to inject cross-vendor project instructions.
  *
@@ -371,6 +388,8 @@ async function lazyCreateAdapter(adapters, vendor, opts) {
 module.exports = {
   createAdapter: createAdapter,
   createAdapters: createAdapters,
+  resolveDefaultVendor: resolveDefaultVendor,
+  DEFAULT_VENDOR_ORDER: DEFAULT_VENDOR_ORDER,
   lazyCreateAdapter: lazyCreateAdapter,
   checkAuth: checkAuth,
   checkInstalled: checkInstalled,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "3.3.0-beta.1",
+  "version": "3.3.0",
   "description": "Self-hosted team workspace for Claude Code and Codex. Multi-user, browser-based, with persistent AI mates.",
   "bin": {
     "clay-server": "./bin/cli.js",