@zonease/happy 0.6.41 → 0.6.43

package/dist/runCursor-BlPAxaTy.cjs

@@ -0,0 +1,754 @@
+'use strict';
+
+var node_crypto = require('node:crypto');
+var chalk = require('chalk');
+var api = require('./api-B-PlVQY6.cjs');
+var logger = require('./persistence-D7zNFI-d.cjs');
+var run = require('./run-C5StYRIB.cjs');
+var setupOfflineReconnection = require('./setupOfflineReconnection-Dkp00dC9.cjs');
+var controlClient = require('./controlClient-yTkpwcOq.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-MoLdSQxM.cjs');
+var node_child_process = require('node:child_process');
+var cursorApprovalServer = require('./cursorApprovalServer-xwxVGL3u.cjs');
+require('axios');
+require('node:events');
+require('socket.io-client');
+require('zod');
+require('./index-BeKrqPYR.cjs');
+require('@paralleldrive/cuid2');
+require('./time-Bj2HRkKH.cjs');
+require('node:fs');
+require('node:path');
+require('node:fs/promises');
+require('node:os');
+require('node:util');
+require('child_process');
+require('util');
+require('fs/promises');
+require('path');
+require('./projectPath-ChLhdOyt.cjs');
+require('url');
+require('node:module');
+require('ws');
+require('crypto');
+require('tweetnacl');
+require('@stablelib/base64');
+require('node:readline');
+require('expo-server-sdk');
+require('./sessionKeyCache-3Pme04yL.cjs');
+require('fs');
+require('os');
+require('tmp');
+require('./auth-BqGkUXvq.cjs');
+require('qrcode-terminal');
+require('./browser-CY7VNU0C.cjs');
+require('open');
+require('react');
+require('ink');
+require('./doctor-D4xWXiE7.cjs');
+require('./doctor-C08m5Z9f.cjs');
+require('ps-list');
+require('cross-spawn');
+require('./spawnHappyCLI-C2uY9WV-.cjs');
+require('./deviceKeys-CdW-HPnz.cjs');
+require('./install-Jrs6YUu8.cjs');
+require('./trimIdent-4gvk9Wk6.cjs');
+require('fastify');
+require('fastify-type-provider-zod');
+require('./common-CZvSRU4p.cjs');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('node:http');
+require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+require('@modelcontextprotocol/sdk/types.js');
+require('./prompt-BTWDZZO0.cjs');
+require('./mcpToolSchemas-DK42yoZ_.cjs');
+require('./types-DWeB7aqh.cjs');
+
+function createCursorStreamState() {
+  return { thinkingBuffer: "" };
+}
+function textFromMessageContent(message) {
+  if (!message || typeof message !== "object") return null;
+  const content = message.content;
+  if (!Array.isArray(content)) return null;
+  const parts = [];
+  for (const block of content) {
+    if (block && typeof block === "object" && block.type === "text") {
+      const text = block.text;
+      if (typeof text === "string") parts.push(text);
+    }
+  }
+  return parts.length > 0 ? parts.join("") : null;
+}
+function unwrapToolCall(toolCall) {
+  if (!toolCall || typeof toolCall !== "object") return null;
+  for (const [key, value] of Object.entries(toolCall)) {
+    if (!key.endsWith("ToolCall") || !value || typeof value !== "object") continue;
+    const inner = value;
+    const normalized = cursorApprovalServer.normalizeCursorTool(key.replace(/ToolCall$/, ""), inner.args);
+    return {
+      toolName: normalized.name,
+      args: normalized.input,
+      result: inner.result ?? null
+    };
+  }
+  return null;
+}
+function editDiffFromResult(result) {
+  if (!result || typeof result !== "object") return null;
+  const success = result.success;
+  if (!success || typeof success !== "object") return null;
+  const diff = success.diffString;
+  if (typeof diff !== "string" || diff.length === 0) return null;
+  const path = success.path;
+  return { diff, path: typeof path === "string" ? path : null };
+}
+function parseCursorSessionInit(event) {
+  if (event.type !== "system" || event.subtype !== "init") return null;
+  const sessionId = event.session_id;
+  if (typeof sessionId !== "string" || sessionId.length === 0) return null;
+  const str = (key) => typeof event[key] === "string" ? event[key] : null;
+  return {
+    sessionId,
+    model: str("model"),
+    cwd: str("cwd"),
+    permissionMode: str("permissionMode"),
+    apiKeySource: str("apiKeySource")
+  };
+}
+function mapCursorStreamEvent(event, state) {
+  switch (event.type) {
+    case "system": {
+      if (event.subtype !== "init") return [];
+      const init = parseCursorSessionInit(event);
+      return [{
+        type: "status",
+        status: "running",
+        detail: init?.model ? `cursor-agent ready (${init.model})` : "cursor-agent ready"
+      }];
+    }
+    // The user turn is echoed back to us; Happy already has that text from
+    // the send path, so re-emitting it would duplicate the bubble.
+    case "user":
+      return [];
+    case "thinking": {
+      const text = typeof event.text === "string" ? event.text : "";
+      if (event.subtype === "delta") {
+        if (!text) return [];
+        if (!state) return [{ type: "event", name: "thinking", payload: { textDelta: text } }];
+        state.thinkingBuffer += text;
+        return [];
+      }
+      if (event.subtype === "completed" && state?.thinkingBuffer) {
+        const full = state.thinkingBuffer;
+        state.thinkingBuffer = "";
+        return [{ type: "event", name: "thinking", payload: { textDelta: full } }];
+      }
+      return [];
+    }
+    case "assistant": {
+      const text = textFromMessageContent(event.message);
+      if (!text) return [];
+      return [{ type: "model-output", fullText: text }];
+    }
+    case "tool_call": {
+      const callId = typeof event.call_id === "string" ? event.call_id : null;
+      const unwrapped = unwrapToolCall(event.tool_call);
+      if (!callId || !unwrapped) return [];
+      if (event.subtype === "started") {
+        return [{ type: "tool-call", toolName: unwrapped.toolName, args: unwrapped.args, callId }];
+      }
+      if (event.subtype !== "completed") return [];
+      const messages = [{
+        type: "tool-result",
+        toolName: unwrapped.toolName,
+        result: unwrapped.result,
+        callId
+      }];
+      const edit = editDiffFromResult(unwrapped.result);
+      if (edit) {
+        messages.push({
+          type: "fs-edit",
+          description: edit.path ? `Edited ${edit.path}` : "Edited file",
+          diff: edit.diff,
+          ...edit.path ? { path: edit.path } : {}
+        });
+      }
+      return messages;
+    }
+    case "result": {
+      const messages = [];
+      const usage = event.usage;
+      if (usage && typeof usage === "object") {
+        messages.push({ type: "token-count", ...usage });
+      }
+      const isError = event.is_error === true;
+      messages.push({
+        type: "status",
+        status: isError ? "error" : "idle",
+        detail: typeof event.subtype === "string" ? event.subtype : void 0
+      });
+      return messages;
+    }
+    default:
+      return [];
+  }
+}
+function drainJsonLines(buffer) {
+  const events = [];
+  const lines = buffer.split("\n");
+  const rest = lines.pop() ?? "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+        events.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return { events, rest };
+}
+
+const CANCEL_GRACE_MS = 2e3;
+const THINKING_FLUSH_MS = 800;
+class CursorCliBackend {
+  options;
+  handlers = /* @__PURE__ */ new Set();
+  /** stdin is closed: the CLI takes its prompt as an argument, not on stdin. */
+  child = null;
+  /** Cursor's own chat id, used to resume on the next turn. */
+  chatId = null;
+  /** Current model id; null leaves the choice to Cursor. */
+  model = null;
+  stdoutBuffer = "";
+  streamState = createCursorStreamState();
+  thinkingFlushTimer = null;
+  turnComplete = Promise.resolve();
+  resolveTurn = null;
+  disposed = false;
+  constructor(options) {
+    this.options = options;
+    this.chatId = options.resumeChatId ?? null;
+    this.model = options.model ?? null;
+  }
+  /**
+   * The app sends the chosen model with every message, so it can change
+   * between turns. Each turn spawns its own process, which is where the new
+   * value takes effect.
+   */
+  setModel(model) {
+    this.model = model;
+  }
+  /** Cursor's own chat id, once it is known. */
+  getChatId() {
+    return this.chatId;
+  }
+  onMessage(handler) {
+    this.handlers.add(handler);
+  }
+  offMessage(handler) {
+    this.handlers.delete(handler);
+  }
+  emit(message) {
+    for (const handler of this.handlers) {
+      try {
+        handler(message);
+      } catch (error) {
+        logger.logger.debug(`[cursor] message handler threw: ${error}`);
+      }
+    }
+  }
+  async startSession(initialPrompt) {
+    if (this.disposed) throw new Error("CursorCliBackend has been disposed");
+    if (initialPrompt !== void 0) {
+      await this.runTurn(initialPrompt);
+    }
+    return { sessionId: this.chatId ?? "" };
+  }
+  async sendPrompt(_sessionId, prompt, options) {
+    if (options?.images?.length) {
+      throw new Error("CursorCliBackend does not support image prompts yet");
+    }
+    await this.runTurn(prompt);
+  }
+  /**
+   * One turn is one child process: the CLI's print mode runs a single prompt
+   * and exits. Continuity comes from `--resume <chatId>`, which is why the
+   * chat id from the first turn has to be kept.
+   */
+  async runTurn(prompt) {
+    if (this.child) {
+      throw new Error("CursorCliBackend is already running a turn");
+    }
+    const args = ["-p", prompt, "--output-format", "stream-json", "--trust", "--force"];
+    if (this.model) args.push("--model", this.model);
+    if (this.chatId) args.push("--resume", this.chatId);
+    if (this.options.extraArgs?.length) args.push(...this.options.extraArgs);
+    const command = this.options.command ?? "cursor-agent";
+    logger.logger.debug(`[cursor] spawn ${command} model=${this.model ?? "(Cursor default)"} ${this.chatId ? `(resume ${this.chatId})` : "(new chat)"}`);
+    this.emit({ type: "status", status: "starting" });
+    this.stdoutBuffer = "";
+    this.flushThinking();
+    this.streamState = createCursorStreamState();
+    this.turnComplete = new Promise((resolve) => {
+      this.resolveTurn = resolve;
+    });
+    const child = node_child_process.spawn(command, args, {
+      cwd: this.options.cwd,
+      env: { ...process.env, ...this.options.env },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    this.child = child;
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => this.consumeStdout(chunk));
+    let lastStderr = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.trim();
+      if (text.length === 0) return;
+      lastStderr = text.split("\n").slice(-3).join(" ").slice(0, 300);
+      logger.logger.debug(`[cursor] stderr: ${text}`);
+    });
+    child.on("error", (error) => {
+      this.emit({ type: "status", status: "error", detail: `failed to start cursor-agent: ${error.message}` });
+      this.finishTurn();
+    });
+    child.on("close", (code) => {
+      this.consumeStdout("\n");
+      this.flushThinking();
+      if (code !== 0) {
+        const reason = lastStderr.length > 0 ? `: ${lastStderr}` : "";
+        this.emit({ type: "status", status: "error", detail: `cursor-agent exited with code ${code}${reason}` });
+      }
+      logger.logger.debug(`[cursor] turn finished with code ${code}`);
+      this.finishTurn();
+    });
+    await this.turnComplete;
+  }
+  /** Emits whatever reasoning has accumulated, if any. */
+  flushThinking() {
+    if (this.thinkingFlushTimer) {
+      clearTimeout(this.thinkingFlushTimer);
+      this.thinkingFlushTimer = null;
+    }
+    const text = this.streamState.thinkingBuffer;
+    if (!text) return;
+    this.streamState.thinkingBuffer = "";
+    this.emit({ type: "event", name: "thinking", payload: { textDelta: text } });
+  }
+  consumeStdout(chunk) {
+    this.stdoutBuffer += chunk;
+    const { events, rest } = drainJsonLines(this.stdoutBuffer);
+    this.stdoutBuffer = rest;
+    for (const event of events) {
+      const init = parseCursorSessionInit(event);
+      if (init) {
+        this.chatId = init.sessionId;
+        logger.logger.debug(`[cursor] chat id ${init.sessionId} model ${init.model ?? "(default)"}`);
+      }
+      for (const message of mapCursorStreamEvent(event, this.streamState)) {
+        if (message.type === "event" && message.name === "thinking" && this.thinkingFlushTimer) {
+          clearTimeout(this.thinkingFlushTimer);
+          this.thinkingFlushTimer = null;
+        }
+        this.emit(message);
+      }
+      if (this.streamState.thinkingBuffer && !this.thinkingFlushTimer) {
+        this.thinkingFlushTimer = setTimeout(() => {
+          this.thinkingFlushTimer = null;
+          this.flushThinking();
+        }, THINKING_FLUSH_MS);
+      }
+    }
+  }
+  finishTurn() {
+    this.child = null;
+    const resolve = this.resolveTurn;
+    this.resolveTurn = null;
+    resolve?.();
+  }
+  async cancel(_sessionId) {
+    const child = this.child;
+    if (!child) return;
+    logger.logger.debug("[cursor] cancelling current turn");
+    child.kill("SIGTERM");
+    const killed = await Promise.race([
+      this.turnComplete.then(() => true),
+      new Promise((resolve) => setTimeout(() => resolve(false), CANCEL_GRACE_MS))
+    ]);
+    if (!killed && this.child) {
+      this.child.kill("SIGKILL");
+    }
+    this.emit({ type: "status", status: "stopped", detail: "cancelled" });
+  }
+  async waitForResponseComplete(timeoutMs = 12e4) {
+    await Promise.race([
+      this.turnComplete,
+      new Promise((_, reject) => setTimeout(() => reject(new Error("cursor-agent turn timed out")), timeoutMs))
+    ]);
+  }
+  async dispose() {
+    this.disposed = true;
+    if (this.child) {
+      await this.cancel(this.chatId ?? "");
+    }
+    this.handlers.clear();
+  }
+}
+
+function agentMessageToAcp(message, newId) {
+  switch (message.type) {
+    case "model-output": {
+      const text = message.fullText ?? message.textDelta;
+      if (!text) return [];
+      return [{ type: "message", message: text }];
+    }
+    case "event": {
+      if (message.name !== "thinking") return [];
+      const payload = message.payload;
+      const text = payload && typeof payload.textDelta === "string" ? payload.textDelta : null;
+      if (!text) return [];
+      return [{ type: "thinking", text }];
+    }
+    case "tool-call":
+      return [{
+        type: "tool-call",
+        callId: message.callId,
+        name: message.toolName,
+        input: message.args,
+        id: newId()
+      }];
+    case "tool-result":
+      return [{
+        type: "tool-result",
+        callId: message.callId,
+        output: message.result,
+        id: newId()
+      }];
+    case "fs-edit":
+      return [{
+        type: "file-edit",
+        description: message.description,
+        // The app keys file edits by path; an edit without one would
+        // render as an orphan card, so fall back to a visible marker.
+        filePath: message.path ?? "(unknown path)",
+        ...message.diff ? { diff: message.diff } : {},
+        id: newId()
+      }];
+    case "terminal-output":
+      return [{ type: "terminal-output", data: message.data, callId: newId() }];
+    case "token-count": {
+      const { type: _type, ...rest } = message;
+      return [{ type: "token_count", ...rest }];
+    }
+    case "status": {
+      switch (message.status) {
+        case "starting":
+          return [{ type: "task_started", id: newId() }];
+        case "idle":
+          return [{ type: "task_complete", id: newId() }];
+        case "stopped":
+          return [{ type: "turn_aborted", id: newId() }];
+        case "error":
+          return [
+            { type: "message", message: message.detail ?? "cursor-agent failed" },
+            { type: "task_complete", id: newId() }
+          ];
+        default:
+          return [];
+      }
+    }
+    default:
+      return [];
+  }
+}
+
+const ALWAYS_ALLOWED_TOOLS = ["change_title", "happy__change_title", "preview_html", "happy__preview_html"];
+const UNATTENDED_MODES = ["yolo", "safe-yolo", "bypassPermissions"];
+class CursorPermissionHandler extends setupOfflineReconnection.BasePermissionHandler {
+  /** Set by "allow all tools for this session", or by an unattended mode. */
+  approveEverything = false;
+  /** Tools the user answered "don't ask again" for. */
+  allowedTools = /* @__PURE__ */ new Set();
+  currentPermissionMode = null;
+  constructor(session, pushClient) {
+    super(session, pushClient);
+  }
+  getLogPrefix() {
+    return "[cursor]";
+  }
+  getAgentName() {
+    return "Cursor";
+  }
+  /**
+   * The app sends the mode with each message. In an unattended mode asking
+   * would contradict what the session badge promises, so tools just run.
+   */
+  setPermissionMode(mode) {
+    if (mode === this.currentPermissionMode) return;
+    this.currentPermissionMode = mode;
+    logger.logger.debug(`${this.getLogPrefix()} permission mode is now ${mode ?? "default"}`);
+  }
+  isUnattended() {
+    return this.currentPermissionMode !== null && UNATTENDED_MODES.includes(this.currentPermissionMode);
+  }
+  shouldAutoApprove(toolName) {
+    if (this.approveEverything || this.isUnattended()) return true;
+    if (this.allowedTools.has(toolName)) return true;
+    const lower = toolName.toLowerCase();
+    return ALWAYS_ALLOWED_TOOLS.some((name) => lower.includes(name.toLowerCase()));
+  }
+  /**
+   * Blocks until the phone answers. The hook process on the other end is
+   * happy to wait — Cursor imposes no deadline of its own beyond the
+   * `timeout` we write into hooks.json.
+   */
+  async requestApproval(toolCallId, toolName, input) {
+    if (this.shouldAutoApprove(toolName)) {
+      logger.logger.debug(`${this.getLogPrefix()} auto-approving ${toolName}`);
+      return true;
+    }
+    const result = await new Promise((resolve, reject) => {
+      this.pendingRequests.set(toolCallId, { resolve, reject, toolName, input });
+      this.addPendingRequestToState(toolCallId, toolName, input);
+      logger.logger.debug(`${this.getLogPrefix()} awaiting approval for ${toolName} (${toolCallId})`);
+    });
+    for (const allowed of result.allowTools ?? []) {
+      this.allowedTools.add(allowed);
+    }
+    if (result.decision === "approved_for_session" || result.mode && UNATTENDED_MODES.includes(result.mode)) {
+      this.approveEverything = true;
+    }
+    return result.decision === "approved" || result.decision === "approved_for_session";
+  }
+}
+
+const KEEP_ALIVE_INTERVAL_MS = 2e3;
+const SHUTDOWN_TIMEOUT_MS = 5e3;
+async function runCursor(opts) {
+  const api$1 = await api.ApiClient.create(opts.credentials);
+  const settings = await logger.readSettings();
+  const machineId = settings?.machineId;
+  if (!machineId) {
+    console.error(chalk.red("No machine ID found in settings. Run `happy` once to finish setup."));
+    process.exit(1);
+  }
+  await api$1.getOrCreateMachine({ machineId, metadata: run.initialMachineMetadata });
+  const { state, metadata } = setupOfflineReconnection.createSessionMetadata({
+    flavor: "cursor",
+    machineId,
+    startedBy: opts.startedBy
+  });
+  const sessionTag = node_crypto.randomUUID();
+  const response = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
+  let session;
+  const { session: initialSession } = setupOfflineReconnection.setupOfflineReconnection({
+    api: api$1,
+    sessionTag,
+    metadata,
+    state,
+    response,
+    onSessionSwap: (newSession) => {
+      session = newSession;
+    }
+  });
+  session = initialSession;
+  if (response) {
+    try {
+      const result = await controlClient.notifyDaemonSessionStarted(response.id, metadata);
+      if (result?.error) {
+        logger.logger.debug(`[cursor] daemon did not accept the session report: ${result.error}`);
+      }
+    } catch (error) {
+      logger.logger.debug(`[cursor] could not report session to daemon: ${error}`);
+    }
+  }
+  const mcp = await registerKillSessionHandler.createMcpContext(session);
+  const mcpStdio = mcp.configForStdio().happy;
+  const mcpUrlArg = mcpStdio?.args?.indexOf("--url") ?? -1;
+  const mcpUrl = mcpUrlArg >= 0 ? mcpStdio.args[mcpUrlArg + 1] : null;
+  const mcpBridge = mcpStdio ? { command: mcpStdio.command, args: mcpStdio.args ?? [] } : null;
+  const permissionHandler = new CursorPermissionHandler(session, api$1.push());
+  const approvalBridge = new cursorApprovalServer.CursorApprovalBridge({ cwd: process.cwd(), handler: permissionHandler, mcpBridge });
+  let approvalReady = false;
+  try {
+    await approvalBridge.start();
+    approvalReady = true;
+  } catch (error) {
+    logger.logger.debug(`[cursor] approval bridge failed to start: ${error}`);
+  }
+  const backend = new CursorCliBackend({
+    cwd: process.cwd(),
+    model: opts.model ?? null,
+    resumeChatId: opts.resumeChatId ?? null,
+    // Cursor asks before loading an MCP server; nobody is at the terminal.
+    extraArgs: mcpBridge ? ["--approve-mcps"] : void 0
+  });
+  let publishedChatId = opts.resumeChatId ?? null;
+  if (publishedChatId) {
+    session.updateMetadata((current) => ({ ...current, cursorSessionId: publishedChatId }));
+  }
+  const queue = [];
+  let draining = false;
+  let thinking = false;
+  let reportedModel = null;
+  backend.onMessage((message) => {
+    const chatId = backend.getChatId();
+    if (chatId && chatId !== publishedChatId) {
+      publishedChatId = chatId;
+      session.updateMetadata((current) => ({ ...current, cursorSessionId: chatId }));
+      void approvalBridge.registerChat(chatId);
+    }
+    if (message.type === "token-count") {
+      const usage = message;
+      const num = (key) => typeof usage[key] === "number" ? usage[key] : 0;
+      const input = num("inputTokens");
+      const output = num("outputTokens");
+      const cacheRead = num("cacheReadTokens");
+      const cacheWrite = num("cacheWriteTokens");
+      const total = input + output + cacheRead + cacheWrite;
+      if (total > 0) {
+        session.sendUsageReport({
+          key: "cursor-session",
+          tokens: { total, input, output, cache_read: cacheRead, cache_creation: cacheWrite },
+          // Cursor bills against its own subscription and reports no
+          // per-request price, so there is nothing honest to put here.
+          cost: { total: 0 }
+        });
+      }
+    }
+    if (message.type === "status") {
+      thinking = message.status === "starting" || message.status === "running";
+      const named = message.detail?.match(/^cursor-agent ready \((.+)\)$/)?.[1];
+      if (named && named !== reportedModel) {
+        reportedModel = named;
+        session.updateMetadata((current) => ({ ...current, model: named }));
+      }
+    }
+    for (const acp of agentMessageToAcp(message, () => node_crypto.randomUUID())) {
+      session.sendAgentMessage("cursor", acp);
+    }
+  });
+  const drain = async () => {
+    if (draining) return;
+    draining = true;
+    try {
+      while (queue.length > 0) {
+        const prompt = queue.shift();
+        logger.logger.debug(`[cursor] running turn (${queue.length} queued behind it)`);
+        try {
+          await backend.sendPrompt("", prompt);
+        } catch (error) {
+          const detail = error instanceof Error ? error.message : String(error);
+          session.sendAgentMessage("cursor", { type: "message", message: `Cursor turn failed: ${detail}` });
+          logger.logger.debug(`[cursor] turn failed: ${detail}`);
+        }
+      }
+    } finally {
+      draining = false;
+      thinking = false;
+    }
+  };
+  const handleAbort = async () => {
+    logger.logger.debug(`[cursor] abort requested (${queue.length} queued)`);
+    queue.length = 0;
+    try {
+      await backend.cancel("");
+    } catch (error) {
+      logger.logger.debug(`[cursor] abort failed: ${error}`);
+    }
+    permissionHandler.reset();
+    thinking = false;
+    session.sendSessionEvent({ type: "message", message: "Aborted by user" });
+  };
+  session.onUserMessage((message) => {
+    const text = message.content?.text;
+    if (typeof text !== "string" || text.trim().length === 0) return;
+    if (message.meta?.permissionMode) {
+      permissionHandler.setPermissionMode(message.meta.permissionMode);
+    }
+    if (message.meta?.hasOwnProperty("model")) {
+      const chosen = message.meta.model || null;
+      backend.setModel(chosen);
+      logger.logger.debug(`[cursor] model set to ${chosen ?? "(Cursor default)"}`);
+    }
+    queue.push(text);
+    void drain();
+  });
+  const keepAlive = setInterval(() => {
+    session.keepAlive(thinking, "remote");
+  }, KEEP_ALIVE_INTERVAL_MS);
+  session.sendSessionEvent({ type: "ready" });
+  console.log(chalk.green("Cursor session ready.") + " Open Happy on your phone to drive it.");
+  if (response?.id) {
+    console.log(chalk.gray(`  id     ${response.id}`));
+  } else {
+    console.log(chalk.yellow("  id     (offline \u2014 reconnecting in the background)"));
+  }
+  console.log(chalk.gray(`  cwd    ${process.cwd()}`));
+  console.log(chalk.gray(`  model  ${opts.model ?? "(Cursor default)"}`));
+  if (mcpUrl) {
+    console.log(chalk.gray(`  tools     Happy MCP on ${mcpUrl}`));
+  } else {
+    console.log(chalk.yellow("  tools     Happy MCP unavailable \u2014 change_title, preview_html and device tools are missing"));
+  }
+  if (approvalReady) {
+    console.log(chalk.gray("  approval  tool calls are sent to your phone before they run"));
+  } else {
+    console.log(chalk.yellow("  approval  UNAVAILABLE \u2014 the bridge did not start, so tools run unchecked"));
+  }
+  if (opts.initialPrompt) {
+    queue.push(opts.initialPrompt);
+    void drain();
+  }
+  let shuttingDown = false;
+  const shutdown = async (archived = false) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    clearInterval(keepAlive);
+    thinking = false;
+    logger.logger.debug(`[cursor] shutting down${archived ? " (archived)" : ""}`);
+    if (archived) {
+      session.updateMetadata((current) => ({
+        ...current,
+        lifecycleState: "archived",
+        lifecycleStateSince: Date.now(),
+        archivedBy: "cli",
+        archiveReason: "User terminated"
+      }));
+    }
+    try {
+      permissionHandler.reset();
+      await backend.dispose();
+      await approvalBridge.stop();
+      mcp.stop();
+    } finally {
+      session.sendSessionDeath();
+      await session.flush();
+      await session.close();
+    }
+  };
+  const shutdownAndExit = () => {
+    void Promise.race([
+      shutdown(),
+      new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS))
+    ]).finally(() => process.exit(0));
+  };
+  process.on("SIGINT", shutdownAndExit);
+  process.on("SIGTERM", shutdownAndExit);
+  session.rpcHandlerManager.registerHandler("abort", handleAbort);
+  registerKillSessionHandler.registerKillSessionHandler(session.rpcHandlerManager, async () => {
+    await Promise.race([
+      shutdown(true),
+      new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS))
+    ]);
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+
+exports.runCursor = runCursor;