@zonease/happy 0.6.38 → 0.6.40

package/dist/downloadImage-cQ1Z7hkC.cjs

@@ -0,0 +1,897 @@
+'use strict';
+
+var logger = require('./persistence-CBTtC_dm.cjs');
+var crypto = require('crypto');
+var path = require('node:path');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
+var node_http = require('node:http');
+var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var z = require('zod');
+var deviceKeys = require('./deviceKeys-C540DcXl.cjs');
+var node_crypto = require('node:crypto');
+var prompt = require('./prompt-BTWDZZO0.cjs');
+require('./mcpToolSchemas-DK42yoZ_.cjs');
+require('./index-CDTNgfUf.cjs');
+var node_child_process = require('node:child_process');
+var axios = require('axios');
+require('node:events');
+require('socket.io-client');
+require('./api-C7FyJfZ1.cjs');
+require('tweetnacl');
+require('ws');
+require('@stablelib/base64');
+require('node:os');
+require('node:fs/promises');
+require('node:fs');
+require('node:readline');
+require('expo-server-sdk');
+require('chalk');
+require('./types-DWeB7aqh.cjs');
+
+function parseCompact(message) {
+  const trimmed = message.trim();
+  if (trimmed === "/compact") {
+    return {
+      isCompact: true,
+      originalMessage: trimmed
+    };
+  }
+  if (trimmed.startsWith("/compact ")) {
+    return {
+      isCompact: true,
+      originalMessage: trimmed
+    };
+  }
+  return {
+    isCompact: false,
+    originalMessage: message
+  };
+}
+function parseClear(message) {
+  const trimmed = message.trim();
+  return {
+    isClear: trimmed === "/clear"
+  };
+}
+function parseSpecialCommand(message) {
+  const compactResult = parseCompact(message);
+  if (compactResult.isCompact) {
+    return {
+      type: "compact",
+      originalMessage: compactResult.originalMessage
+    };
+  }
+  const clearResult = parseClear(message);
+  if (clearResult.isClear) {
+    return {
+      type: "clear"
+    };
+  }
+  return {
+    type: null
+  };
+}
+
+class MessageQueue2 {
+  queue = [];
+  // Made public for testing
+  waiter = null;
+  closed = false;
+  onMessageHandler = null;
+  modeHasher;
+  constructor(modeHasher, onMessageHandler = null) {
+    this.modeHasher = modeHasher;
+    this.onMessageHandler = onMessageHandler;
+    logger.logger.debug(`[MessageQueue2] Initialized`);
+  }
+  /**
+   * Set a handler that will be called when a message arrives
+   */
+  setOnMessage(handler) {
+    this.onMessageHandler = handler;
+  }
+  /**
+   * Push a message to the queue with a mode.
+   */
+  push(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    logger.logger.debug(`[MessageQueue2] push() called with mode hash: ${modeHash}`);
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: false
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      logger.logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.logger.debug(`[MessageQueue2] push() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Push a message immediately without batching delay.
+   * Does not clear the queue or enforce isolation.
+   */
+  pushImmediate(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    logger.logger.debug(`[MessageQueue2] pushImmediate() called with mode hash: ${modeHash}`);
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: false
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      logger.logger.debug(`[MessageQueue2] Notifying waiter for immediate message`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.logger.debug(`[MessageQueue2] pushImmediate() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Push a message that must be processed in complete isolation.
+   * Clears any pending messages and ensures this message is never batched with others.
+   * Used for special commands that require dedicated processing.
+   */
+  pushIsolateAndClear(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    logger.logger.debug(`[MessageQueue2] pushIsolateAndClear() called with mode hash: ${modeHash} - clearing ${this.queue.length} pending messages`);
+    this.queue = [];
+    this.queue.push({
+      message,
+      mode,
+      modeHash,
+      isolate: true
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      logger.logger.debug(`[MessageQueue2] Notifying waiter for isolated message`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.logger.debug(`[MessageQueue2] pushIsolateAndClear() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Push a message to the beginning of the queue with a mode.
+   */
+  unshift(message, mode) {
+    if (this.closed) {
+      throw new Error("Cannot unshift to closed queue");
+    }
+    const modeHash = this.modeHasher(mode);
+    logger.logger.debug(`[MessageQueue2] unshift() called with mode hash: ${modeHash}`);
+    this.queue.unshift({
+      message,
+      mode,
+      modeHash,
+      isolate: false
+    });
+    if (this.onMessageHandler) {
+      this.onMessageHandler(message, mode);
+    }
+    if (this.waiter) {
+      logger.logger.debug(`[MessageQueue2] Notifying waiter`);
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(true);
+    }
+    logger.logger.debug(`[MessageQueue2] unshift() completed. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Reset the queue - clears all messages and resets to empty state
+   */
+  reset() {
+    logger.logger.debug(`[MessageQueue2] reset() called. Clearing ${this.queue.length} messages`);
+    this.queue = [];
+    this.closed = false;
+    this.waiter = null;
+  }
+  /**
+   * Close the queue - no more messages can be pushed
+   */
+  close() {
+    logger.logger.debug(`[MessageQueue2] close() called`);
+    this.closed = true;
+    if (this.waiter) {
+      const waiter = this.waiter;
+      this.waiter = null;
+      waiter(false);
+    }
+  }
+  /**
+   * Check if the queue is closed
+   */
+  isClosed() {
+    return this.closed;
+  }
+  /**
+   * Get the current queue size
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * Wait for messages and return all messages with the same mode.
+   * For string messages, multiple messages are joined with newlines.
+   * For object messages (e.g., mixed content with images), returns them one at a time.
+   * Returns { message: M, mode: T } or null if aborted/closed
+   */
+  async waitForMessagesAndGetAsString(abortSignal) {
+    if (this.queue.length > 0) {
+      return this.collectBatch();
+    }
+    if (this.closed || abortSignal?.aborted) {
+      return null;
+    }
+    const hasMessages = await this.waitForMessages(abortSignal);
+    if (!hasMessages) {
+      return null;
+    }
+    return this.collectBatch();
+  }
+  /**
+   * Collect a batch of messages with the same mode, respecting isolation requirements.
+   * For string messages, joins them with newlines.
+   * For object messages (like mixed content with images), returns one at a time.
+   */
+  collectBatch() {
+    if (this.queue.length === 0) {
+      return null;
+    }
+    const firstItem = this.queue[0];
+    let mode = firstItem.mode;
+    let isolate = firstItem.isolate ?? false;
+    const targetModeHash = firstItem.modeHash;
+    if (firstItem.isolate) {
+      const item = this.queue.shift();
+      logger.logger.debug(`[MessageQueue2] Collected isolated message with mode hash: ${targetModeHash}`);
+      return {
+        message: item.message,
+        mode,
+        hash: targetModeHash,
+        isolate
+      };
+    }
+    if (typeof firstItem.message !== "string") {
+      const item = this.queue.shift();
+      logger.logger.debug(`[MessageQueue2] Collected single object message with mode hash: ${targetModeHash}`);
+      return {
+        message: item.message,
+        mode,
+        hash: targetModeHash,
+        isolate
+      };
+    }
+    const sameModeMessages = [];
+    while (this.queue.length > 0 && this.queue[0].modeHash === targetModeHash && !this.queue[0].isolate && typeof this.queue[0].message === "string") {
+      const item = this.queue.shift();
+      sameModeMessages.push(item.message);
+    }
+    logger.logger.debug(`[MessageQueue2] Collected batch of ${sameModeMessages.length} messages with mode hash: ${targetModeHash}`);
+    const combinedMessage = sameModeMessages.join("\n");
+    return {
+      message: combinedMessage,
+      mode,
+      hash: targetModeHash,
+      isolate
+    };
+  }
+  /**
+   * Wait for messages to arrive
+   */
+  waitForMessages(abortSignal) {
+    return new Promise((resolve) => {
+      let abortHandler = null;
+      if (abortSignal) {
+        abortHandler = () => {
+          logger.logger.debug("[MessageQueue2] Wait aborted");
+          if (this.waiter === waiterFunc) {
+            this.waiter = null;
+          }
+          resolve(false);
+        };
+        abortSignal.addEventListener("abort", abortHandler);
+      }
+      const waiterFunc = (hasMessages) => {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(hasMessages);
+      };
+      if (this.queue.length > 0) {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(true);
+        return;
+      }
+      if (this.closed || abortSignal?.aborted) {
+        if (abortHandler && abortSignal) {
+          abortSignal.removeEventListener("abort", abortHandler);
+        }
+        resolve(false);
+        return;
+      }
+      this.waiter = waiterFunc;
+      logger.logger.debug("[MessageQueue2] Waiting for messages...");
+    });
+  }
+}
+
+function deterministicStringify(obj, options = {}) {
+  const {
+    undefinedBehavior = "omit",
+    sortArrays = false,
+    replacer,
+    includeSymbols = false
+  } = options;
+  const seen = /* @__PURE__ */ new WeakSet();
+  function processValue(value, key) {
+    if (replacer && key !== void 0) {
+      value = replacer(key, value);
+    }
+    if (value === null) return null;
+    if (value === void 0) {
+      switch (undefinedBehavior) {
+        case "omit":
+          return void 0;
+        case "null":
+          return null;
+        case "throw":
+          throw new Error(`Undefined value at key: ${key}`);
+      }
+    }
+    if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+      return value;
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (typeof value === "function") {
+      return void 0;
+    }
+    if (typeof value === "symbol") {
+      return includeSymbols ? value.toString() : void 0;
+    }
+    if (typeof value === "bigint") {
+      return value.toString() + "n";
+    }
+    if (seen.has(value)) {
+      throw new Error("Circular reference detected");
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+      const processed2 = value.map((item, index) => processValue(item, String(index))).filter((item) => item !== void 0);
+      if (sortArrays) {
+        processed2.sort((a, b) => {
+          const aStr = JSON.stringify(processValue(a));
+          const bStr = JSON.stringify(processValue(b));
+          return aStr.localeCompare(bStr);
+        });
+      }
+      seen.delete(value);
+      return processed2;
+    }
+    if (value.constructor === Object || value.constructor === void 0) {
+      const processed2 = {};
+      const keys = Object.keys(value).sort();
+      for (const k of keys) {
+        const processedValue = processValue(value[k], k);
+        if (processedValue !== void 0) {
+          processed2[k] = processedValue;
+        }
+      }
+      seen.delete(value);
+      return processed2;
+    }
+    try {
+      const plain = { ...value };
+      seen.delete(value);
+      return processValue(plain, key);
+    } catch {
+      seen.delete(value);
+      return String(value);
+    }
+  }
+  const processed = processValue(obj);
+  return JSON.stringify(processed);
+}
+function hashObject(obj, options, encoding = "hex") {
+  const jsonString = deterministicStringify(obj, options);
+  return crypto.createHash("sha256").update(jsonString).digest(encoding);
+}
+
+function createMcpServer(client, options) {
+  const mcp = new mcp_js.McpServer({
+    name: "Happy MCP",
+    version: "1.0.0"
+  });
+  const handler = async (title) => {
+    logger.logger.debug("[happyMCP] Changing title to:", title);
+    if (client.isTitlePinned) {
+      return { success: false, error: "Title is pinned by user and cannot be changed automatically" };
+    }
+    try {
+      client.sendClaudeSessionMessage({
+        type: "summary",
+        summary: title,
+        leafUuid: node_crypto.randomUUID()
+      });
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  };
+  mcp.registerTool("device_list", {
+    description: "List enrolled Happy devices (servers and computers) with their online state. Use before device_exec when you need a device id.",
+    title: "List Devices",
+    inputSchema: {}
+  }, async () => {
+    const credentials = await logger.readCredentials();
+    if (!credentials) {
+      return { content: [{ type: "text", text: "No Happy credentials on this machine." }] };
+    }
+    try {
+      const devices = await deviceKeys.listDevices(credentials);
+      const target = client.targetDevices.map((device) => device.id);
+      const lines = devices.map((device) => {
+        const marks = [device.active ? "online" : "offline"];
+        if (target.includes(device.id)) marks.push("session default");
+        return `${device.id}  ${device.name}${device.platform ? ` (${device.platform})` : ""}  [${marks.join(", ")}]${device.description ? `  \u2014 ${device.description}` : ""}`;
+      });
+      return { content: [{ type: "text", text: lines.length ? lines.join("\n") : "No devices enrolled yet." }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Failed to list devices: ${error instanceof Error ? error.message : String(error)}` }] };
+    }
+  });
+  mcp.registerTool("device_exec", {
+    description: "Run a shell command on an enrolled device (a server or computer registered in Happy). Omit deviceId to use the device the user selected for this session. Returns stdout, stderr and exit code.",
+    title: "Run Command on Device",
+    inputSchema: {
+      command: z.z.string().describe("Shell command to run on the device"),
+      deviceId: z.z.string().optional().describe("Target device id. Defaults to the session's selected device."),
+      cwd: z.z.string().optional().describe("Working directory on the device"),
+      timeout: z.z.number().optional().describe("Timeout in milliseconds (default 60000)")
+    }
+  }, async (args) => {
+    const credentials = await logger.readCredentials();
+    if (!credentials) {
+      return { content: [{ type: "text", text: "No Happy credentials on this machine." }] };
+    }
+    const targets = client.targetDevices;
+    const deviceId = args.deviceId || (targets.length === 1 ? targets[0].id : null);
+    if (!deviceId && targets.length > 1) {
+      return { content: [{ type: "text", text: `This session targets several devices \u2014 pass deviceId: ${targets.map((device) => `${device.name} (${device.id})`).join(", ")}` }] };
+    }
+    if (!deviceId) {
+      return { content: [{ type: "text", text: "No device selected for this session. Pick one in the app or pass deviceId (see device_list)." }] };
+    }
+    try {
+      const result = await deviceKeys.deviceExec(client.rpcSocket, credentials, deviceId, args.command, {
+        cwd: args.cwd,
+        timeout: args.timeout,
+        deviceKeyBase64: targets.find((device) => device.id === deviceId)?.key ?? null
+      });
+      const parts = [`exit code: ${result.exitCode}`];
+      if (result.stdout) parts.push(`stdout:
+${result.stdout}`);
+      if (result.stderr) parts.push(`stderr:
+${result.stderr}`);
+      return { content: [{ type: "text", text: parts.join("\n\n") }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Device command failed: ${error instanceof Error ? error.message : String(error)}` }] };
+    }
+  });
+  mcp.registerTool("change_title", {
+    description: "Change the title of the current chat session",
+    title: "Change Chat Title",
+    inputSchema: {
+      title: z.z.string().describe("The new title for the chat session")
+    }
+  }, async (args) => {
+    const response = await handler(args.title);
+    logger.logger.debug("[happyMCP] Response:", response);
+    if (response.success) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Successfully changed chat title to: "${args.title}"`
+          }
+        ],
+        isError: false
+      };
+    } else {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to change chat title: ${response.error || "Unknown error"}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  mcp.registerTool("preview_html", {
+    description: "Preview an HTML page in the client app. The HTML must be a complete, self-contained document with all CSS and JS inlined.",
+    title: "Preview HTML",
+    inputSchema: {
+      html: z.z.string().describe("Complete self-contained HTML document string"),
+      title: z.z.string().optional().describe("Display title for the preview")
+    }
+  }, async (args) => {
+    logger.logger.debug("[happyMCP] Preview HTML:", args.title || "Untitled");
+    return {
+      content: [{
+        type: "text",
+        text: `HTML preview ready: ${args.title || "Untitled"}`
+      }],
+      isError: false
+    };
+  });
+  return mcp;
+}
+async function startHappyServer(client) {
+  const transports = /* @__PURE__ */ new Map();
+  const enableOrchestratorTools = prompt.shouldEnableOrchestratorTools();
+  const toolNames = ["change_title", "preview_html", "device_list", "device_exec"];
+  const originalConsoleError = console.error;
+  console.error = (...args) => {
+    logger.logger.debug("[happyMCP] console.error:", ...args);
+    originalConsoleError.apply(console, args);
+  };
+  const server = node_http.createServer(async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    logger.logger.debug("[happyMCP] Received request:", req.method, req.url, "sessionId:", sessionId);
+    try {
+      if (req.method === "POST") {
+        const body = await readRequestBody(req);
+        const parsedBody = JSON.parse(body);
+        let transport;
+        if (sessionId && transports.has(sessionId)) {
+          transport = transports.get(sessionId);
+          logger.logger.debug("[happyMCP] Reusing transport for session:", sessionId);
+        } else if (!sessionId && types_js.isInitializeRequest(parsedBody)) {
+          logger.logger.debug("[happyMCP] New initialize request, creating transport");
+          transport = new streamableHttp_js.StreamableHTTPServerTransport({
+            sessionIdGenerator: () => node_crypto.randomUUID(),
+            onsessioninitialized: (newSessionId) => {
+              logger.logger.debug("[happyMCP] Session initialized:", newSessionId);
+              transports.set(newSessionId, transport);
+            }
+          });
+          transport.onclose = () => {
+            const sid = transport.sessionId;
+            if (sid && transports.has(sid)) {
+              logger.logger.debug("[happyMCP] Transport closed, removing session:", sid);
+              transports.delete(sid);
+            }
+          };
+          transport.onerror = (error) => {
+            logger.logger.debug("[happyMCP] Transport error:", error);
+          };
+          const mcp = createMcpServer(client, { enableOrchestratorTools });
+          await mcp.connect(transport);
+          await transport.handleRequest(req, res, parsedBody);
+          logger.logger.debug("[happyMCP] Initialize request handled successfully");
+          return;
+        } else {
+          logger.logger.debug("[happyMCP] Bad request: no session ID and not initialize");
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Bad Request: No valid session ID provided"
+            },
+            id: null
+          }));
+          return;
+        }
+        await transport.handleRequest(req, res, parsedBody);
+        logger.logger.debug("[happyMCP] Request handled successfully");
+      } else if (req.method === "GET" || req.method === "DELETE") {
+        if (!sessionId || !transports.has(sessionId)) {
+          logger.logger.debug("[happyMCP] Bad request: invalid session for GET/DELETE");
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Invalid or missing session ID");
+          return;
+        }
+        const transport = transports.get(sessionId);
+        await transport.handleRequest(req, res);
+        logger.logger.debug("[happyMCP] GET/DELETE request handled successfully");
+      } else {
+        res.writeHead(405, { "Content-Type": "text/plain" });
+        res.end("Method not allowed");
+      }
+    } catch (error) {
+      logger.logger.debug("[happyMCP] Error handling request:", error);
+      if (!res.headersSent) {
+        res.writeHead(500).end();
+      }
+    }
+  });
+  const baseUrl = await new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolve(new URL(`http://127.0.0.1:${addr.port}`));
+    });
+  });
+  logger.logger.debug("[happyMCP] Server started at:", baseUrl.toString());
+  return {
+    url: baseUrl.toString(),
+    toolNames,
+    stop: async () => {
+      logger.logger.debug("[happyMCP] Stopping server");
+      for (const [sessionId, transport] of transports) {
+        logger.logger.debug("[happyMCP] Closing transport for session:", sessionId);
+        try {
+          await transport.close();
+        } catch (error) {
+          logger.logger.debug("[happyMCP] Error closing transport:", error);
+        }
+      }
+      transports.clear();
+      server.close();
+    }
+  };
+}
+function readRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}
+
+const getBridgeCommand = () => path.join(projectPath.projectPath(), "bin", "happy-mcp.mjs");
+function adaptForClaude(def) {
+  return { type: "http", url: def.url, ...def.headers && { headers: def.headers } };
+}
+function adaptForStdio(def) {
+  const args = ["--url", def.url];
+  if (def.headers) {
+    for (const [k, v] of Object.entries(def.headers)) {
+      args.push("--header", `${k}: ${v}`);
+    }
+  }
+  return { command: getBridgeCommand(), args };
+}
+function adaptForHttp(def) {
+  return { type: "http", url: def.url, headers: def.headers || {} };
+}
+async function createMcpContext(session) {
+  const happyServer = await startHappyServer(session);
+  const servers = {
+    happy: {
+      url: happyServer.url,
+      toolNames: happyServer.toolNames,
+      stop: () => happyServer.stop()
+    }
+  };
+  const extraServersJson = process.env.HAPPY_EXTRA_MCP_SERVERS;
+  if (extraServersJson) {
+    try {
+      const extraServers = JSON.parse(extraServersJson);
+      for (const srv of extraServers) {
+        servers[srv.name] = {
+          url: srv.url,
+          toolNames: [],
+          // External MCP — tools discovered by agent, not whitelisted
+          headers: srv.headers,
+          stop: () => {
+          }
+          // No lifecycle management for external servers
+        };
+      }
+    } catch (e) {
+      console.warn("Failed to parse HAPPY_EXTRA_MCP_SERVERS:", e);
+    }
+  }
+  return {
+    configForClaude() {
+      const result = {};
+      for (const [name, def] of Object.entries(servers)) {
+        result[name] = adaptForClaude(def);
+      }
+      return result;
+    },
+    configForStdio() {
+      const result = {};
+      for (const [name, def] of Object.entries(servers)) {
+        result[name] = adaptForStdio(def);
+      }
+      return result;
+    },
+    configForHttp() {
+      const result = {};
+      for (const [name, def] of Object.entries(servers)) {
+        result[name] = adaptForHttp(def);
+      }
+      return result;
+    },
+    allowedToolNames() {
+      return Object.entries(servers).flatMap(
+        ([name, def]) => def.toolNames.map((tool) => `mcp__${name}__${tool}`)
+      );
+    },
+    normalizeToolName(rawName) {
+      for (const [name, def] of Object.entries(servers)) {
+        if (def.toolNames.includes(rawName)) {
+          return `mcp:${name}:${rawName}`;
+        }
+      }
+      return rawName;
+    },
+    stop() {
+      for (const def of Object.values(servers)) {
+        def.stop();
+      }
+    }
+  };
+}
+
+function detectGitWorktree(cwd) {
+  try {
+    const gitDir = node_child_process.execSync("git rev-parse --git-dir", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const gitCommonDir = node_child_process.execSync("git rev-parse --git-common-dir", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const absGitDir = path.resolve(cwd, gitDir);
+    const absCommonDir = path.resolve(cwd, gitCommonDir);
+    if (absGitDir === absCommonDir) {
+      return { isWorktree: false };
+    }
+    const basePath = path.dirname(absCommonDir);
+    const branchName = node_child_process.execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return {
+      isWorktree: true,
+      worktreeBasePath: basePath,
+      worktreeBranchName: branchName || void 0
+    };
+  } catch {
+    return { isWorktree: false };
+  }
+}
+
+class MessageBuffer {
+  messages = [];
+  listeners = [];
+  nextId = 1;
+  addMessage(content, type = "assistant") {
+    const message = {
+      id: `msg-${this.nextId++}`,
+      timestamp: /* @__PURE__ */ new Date(),
+      content,
+      type
+    };
+    this.messages.push(message);
+    this.notifyListeners();
+  }
+  /**
+   * Update the last message of a specific type by appending content to it
+   * Useful for streaming responses where deltas should accumulate in one message
+   */
+  updateLastMessage(contentDelta, type = "assistant") {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      if (this.messages[i].type === type) {
+        const oldMessage = this.messages[i];
+        const updatedMessage = {
+          ...oldMessage,
+          content: oldMessage.content + contentDelta
+        };
+        this.messages[i] = updatedMessage;
+        this.notifyListeners();
+        return;
+      }
+    }
+    this.addMessage(contentDelta, type);
+  }
+  /**
+   * Remove the last message of a specific type
+   * Useful for removing placeholder messages like "Thinking..." when actual response starts
+   */
+  removeLastMessage(type) {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      if (this.messages[i].type === type) {
+        this.messages.splice(i, 1);
+        this.notifyListeners();
+        return true;
+      }
+    }
+    return false;
+  }
+  getMessages() {
+    return [...this.messages];
+  }
+  clear() {
+    this.messages = [];
+    this.nextId = 1;
+    this.notifyListeners();
+  }
+  onUpdate(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const index = this.listeners.indexOf(listener);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  notifyListeners() {
+    const messages = this.getMessages();
+    this.listeners.forEach((listener) => listener(messages));
+  }
+}
+
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    logger.logger.debug("Kill session request received");
+    void killThisHappy();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
+  });
+}
+
+async function downloadImage(url) {
+  const response = await axios.get(url, {
+    responseType: "arraybuffer"
+  });
+  const buffer = Buffer.from(response.data);
+  const base64 = buffer.toString("base64");
+  let mimeType = response.headers["content-type"] || "image/jpeg";
+  if (mimeType.includes(";")) {
+    mimeType = mimeType.split(";")[0].trim();
+  }
+  return { base64, mimeType };
+}
+
+exports.MessageBuffer = MessageBuffer;
+exports.MessageQueue2 = MessageQueue2;
+exports.createMcpContext = createMcpContext;
+exports.detectGitWorktree = detectGitWorktree;
+exports.downloadImage = downloadImage;
+exports.hashObject = hashObject;
+exports.parseClear = parseClear;
+exports.parseSpecialCommand = parseSpecialCommand;
+exports.registerKillSessionHandler = registerKillSessionHandler;