clay-server 2.34.0-beta.3 → 2.34.0-beta.4

package/lib/yoke/adapters/codex.js

@@ -89,6 +89,56 @@ function generateUuid() {
   return "codex-" + ts + "-" + cnt + "-" + rnd;
 }
 
+function waitMs(ms) {
+  return new Promise(function(resolve) {
+    setTimeout(resolve, ms);
+  });
+}
+
+function waitForProcessExit(proc, timeoutMs) {
+  return new Promise(function(resolve) {
+    if (!proc) {
+      resolve(true);
+      return;
+    }
+
+    if (proc.exitCode !== null || proc.signalCode !== null) {
+      resolve(true);
+      return;
+    }
+
+    var done = false;
+    var timer = null;
+
+    function cleanup() {
+      if (done) return;
+      done = true;
+      if (timer) clearTimeout(timer);
+      proc.removeListener("exit", onDone);
+      proc.removeListener("close", onDone);
+    }
+
+    function onDone() {
+      cleanup();
+      resolve(true);
+    }
+
+    proc.once("exit", onDone);
+    proc.once("close", onDone);
+
+    timer = setTimeout(function() {
+      cleanup();
+      resolve(false);
+    }, timeoutMs || 5000);
+  });
+}
+
+function createShutdownError() {
+  var err = new Error("Codex adapter is shutting down, retry shortly");
+  err.code = "CODEX_ADAPTER_SHUTTING_DOWN";
+  return err;
+}
+
 function normalizePlanStatus(status) {
   if (status === "inProgress") return "in_progress";
   if (status === "completed") return "completed";
@@ -310,16 +360,33 @@ function flattenEvent(notification, state) {
         state.thinkingBlocks[item.id] = "blk_" + state.blockCounter;
         events.push({ yokeType: "thinking_start", blockId: "blk_" + state.blockCounter });
       }
-      if (item.text) {
+      // Codex reasoning items may expose plain text via `text`, a short
+      // `summary`, or nested `content` parts. Prefer whichever is present;
+      // many turns arrive with only encrypted reasoning and no readable
+      // text at all, in which case the UI will hide the expand affordance.
+      var reasoningText = "";
+      if (typeof item.text === "string" && item.text.length > 0) {
+        reasoningText = item.text;
+      } else if (typeof item.summary === "string" && item.summary.length > 0) {
+        reasoningText = item.summary;
+      } else if (Array.isArray(item.content)) {
+        var parts = [];
+        for (var rpi = 0; rpi < item.content.length; rpi++) {
+          var rp = item.content[rpi];
+          if (rp && typeof rp.text === "string") parts.push(rp.text);
+        }
+        reasoningText = parts.join("\n");
+      }
+      if (reasoningText) {
         var thinkBlockId = state.thinkingBlocks[item.id];
         var prevThinkLen = state.thinkingLengths[item.id] || 0;
-        if (item.text.length > prevThinkLen) {
+        if (reasoningText.length > prevThinkLen) {
           events.push({
             yokeType: "thinking_delta",
             blockId: thinkBlockId,
-            text: item.text.substring(prevThinkLen),
+            text: reasoningText.substring(prevThinkLen),
           });
-          state.thinkingLengths[item.id] = item.text.length;
+          state.thinkingLengths[item.id] = reasoningText.length;
         }
       }
       if (evtPhase === "completed") {
@@ -503,6 +570,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
   var systemPrompt = queryOpts.systemPrompt || "";
   var canUseTool = queryOpts.canUseTool || null;
   var onElicitation = queryOpts.onElicitation || null;
+  var onFinished = queryOpts.onFinished || null;
 
   // Check if the query was cancelled (either via handle.abort() or direct signal abort)
   function isCancelled() {
@@ -533,6 +601,19 @@ function createCodexQueryHandle(appServer, queryOpts) {
   var eventBuffer = [];
   var eventWaiting = null;
   var iteratorDone = false;
+  var finishedNotified = false;
+
+  function notifyFinished() {
+    if (finishedNotified) return;
+    finishedNotified = true;
+    if (typeof onFinished === "function") {
+      try {
+        onFinished();
+      } catch (e) {
+        console.error("[yoke/codex] onFinished error:", e.message || e);
+      }
+    }
+  }
 
   function pushEvent(evt) {
     if (iteratorDone) return;
@@ -552,6 +633,7 @@ function createCodexQueryHandle(appServer, queryOpts) {
       eventWaiting = null;
       resolve({ value: undefined, done: true });
     }
+    notifyFinished();
   }
 
   // Message queue for multi-turn
@@ -936,48 +1018,182 @@ function createCodexQueryHandle(appServer, queryOpts) {
 
 function createCodexAdapter(opts) {
   var _cwd = (opts && opts.cwd) || process.cwd();
+  var _slug = (opts && opts.slug) || "";
+  var _defaultInitOpts = Object.assign({}, opts || {});
   var _cachedModels = [];
   var _appServer = null;
   var _initPromise = null;
-  var _initOpts = null; // stored for query-time access
+  var _shutdownPromise = null;
+  var _refCount = 0;
+  var _lastActiveAt = Date.now();
+  var _shuttingDown = false;
+  var _activeQueries = [];
+
+  function updateLastActiveAt() {
+    _lastActiveAt = Date.now();
+  }
+
+  function registerActiveQuery(entry) {
+    _activeQueries.push(entry);
+  }
+
+  function removeActiveQuery(entry) {
+    var next = [];
+    for (var i = 0; i < _activeQueries.length; i++) {
+      if (_activeQueries[i] !== entry) next.push(_activeQueries[i]);
+    }
+    _activeQueries = next;
+  }
+
+  function decrementRefCount() {
+    if (_refCount > 0) {
+      _refCount--;
+    } else {
+      console.error("[yoke/codex] refCount negative, bug!");
+      _refCount = 0;
+    }
+    updateLastActiveAt();
+  }
+
+  function buildReadyResponse(skillNames) {
+    return {
+      models: _cachedModels,
+      defaultModel: "gpt-5.4",
+      skills: skillNames || [],
+      slashCommands: skillNames || [],
+      fastModeState: null,
+      capabilities: {
+        thinking: true,
+        betas: false,
+        rewind: false,
+        sessionResume: true,
+        promptSuggestions: true,
+        elicitation: true,
+        fileCheckpointing: false,
+        contextCompacting: false,
+        toolPolicy: ["ask", "allow-all"],
+      },
+    };
+  }
+
+  function clearRuntimeState() {
+    _appServer = null;
+    _initPromise = null;
+    _cachedModels = [];
+    _refCount = 0;
+    _activeQueries = [];
+    updateLastActiveAt();
+  }
+
+  function waitForRefCount(targetCount, timeoutMs) {
+    var deadline = Date.now() + (timeoutMs || 5000);
+    return new Promise(function(resolve) {
+      function tick() {
+        if (_refCount <= targetCount) {
+          resolve(true);
+          return;
+        }
+        if (Date.now() >= deadline) {
+          resolve(false);
+          return;
+        }
+        setTimeout(tick, 50);
+      }
+      tick();
+    });
+  }
+
+  function stopAppServer(deadlineMs) {
+    var proc = _appServer && _appServer.proc ? _appServer.proc : null;
+    if (!_appServer) return Promise.resolve(true);
+    try {
+      _appServer.stop();
+    } catch (e) {
+      console.error("[yoke/codex] App-server stop error:", e.message || e);
+    }
+    if (!proc) return Promise.resolve(true);
+    var remaining = (typeof deadlineMs === "number") ? Math.max(0, deadlineMs - Date.now()) : 5000;
+    return waitForProcessExit(proc, remaining).then(function(exited) {
+      if (!exited) {
+        try {
+          proc.kill("SIGKILL");
+        } catch (e) {}
+      }
+      return exited;
+    });
+  }
+
+  function beginShutdown(force, idleMs) {
+    if (_shutdownPromise) return _shutdownPromise;
+    if (_shuttingDown) return null;
+
+    _shuttingDown = true;
+
+    _shutdownPromise = (async function() {
+      var deadline = Date.now() + 5000;
+      var shouldAbort = !!force;
+
+      if (_initPromise) {
+        try {
+          await Promise.race([
+            _initPromise.catch(function() { return null; }),
+            waitMs(Math.max(0, deadline - Date.now())),
+          ]);
+        } catch (e) {}
+      }
+
+      if (shouldAbort && _activeQueries.length > 0) {
+        var active = _activeQueries.slice();
+        for (var i = 0; i < active.length; i++) {
+          try {
+            if (active[i] && active[i].abort) active[i].abort();
+          } catch (e) {}
+        }
+        await waitForRefCount(0, Math.max(0, deadline - Date.now()));
+      }
+
+      if (_appServer) {
+        await stopAppServer(deadline);
+      }
+
+      clearRuntimeState();
+      _shuttingDown = false;
+      _shutdownPromise = null;
+      return true;
+    })().catch(function(err) {
+      clearRuntimeState();
+      _shuttingDown = false;
+      _shutdownPromise = null;
+      throw err;
+    });
+
+    return _shutdownPromise;
+  }
 
   var adapter = {
     vendor: "codex",
 
     init: function(initOpts) {
+      if (_shuttingDown) {
+        return Promise.reject(createShutdownError());
+      }
+
+      var effectiveInitOpts = Object.assign({}, _defaultInitOpts, initOpts || {});
+
       // Already initialized - return cached result
       if (_appServer && _appServer.started && _cachedModels.length > 0) {
-        return Promise.resolve({
-          models: _cachedModels,
-          defaultModel: "gpt-5.4",
-          skills: [],
-          slashCommands: [],
-          fastModeState: null,
-          capabilities: {
-            thinking: true,
-            betas: false,
-            rewind: false,
-            sessionResume: true,
-            promptSuggestions: true,
-            elicitation: true,
-            fileCheckpointing: false,
-            contextCompacting: false,
-            toolPolicy: ["ask", "allow-all"],
-          },
-        });
+        return Promise.resolve(buildReadyResponse([]));
       }
 
       // Deduplicate concurrent init calls
       if (_initPromise) return _initPromise;
 
       _initPromise = (async function() {
-        _initOpts = initOpts;
-
         var serverOpts = { cwd: _cwd };
 
         // Extract adapter options
-        if (initOpts && initOpts.adapterOptions && initOpts.adapterOptions.CODEX) {
-          var co = initOpts.adapterOptions.CODEX;
+        if (effectiveInitOpts && effectiveInitOpts.adapterOptions && effectiveInitOpts.adapterOptions.CODEX) {
+          var co = effectiveInitOpts.adapterOptions.CODEX;
           if (co.apiKey) serverOpts.env = Object.assign({}, serverOpts.env || {}, { OPENAI_API_KEY: co.apiKey });
           if (co.baseUrl) serverOpts.env = Object.assign({}, serverOpts.env || {}, { OPENAI_BASE_URL: co.baseUrl });
           if (co.config) serverOpts.config = co.config;
@@ -1005,10 +1221,10 @@ function createCodexAdapter(opts) {
 
         // Track 2: Add clay-tools bridge server for in-app + remote MCP tools.
         var bridgePath = require("path").join(__dirname, "..", "mcp-bridge-server.js");
-        var clayPort = (initOpts && initOpts.clayPort) || process.env.CLAY_PORT || 2633;
-        var clayTls = (initOpts && initOpts.clayTls) || false;
-        var clayAuthToken = (initOpts && initOpts.clayAuthToken) || "";
-        var claySlug = (initOpts && initOpts.slug) || "";
+        var clayPort = effectiveInitOpts.clayPort || process.env.CLAY_PORT || 2633;
+        var clayTls = effectiveInitOpts.clayTls || false;
+        var clayAuthToken = effectiveInitOpts.clayAuthToken || "";
+        var claySlug = effectiveInitOpts.slug || _slug || "";
         try {
           if (require("fs").existsSync(bridgePath)) {
             var bridgeArgs = [bridgePath, "--port", String(clayPort), "--slug", claySlug];
@@ -1049,6 +1265,11 @@ function createCodexAdapter(opts) {
         });
         _appServer.notify("initialized", {});
 
+        if (_shuttingDown) {
+          await stopAppServer(Date.now() + 1000);
+          throw createShutdownError();
+        }
+
         console.log("[codex] App-server initialized, models: gpt-5.4, gpt-5.4-mini, gpt-5.3-codex, gpt-5.3-codex-spark, gpt-5.2");
 
         _cachedModels = [
@@ -1097,26 +1318,15 @@ function createCodexAdapter(opts) {
           console.error("[codex] Failed to discover skills:", e.message);
         }
 
+        if (_shuttingDown) {
+          await stopAppServer(Date.now() + 1000);
+          throw createShutdownError();
+        }
+
         _initPromise = null;
+        updateLastActiveAt();
 
-        return {
-          models: _cachedModels,
-          defaultModel: "gpt-5.4",
-          skills: skillNames,
-          slashCommands: skillNames,
-          fastModeState: null,
-          capabilities: {
-            thinking: true,
-            betas: false,
-            rewind: false,
-            sessionResume: true,
-            promptSuggestions: true,
-            elicitation: true,
-            fileCheckpointing: false,
-            contextCompacting: false,
-            toolPolicy: ["ask", "allow-all"],
-          },
-        };
+        return buildReadyResponse(skillNames);
       })();
 
       return _initPromise;
@@ -1134,12 +1344,31 @@ function createCodexAdapter(opts) {
     },
 
     createQuery: async function(queryOpts) {
+      if (_shuttingDown) {
+        throw createShutdownError();
+      }
+
+      if (!_appServer || !_appServer.started) {
+        await adapter.init(queryOpts || {});
+      }
+
+      if (_shuttingDown) {
+        throw createShutdownError();
+      }
+
       if (!_appServer || !_appServer.started) {
         throw new Error("[yoke/codex] Adapter not initialized. Call init() first.");
       }
 
       var model = queryOpts.model || "gpt-5.4";
       var ac = queryOpts.abortController || new AbortController();
+      var activeEntry = {
+        abort: function() {
+          try {
+            ac.abort();
+          } catch (e) {}
+        },
+      };
 
       // Map YOKE options to Codex thread options
       var codexOpts = (queryOpts.adapterOptions && queryOpts.adapterOptions.CODEX) || {};
@@ -1176,7 +1405,33 @@ function createCodexAdapter(opts) {
 
       console.log("[yoke/codex] createQuery: model=" + model + " approval=" + handleOpts.approvalPolicy + " sandbox=" + handleOpts.sandboxMode);
 
-      var handle = createCodexQueryHandle(_appServer, handleOpts);
+      _refCount++;
+      registerActiveQuery(activeEntry);
+
+      var handle;
+      try {
+        handleOpts.onFinished = function() {
+          removeActiveQuery(activeEntry);
+          decrementRefCount();
+        };
+        handle = createCodexQueryHandle(_appServer, handleOpts);
+      } catch (e) {
+        removeActiveQuery(activeEntry);
+        decrementRefCount();
+        throw e;
+      }
+
+      activeEntry.handle = handle;
+      activeEntry.abort = function() {
+        try {
+          if (handle && typeof handle.abort === "function") {
+            handle.abort();
+          } else {
+            ac.abort();
+          }
+        } catch (e) {}
+      };
+
       return handle;
     },
 
@@ -1243,10 +1498,19 @@ function createCodexAdapter(opts) {
 
     // Shutdown the app-server process
     shutdown: function() {
-      if (_appServer) {
-        _appServer.stop();
-        _appServer = null;
-      }
+      return beginShutdown(true);
+    },
+
+    shutdownIfIdle: function(idleMs) {
+      if (_shuttingDown || _shutdownPromise) return Promise.resolve(false);
+      if (_initPromise) return Promise.resolve(false);
+      if (!_appServer) return Promise.resolve(false);
+      if (_refCount > 0) return Promise.resolve(false);
+      if (Date.now() - _lastActiveAt < (idleMs || 0)) return Promise.resolve(false);
+      return beginShutdown(false).then(function() {
+        console.log("[yoke/codex] Reclaimed idle adapter for project " + (_slug || _cwd));
+        return true;
+      });
     },
   };
 

package/lib/yoke/index.js

@@ -19,6 +19,7 @@ function wrapCreateQuery(adapter, defaultCwd) {
   var originalCreateQuery = adapter.createQuery.bind(adapter);
 
   adapter.createQuery = function(queryOpts) {
+    queryOpts = queryOpts || {};
     var projectDir = (queryOpts && queryOpts.cwd) || defaultCwd;
     var merged = instructions.scanAndMerge(projectDir, adapter.vendor);
 
@@ -53,7 +54,7 @@ function createAdapter(opts) {
     throw new Error("[YOKE] Unknown adapter vendor: " + vendor);
   }
   iface.validateAdapter(adapter);
-  wrapCreateQuery(adapter, opts.cwd);
+  wrapCreateQuery(adapter, opts && opts.cwd);
   return adapter;
 }
 
@@ -187,8 +188,19 @@ function checkAuth() {
 
 /**
  * Check which vendor binaries are installed (regardless of auth status).
+ *
+ * Result is cached at module scope because the check runs two execFileSync
+ * calls per invocation and is triggered once per project context on daemon
+ * startup. With N projects this used to cost ~2N synchronous subprocesses;
+ * caching collapses it to two total. The cache is invalidated alongside
+ * the auth cache (via invalidateAuthCache) since "just installed" is the
+ * same situation as "just logged in" from the daemon's perspective.
  */
+var _installedCache = null;
+
 function checkInstalled() {
+  if (_installedCache) return _installedCache;
+
   var fs = require("fs");
   var execFileSync = require("child_process").execFileSync;
   var result = { claude: false, codex: false };
@@ -204,6 +216,7 @@ function checkInstalled() {
       codexBin = findCodexPath();
       if (codexBin && fs.existsSync(codexBin)) {
         result.codex = true;
+        _installedCache = result;
         return result;
       }
     } catch (e) {}
@@ -213,27 +226,25 @@ function checkInstalled() {
       : execFileSync("which", ["codex"], { timeout: 3000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
     if (whichOut.trim()) result.codex = true;
   } catch (e) {}
+  _installedCache = result;
   return result;
 }
 
 function invalidateAuthCache() {
   _authCache = null;
+  _installedCache = null;
 }
 
 /**
  * Create adapters for all authenticated vendors.
- * Adapters are singletons shared across all projects (they are stateless factories).
- * The cwd is passed per-query, not per-adapter.
+ * Claude may be shared across projects, but Codex is instantiated per project
+ * so its app-server and bridge stay scoped to a single project slug.
  * Returns { adapters: { vendor: Adapter }, auth: { vendor: boolean } }
  */
-var _sharedAdapters = null;
-var _sharedAuth = null;
+var _sharedClaudeAdapter = null;
 
 function createAdapters(opts) {
-  if (_sharedAdapters) {
-    return { adapters: _sharedAdapters, auth: _sharedAuth };
-  }
-
+  opts = opts || {};
   // Gate adapter creation on binary installation, not OAuth auth status.
   // Claude Code supports multiple auth modes (OAuth, Bedrock, Vertex, API key)
   // that `claude auth status` does not always detect. Runtime auth failures are
@@ -241,22 +252,30 @@ function createAdapters(opts) {
   var installed = checkInstalled();
   var auth = { claude: false, codex: false };
   var adapters = {};
-  var vendors = Object.keys(installed);
 
-  for (var i = 0; i < vendors.length; i++) {
-    var vendor = vendors[i];
-    if (!installed[vendor]) continue;
+  if (installed.claude) {
+    try {
+      if (!_sharedClaudeAdapter) {
+        _sharedClaudeAdapter = createAdapter({ vendor: "claude", cwd: opts.cwd });
+      }
+      adapters.claude = _sharedClaudeAdapter;
+      auth.claude = true;
+      console.log("[yoke] Adapter created: claude");
+    } catch (e) {
+      console.error("[yoke] Failed to create adapter for claude:", e.message);
+    }
+  }
+
+  if (installed.codex) {
     try {
-      adapters[vendor] = createAdapter({ vendor: vendor, cwd: opts.cwd });
-      auth[vendor] = true;
-      console.log("[yoke] Adapter created: " + vendor);
+      adapters.codex = createAdapter({ vendor: "codex", cwd: opts.cwd, slug: opts.slug });
+      auth.codex = true;
+      console.log("[yoke] Adapter created: codex");
     } catch (e) {
-      console.error("[yoke] Failed to create adapter for " + vendor + ":", e.message);
+      console.error("[yoke] Failed to create adapter for codex:", e.message);
     }
   }
 
-  _sharedAdapters = adapters;
-  _sharedAuth = auth;
   return { adapters: adapters, auth: auth };
 }
 
@@ -266,26 +285,19 @@ function createAdapters(opts) {
  * Returns the adapter or null.
  */
 async function lazyCreateAdapter(adapters, vendor, opts) {
-  if (_sharedAdapters && _sharedAdapters[vendor]) {
-    adapters[vendor] = _sharedAdapters[vendor];
-    return adapters[vendor];
-  }
+  opts = opts || {};
 
   // Force re-check since user may have logged in after server start
   invalidateAuthCache();
-  _sharedAdapters = null;
-  _sharedAuth = null;
   var installed = checkInstalled();
   if (!installed[vendor]) return null;
 
   try {
-    var ad = createAdapter({ vendor: vendor, cwd: opts.cwd });
+    var ad = createAdapter({ vendor: vendor, cwd: opts.cwd, slug: opts.slug });
     if (typeof ad.init === "function") {
       await ad.init(opts || {});
     }
     console.log("[yoke] Lazy adapter created: " + vendor);
-    if (_sharedAdapters) _sharedAdapters[vendor] = ad;
-    if (_sharedAuth) _sharedAuth[vendor] = true;
     adapters[vendor] = ad;
     return ad;
   } catch (e) {

package/lib/yoke/mcp-bridge-server.js

@@ -3,7 +3,8 @@
 // --------------------------------------------------
 // Codex spawns this as a native MCP server via config.mcp_servers["clay-tools"].
 // It implements the MCP protocol on stdio (JSON-RPC) and proxies tool
-// list/call requests to Clay's HTTP endpoint (/api/mcp-bridge).
+// list/call requests to Clay's project-scoped HTTP endpoint
+// (/p/{slug}/api/mcp-bridge) when a slug is provided.
 //
 // Usage: node mcp-bridge-server.js --port 2633 --slug my-project
 //
@@ -37,8 +38,10 @@ for (var i = 0; i < args.length; i++) {
 }
 
 var CLAY_PROTOCOL = clayTls ? "https" : "http";
-// Use global endpoint (not project-scoped) so bridge works regardless of which project was active at init
 var CLAY_BASE_URL = CLAY_PROTOCOL + "://127.0.0.1:" + clayPort;
+var CLAY_MCP_PATH = claySlug
+  ? ("/p/" + claySlug + "/api/mcp-bridge")
+  : "/api/mcp-bridge";
 
 // --- Auth ---
 var clayAuthToken = process.env.CLAY_AUTH_TOKEN || "";
@@ -91,8 +94,13 @@ function postJson(urlPath, body) {
       reject(err);
     });
 
-    // 30s timeout for tool calls
-    req.setTimeout(30000, function () {
+    // 10 min safety ceiling. ask_user_questions is stateless (returns
+    // immediately; the user's answer arrives on the next turn as a new
+    // user message), so no tool call should legitimately block long.
+    // The generous ceiling is just a belt-and-suspenders against slow
+    // browser automation or external MCP servers, not the primary
+    // mechanism for human-in-the-loop tools.
+    req.setTimeout(600000, function () {
       req.destroy(new Error("Request timed out"));
     });
 
@@ -103,7 +111,7 @@ function postJson(urlPath, body) {
 
 // --- Fetch tools from Clay ---
 function fetchTools() {
-  return postJson("/api/mcp-bridge", { action: "list_tools" }).then(function (resp) {
+  return postJson(CLAY_MCP_PATH, { action: "list_tools" }).then(function (resp) {
     if (resp.error) {
       log("Failed to fetch tools: " + resp.error);
       return [];
@@ -124,7 +132,7 @@ function fetchTools() {
 
 // --- Call a tool via Clay ---
 function callTool(serverName, toolName, args) {
-  return postJson("/api/mcp-bridge", {
+  return postJson(CLAY_MCP_PATH, {
     action: "call_tool",
     server: serverName,
     tool: toolName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clay-server",
-  "version": "2.34.0-beta.3",
+  "version": "2.34.0-beta.4",
   "description": "Self-hosted Claude Code in your browser. Multi-session, multi-user, push notifications.",
   "bin": {
     "clay-server": "./bin/cli.js",