@zonease/happy 0.6.41 → 0.6.42

package/dist/runCursor-CD5wC3gA.cjs

@@ -0,0 +1,578 @@
+'use strict';
+
+var node_crypto = require('node:crypto');
+var chalk = require('chalk');
+var api = require('./api-CIE4_cWd.cjs');
+var logger = require('./persistence-BcQmjobZ.cjs');
+var run = require('./run-CiPWWhXt.cjs');
+var setupOfflineReconnection = require('./setupOfflineReconnection-B6coH9QN.cjs');
+var node_child_process = require('node:child_process');
+var cursorApprovalServer = require('./cursorApprovalServer-DzY8yJlI.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-BwFUGgMs.cjs');
+require('fs');
+require('os');
+require('tmp');
+require('./auth-G9fZpVJ2.cjs');
+require('qrcode-terminal');
+require('./browser-qDIIAL7S.cjs');
+require('open');
+require('react');
+require('ink');
+require('./doctor-BJSuVRUZ.cjs');
+require('./controlClient-CEz_p1zc.cjs');
+require('./doctor-C08m5Z9f.cjs');
+require('ps-list');
+require('cross-spawn');
+require('./spawnHappyCLI-Cfu7C1uM.cjs');
+require('./deviceKeys-DyUn0bEx.cjs');
+require('./install-Tyhs6rUp.cjs');
+require('./trimIdent-4gvk9Wk6.cjs');
+require('fastify');
+require('fastify-type-provider-zod');
+require('./common-CZvSRU4p.cjs');
+require('./gitWorktree-C6jLoaMw.cjs');
+require('node:http');
+
+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;
+    return {
+      toolName: key.replace(/ToolCall$/, ""),
+      args: inner.args && typeof inner.args === "object" ? inner.args : {},
+      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) {
+  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": {
+      if (event.subtype !== "delta") return [];
+      const text = typeof event.text === "string" ? event.text : null;
+      if (!text) return [];
+      return [{ type: "event", name: "thinking", payload: { textDelta: text } }];
+    }
+    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;
+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;
+  stdoutBuffer = "";
+  turnComplete = Promise.resolve();
+  resolveTurn = null;
+  disposed = false;
+  constructor(options) {
+    this.options = options;
+  }
+  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"];
+    if (this.options.model) args.push("--model", this.options.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} ${this.chatId ? `(resume ${this.chatId})` : "(new chat)"}`);
+    this.emit({ type: "status", status: "starting" });
+    this.stdoutBuffer = "";
+    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");
+      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;
+  }
+  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.emit(message);
+      }
+    }
+  }
+  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"];
+class CursorPermissionHandler extends setupOfflineReconnection.BasePermissionHandler {
+  /** Set once the user answers "approve for session" or picks a yolo mode. */
+  approveEverything = false;
+  constructor(session, pushClient) {
+    super(session, pushClient);
+  }
+  getLogPrefix() {
+    return "[cursor]";
+  }
+  getAgentName() {
+    return "Cursor";
+  }
+  /** Skip the round trip for tools that are part of Happy's own plumbing. */
+  shouldAutoApprove(toolName) {
+    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.approveEverything || 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})`);
+    });
+    if (result.decision === "approved_for_session") {
+      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;
+  const permissionHandler = new CursorPermissionHandler(session, api$1.push());
+  const approvalBridge = new cursorApprovalServer.CursorApprovalBridge({ cwd: process.cwd(), handler: permissionHandler });
+  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
+  });
+  const queue = [];
+  let draining = false;
+  let thinking = false;
+  backend.onMessage((message) => {
+    if (message.type === "status") {
+      thinking = message.status === "starting" || message.status === "running";
+    }
+    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;
+    }
+  };
+  session.onUserMessage((message) => {
+    const text = message.content?.text;
+    if (typeof text !== "string" || text.trim().length === 0) return;
+    if (message.meta?.hasOwnProperty("model")) {
+      logger.logger.debug("[cursor] per-message model override is not wired yet, ignoring");
+    }
+    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 (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 () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    clearInterval(keepAlive);
+    logger.logger.debug("[cursor] shutting down");
+    try {
+      await backend.dispose();
+      await approvalBridge.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);
+  await new Promise(() => {
+  });
+}
+
+exports.runCursor = runCursor;