clay-server 2.5.0

package/lib/sdk-bridge.js

@@ -0,0 +1,989 @@
+const crypto = require("crypto");
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var { execSync } = require("child_process");
+
+// Async message queue for streaming input to SDK
+function createMessageQueue() {
+  var queue = [];
+  var waiting = null;
+  var ended = false;
+  return {
+    push: function(msg) {
+      if (waiting) {
+        var resolve = waiting;
+        waiting = null;
+        resolve({ value: msg, done: false });
+      } else {
+        queue.push(msg);
+      }
+    },
+    end: function() {
+      ended = true;
+      if (waiting) {
+        var resolve = waiting;
+        waiting = null;
+        resolve({ value: undefined, done: true });
+      }
+    },
+    [Symbol.asyncIterator]: function() {
+      return {
+        next: function() {
+          if (queue.length > 0) {
+            return Promise.resolve({ value: queue.shift(), done: false });
+          }
+          if (ended) {
+            return Promise.resolve({ value: undefined, done: true });
+          }
+          return new Promise(function(resolve) {
+            waiting = resolve;
+          });
+        },
+      };
+    },
+  };
+}
+
+function createSDKBridge(opts) {
+  var cwd = opts.cwd;
+  var slug = opts.slug || "";
+  var sm = opts.sessionManager;   // session manager instance
+  var send = opts.send;           // broadcast to all clients
+  var pushModule = opts.pushModule;
+  var getSDK = opts.getSDK;
+  var dangerouslySkipPermissions = opts.dangerouslySkipPermissions || false;
+
+  // --- Skill discovery helpers ---
+
+  function discoverSkillDirs() {
+    var skills = {};
+    var dirs = [
+      path.join(os.homedir(), ".claude", "skills"),
+      path.join(cwd, ".claude", "skills"),
+    ];
+    for (var d = 0; d < dirs.length; d++) {
+      var base = dirs[d];
+      var entries;
+      try {
+        entries = fs.readdirSync(base, { withFileTypes: true });
+      } catch (e) {
+        continue; // directory doesn't exist
+      }
+      for (var i = 0; i < entries.length; i++) {
+        var entry = entries[i];
+        if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+        var skillDir = path.join(base, entry.name);
+        var skillMd = path.join(skillDir, "SKILL.md");
+        try {
+          fs.accessSync(skillMd, fs.constants.R_OK);
+          // project skills override global skills with same name
+          skills[entry.name] = skillDir;
+        } catch (e) {
+          // no SKILL.md, skip
+        }
+      }
+    }
+    return skills;
+  }
+
+  function mergeSkills(sdkSkills, fsSkills) {
+    var merged = new Set();
+    if (Array.isArray(sdkSkills)) {
+      for (var i = 0; i < sdkSkills.length; i++) {
+        merged.add(sdkSkills[i]);
+      }
+    }
+    var fsNames = Object.keys(fsSkills);
+    for (var i = 0; i < fsNames.length; i++) {
+      merged.add(fsNames[i]);
+    }
+    return merged;
+  }
+
+  function sendAndRecord(session, obj) {
+    sm.sendAndRecord(session, obj);
+  }
+
+  function processSDKMessage(session, parsed) {
+    // Extract session_id from any message that carries it
+    if (parsed.session_id && !session.cliSessionId) {
+      session.cliSessionId = parsed.session_id;
+      sm.saveSessionFile(session);
+      if (session.localId === sm.activeSessionId) {
+        send({ type: "session_id", cliSessionId: session.cliSessionId });
+      }
+    } else if (parsed.session_id) {
+      session.cliSessionId = parsed.session_id;
+    }
+
+    // Capture message UUIDs for rewind support
+    if (parsed.uuid) {
+      if (parsed.type === "user" && !parsed.parent_tool_use_id) {
+        session.messageUUIDs.push({ uuid: parsed.uuid, type: "user", historyIndex: session.history.length });
+        sendAndRecord(session, { type: "message_uuid", uuid: parsed.uuid, messageType: "user" });
+      } else if (parsed.type === "assistant") {
+        session.messageUUIDs.push({ uuid: parsed.uuid, type: "assistant", historyIndex: session.history.length });
+        sendAndRecord(session, { type: "message_uuid", uuid: parsed.uuid, messageType: "assistant" });
+      }
+    }
+
+    // Cache slash_commands and model from CLI init message
+    if (parsed.type === "system" && parsed.subtype === "init") {
+      var fsSkills = discoverSkillDirs();
+      sm.skillNames = mergeSkills(parsed.skills, fsSkills);
+      if (parsed.slash_commands) {
+        // Union: SDK slash_commands + merged skills (deduplicated)
+        var seen = new Set();
+        var combined = [];
+        var all = parsed.slash_commands.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 (parsed.model) {
+        sm.currentModel = parsed.model;
+        send({ type: "model_info", model: parsed.model, models: sm.availableModels || [] });
+      }
+      if (parsed.fast_mode_state) {
+        sendAndRecord(session, { type: "fast_mode_state", state: parsed.fast_mode_state });
+      }
+    }
+
+    if (parsed.type === "stream_event" && parsed.event) {
+      var evt = parsed.event;
+
+      if (evt.type === "content_block_start") {
+        var block = evt.content_block;
+        var idx = evt.index;
+
+        if (block.type === "tool_use") {
+          session.blocks[idx] = { type: "tool_use", id: block.id, name: block.name, inputJson: "" };
+          sendAndRecord(session, { type: "tool_start", id: block.id, name: block.name });
+        } else if (block.type === "thinking") {
+          session.blocks[idx] = { type: "thinking", thinkingText: "", startTime: Date.now() };
+          sendAndRecord(session, { type: "thinking_start" });
+        } else if (block.type === "text") {
+          session.blocks[idx] = { type: "text" };
+        }
+      }
+
+      if (evt.type === "content_block_delta" && evt.delta) {
+        var idx = evt.index;
+
+        if (evt.delta.type === "text_delta" && typeof evt.delta.text === "string") {
+          session.streamedText = true;
+          if (session.responsePreview.length < 200) {
+            session.responsePreview += evt.delta.text;
+          }
+          sendAndRecord(session, { type: "delta", text: evt.delta.text });
+        } else if (evt.delta.type === "input_json_delta" && session.blocks[idx]) {
+          session.blocks[idx].inputJson += evt.delta.partial_json;
+        } else if (evt.delta.type === "thinking_delta" && session.blocks[idx]) {
+          session.blocks[idx].thinkingText += evt.delta.thinking;
+          sendAndRecord(session, { type: "thinking_delta", text: evt.delta.thinking });
+        }
+      }
+
+      if (evt.type === "content_block_stop") {
+        var idx = evt.index;
+        var block = session.blocks[idx];
+
+        if (block && block.type === "tool_use") {
+          var input = {};
+          try { input = JSON.parse(block.inputJson); } catch {}
+          sendAndRecord(session, { type: "tool_executing", id: block.id, name: block.name, input: input });
+
+          // Track active Task tools for sub-agent done detection
+          if (block.name === "Task") {
+            if (!session.activeTaskToolIds) session.activeTaskToolIds = {};
+            session.activeTaskToolIds[block.id] = true;
+          }
+
+          if (pushModule && block.name === "AskUserQuestion" && input.questions) {
+            var q = input.questions[0];
+            pushModule.sendPush({
+              type: "ask_user",
+              slug: slug,
+              title: "Claude has a question",
+              body: q ? q.question : "Waiting for your response",
+              tag: "claude-ask",
+            });
+          }
+        } else if (block && block.type === "thinking") {
+          var duration = block.startTime ? (Date.now() - block.startTime) / 1000 : 0;
+          sendAndRecord(session, { type: "thinking_stop", duration: duration });
+        }
+
+        delete session.blocks[idx];
+      }
+
+    } else if ((parsed.type === "assistant" || parsed.type === "user") && parsed.message && parsed.message.content) {
+      // Sub-agent messages: extract tool_use blocks for activity display
+      if (parsed.parent_tool_use_id) {
+        processSubagentMessage(session, parsed);
+        return;
+      }
+
+      var content = parsed.message.content;
+
+      // Fallback: if assistant text wasn't streamed via deltas, send it now
+      if (parsed.type === "assistant" && !session.streamedText && Array.isArray(content)) {
+        var assistantText = content
+          .filter(function(c) { return c.type === "text"; })
+          .map(function(c) { return c.text; })
+          .join("");
+        if (assistantText) {
+          sendAndRecord(session, { type: "delta", text: assistantText });
+        }
+      }
+
+      // Check for local slash command output in user messages
+      if (parsed.type === "user") {
+        var fullText = "";
+        if (typeof content === "string") {
+          fullText = content;
+        } else if (Array.isArray(content)) {
+          fullText = content
+            .filter(function(c) { return c.type === "text"; })
+            .map(function(c) { return c.text; })
+            .join("\n");
+        }
+        if (fullText.indexOf("local-command-stdout") !== -1) {
+          var m = fullText.match(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/);
+          if (m) {
+            sendAndRecord(session, { type: "slash_command_result", text: m[1].trim() });
+          }
+        }
+      }
+
+      if (Array.isArray(content)) {
+        for (var i = 0; i < content.length; i++) {
+          var block = content[i];
+          if (block.type === "tool_result" && !session.sentToolResults[block.tool_use_id]) {
+            // Clear active Task tool when its result arrives
+            if (session.activeTaskToolIds && session.activeTaskToolIds[block.tool_use_id]) {
+              sendAndRecord(session, {
+                type: "subagent_done",
+                parentToolId: block.tool_use_id,
+              });
+              delete session.activeTaskToolIds[block.tool_use_id];
+            }
+            var resultText = "";
+            if (typeof block.content === "string") {
+              resultText = block.content;
+            } else if (Array.isArray(block.content)) {
+              resultText = block.content
+                .filter(function(c) { return c.type === "text"; })
+                .map(function(c) { return c.text; })
+                .join("\n");
+            }
+            session.sentToolResults[block.tool_use_id] = true;
+            sendAndRecord(session, {
+              type: "tool_result",
+              id: block.tool_use_id,
+              content: resultText,
+              is_error: block.is_error || false,
+            });
+          }
+        }
+      }
+
+    } else if (parsed.type === "result") {
+      session.blocks = {};
+      session.sentToolResults = {};
+      session.pendingPermissions = {};
+      // 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++) {
+        sendAndRecord(session, { type: "ask_user_answered", toolId: leftoverAskIds[lai] });
+      }
+      session.pendingAskUser = {};
+      session.activeTaskToolIds = {};
+      session.taskIdMap = {};
+      session.isProcessing = false;
+      sendAndRecord(session, {
+        type: "result",
+        cost: parsed.total_cost_usd,
+        duration: parsed.duration_ms,
+        usage: parsed.usage || null,
+        modelUsage: parsed.modelUsage || null,
+        sessionId: parsed.session_id,
+      });
+      if (parsed.fast_mode_state) {
+        sendAndRecord(session, { type: "fast_mode_state", state: parsed.fast_mode_state });
+      }
+      sendAndRecord(session, { type: "done", code: 0 });
+      if (pushModule) {
+        var preview = (session.responsePreview || "").replace(/\s+/g, " ").trim();
+        if (preview.length > 140) preview = preview.substring(0, 140) + "...";
+        pushModule.sendPush({
+          type: "done",
+          slug: slug,
+          title: session.title || "Claude",
+          body: preview || "Response ready",
+          tag: "claude-done",
+        });
+      }
+      // Reset for next turn in the same query
+      session.responsePreview = "";
+      session.streamedText = false;
+      sm.broadcastSessionList();
+
+    } else if (parsed.type === "system" && parsed.subtype === "status") {
+      if (parsed.status === "compacting") {
+        sendAndRecord(session, { type: "compacting", active: true });
+      } else if (session.compacting) {
+        sendAndRecord(session, { type: "compacting", active: false });
+      }
+      session.compacting = parsed.status === "compacting";
+
+    } else if (parsed.type === "system" && parsed.subtype === "task_started") {
+      var parentId = parsed.tool_use_id;
+      if (parentId) {
+        if (!session.taskIdMap) session.taskIdMap = {};
+        session.taskIdMap[parentId] = parsed.task_id;
+        sendAndRecord(session, {
+          type: "task_started",
+          parentToolId: parentId,
+          taskId: parsed.task_id,
+          description: parsed.description || "",
+        });
+      }
+
+    } else if (parsed.type === "system" && parsed.subtype === "task_progress") {
+      var parentId = parsed.tool_use_id;
+      if (parentId) {
+        sendAndRecord(session, {
+          type: "task_progress",
+          parentToolId: parentId,
+          taskId: parsed.task_id,
+          usage: parsed.usage || null,
+          lastToolName: parsed.last_tool_name || null,
+          description: parsed.description || "",
+        });
+      }
+
+    } else if (parsed.type === "tool_progress") {
+      // Sub-agent tool_progress: forward as activity update
+      var parentId = parsed.parent_tool_use_id;
+      if (parentId) {
+        sendAndRecord(session, {
+          type: "subagent_activity",
+          parentToolId: parentId,
+          text: parsed.content || "",
+        });
+      }
+
+    } else if (parsed.type === "task_notification") {
+      var parentId = parsed.parent_tool_use_id;
+      if (parentId) {
+        sendAndRecord(session, {
+          type: "subagent_done",
+          parentToolId: parentId,
+          status: parsed.status || "completed",
+          summary: parsed.summary || "",
+          usage: parsed.usage || null,
+        });
+      }
+      if (session.taskIdMap) {
+        for (var k in session.taskIdMap) {
+          if (session.taskIdMap[k] === parsed.task_id) {
+            delete session.taskIdMap[k];
+            break;
+          }
+        }
+      }
+
+    } else if (parsed.type === "rate_limit_event" && parsed.rate_limit_info) {
+      var info = parsed.rate_limit_info;
+      if (info.status === "allowed_warning" || info.status === "rejected") {
+        sendAndRecord(session, {
+          type: "rate_limit",
+          status: info.status,
+          resetsAt: info.resetsAt ? info.resetsAt * 1000 : null,
+          rateLimitType: info.rateLimitType || null,
+          utilization: info.utilization || null,
+          isUsingOverage: info.isUsingOverage || false,
+        });
+      }
+
+    } else if (parsed.type === "prompt_suggestion") {
+      sendAndRecord(session, {
+        type: "prompt_suggestion",
+        suggestion: parsed.suggestion || "",
+      });
+
+    } else if (parsed.type && parsed.type !== "system" && parsed.type !== "user") {
+    }
+  }
+
+  // --- Sub-agent message processing ---
+
+  function toolActivityTextForSubagent(name, input) {
+    if (name === "Bash" && input && input.description) return input.description;
+    if (name === "Read" && input && input.file_path) return "Reading " + input.file_path.split("/").pop();
+    if (name === "Edit" && input && input.file_path) return "Editing " + input.file_path.split("/").pop();
+    if (name === "Write" && input && input.file_path) return "Writing " + input.file_path.split("/").pop();
+    if (name === "Grep" && input && input.pattern) return "Searching for " + input.pattern;
+    if (name === "Glob" && input && input.pattern) return "Finding " + input.pattern;
+    if (name === "WebSearch" && input && input.query) return "Searching: " + input.query;
+    if (name === "WebFetch") return "Fetching URL...";
+    if (name === "Task" && input && input.description) return input.description;
+    return "Running " + name + "...";
+  }
+
+  function processSubagentMessage(session, parsed) {
+    var parentId = parsed.parent_tool_use_id;
+    var content = parsed.message.content;
+    if (!Array.isArray(content)) return;
+
+    if (parsed.type === "assistant") {
+      // Extract tool_use blocks from sub-agent assistant messages
+      for (var i = 0; i < content.length; i++) {
+        var block = content[i];
+        if (block.type === "tool_use") {
+          var activityText = toolActivityTextForSubagent(block.name, block.input);
+          sendAndRecord(session, {
+            type: "subagent_tool",
+            parentToolId: parentId,
+            toolName: block.name,
+            toolId: block.id,
+            text: activityText,
+          });
+        } else if (block.type === "thinking") {
+          sendAndRecord(session, {
+            type: "subagent_activity",
+            parentToolId: parentId,
+            text: "Thinking...",
+          });
+        } else if (block.type === "text" && block.text) {
+          sendAndRecord(session, {
+            type: "subagent_activity",
+            parentToolId: parentId,
+            text: "Writing response...",
+          });
+        }
+      }
+    }
+    // user messages with parent_tool_use_id contain tool_results — skip silently
+  }
+
+  // --- SDK query lifecycle ---
+
+  function handleCanUseTool(session, toolName, input, opts) {
+    // AskUserQuestion: wait for user answers via WebSocket
+    if (toolName === "AskUserQuestion") {
+      return new Promise(function(resolve) {
+        session.pendingAskUser[opts.toolUseID] = {
+          resolve: resolve,
+          input: input,
+        };
+        if (opts.signal) {
+          opts.signal.addEventListener("abort", function() {
+            delete session.pendingAskUser[opts.toolUseID];
+            sendAndRecord(session, { type: "ask_user_answered", toolId: opts.toolUseID });
+            resolve({ behavior: "deny", message: "Cancelled" });
+          });
+        }
+      });
+    }
+
+    // Auto-approve if tool was previously allowed for session
+    if (session.allowedTools && session.allowedTools[toolName]) {
+      return Promise.resolve({ behavior: "allow", updatedInput: input });
+    }
+
+    // Regular tool permission request: send to client and wait
+    return new Promise(function(resolve) {
+      var requestId = crypto.randomUUID();
+      session.pendingPermissions[requestId] = {
+        resolve: resolve,
+        requestId: requestId,
+        toolName: toolName,
+        toolInput: input,
+        toolUseId: opts.toolUseID,
+        decisionReason: opts.decisionReason || "",
+      };
+
+      var permMsg = {
+        type: "permission_request",
+        requestId: requestId,
+        toolName: toolName,
+        toolInput: input,
+        toolUseId: opts.toolUseID,
+        decisionReason: opts.decisionReason || "",
+      };
+      sendAndRecord(session, permMsg);
+
+      if (pushModule) {
+        pushModule.sendPush({
+          type: "permission_request",
+          slug: slug,
+          requestId: requestId,
+          title: permissionPushTitle(toolName, input),
+          body: permissionPushBody(toolName, input),
+        });
+      }
+
+      if (opts.signal) {
+        opts.signal.addEventListener("abort", function() {
+          delete session.pendingPermissions[requestId];
+          sendAndRecord(session, { type: "permission_cancel", requestId: requestId });
+          resolve({ behavior: "deny", message: "Request cancelled" });
+        });
+      }
+    });
+  }
+
+  /**
+   * Detect running Claude Code CLI processes that may conflict with our SDK queries.
+   * Only returns processes whose cwd matches our project directory.
+   * Returns an array of { pid, command } for each conflicting process found.
+   */
+  function findConflictingClaude() {
+    try {
+      var output = execSync("ps ax -o pid,command 2>/dev/null", { encoding: "utf8", timeout: 5000 });
+      var lines = output.trim().split("\n");
+      var candidates = [];
+      for (var i = 1; i < lines.length; i++) { // skip header
+        var line = lines[i].trim();
+        var m = line.match(/^(\d+)\s+(.+)/);
+        if (!m) continue;
+        var pid = parseInt(m[1], 10);
+        var cmd = m[2];
+        // Skip our own process
+        if (pid === process.pid) continue;
+        // Skip node processes (our daemon, dev watchers, etc.)
+        if (/\bnode\b/.test(cmd.split(/\s/)[0])) continue;
+        // Match actual claude binary (e.g. /Users/x/.claude/local/claude, /usr/local/bin/claude)
+        if (/\/claude(\s|$)/.test(cmd) || /^claude(\s|$)/.test(cmd)) {
+          candidates.push({ pid: pid, command: cmd.substring(0, 200) });
+        }
+      }
+
+      // Filter to only processes whose cwd matches our project
+      var results = [];
+      for (var j = 0; j < candidates.length; j++) {
+        var c = candidates[j];
+        try {
+          var lsof = execSync("lsof -a -p " + c.pid + " -d cwd -F n 2>/dev/null", { encoding: "utf8", timeout: 3000 });
+          // lsof -F n output: lines starting with 'n' contain the path
+          var cwdMatch = lsof.match(/\nn(.+)/);
+          if (cwdMatch && cwdMatch[1] === cwd) {
+            results.push(c);
+          }
+        } catch (e) {
+          // lsof failed — include as candidate anyway (conservative)
+          results.push(c);
+        }
+      }
+      return results;
+    } catch (e) {
+      return [];
+    }
+  }
+
+  /**
+   * Verify that a PID is actually a claude binary process (not arbitrary).
+   */
+  function isClaudeProcess(pid) {
+    try {
+      var output = execSync("ps -p " + pid + " -o command= 2>/dev/null", { encoding: "utf8", timeout: 3000 }).trim();
+      return /\/claude(\s|$)/.test(output) || /^claude(\s|$)/.test(output);
+    } catch (e) {
+      return false;
+    }
+  }
+
+  async function processQueryStream(session) {
+    try {
+      for await (var msg of session.queryInstance) {
+        processSDKMessage(session, msg);
+      }
+    } catch (err) {
+      if (session.isProcessing) {
+        session.isProcessing = false;
+        if (err.name === "AbortError" || (session.abortController && session.abortController.signal.aborted)) {
+          sendAndRecord(session, { type: "info", text: "Interrupted \u00b7 What should Claude do instead?" });
+          sendAndRecord(session, { type: "done", code: 0 });
+        } else {
+          var errDetail = err.message || String(err);
+          if (err.stderr) errDetail += "\nstderr: " + err.stderr;
+          if (err.exitCode != null) errDetail += " (exitCode: " + err.exitCode + ")";
+          console.error("[sdk-bridge] Query stream error for session " + session.localId + ":", errDetail);
+          console.error("[sdk-bridge] Stack:", err.stack || "(no stack)");
+
+          // Check for conflicting Claude processes only on exit code 1
+          var isExitCode1 = err.exitCode === 1 || (err.message && err.message.indexOf("exited with code 1") !== -1);
+          var conflicts = isExitCode1 ? findConflictingClaude() : [];
+          if (conflicts.length > 0) {
+            console.error("[sdk-bridge] Found " + conflicts.length + " conflicting Claude process(es):", conflicts.map(function(c) { return "PID " + c.pid; }).join(", "));
+            sendAndRecord(session, {
+              type: "process_conflict",
+              text: "Another Claude Code process is already running in this project.",
+              processes: conflicts,
+            });
+          } else {
+            var errLower = errDetail.toLowerCase();
+            var isContextOverflow = errLower.indexOf("prompt is too long") !== -1
+              || errLower.indexOf("context_length") !== -1
+              || errLower.indexOf("maximum context length") !== -1;
+            if (isContextOverflow) {
+              sendAndRecord(session, {
+                type: "context_overflow",
+                text: "Conversation too long to continue.",
+              });
+            } else {
+              sendAndRecord(session, { type: "error", text: "Claude process error: " + err.message });
+            }
+          }
+          sendAndRecord(session, { type: "done", code: 1 });
+          if (pushModule) {
+            pushModule.sendPush({
+              type: "error",
+              slug: slug,
+              title: "Connection Lost",
+              body: "Claude process disconnected: " + (err.message || "unknown error"),
+              tag: "claude-error",
+            });
+          }
+        }
+        sm.broadcastSessionList();
+      }
+    } finally {
+      session.queryInstance = null;
+      session.messageQueue = null;
+      session.abortController = null;
+      session.pendingPermissions = {};
+      session.pendingAskUser = {};
+    }
+  }
+
+  async function getOrCreateRewindQuery(session) {
+    if (session.queryInstance) return { query: session.queryInstance, isTemp: false, cleanup: function() {} };
+
+    var sdk;
+    try {
+      sdk = await getSDK();
+    } catch (e) {
+      send({ type: "error", text: "Failed to load Claude SDK: " + (e.message || e) });
+      throw e;
+    }
+    var mq = createMessageQueue();
+
+    var tempQuery = sdk.query({
+      prompt: mq,
+      options: {
+        cwd: cwd,
+        settingSources: ["user", "project", "local"],
+        enableFileCheckpointing: true,
+        resume: session.cliSessionId,
+      },
+    });
+
+    // Drain messages in background (stream stays alive until mq.end())
+    (async function() {
+      try { for await (var msg of tempQuery) {} } catch(e) {}
+    })();
+
+    return {
+      query: tempQuery,
+      isTemp: true,
+      cleanup: function() { try { mq.end(); } catch(e) {} },
+    };
+  }
+
+  async function startQuery(session, text, images) {
+    var sdk;
+    try {
+      sdk = await getSDK();
+    } catch (e) {
+      session.isProcessing = false;
+      send({ type: "error", text: "Failed to load Claude SDK: " + (e.message || e) });
+      sendAndRecord(session, { type: "done", code: 1 });
+      sm.broadcastSessionList();
+      return;
+    }
+
+    session.messageQueue = createMessageQueue();
+    session.blocks = {};
+    session.sentToolResults = {};
+    session.activeTaskToolIds = {};
+    session.streamedText = false;
+    session.responsePreview = "";
+
+    // Build initial user message
+    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 });
+    }
+
+    session.messageQueue.push({
+      type: "user",
+      message: { role: "user", content: content },
+    });
+
+    session.abortController = new AbortController();
+
+    var queryOptions = {
+      cwd: cwd,
+      settingSources: ["user", "project", "local"],
+      includePartialMessages: true,
+      enableFileCheckpointing: true,
+      extraArgs: { "replay-user-messages": null },
+      abortController: session.abortController,
+      promptSuggestions: true,
+      canUseTool: function(toolName, input, toolOpts) {
+        return handleCanUseTool(session, toolName, input, toolOpts);
+      },
+    };
+
+    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 (dangerouslySkipPermissions) {
+      queryOptions.permissionMode = "bypassPermissions";
+      queryOptions.allowDangerouslySkipPermissions = true;
+    } else {
+      // Pass permissionMode in queryOptions at creation time to avoid race condition
+      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;
+      }
+    }
+
+    try {
+      session.queryInstance = sdk.query({
+        prompt: session.messageQueue,
+        options: queryOptions,
+      });
+    } catch (e) {
+      console.error("[sdk-bridge] Failed to create query for session " + session.localId + ":", e.message || e);
+      console.error("[sdk-bridge] cliSessionId:", session.cliSessionId, "resume:", !!queryOptions.resume);
+      console.error("[sdk-bridge] Stack:", e.stack || "(no stack)");
+      session.isProcessing = false;
+      session.queryInstance = null;
+      session.messageQueue = null;
+      session.abortController = null;
+      send({ type: "error", text: "Failed to start query: " + (e.message || e) });
+      sendAndRecord(session, { type: "done", code: 1 });
+      sm.broadcastSessionList();
+      return;
+    }
+
+    processQueryStream(session).catch(function(err) {
+    });
+  }
+
+  function pushMessage(session, text, images) {
+    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 });
+    }
+    session.messageQueue.push({
+      type: "user",
+      message: { role: "user", content: content },
+    });
+  }
+
+  function permissionPushTitle(toolName, input) {
+    if (!input) return "Claude wants to use " + toolName;
+    var file = input.file_path ? input.file_path.split(/[/\\]/).pop() : "";
+    switch (toolName) {
+      case "Bash": return "Claude wants to run a command";
+      case "Edit": return "Claude wants to edit " + (file || "a file");
+      case "Write": return "Claude wants to write " + (file || "a file");
+      case "Read": return "Claude wants to read " + (file || "a file");
+      case "Grep": return "Claude wants to search files";
+      case "Glob": return "Claude wants to find files";
+      case "WebFetch": return "Claude wants to fetch a URL";
+      case "WebSearch": return "Claude wants to search the web";
+      case "Task": return "Claude wants to launch an agent";
+      default: return "Claude wants to use " + toolName;
+    }
+  }
+
+  function permissionPushBody(toolName, input) {
+    if (!input) return "";
+    var text = "";
+    if (toolName === "Bash" && input.command) {
+      text = input.command;
+    } else if (toolName === "Edit" && input.file_path) {
+      text = input.file_path.split(/[/\\]/).pop() + ": " + (input.old_string || "").substring(0, 40) + " \u2192 " + (input.new_string || "").substring(0, 40);
+    } else if (toolName === "Write" && input.file_path) {
+      text = input.file_path;
+    } else if (input.file_path) {
+      text = input.file_path;
+    } else if (input.command) {
+      text = input.command;
+    } else if (input.url) {
+      text = input.url;
+    } else if (input.query) {
+      text = input.query;
+    } else if (input.pattern) {
+      text = input.pattern;
+    } else if (input.description) {
+      text = input.description;
+    }
+    if (text.length > 120) text = text.substring(0, 120) + "...";
+    return text;
+  }
+
+  // SDK warmup: grab slash_commands, model, and available models from SDK init
+  async function warmup() {
+    try {
+      var sdk = await getSDK();
+      var ac = new AbortController();
+      var mq = createMessageQueue();
+      mq.push({ type: "user", message: { role: "user", content: [{ type: "text", text: "hi" }] } });
+      mq.end();
+      var warmupOptions = { cwd: cwd, settingSources: ["user", "project", "local"], abortController: ac };
+      if (dangerouslySkipPermissions) {
+        warmupOptions.permissionMode = "bypassPermissions";
+        warmupOptions.allowDangerouslySkipPermissions = true;
+      }
+      var stream = sdk.query({
+        prompt: mq,
+        options: warmupOptions,
+      });
+      for await (var msg of stream) {
+        if (msg.type === "system" && msg.subtype === "init") {
+          var fsSkills = discoverSkillDirs();
+          sm.skillNames = mergeSkills(msg.skills, fsSkills);
+          if (msg.slash_commands) {
+            // Union: SDK slash_commands + merged skills (deduplicated)
+            var seen = new Set();
+            var combined = [];
+            var all = msg.slash_commands.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 (msg.model) {
+            sm.currentModel = msg.model;
+          }
+          // Fetch available models before aborting
+          try {
+            var models = await stream.supportedModels();
+            sm.availableModels = models || [];
+          } catch (e) {}
+          send({ type: "model_info", model: sm.currentModel || "", models: sm.availableModels || [] });
+          ac.abort();
+          break;
+        }
+      }
+    } catch (e) {
+      if (e && e.name !== "AbortError" && !(e.message && e.message.indexOf("aborted") !== -1)) {
+        send({ type: "error", text: "Failed to load Claude SDK: " + (e.message || e) });
+      }
+    }
+  }
+
+  async function setModel(session, model) {
+    if (!session.queryInstance) {
+      // No active query — just store the model for next startQuery
+      sm.currentModel = model;
+      send({ type: "model_info", model: model, models: sm.availableModels || [] });
+      send({ type: "config_state", model: sm.currentModel, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+      return;
+    }
+    try {
+      await session.queryInstance.setModel(model);
+      sm.currentModel = model;
+      send({ type: "model_info", model: model, models: sm.availableModels || [] });
+      send({ type: "config_state", model: sm.currentModel, mode: sm.currentPermissionMode || "default", effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+    } catch (e) {
+      send({ type: "error", text: "Failed to switch model: " + (e.message || e) });
+    }
+  }
+
+  async function setPermissionMode(session, mode) {
+    if (!session.queryInstance) {
+      // No active query — just store the mode for next startQuery
+      sm.currentPermissionMode = mode;
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+      return;
+    }
+    try {
+      await session.queryInstance.setPermissionMode(mode);
+      sm.currentPermissionMode = mode;
+      send({ type: "config_state", model: sm.currentModel || "", mode: sm.currentPermissionMode, effort: sm.currentEffort || "high", betas: sm.currentBetas || [] });
+    } catch (e) {
+      send({ type: "error", text: "Failed to set permission mode: " + (e.message || e) });
+    }
+  }
+
+  async function stopTask(taskId) {
+    var session = sm.getActiveSession();
+    if (!session || !session.queryInstance) return;
+    try {
+      await session.queryInstance.stopTask(taskId);
+    } catch (e) {
+      console.error("[sdk-bridge] stopTask error:", e.message);
+    }
+  }
+
+  return {
+    createMessageQueue: createMessageQueue,
+    processSDKMessage: processSDKMessage,
+    handleCanUseTool: handleCanUseTool,
+    processQueryStream: processQueryStream,
+    getOrCreateRewindQuery: getOrCreateRewindQuery,
+    startQuery: startQuery,
+    pushMessage: pushMessage,
+    setModel: setModel,
+    setPermissionMode: setPermissionMode,
+    isClaudeProcess: isClaudeProcess,
+    permissionPushTitle: permissionPushTitle,
+    permissionPushBody: permissionPushBody,
+    warmup: warmup,
+    stopTask: stopTask,
+  };
+}
+
+module.exports = { createSDKBridge, createMessageQueue };