clay-server 2.10.0 → 2.11.0-beta.10

package/lib/sdk-bridge.js

@@ -2,7 +2,10 @@ const crypto = require("crypto");
 var fs = require("fs");
 var path = require("path");
 var os = require("os");
-var { execSync } = require("child_process");
+var net = require("net");
+var { execSync, spawn } = require("child_process");
+var { resolveOsUserInfo } = require("./os-users");
+var usersModule = require("./users");
 
 // Async message queue for streaming input to SDK
 function createMessageQueue() {
@@ -55,6 +58,7 @@ function createSDKBridge(opts) {
   var dangerouslySkipPermissions = opts.dangerouslySkipPermissions || false;
   var onProcessingChanged = opts.onProcessingChanged || function () {};
 
+
   // --- Skill discovery helpers ---
 
   function discoverSkillDirs() {
@@ -243,6 +247,9 @@ function createSDKBridge(opts) {
           .map(function(c) { return c.text; })
           .join("");
         if (assistantText) {
+          if (session.responsePreview.length < 200) {
+            session.responsePreview += assistantText;
+          }
           sendAndRecord(session, { type: "delta", text: assistantText });
         }
       }
@@ -314,6 +321,7 @@ function createSDKBridge(opts) {
       session.blocks = {};
       session.sentToolResults = {};
       session.pendingPermissions = {};
+      session.pendingElicitations = {};
       // Record ask_user_answered for any leftover pending questions so replay pairs correctly
       var leftoverAskIds = Object.keys(session.pendingAskUser);
       for (var lai = 0; lai < leftoverAskIds.length; lai++) {
@@ -338,6 +346,27 @@ function createSDKBridge(opts) {
       if (parsed.fast_mode_state) {
         sendAndRecord(session, { type: "fast_mode_state", state: parsed.fast_mode_state });
       }
+      // Detect "Not logged in · Please run /login" from SDK.
+      // This is a short canned response with zero cost, not actual AI output.
+      var previewTrimmed = (session.responsePreview || "").trim();
+      var isZeroCost = !parsed.total_cost_usd || parsed.total_cost_usd === 0;
+      var isLoginPrompt = isZeroCost && previewTrimmed.length < 100
+        && /not logged in/i.test(previewTrimmed) && /\/login/i.test(previewTrimmed);
+      if (isLoginPrompt) {
+        var authUser = session.ownerId ? usersModule.findUserById(session.ownerId) : null;
+        var authLinuxUser = authUser && authUser.linuxUser ? authUser.linuxUser : null;
+        var canAutoLogin = !usersModule.isMultiUser()
+          || !!authLinuxUser
+          || (authUser && authUser.role === "admin");
+        sendAndRecord(session, {
+          type: "auth_required",
+          text: "Claude Code is not logged in.",
+          linuxUser: authLinuxUser,
+          canAutoLogin: canAutoLogin,
+        });
+        // Reset CLI session so next query starts fresh with new auth
+        session.cliSessionId = null;
+      }
       sendAndRecord(session, { type: "done", code: 0 });
       if (pushModule) {
         var preview = (session.responsePreview || "").replace(/\s+/g, " ").trim();
@@ -386,6 +415,7 @@ function createSDKBridge(opts) {
           usage: parsed.usage || null,
           lastToolName: parsed.last_tool_name || null,
           description: parsed.description || "",
+          summary: parsed.summary || null,
         });
       }
 
@@ -494,6 +524,524 @@ function createSDKBridge(opts) {
     // user messages with parent_tool_use_id contain tool_results — skip silently
   }
 
+  // --- MCP elicitation ---
+
+  function handleElicitation(session, request, opts) {
+    // Ralph Loop: auto-reject elicitation in autonomous mode
+    if (session.loop && session.loop.active && session.loop.role !== "crafting") {
+      return Promise.resolve({ action: "reject" });
+    }
+
+    return new Promise(function(resolve) {
+      var requestId = crypto.randomUUID();
+      if (!session.pendingElicitations) session.pendingElicitations = {};
+      session.pendingElicitations[requestId] = {
+        resolve: resolve,
+        request: request,
+      };
+      sendAndRecord(session, {
+        type: "elicitation_request",
+        requestId: requestId,
+        serverName: request.serverName,
+        message: request.message,
+        mode: request.mode || "form",
+        url: request.url || null,
+        elicitationId: request.elicitationId || null,
+        requestedSchema: request.requestedSchema || null,
+      });
+
+      if (pushModule) {
+        pushModule.sendPush({
+          type: "elicitation",
+          slug: slug,
+          title: (request.serverName || "MCP Server") + " needs input",
+          body: request.message || "Waiting for your response",
+          tag: "claude-elicitation",
+        });
+      }
+
+      if (opts.signal) {
+        opts.signal.addEventListener("abort", function() {
+          delete session.pendingElicitations[requestId];
+          resolve({ action: "reject" });
+        });
+      }
+    });
+  }
+
+  // --- Worker process management (OS-level multi-user) ---
+
+  var WORKER_SCRIPT = path.join(__dirname, "sdk-worker.js");
+
+  // resolveLinuxUser delegates to shared os-users utility
+  function resolveLinuxUser(username) {
+    return resolveOsUserInfo(username);
+  }
+
+  /**
+   * Spawn an SDK worker process running as the given Linux user.
+   * Returns a worker handle with send/kill/event methods.
+   */
+  function spawnWorker(linuxUser) {
+    var userInfo = resolveLinuxUser(linuxUser);
+    var socketId = crypto.randomUUID();
+    var socketPath = path.join(os.tmpdir(), "clay-worker-" + socketId + ".sock");
+
+    var worker = {
+      process: null,
+      connection: null,
+      socketPath: socketPath,
+      server: null,
+      messageHandlers: [],
+      ready: false,
+      readyPromise: null,
+      _readyResolve: null,
+      buffer: "",
+    };
+
+    worker.readyPromise = new Promise(function(resolve) {
+      worker._readyResolve = resolve;
+    });
+
+    // Create Unix socket server
+    worker.server = net.createServer(function(connection) {
+      worker.connection = connection;
+      connection.on("data", function(chunk) {
+        worker.buffer += chunk.toString();
+        var lines = worker.buffer.split("\n");
+        worker.buffer = lines.pop();
+        for (var i = 0; i < lines.length; i++) {
+          if (!lines[i].trim()) continue;
+          try {
+            var msg = JSON.parse(lines[i]);
+            if (msg.type === "ready") {
+              worker.ready = true;
+              if (worker._readyResolve) {
+                worker._readyResolve();
+                worker._readyResolve = null;
+              }
+            }
+            for (var h = 0; h < worker.messageHandlers.length; h++) {
+              worker.messageHandlers[h](msg);
+            }
+          } catch (e) {
+            console.error("[sdk-bridge] Failed to parse worker message:", e.message);
+          }
+        }
+      });
+      connection.on("error", function(err) {
+        console.error("[sdk-bridge] Worker connection error:", err.message);
+      });
+    });
+
+    worker.server.listen(socketPath, function() {
+      // Set socket permissions so the target user can connect
+      try { fs.chmodSync(socketPath, 0o777); } catch (e) {}
+
+      // Spawn worker process as the target Linux user
+      var workerEnv = {
+        HOME: userInfo.home,
+        USER: linuxUser,
+        PATH: process.env.PATH || "/usr/local/bin:/usr/bin:/bin",
+        NODE_PATH: process.env.NODE_PATH || "",
+        LANG: process.env.LANG || "en_US.UTF-8",
+      };
+
+      worker.process = spawn(process.execPath, [WORKER_SCRIPT, socketPath], {
+        uid: userInfo.uid,
+        gid: userInfo.gid,
+        env: workerEnv,
+        cwd: cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      worker.process.stdout.on("data", function(data) {
+        console.log("[sdk-worker:" + linuxUser + "] " + data.toString().trim());
+      });
+      worker.process.stderr.on("data", function(data) {
+        console.error("[sdk-worker:" + linuxUser + "] " + data.toString().trim());
+      });
+
+      worker.process.on("exit", function(code, signal) {
+        console.log("[sdk-bridge] Worker for " + linuxUser + " exited (code=" + code + ", signal=" + signal + ")");
+        cleanupWorker(worker);
+      });
+    });
+
+    worker.send = function(msg) {
+      if (!worker.connection || worker.connection.destroyed) return;
+      try {
+        worker.connection.write(JSON.stringify(msg) + "\n");
+      } catch (e) {
+        console.error("[sdk-bridge] Failed to send to worker:", e.message);
+      }
+    };
+
+    worker.onMessage = function(handler) {
+      worker.messageHandlers.push(handler);
+    };
+
+    worker.kill = function() {
+      worker.send({ type: "shutdown" });
+      // Force kill after 3 seconds if still alive
+      setTimeout(function() {
+        if (worker.process && !worker.process.killed) {
+          try { worker.process.kill("SIGKILL"); } catch (e) {}
+        }
+      }, 3000);
+      cleanupWorker(worker);
+    };
+
+    return worker;
+  }
+
+  function cleanupWorker(worker) {
+    if (worker.connection && !worker.connection.destroyed) {
+      try { worker.connection.end(); } catch (e) {}
+    }
+    if (worker.server) {
+      try { worker.server.close(); } catch (e) {}
+    }
+    // Remove socket file
+    try { fs.unlinkSync(worker.socketPath); } catch (e) {}
+    worker.ready = false;
+  }
+
+  /**
+   * Start a query via a worker process running as the target Linux user.
+   * Mirrors the in-process startQuery flow but delegates SDK execution to the worker.
+   */
+  async function startQueryViaWorker(session, text, images, linuxUser) {
+    var worker;
+    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;
+    }
+
+    session.messageQueue = "worker"; // sentinel: messages go via worker IPC
+    session.blocks = {};
+    session.sentToolResults = {};
+    session.activeTaskToolIds = {};
+    session.pendingElicitations = {};
+    session.streamedText = false;
+    session.responsePreview = "";
+    session.abortController = { abort: function() { worker.send({ type: "abort" }); } };
+
+    // Build initial user message content
+    var content = [];
+    if (images && images.length > 0) {
+      for (var i = 0; i < images.length; i++) {
+        content.push({
+          type: "image",
+          source: { type: "base64", media_type: images[i].mediaType, data: images[i].data },
+        });
+      }
+    }
+    if (text) {
+      content.push({ type: "text", text: text });
+    }
+
+    var initialMessage = {
+      type: "user",
+      message: { role: "user", content: content },
+    };
+
+    // Build serializable query options (no callbacks, no AbortController)
+    var queryOptions = {
+      cwd: cwd,
+      settingSources: ["user", "project", "local"],
+      includePartialMessages: true,
+      enableFileCheckpointing: true,
+      extraArgs: { "replay-user-messages": null },
+      promptSuggestions: true,
+      agentProgressSummaries: true,
+    };
+
+    if (sm.currentModel) queryOptions.model = sm.currentModel;
+    if (sm.currentEffort) queryOptions.effort = sm.currentEffort;
+    if (sm.currentBetas && sm.currentBetas.length > 0) queryOptions.betas = sm.currentBetas;
+    if (sm.currentThinking === "disabled") {
+      queryOptions.thinking = { type: "disabled" };
+    } else if (sm.currentThinking === "budget" && sm.currentThinkingBudget) {
+      queryOptions.thinking = { type: "enabled", budgetTokens: sm.currentThinkingBudget };
+    }
+
+    if (dangerouslySkipPermissions) {
+      queryOptions.permissionMode = "bypassPermissions";
+      queryOptions.allowDangerouslySkipPermissions = true;
+    } else {
+      var modeToApply = session.acceptEditsAfterStart ? "acceptEdits" : sm.currentPermissionMode;
+      if (session.acceptEditsAfterStart) delete session.acceptEditsAfterStart;
+      if (modeToApply && modeToApply !== "default") {
+        queryOptions.permissionMode = modeToApply;
+      }
+    }
+
+    if (session.cliSessionId) {
+      queryOptions.resume = session.cliSessionId;
+      if (session.lastRewindUuid) {
+        queryOptions.resumeSessionAt = session.lastRewindUuid;
+        delete session.lastRewindUuid;
+      }
+    }
+
+    // Set up message handler for worker events
+    worker.onMessage(function(msg) {
+      switch (msg.type) {
+        case "sdk_event":
+          processSDKMessage(session, msg.event);
+          break;
+
+        case "permission_request":
+          handleCanUseTool(session, msg.toolName, msg.input, {
+            toolUseID: msg.toolUseId,
+            decisionReason: msg.decisionReason,
+            signal: session.abortController ? { addEventListener: function() {} } : undefined,
+          }).then(function(result) {
+            worker.send({ type: "permission_response", requestId: msg.requestId, result: result });
+          });
+          break;
+
+        case "ask_user_request":
+          // Delegate to the daemon's AskUserQuestion handling
+          handleCanUseTool(session, "AskUserQuestion", msg.input, {
+            toolUseID: msg.toolUseId,
+            signal: session.abortController ? { addEventListener: function() {} } : undefined,
+          }).then(function(result) {
+            worker.send({ type: "ask_user_response", toolUseId: msg.toolUseId, result: result });
+          });
+          break;
+
+        case "elicitation_request":
+          handleElicitation(session, {
+            serverName: msg.serverName,
+            message: msg.message,
+            mode: msg.mode,
+            url: msg.url,
+            elicitationId: msg.elicitationId,
+            requestedSchema: msg.requestedSchema,
+          }, {
+            signal: session.abortController ? { addEventListener: function() {} } : undefined,
+          }).then(function(result) {
+            worker.send({ type: "elicitation_response", requestId: msg.requestId, result: result });
+          });
+          break;
+
+        case "query_done":
+          // Stream ended normally
+          if (session.isProcessing && session.taskStopRequested) {
+            session.isProcessing = false;
+            onProcessingChanged();
+            sendAndRecord(session, { type: "info", text: "Interrupted \u00b7 What should Claude do instead?" });
+            sendAndRecord(session, { type: "done", code: 0 });
+            sm.broadcastSessionList();
+          }
+          cleanupSessionWorker(session);
+          if (session.onQueryComplete) {
+            try { session.onQueryComplete(session); } catch (err) {
+              console.error("[sdk-bridge] onQueryComplete error:", err.message || err);
+            }
+          }
+          break;
+
+        case "query_error":
+          if (session.isProcessing) {
+            session.isProcessing = false;
+            onProcessingChanged();
+            var isAbort = (msg.error && (msg.error.indexOf("AbortError") !== -1 || msg.error.indexOf("aborted") !== -1))
+              || session.taskStopRequested;
+            if (isAbort) {
+              if (!session.destroying) {
+                sendAndRecord(session, { type: "info", text: "Interrupted \u00b7 What should Claude do instead?" });
+                sendAndRecord(session, { type: "done", code: 0 });
+              }
+            } else if (session.destroying) {
+              console.log("[sdk-bridge] Suppressing worker error during shutdown for session " + session.localId);
+            } else {
+              var errDetail = msg.error || "Unknown error";
+              if (msg.stderr) errDetail += "\nstderr: " + msg.stderr;
+              if (msg.exitCode != null) errDetail += " (exitCode: " + msg.exitCode + ")";
+              console.error("[sdk-bridge] Worker query error for session " + session.localId + ":", errDetail);
+
+              var errLower = errDetail.toLowerCase();
+              var isContextOverflow = errLower.indexOf("prompt is too long") !== -1
+                || errLower.indexOf("context_length") !== -1
+                || errLower.indexOf("maximum context length") !== -1;
+              var isAuthError = errLower.indexOf("not logged in") !== -1
+                || errLower.indexOf("unauthenticated") !== -1
+                || errLower.indexOf("authentication") !== -1
+                || errLower.indexOf("sign in") !== -1
+                || errLower.indexOf("log in") !== -1
+                || errLower.indexOf("please login") !== -1;
+              if (isContextOverflow) {
+                sendAndRecord(session, { type: "context_overflow", text: "Conversation too long to continue." });
+              } else if (isAuthError) {
+                var authUser = session.ownerId ? usersModule.findUserById(session.ownerId) : null;
+                var authLinuxUser = authUser && authUser.linuxUser ? authUser.linuxUser : null;
+                // Determine if auto-login (auto terminal + claude) is safe:
+                // - Single-user mode: always ok
+                // - Multi-user + OS user isolation (linuxUser set): ok (isolated)
+                // - Multi-user + admin role: ok (they own the shared account)
+                // - Multi-user + regular user (no linuxUser): not ok (shared account)
+                var canAutoLogin = !usersModule.isMultiUser()
+                  || !!authLinuxUser
+                  || (authUser && authUser.role === "admin");
+                sendAndRecord(session, {
+                  type: "auth_required",
+                  text: "Claude Code is not logged in.",
+                  linuxUser: authLinuxUser,
+                  canAutoLogin: canAutoLogin,
+                });
+              } else {
+                sendAndRecord(session, { type: "error", text: "Claude process error: " + msg.error });
+              }
+              sendAndRecord(session, { type: "done", code: 1 });
+              if (pushModule) {
+                pushModule.sendPush({
+                  type: "error",
+                  slug: slug,
+                  title: "Connection Lost",
+                  body: "Claude process disconnected: " + (msg.error || "unknown error"),
+                  tag: "claude-error",
+                });
+              }
+            }
+            sm.broadcastSessionList();
+          }
+          cleanupSessionWorker(session);
+          if (session.onQueryComplete) {
+            try { session.onQueryComplete(session); } catch (err) {
+              console.error("[sdk-bridge] onQueryComplete error:", err.message || err);
+            }
+          }
+          break;
+
+        case "model_changed":
+          sm.currentModel = msg.model;
+          send({ type: "model_info", model: msg.model, models: sm.availableModels || [] });
+          send({ type: "config_state", model: sm.currentModel, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+          break;
+
+        case "effort_changed":
+          sm.currentEffort = msg.effort;
+          send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [] });
+          break;
+
+        case "permission_mode_changed":
+          sm.currentPermissionMode = msg.mode;
+          send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
+          break;
+
+        case "worker_error":
+          send({ type: "error", text: msg.error });
+          break;
+      }
+    });
+
+    // Wait for worker to be ready, then send query
+    try {
+      await worker.readyPromise;
+    } catch (e) {
+      session.isProcessing = false;
+      onProcessingChanged();
+      sendAndRecord(session, { type: "error", text: "Worker failed to connect: " + (e.message || e) });
+      sendAndRecord(session, { type: "done", code: 1 });
+      sm.broadcastSessionList();
+      cleanupSessionWorker(session);
+      return;
+    }
+
+    worker.send({
+      type: "query_start",
+      prompt: initialMessage,
+      options: queryOptions,
+      singleTurn: !!session.singleTurn,
+    });
+  }
+
+  function cleanupSessionWorker(session) {
+    session.queryInstance = null;
+    session.messageQueue = null;
+    session.abortController = null;
+    session.taskStopRequested = false;
+    session.pendingPermissions = {};
+    session.pendingAskUser = {};
+    session.pendingElicitations = {};
+    if (session.worker) {
+      session.worker.kill();
+      session.worker = null;
+    }
+  }
+
+  /**
+   * Run warmup via a worker process for a specific Linux user.
+   */
+  async function warmupViaWorker(linuxUser) {
+    var worker;
+    try {
+      worker = spawnWorker(linuxUser);
+    } catch (e) {
+      send({ type: "error", text: "Failed to spawn warmup worker for " + linuxUser + ": " + (e.message || e) });
+      return;
+    }
+
+    var warmupDone = false;
+
+    worker.onMessage(function(msg) {
+      if (msg.type === "warmup_done" && !warmupDone) {
+        warmupDone = true;
+        var result = msg.result || {};
+        var fsSkills = discoverSkillDirs();
+        sm.skillNames = mergeSkills(result.skills, fsSkills);
+        if (result.slashCommands) {
+          var seen = new Set();
+          var combined = [];
+          var all = result.slashCommands.concat(Array.from(sm.skillNames));
+          for (var k = 0; k < all.length; k++) {
+            if (!seen.has(all[k])) {
+              seen.add(all[k]);
+              combined.push(all[k]);
+            }
+          }
+          sm.slashCommands = combined;
+          send({ type: "slash_commands", commands: sm.slashCommands });
+        }
+        if (result.model) {
+          sm.currentModel = sm._savedDefaultModel || result.model;
+        }
+        sm.availableModels = result.models || [];
+        send({ type: "model_info", model: sm.currentModel || "", models: sm.availableModels || [] });
+        worker.kill();
+      } else if (msg.type === "warmup_error" && !warmupDone) {
+        warmupDone = true;
+        send({ type: "error", text: result.error || "Warmup failed" });
+        worker.kill();
+      }
+    });
+
+    try {
+      await worker.readyPromise;
+    } catch (e) {
+      send({ type: "error", text: "Warmup worker failed to connect: " + (e.message || e) });
+      cleanupWorker(worker);
+      return;
+    }
+
+    var warmupOptions = { cwd: cwd, settingSources: ["user", "project", "local"] };
+    if (dangerouslySkipPermissions) {
+      warmupOptions.permissionMode = "bypassPermissions";
+      warmupOptions.allowDangerouslySkipPermissions = true;
+    }
+    worker.send({ type: "warmup", options: warmupOptions });
+  }
+
   // --- SDK query lifecycle ---
 
   function handleCanUseTool(session, toolName, input, opts) {
@@ -681,11 +1229,29 @@ function createSDKBridge(opts) {
             var isContextOverflow = errLower.indexOf("prompt is too long") !== -1
               || errLower.indexOf("context_length") !== -1
               || errLower.indexOf("maximum context length") !== -1;
+            var isAuthError = errLower.indexOf("not logged in") !== -1
+              || errLower.indexOf("unauthenticated") !== -1
+              || errLower.indexOf("authentication") !== -1
+              || errLower.indexOf("sign in") !== -1
+              || errLower.indexOf("log in") !== -1
+              || errLower.indexOf("please login") !== -1;
             if (isContextOverflow) {
               sendAndRecord(session, {
                 type: "context_overflow",
                 text: "Conversation too long to continue.",
               });
+            } else if (isAuthError) {
+              var authUser = session.ownerId ? usersModule.findUserById(session.ownerId) : null;
+              var authLinuxUser = authUser && authUser.linuxUser ? authUser.linuxUser : null;
+              var canAutoLogin = !usersModule.isMultiUser()
+                || !!authLinuxUser
+                || (authUser && authUser.role === "admin");
+              sendAndRecord(session, {
+                type: "auth_required",
+                text: "Claude Code is not logged in.",
+                linuxUser: authLinuxUser,
+                canAutoLogin: canAutoLogin,
+              });
             } else {
               sendAndRecord(session, { type: "error", text: "Claude process error: " + err.message });
             }
@@ -710,6 +1276,7 @@ function createSDKBridge(opts) {
       session.taskStopRequested = false;
       session.pendingPermissions = {};
       session.pendingAskUser = {};
+      session.pendingElicitations = {};
     }
     // Ralph Loop: notify completion so loop orchestrator can proceed
     if (session.onQueryComplete) {
@@ -756,7 +1323,12 @@ function createSDKBridge(opts) {
     };
   }
 
-  async function startQuery(session, text, images) {
+  async function startQuery(session, text, images, linuxUser) {
+    // OS-level isolation: delegate to worker process if linuxUser is set
+    if (linuxUser) {
+      return startQueryViaWorker(session, text, images, linuxUser);
+    }
+
     var sdk;
     try {
       sdk = await getSDK();
@@ -773,6 +1345,7 @@ function createSDKBridge(opts) {
     session.blocks = {};
     session.sentToolResults = {};
     session.activeTaskToolIds = {};
+    session.pendingElicitations = {};
     session.streamedText = false;
     session.responsePreview = "";
 
@@ -805,9 +1378,13 @@ function createSDKBridge(opts) {
       extraArgs: { "replay-user-messages": null },
       abortController: session.abortController,
       promptSuggestions: true,
+      agentProgressSummaries: true,
       canUseTool: function(toolName, input, toolOpts) {
         return handleCanUseTool(session, toolName, input, toolOpts);
       },
+      onElicitation: function(request, elicitOpts) {
+        return handleElicitation(session, request, elicitOpts);
+      },
     };
 
     if (sm.currentModel) {
@@ -822,6 +1399,12 @@ function createSDKBridge(opts) {
       queryOptions.betas = sm.currentBetas;
     }
 
+    if (sm.currentThinking === "disabled") {
+      queryOptions.thinking = { type: "disabled" };
+    } else if (sm.currentThinking === "budget" && sm.currentThinkingBudget) {
+      queryOptions.thinking = { type: "enabled", budgetTokens: sm.currentThinkingBudget };
+    }
+
     if (dangerouslySkipPermissions) {
       queryOptions.permissionMode = "bypassPermissions";
       queryOptions.allowDangerouslySkipPermissions = true;
@@ -887,10 +1470,16 @@ function createSDKBridge(opts) {
     if (text) {
       content.push({ type: "text", text: text });
     }
-    session.messageQueue.push({
+    var userMsg = {
       type: "user",
       message: { role: "user", content: content },
-    });
+    };
+    // Route through worker if active, otherwise direct to message queue
+    if (session.worker) {
+      session.worker.send({ type: "push_message", content: userMsg });
+    } else {
+      session.messageQueue.push(userMsg);
+    }
   }
 
   function permissionPushTitle(toolName, input) {
@@ -937,7 +1526,12 @@ function createSDKBridge(opts) {
   }
 
   // SDK warmup: grab slash_commands, model, and available models from SDK init
-  async function warmup() {
+  async function warmup(linuxUser) {
+    // OS-level isolation: delegate warmup to worker process
+    if (linuxUser) {
+      return warmupViaWorker(linuxUser);
+    }
+
     try {
       var sdk = await getSDK();
       var ac = new AbortController();
@@ -992,6 +1586,10 @@ function createSDKBridge(opts) {
   }
 
   async function setModel(session, model) {
+    if (session.worker) {
+      session.worker.send({ type: "set_model", model: model });
+      return;
+    }
     if (!session.queryInstance) {
       // No active query — just store the model for next startQuery
       sm.currentModel = model;
@@ -1009,6 +1607,25 @@ function createSDKBridge(opts) {
     }
   }
 
+  async function setEffort(session, effort) {
+    if (session.worker) {
+      session.worker.send({ type: "set_effort", effort: effort });
+      return;
+    }
+    if (!session.queryInstance) {
+      sm.currentEffort = effort;
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [] });
+      return;
+    }
+    try {
+      await session.queryInstance.setEffort(effort);
+      sm.currentEffort = effort;
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode || "default", effort: sm.currentEffort, betas: sm.currentBetas || [] });
+    } catch (e) {
+      send({ type: "error", text: "Failed to set effort: " + (e.message || e) });
+    }
+  }
+
   async function setPermissionMode(session, mode) {
     // When dangerouslySkipPermissions is active, ignore mode changes from UI
     // to prevent accidentally downgrading from bypassPermissions
@@ -1016,6 +1633,10 @@ function createSDKBridge(opts) {
       send({ type: "config_state", model: sm.currentModel || "", mode: "bypassPermissions", effort: sm.currentEffort || "medium", betas: sm.currentBetas || [] });
       return;
     }
+    if (session.worker) {
+      session.worker.send({ type: "set_permission_mode", mode: mode });
+      return;
+    }
     if (!session.queryInstance) {
       // No active query — just store the mode for next startQuery
       sm.currentPermissionMode = mode;
@@ -1033,8 +1654,13 @@ function createSDKBridge(opts) {
 
   async function stopTask(taskId) {
     var session = sm.getActiveSession();
-    if (!session || !session.queryInstance) return;
+    if (!session) return;
     session.taskStopRequested = true;
+    if (session.worker) {
+      session.worker.send({ type: "stop_task", taskId: taskId });
+      return;
+    }
+    if (!session.queryInstance) return;
     try {
       await session.queryInstance.stopTask(taskId);
     } catch (e) {
@@ -1051,11 +1677,13 @@ function createSDKBridge(opts) {
     createMessageQueue: createMessageQueue,
     processSDKMessage: processSDKMessage,
     handleCanUseTool: handleCanUseTool,
+    handleElicitation: handleElicitation,
     processQueryStream: processQueryStream,
     getOrCreateRewindQuery: getOrCreateRewindQuery,
     startQuery: startQuery,
     pushMessage: pushMessage,
     setModel: setModel,
+    setEffort: setEffort,
     setPermissionMode: setPermissionMode,
     isClaudeProcess: isClaudeProcess,
     permissionPushTitle: permissionPushTitle,