clay-server 2.23.1 → 2.23.2-beta.1

package/lib/build-user-env.js

@@ -51,6 +51,12 @@ function buildUserEnv(osUserInfo) {
     env.XDG_RUNTIME_DIR = process.env.XDG_RUNTIME_DIR;
   }
 
+  // Force Node.js to prefer IPv4. Without this, the SDK CLI subprocess
+  // tries IPv6 first (happy eyeballs), times out on servers without IPv6
+  // outbound, then falls back to IPv4. This causes multi-second delays
+  // on cold start (compounded by exponential backoff retries).
+  env.NODE_OPTIONS = (env.NODE_OPTIONS ? env.NODE_OPTIONS + " " : "") + "--dns-result-order=ipv4first";
+
   return env;
 }
 

package/lib/project.js

@@ -3788,6 +3788,8 @@ function createProjectContext(opts) {
       sendToSession(session.localId, { type: "status", status: "processing" });
       if (!session.queryInstance && (!session.worker || session.messageQueue !== "worker")) {
         // No active query (or worker idle between queries): start a new query
+        session._queryStartTs = Date.now();
+        console.log("[PERF] project.js: startQuery called, localId=" + session.localId + " t=0ms");
         sdk.startQuery(session, fullText, msg.images, getLinuxUserForSession(session));
       } else {
         sdk.pushMessage(session, fullText, msg.images);

package/lib/public/modules/notifications.js

@@ -72,6 +72,10 @@ export function initNotifications(_ctx) {
   if (window.visualViewport) {
     var layout = $("layout");
     var mobileTabBar = document.getElementById("mobile-tab-bar");
+    // Capture initial viewport height before any keyboard interaction.
+    // In iOS PWA standalone mode, window.innerHeight shrinks when the
+    // keyboard opens, so we need a stable baseline for comparison.
+    var stableViewportHeight = window.innerHeight;
     function onViewportChange() {
       var vv = window.visualViewport;
       // Shrink layout to visual viewport height so input area sits above keyboard
@@ -80,7 +84,7 @@ export function initNotifications(_ctx) {
       layout.style.top = vv.offsetTop + "px";
       document.documentElement.scrollTop = 0;
       // Toggle class so CSS can remove the tab-bar bottom padding while keyboard is up
-      var keyboardOpen = vv.height < window.innerHeight - 100;
+      var keyboardOpen = vv.height < stableViewportHeight - 100;
       document.body.classList.toggle("keyboard-open", keyboardOpen);
       if (!keyboardOpen) ctx.scrollToBottom();
       // Hide tab bar when software keyboard is open

package/lib/sdk-bridge.js

@@ -189,6 +189,26 @@ function createSDKBridge(opts) {
   }
 
   function processSDKMessage(session, parsed) {
+    // Timing: log key SDK milestones relative to query start
+    if (session._queryStartTs) {
+      var _elapsed = Date.now() - session._queryStartTs;
+      if (parsed.type === "system" && parsed.subtype === "init") {
+        console.log("[PERF] processSDKMessage: system/init +" + _elapsed + "ms");
+      }
+      if (parsed.type === "stream_event" && parsed.event) {
+        if (parsed.event.type === "message_start") {
+          console.log("[PERF] processSDKMessage: message_start (API response begun) +" + _elapsed + "ms");
+        }
+        if (parsed.event.type === "content_block_delta" && !session._firstTextLogged) {
+          session._firstTextLogged = true;
+          console.log("[PERF] processSDKMessage: FIRST content_block_delta (visible text) +" + _elapsed + "ms");
+        }
+      }
+      if (parsed.type === "result") {
+        console.log("[PERF] processSDKMessage: result +" + _elapsed + "ms");
+      }
+    }
+
     // Extract session_id from any message that carries it
     if (parsed.session_id && !session.cliSessionId) {
       session.cliSessionId = parsed.session_id;
@@ -756,7 +776,9 @@ function createSDKBridge(opts) {
     });
 
     // Create Unix socket server
+    var spawnT0 = Date.now();
     worker.server = net.createServer(function(connection) {
+      console.log("[PERF] spawnWorker: socket connection accepted +" + (Date.now() - spawnT0) + "ms");
       worker.connection = connection;
       connection.on("data", function(chunk) {
         worker.buffer += chunk.toString();
@@ -767,6 +789,7 @@ function createSDKBridge(opts) {
           try {
             var msg = JSON.parse(lines[i]);
             if (msg.type === "ready") {
+              console.log("[PERF] spawnWorker: 'ready' IPC received +" + (Date.now() - spawnT0) + "ms");
               worker.ready = true;
               if (worker._readyResolve) {
                 worker._readyResolve();
@@ -787,6 +810,7 @@ function createSDKBridge(opts) {
     });
 
     worker.server.listen(socketPath, function() {
+      console.log("[PERF] spawnWorker: socket listen ready +" + (Date.now() - spawnT0) + "ms");
       // Set socket permissions so the target user can connect
       try { fs.chmodSync(socketPath, 0o777); } catch (e) {}
 
@@ -933,125 +957,96 @@ function createSDKBridge(opts) {
    * Mirrors the in-process startQuery flow but delegates SDK execution to the worker.
    */
   async function startQueryViaWorker(session, text, images, linuxUser) {
+    var t0 = session._queryStartTs || Date.now();
+    function perf(label) { console.log("[PERF] sdk-bridge: " + label + " +" + (Date.now() - t0) + "ms"); }
+    perf("startQueryViaWorker entered");
+
     // Wait for the previous worker to fully exit before spawning a new one.
     // Without this, the new worker may try to resume the SDK session file
     // while the old worker is still flushing it to disk (800ms grace period),
     // causing "no conversation found" and losing all prior context.
     if (session._workerExitPromise) {
-      console.log("[sdk-bridge] startQueryViaWorker: waiting for old worker exit, localId=" + session.localId);
+      perf("waiting for old worker exit");
       var exitWait = session._workerExitPromise;
       session._workerExitPromise = null;
       await Promise.race([
         exitWait,
         new Promise(function(resolve) { setTimeout(resolve, 3000); }),
       ]);
-      console.log("[sdk-bridge] startQueryViaWorker: old worker exit wait done");
+      perf("old worker exit wait done");
     }
 
-    // Ensure the linux user's .claude directories are writable.
-    // The daemon runs as root, so any dirs it creates (mkdirSync) will be
-    // root-owned. The SDK (running as the linux user) needs write access
-    // to create session files, otherwise resume silently fails.
-    if (linuxUser) {
+    // Reuse existing worker if alive, otherwise spawn a new one.
+    // Spawn FIRST so the worker starts booting while we do dir setup below.
+    var worker;
+    var reusingWorker = false;
+    if (session.worker && session.worker.ready && session.worker.process && !session.worker.process.killed) {
+      worker = session.worker;
+      reusingWorker = true;
+      // Clear old message handlers so they don't fire for the new query
+      worker.messageHandlers = [];
+      worker._queryEnded = false;
+      worker._abortSent = false;
+      perf("reusing existing worker pid=" + (worker.process ? worker.process.pid : "?"));
+    } else {
       try {
-        var osUsersMod0 = require("./os-users");
-        var linuxUserHome0 = osUsersMod0.getLinuxUserHome(linuxUser);
-        var uid0 = osUsersMod0.getLinuxUserUid(linuxUser);
-        if (uid0 != null) {
-          var claudeDir = path.join(linuxUserHome0, ".claude");
-          var projectSlug0 = (cwd || "").replace(/\//g, "-");
-          var projDir = path.join(claudeDir, "projects", projectSlug0);
-          // Create the project directory if missing and chown the whole tree
-          if (!fs.existsSync(projDir)) {
-            fs.mkdirSync(projDir, { recursive: true });
-            try { require("child_process").execSync("chown -R " + uid0 + " " + JSON.stringify(claudeDir)); } catch (e) {}
-          } else {
-            // Fix existing directory if root-owned
-            try {
-              var pstat = fs.statSync(projDir);
-              if (pstat.uid !== uid0) {
-                require("child_process").execSync("chown " + uid0 + " " + JSON.stringify(projDir));
-              }
-            } catch (e) {}
-          }
-        }
+        perf("spawning new worker");
+        worker = spawnWorker(linuxUser);
+        perf("spawnWorker returned");
+        session.worker = worker;
       } catch (e) {
-        console.log("[sdk-bridge] Dir ownership fix skipped:", e.message);
+        session.isProcessing = false;
+        onProcessingChanged();
+        sendAndRecord(session, { type: "error", text: "Failed to spawn worker for " + linuxUser + ": " + (e.message || e) });
+        sendAndRecord(session, { type: "done", code: 1 });
+        sm.broadcastSessionList();
+        return;
       }
     }
 
-    // Pre-copy CLI session file BEFORE spawning worker.
-    // Must happen before spawn so execSync doesn't block the event loop
-    // while worker is alive (which causes ready/exit race conditions).
-    if (session.cliSessionId && linuxUser) {
+    // Ensure the linux user's .claude project directory exists and is writable,
+    // then pre-copy CLI session file if needed. This runs while the worker is
+    // booting (readyPromise pending), so it adds no extra latency.
+    perf("dir setup start");
+    if (linuxUser) {
       try {
         var configMod = require("./config");
         var osUsersMod = require("./os-users");
         var originalHome = configMod.REAL_HOME || require("os").homedir();
         var linuxUserHome = osUsersMod.getLinuxUserHome(linuxUser);
-        if (originalHome !== linuxUserHome) {
+        var uid = osUsersMod.getLinuxUserUid(linuxUser);
+        if (originalHome !== linuxUserHome && uid != null) {
           var projectSlug = (cwd || "").replace(/\//g, "-");
-          var sessionFileName = session.cliSessionId + ".jsonl";
-          var srcFile = path.join(originalHome, ".claude", "projects", projectSlug, sessionFileName);
           var dstDir = path.join(linuxUserHome, ".claude", "projects", projectSlug);
-          var dstFile = path.join(dstDir, sessionFileName);
-          var uid = osUsersMod.getLinuxUserUid(linuxUser);
-          // Ensure the projects directory is owned by the linux user so the
-          // SDK can create new session files. Without this, mkdirSync creates
-          // root-owned directories and the SDK silently fails to save sessions.
+          // Create and chown the project directory once
           if (!fs.existsSync(dstDir)) {
             fs.mkdirSync(dstDir, { recursive: true });
-            if (uid != null) {
-              try { require("child_process").execSync("chown -R " + uid + " " + JSON.stringify(dstDir)); } catch (e2) {}
-            }
+            try { require("child_process").execSync("chown -R " + uid + " " + JSON.stringify(path.join(linuxUserHome, ".claude"))); } catch (e2) {}
           } else {
-            // Fix ownership of existing directories created by root
             try {
               var dirStat = fs.statSync(dstDir);
-              if (uid != null && dirStat.uid !== uid) {
+              if (dirStat.uid !== uid) {
                 require("child_process").execSync("chown " + uid + " " + JSON.stringify(dstDir));
               }
             } catch (e2) {}
           }
-          if (fs.existsSync(srcFile) && !fs.existsSync(dstFile)) {
-            fs.copyFileSync(srcFile, dstFile);
-            if (uid != null) {
+          // Pre-copy CLI session file so the worker can resume the conversation
+          if (session.cliSessionId) {
+            var sessionFileName = session.cliSessionId + ".jsonl";
+            var srcFile = path.join(originalHome, ".claude", "projects", projectSlug, sessionFileName);
+            var dstFile = path.join(dstDir, sessionFileName);
+            if (fs.existsSync(srcFile) && !fs.existsSync(dstFile)) {
+              fs.copyFileSync(srcFile, dstFile);
               try { require("child_process").execSync("chown " + uid + " " + JSON.stringify(dstFile)); } catch (e2) {}
+              console.log("[sdk-bridge] Pre-copied CLI session " + session.cliSessionId + " to " + linuxUser);
             }
-            console.log("[sdk-bridge] Pre-copied CLI session " + session.cliSessionId + " to " + linuxUser);
           }
         }
       } catch (copyErr) {
-        console.log("[sdk-bridge] Session pre-copy skipped:", copyErr.message);
-      }
-    }
-
-    // Reuse existing worker if alive, otherwise spawn a new one.
-    // Keeping the worker alive between queries lets the SDK maintain session
-    // state in memory, avoiding disk-based resume that fails on abort.
-    var worker;
-    var reusingWorker = false;
-    if (session.worker && session.worker.ready && session.worker.process && !session.worker.process.killed) {
-      worker = session.worker;
-      reusingWorker = true;
-      // Clear old message handlers so they don't fire for the new query
-      worker.messageHandlers = [];
-      worker._queryEnded = false;
-      worker._abortSent = false;
-      console.log("[sdk-bridge] Reusing existing worker pid=" + (worker.process ? worker.process.pid : "?"));
-    } else {
-      try {
-        worker = spawnWorker(linuxUser);
-        session.worker = worker;
-      } catch (e) {
-        session.isProcessing = false;
-        onProcessingChanged();
-        sendAndRecord(session, { type: "error", text: "Failed to spawn worker for " + linuxUser + ": " + (e.message || e) });
-        sendAndRecord(session, { type: "done", code: 1 });
-        sm.broadcastSessionList();
-        return;
+        console.log("[sdk-bridge] Dir setup / session pre-copy skipped:", copyErr.message);
       }
     }
+    perf("dir setup done");
 
     session.messageQueue = "worker"; // sentinel: messages go via worker IPC
     session.blocks = {};
@@ -1119,7 +1114,12 @@ function createSDKBridge(opts) {
     }
 
     // Set up message handler for worker events
+    var firstEventLogged = false;
     worker.onMessage(function(msg) {
+      if (!firstEventLogged && msg.type === "sdk_event") {
+        firstEventLogged = true;
+        perf("FIRST sdk_event received (type=" + (msg.event && msg.event.type || "?") + ")");
+      }
       switch (msg.type) {
         case "sdk_event":
           processSDKMessage(session, msg.event);
@@ -1312,8 +1312,10 @@ function createSDKBridge(opts) {
 
     // Wait for worker to be ready, then send query
     if (!reusingWorker) {
+      perf("awaiting readyPromise");
       try {
         await worker.readyPromise;
+        perf("readyPromise resolved");
       } catch (e) {
         session.isProcessing = false;
         onProcessingChanged();
@@ -1325,6 +1327,7 @@ function createSDKBridge(opts) {
       }
     }
 
+    perf("sending query_start to worker");
     worker.send({
       type: "query_start",
       prompt: initialMessage,
@@ -1332,7 +1335,9 @@ function createSDKBridge(opts) {
       singleTurn: !!session.singleTurn,
       originalHome: require("./config").REAL_HOME || null,
       projectPath: session.cwd || null,
+      _perfT0: t0,
     });
+    perf("query_start sent");
   }
 
   function cleanupSessionWorker(session, fromWorker) {

package/lib/sdk-worker.js

@@ -5,7 +5,8 @@
 // Usage: node sdk-worker.js <socket-path>
 
 // Early diagnostic — writes directly to fd 2 to ensure output even if pipes close fast
-try { require("fs").writeSync(2, "[sdk-worker] BOOT pid=" + process.pid + " uid=" + (typeof process.getuid === "function" ? process.getuid() : "?") + " argv=" + process.argv.slice(1).join(" ") + "\n"); } catch (e) {}
+var _workerBootTs = Date.now();
+try { require("fs").writeSync(2, "[sdk-worker] BOOT pid=" + process.pid + " uid=" + (typeof process.getuid === "function" ? process.getuid() : "?") + " argv=" + process.argv.slice(1).join(" ") + " bootTs=" + _workerBootTs + "\n"); } catch (e) {}
 
 var net = require("net");
 var crypto = require("crypto");
@@ -204,9 +205,16 @@ function handleElicitationResponse(msg) {
 
 // --- Query handling ---
 async function handleQueryStart(msg) {
+  var t0 = msg._perfT0 || Date.now();
+  var localT0 = Date.now();
+  function perf(label) { console.log("[PERF] sdk-worker: " + label + " +" + (Date.now() - t0) + "ms (local +" + (Date.now() - localT0) + "ms)"); }
+  perf("handleQueryStart entered");
+
   var sdk;
   try {
+    perf("loading SDK");
     sdk = await getSDK();
+    perf("SDK loaded");
   } catch (e) {
     sendToDaemon({ type: "query_error", error: "Failed to load SDK: " + (e.message || e), exitCode: null, stderr: null });
     return;
@@ -223,6 +231,17 @@ async function handleQueryStart(msg) {
   // Build query options (callbacks are local, everything else from daemon)
   var options = msg.options || {};
   options.abortController = abortController;
+  // Override CLI subprocess spawn to inject NODE_OPTIONS for IPv4-first DNS.
+  // The SDK constructs its own env for the CLI process, so worker env vars
+  // like NODE_OPTIONS are not inherited. We intercept the spawn to fix this.
+  options.spawnClaudeCodeProcess = function(spawnOpts) {
+    spawnOpts.env.NODE_OPTIONS = (spawnOpts.env.NODE_OPTIONS || "") + " --dns-result-order=ipv4first";
+    return require("child_process").spawn(spawnOpts.command, spawnOpts.args, {
+      cwd: spawnOpts.cwd,
+      env: spawnOpts.env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+  };
   options.canUseTool = function(toolName, input, toolOpts) {
     // AskUserQuestion is handled specially: we send it as a separate IPC type
     // so the daemon can use its own AskUserQuestion handling logic
@@ -249,11 +268,13 @@ async function handleQueryStart(msg) {
     return onElicitation(request, elicitOpts);
   };
 
+  perf("creating query instance");
   try {
     queryInstance = sdk.query({
       prompt: messageQueue,
       options: options,
     });
+    perf("query instance created");
   } catch (e) {
     sendToDaemon({ type: "query_error", error: "Failed to create query: " + (e.message || e), exitCode: null, stderr: null });
     queryInstance = null;
@@ -269,9 +290,41 @@ async function handleQueryStart(msg) {
 
   // Stream events to daemon
   try {
+    var firstEvent = true;
+    var firstText = true;
+    var eventCounts = {};
     for await (var event of queryInstance) {
+      var etype = (event && event.type || "?");
+      var esubtype = (event && event.subtype || "");
+      eventCounts[etype] = (eventCounts[etype] || 0) + 1;
+      if (firstEvent) {
+        perf("FIRST event from SDK (type=" + etype + " subtype=" + esubtype + ")");
+        firstEvent = false;
+      }
+      // Log every non-content event, and the first content/text event
+      if (etype !== "content_block_delta" && etype !== "content_block_start" && etype !== "content_block_stop") {
+        var extraInfo = "";
+        if (esubtype === "api_retry") {
+          // Dump full event to see all available fields
+          try {
+            var retryDump = JSON.stringify(event, function(k, v) {
+              if (typeof v === "string" && v.length > 200) return v.substring(0, 200) + "...[truncated]";
+              return v;
+            });
+            extraInfo = " FULL=" + retryDump;
+          } catch (je) {
+            extraInfo = " keys=" + Object.keys(event).join(",");
+          }
+        }
+        perf("SDK event #" + eventCounts[etype] + " type=" + etype + " subtype=" + esubtype + extraInfo);
+      }
+      if (firstText && (etype === "content_block_delta" || etype === "assistant" || (etype === "content_block_start"))) {
+        perf("FIRST TEXT/CONTENT event (type=" + etype + " subtype=" + esubtype + ")");
+        firstText = false;
+      }
       sendToDaemon({ type: "sdk_event", event: event });
     }
+    perf("all events streamed (counts=" + JSON.stringify(eventCounts) + "), sending query_done");
     sendToDaemon({ type: "query_done" });
   } catch (err) {
     var errMsg = err.message || String(err);
@@ -424,9 +477,9 @@ function gracefulExit(code) {
 var _keepAlive = setInterval(function() {}, 30000);
 
 // --- Connect to daemon socket ---
-try { require("fs").writeSync(2, "[sdk-worker] Connecting to socket: " + socketPath + "\n"); } catch (e) {}
+try { require("fs").writeSync(2, "[sdk-worker] Connecting to socket: " + socketPath + " +" + (Date.now() - _workerBootTs) + "ms since boot\n"); } catch (e) {}
 conn = net.connect(socketPath, function() {
-  try { require("fs").writeSync(2, "[sdk-worker] Connected, sending ready\n"); } catch (e) {}
+  try { require("fs").writeSync(2, "[sdk-worker] Connected, sending ready +" + (Date.now() - _workerBootTs) + "ms since boot\n"); } catch (e) {}
   sendToDaemon({ type: "ready" });
 });
 

package/package.json

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