@zonease/happy 0.6.41 → 0.6.43

package/dist/cursorApprovalServer-Ba1yOUCA.mjs

@@ -0,0 +1,263 @@
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { mkdir, writeFile, rename, readFile, rm, readdir, rmdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { l as logger } from './persistence-DbLMvLvk.mjs';
+
+const TOOL_NAME_MAP = {
+  read: "Read",
+  write: "Write",
+  edit: "Edit",
+  grep: "Grep",
+  glob: "Glob",
+  ls: "LS",
+  list: "LS",
+  // Cursor calls it Shell; the app's card for running commands is Bash.
+  shell: "Bash",
+  terminal: "Bash",
+  task: "Task",
+  todowrite: "TodoWrite",
+  websearch: "WebSearch",
+  webfetch: "WebFetch"
+};
+function normalizeCursorToolName(rawName) {
+  const mapped = TOOL_NAME_MAP[rawName.toLowerCase()];
+  if (mapped) return mapped;
+  return rawName.charAt(0).toUpperCase() + rawName.slice(1);
+}
+function normalizeCursorToolInput(input) {
+  const out = { ...input };
+  if (typeof out.path === "string" && out.file_path === void 0) {
+    out.file_path = out.path;
+  }
+  if (typeof out.file_path === "string" && out.path === void 0) {
+    out.path = out.file_path;
+  }
+  if (typeof out.workingDirectory === "string" && out.cwd === void 0) {
+    out.cwd = out.workingDirectory;
+  }
+  if (typeof out.streamContent === "string" && out.content === void 0) {
+    out.content = out.streamContent;
+  }
+  return out;
+}
+function normalizeCursorTool(rawName, rawInput) {
+  const input = rawInput && typeof rawInput === "object" ? rawInput : {};
+  return {
+    name: normalizeCursorToolName(rawName),
+    input: normalizeCursorToolInput(input)
+  };
+}
+
+function approvalRegistryDir() {
+  return join(homedir(), ".happy", "cursor-approvals");
+}
+const APPROVAL_ENDPOINT_FILE = ".happy-approval.json";
+const HOOKS_FILE = "hooks.json";
+const HOOKS_BACKUP_FILE = "hooks.json.happy-backup";
+const MCP_FILE = "mcp.json";
+const MCP_BACKUP_FILE = "mcp.json.happy-backup";
+const HOOK_TIMEOUT_SECONDS = 900;
+class CursorApprovalBridge {
+  cwd;
+  handler;
+  token = randomUUID();
+  server = null;
+  port = 0;
+  hadExistingHooks = false;
+  hadExistingMcp = false;
+  mcpBridge;
+  /** True when .cursor/ did not exist before this session created it. */
+  createdCursorDir = false;
+  started = false;
+  /** Chat ids this session has registered, so they can be cleaned up. */
+  registeredChatIds = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.handler = options.handler;
+    this.mcpBridge = options.mcpBridge ?? null;
+  }
+  get cursorDir() {
+    return join(this.cwd, ".cursor");
+  }
+  async start() {
+    await this.listen();
+    await this.installHooks();
+    this.started = true;
+    logger.debug(`[cursor] approval bridge listening on 127.0.0.1:${this.port}`);
+  }
+  /**
+   * Claims a chat id for this session. Called as soon as cursor-agent reveals
+   * it, which is what lets the hook route an approval back to the session
+   * that actually made the call.
+   */
+  async registerChat(chatId) {
+    if (!this.started || this.registeredChatIds.has(chatId)) return;
+    const dir = approvalRegistryDir();
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, `${chatId}.json`), JSON.stringify({
+      port: this.port,
+      token: this.token,
+      pid: process.pid
+    }), "utf8");
+    this.registeredChatIds.add(chatId);
+    logger.debug(`[cursor] chat ${chatId} routed to this session's bridge`);
+  }
+  listen() {
+    return new Promise((resolve, reject) => {
+      const server = createServer((req, res) => {
+        if (req.method !== "POST" || !req.url?.startsWith("/approve")) {
+          res.writeHead(404).end();
+          return;
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk;
+        });
+        req.on("end", () => {
+          void this.decide(body).then((approved) => {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ approved }));
+          }).catch((error) => {
+            logger.debug(`[cursor] approval failed: ${error}`);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ approved: false }));
+          });
+        });
+      });
+      server.listen(0, "127.0.0.1", () => {
+        const address = server.address();
+        if (address === null || typeof address === "string") {
+          reject(new Error("Failed to determine approval server port"));
+          return;
+        }
+        this.port = address.port;
+        this.server = server;
+        resolve();
+      });
+      server.on("error", reject);
+    });
+  }
+  async decide(rawBody) {
+    let parsed;
+    try {
+      parsed = JSON.parse(rawBody);
+    } catch {
+      return false;
+    }
+    if (parsed.token !== this.token) {
+      logger.debug("[cursor] rejecting approval request with a bad token");
+      return false;
+    }
+    const { name: toolName, input: toolInput } = normalizeCursorTool(
+      typeof parsed.tool_name === "string" && parsed.tool_name.length > 0 ? parsed.tool_name : "unknown",
+      parsed.tool_input
+    );
+    const toolCallId = typeof parsed.tool_use_id === "string" && parsed.tool_use_id.length > 0 ? parsed.tool_use_id : `cursor-${randomUUID()}`;
+    return this.handler.requestApproval(toolCallId, toolName, toolInput);
+  }
+  /**
+   * Writes .cursor/hooks.json pointing at this CLI. Any file already there is
+   * moved aside and restored on stop, so a project with its own hooks is not
+   * quietly clobbered.
+   */
+  async installHooks() {
+    this.createdCursorDir = !existsSync(this.cursorDir);
+    await mkdir(this.cursorDir, { recursive: true });
+    const hooksPath = join(this.cursorDir, HOOKS_FILE);
+    if (existsSync(hooksPath)) {
+      await rename(hooksPath, join(this.cursorDir, HOOKS_BACKUP_FILE));
+      this.hadExistingHooks = true;
+      logger.debug("[cursor] existing hooks.json moved aside for the session");
+    }
+    const hookCommand = `${process.execPath} ${process.argv[1]} cursor-approval-hook`;
+    await writeFile(hooksPath, JSON.stringify({
+      version: 1,
+      hooks: {
+        // preToolUse covers every tool, including Read, Write and Shell.
+        // It only understands allow/deny — never "ask" — and failClosed
+        // has to be explicit because hooks fail open by default.
+        preToolUse: [
+          { type: "command", command: hookCommand, timeout: HOOK_TIMEOUT_SECONDS, failClosed: true }
+        ]
+      }
+    }, null, 2), "utf8");
+    await this.installMcpConfig();
+    await this.excludeFromGit();
+  }
+  /** Points Cursor at Happy's tools (change_title, preview_html, devices…). */
+  async installMcpConfig() {
+    if (!this.mcpBridge) return;
+    const mcpPath = join(this.cursorDir, MCP_FILE);
+    if (existsSync(mcpPath)) {
+      await rename(mcpPath, join(this.cursorDir, MCP_BACKUP_FILE));
+      this.hadExistingMcp = true;
+      logger.debug("[cursor] existing mcp.json moved aside for the session");
+    }
+    await writeFile(mcpPath, JSON.stringify({
+      mcpServers: {
+        happy: { command: this.mcpBridge.command, args: this.mcpBridge.args }
+      }
+    }, null, 2), "utf8");
+  }
+  /** Keep the session's scaffolding out of `git status`. */
+  async excludeFromGit() {
+    const excludePath = join(this.cwd, ".git", "info", "exclude");
+    if (!existsSync(excludePath)) return;
+    try {
+      const current = await readFile(excludePath, "utf8");
+      if (current.includes(".cursor/.happy-approval.json")) return;
+      await writeFile(
+        excludePath,
+        `${current}${current.endsWith("\n") ? "" : "\n"}# added by happy cursor session
+.cursor/hooks.json
+.cursor/mcp.json
+.cursor/.happy-approval.json
+`,
+        "utf8"
+      );
+    } catch (error) {
+      logger.debug(`[cursor] could not update .git/info/exclude: ${error}`);
+    }
+  }
+  async stop() {
+    if (!this.started) return;
+    this.started = false;
+    try {
+      for (const chatId of this.registeredChatIds) {
+        await rm(join(approvalRegistryDir(), `${chatId}.json`), { force: true });
+      }
+      this.registeredChatIds.clear();
+      await rm(join(this.cursorDir, APPROVAL_ENDPOINT_FILE), { force: true });
+      const hooksPath = join(this.cursorDir, HOOKS_FILE);
+      const backupPath = join(this.cursorDir, HOOKS_BACKUP_FILE);
+      if (this.hadExistingHooks && existsSync(backupPath)) {
+        await rename(backupPath, hooksPath);
+      } else {
+        await rm(hooksPath, { force: true });
+      }
+      const mcpPath = join(this.cursorDir, MCP_FILE);
+      const mcpBackup = join(this.cursorDir, MCP_BACKUP_FILE);
+      if (this.hadExistingMcp && existsSync(mcpBackup)) {
+        await rename(mcpBackup, mcpPath);
+      } else if (this.mcpBridge) {
+        await rm(mcpPath, { force: true });
+      }
+      if (this.createdCursorDir && (await readdir(this.cursorDir)).length === 0) {
+        await rmdir(this.cursorDir);
+      }
+    } catch (error) {
+      logger.debug(`[cursor] cleanup of .cursor/ failed: ${error}`);
+    }
+    await new Promise((resolve) => {
+      if (!this.server) return resolve();
+      this.server.close(() => resolve());
+      this.server = null;
+    });
+    logger.debug("[cursor] approval bridge stopped");
+  }
+}
+
+export { APPROVAL_ENDPOINT_FILE as A, CursorApprovalBridge as C, approvalRegistryDir as a, normalizeCursorTool as n };

package/dist/cursorApprovalServer-xwxVGL3u.cjs

@@ -0,0 +1,268 @@
+'use strict';
+
+var node_http = require('node:http');
+var node_crypto = require('node:crypto');
+var promises = require('node:fs/promises');
+var fs = require('node:fs');
+var path = require('node:path');
+var os = require('node:os');
+var logger = require('./persistence-D7zNFI-d.cjs');
+
+const TOOL_NAME_MAP = {
+  read: "Read",
+  write: "Write",
+  edit: "Edit",
+  grep: "Grep",
+  glob: "Glob",
+  ls: "LS",
+  list: "LS",
+  // Cursor calls it Shell; the app's card for running commands is Bash.
+  shell: "Bash",
+  terminal: "Bash",
+  task: "Task",
+  todowrite: "TodoWrite",
+  websearch: "WebSearch",
+  webfetch: "WebFetch"
+};
+function normalizeCursorToolName(rawName) {
+  const mapped = TOOL_NAME_MAP[rawName.toLowerCase()];
+  if (mapped) return mapped;
+  return rawName.charAt(0).toUpperCase() + rawName.slice(1);
+}
+function normalizeCursorToolInput(input) {
+  const out = { ...input };
+  if (typeof out.path === "string" && out.file_path === void 0) {
+    out.file_path = out.path;
+  }
+  if (typeof out.file_path === "string" && out.path === void 0) {
+    out.path = out.file_path;
+  }
+  if (typeof out.workingDirectory === "string" && out.cwd === void 0) {
+    out.cwd = out.workingDirectory;
+  }
+  if (typeof out.streamContent === "string" && out.content === void 0) {
+    out.content = out.streamContent;
+  }
+  return out;
+}
+function normalizeCursorTool(rawName, rawInput) {
+  const input = rawInput && typeof rawInput === "object" ? rawInput : {};
+  return {
+    name: normalizeCursorToolName(rawName),
+    input: normalizeCursorToolInput(input)
+  };
+}
+
+function approvalRegistryDir() {
+  return path.join(os.homedir(), ".happy", "cursor-approvals");
+}
+const APPROVAL_ENDPOINT_FILE = ".happy-approval.json";
+const HOOKS_FILE = "hooks.json";
+const HOOKS_BACKUP_FILE = "hooks.json.happy-backup";
+const MCP_FILE = "mcp.json";
+const MCP_BACKUP_FILE = "mcp.json.happy-backup";
+const HOOK_TIMEOUT_SECONDS = 900;
+class CursorApprovalBridge {
+  cwd;
+  handler;
+  token = node_crypto.randomUUID();
+  server = null;
+  port = 0;
+  hadExistingHooks = false;
+  hadExistingMcp = false;
+  mcpBridge;
+  /** True when .cursor/ did not exist before this session created it. */
+  createdCursorDir = false;
+  started = false;
+  /** Chat ids this session has registered, so they can be cleaned up. */
+  registeredChatIds = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.handler = options.handler;
+    this.mcpBridge = options.mcpBridge ?? null;
+  }
+  get cursorDir() {
+    return path.join(this.cwd, ".cursor");
+  }
+  async start() {
+    await this.listen();
+    await this.installHooks();
+    this.started = true;
+    logger.logger.debug(`[cursor] approval bridge listening on 127.0.0.1:${this.port}`);
+  }
+  /**
+   * Claims a chat id for this session. Called as soon as cursor-agent reveals
+   * it, which is what lets the hook route an approval back to the session
+   * that actually made the call.
+   */
+  async registerChat(chatId) {
+    if (!this.started || this.registeredChatIds.has(chatId)) return;
+    const dir = approvalRegistryDir();
+    await promises.mkdir(dir, { recursive: true });
+    await promises.writeFile(path.join(dir, `${chatId}.json`), JSON.stringify({
+      port: this.port,
+      token: this.token,
+      pid: process.pid
+    }), "utf8");
+    this.registeredChatIds.add(chatId);
+    logger.logger.debug(`[cursor] chat ${chatId} routed to this session's bridge`);
+  }
+  listen() {
+    return new Promise((resolve, reject) => {
+      const server = node_http.createServer((req, res) => {
+        if (req.method !== "POST" || !req.url?.startsWith("/approve")) {
+          res.writeHead(404).end();
+          return;
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk;
+        });
+        req.on("end", () => {
+          void this.decide(body).then((approved) => {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ approved }));
+          }).catch((error) => {
+            logger.logger.debug(`[cursor] approval failed: ${error}`);
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ approved: false }));
+          });
+        });
+      });
+      server.listen(0, "127.0.0.1", () => {
+        const address = server.address();
+        if (address === null || typeof address === "string") {
+          reject(new Error("Failed to determine approval server port"));
+          return;
+        }
+        this.port = address.port;
+        this.server = server;
+        resolve();
+      });
+      server.on("error", reject);
+    });
+  }
+  async decide(rawBody) {
+    let parsed;
+    try {
+      parsed = JSON.parse(rawBody);
+    } catch {
+      return false;
+    }
+    if (parsed.token !== this.token) {
+      logger.logger.debug("[cursor] rejecting approval request with a bad token");
+      return false;
+    }
+    const { name: toolName, input: toolInput } = normalizeCursorTool(
+      typeof parsed.tool_name === "string" && parsed.tool_name.length > 0 ? parsed.tool_name : "unknown",
+      parsed.tool_input
+    );
+    const toolCallId = typeof parsed.tool_use_id === "string" && parsed.tool_use_id.length > 0 ? parsed.tool_use_id : `cursor-${node_crypto.randomUUID()}`;
+    return this.handler.requestApproval(toolCallId, toolName, toolInput);
+  }
+  /**
+   * Writes .cursor/hooks.json pointing at this CLI. Any file already there is
+   * moved aside and restored on stop, so a project with its own hooks is not
+   * quietly clobbered.
+   */
+  async installHooks() {
+    this.createdCursorDir = !fs.existsSync(this.cursorDir);
+    await promises.mkdir(this.cursorDir, { recursive: true });
+    const hooksPath = path.join(this.cursorDir, HOOKS_FILE);
+    if (fs.existsSync(hooksPath)) {
+      await promises.rename(hooksPath, path.join(this.cursorDir, HOOKS_BACKUP_FILE));
+      this.hadExistingHooks = true;
+      logger.logger.debug("[cursor] existing hooks.json moved aside for the session");
+    }
+    const hookCommand = `${process.execPath} ${process.argv[1]} cursor-approval-hook`;
+    await promises.writeFile(hooksPath, JSON.stringify({
+      version: 1,
+      hooks: {
+        // preToolUse covers every tool, including Read, Write and Shell.
+        // It only understands allow/deny — never "ask" — and failClosed
+        // has to be explicit because hooks fail open by default.
+        preToolUse: [
+          { type: "command", command: hookCommand, timeout: HOOK_TIMEOUT_SECONDS, failClosed: true }
+        ]
+      }
+    }, null, 2), "utf8");
+    await this.installMcpConfig();
+    await this.excludeFromGit();
+  }
+  /** Points Cursor at Happy's tools (change_title, preview_html, devices…). */
+  async installMcpConfig() {
+    if (!this.mcpBridge) return;
+    const mcpPath = path.join(this.cursorDir, MCP_FILE);
+    if (fs.existsSync(mcpPath)) {
+      await promises.rename(mcpPath, path.join(this.cursorDir, MCP_BACKUP_FILE));
+      this.hadExistingMcp = true;
+      logger.logger.debug("[cursor] existing mcp.json moved aside for the session");
+    }
+    await promises.writeFile(mcpPath, JSON.stringify({
+      mcpServers: {
+        happy: { command: this.mcpBridge.command, args: this.mcpBridge.args }
+      }
+    }, null, 2), "utf8");
+  }
+  /** Keep the session's scaffolding out of `git status`. */
+  async excludeFromGit() {
+    const excludePath = path.join(this.cwd, ".git", "info", "exclude");
+    if (!fs.existsSync(excludePath)) return;
+    try {
+      const current = await promises.readFile(excludePath, "utf8");
+      if (current.includes(".cursor/.happy-approval.json")) return;
+      await promises.writeFile(
+        excludePath,
+        `${current}${current.endsWith("\n") ? "" : "\n"}# added by happy cursor session
+.cursor/hooks.json
+.cursor/mcp.json
+.cursor/.happy-approval.json
+`,
+        "utf8"
+      );
+    } catch (error) {
+      logger.logger.debug(`[cursor] could not update .git/info/exclude: ${error}`);
+    }
+  }
+  async stop() {
+    if (!this.started) return;
+    this.started = false;
+    try {
+      for (const chatId of this.registeredChatIds) {
+        await promises.rm(path.join(approvalRegistryDir(), `${chatId}.json`), { force: true });
+      }
+      this.registeredChatIds.clear();
+      await promises.rm(path.join(this.cursorDir, APPROVAL_ENDPOINT_FILE), { force: true });
+      const hooksPath = path.join(this.cursorDir, HOOKS_FILE);
+      const backupPath = path.join(this.cursorDir, HOOKS_BACKUP_FILE);
+      if (this.hadExistingHooks && fs.existsSync(backupPath)) {
+        await promises.rename(backupPath, hooksPath);
+      } else {
+        await promises.rm(hooksPath, { force: true });
+      }
+      const mcpPath = path.join(this.cursorDir, MCP_FILE);
+      const mcpBackup = path.join(this.cursorDir, MCP_BACKUP_FILE);
+      if (this.hadExistingMcp && fs.existsSync(mcpBackup)) {
+        await promises.rename(mcpBackup, mcpPath);
+      } else if (this.mcpBridge) {
+        await promises.rm(mcpPath, { force: true });
+      }
+      if (this.createdCursorDir && (await promises.readdir(this.cursorDir)).length === 0) {
+        await promises.rmdir(this.cursorDir);
+      }
+    } catch (error) {
+      logger.logger.debug(`[cursor] cleanup of .cursor/ failed: ${error}`);
+    }
+    await new Promise((resolve) => {
+      if (!this.server) return resolve();
+      this.server.close(() => resolve());
+      this.server = null;
+    });
+    logger.logger.debug("[cursor] approval bridge stopped");
+  }
+}
+
+exports.APPROVAL_ENDPOINT_FILE = APPROVAL_ENDPOINT_FILE;
+exports.CursorApprovalBridge = CursorApprovalBridge;
+exports.approvalRegistryDir = approvalRegistryDir;
+exports.normalizeCursorTool = normalizeCursorTool;

package/dist/{deviceKeys-CejCdWpw.mjs → deviceKeys-CQyFFPtt.mjs}

@@ -1,6 +1,6 @@
 import axios from 'axios';
-import { h as decodeBase64, e as encodeBase64, f as encrypt, g as decrypt, c as configuration } from './persistence-CIUFyOwz.mjs';
-import { decryptWithEphemeralKey } from './auth-DS8fzlin.mjs';
+import { h as decodeBase64, e as encodeBase64, f as encrypt, g as decrypt, c as configuration } from './persistence-DbLMvLvk.mjs';
+import { decryptWithEphemeralKey } from './auth-qM2eojWx.mjs';
 import tweetnacl from 'tweetnacl';
 import { existsSync } from 'node:fs';
 import { writeFile, mkdir, readFile } from 'node:fs/promises';

package/dist/{deviceKeys-BpIAWz13.cjs → deviceKeys-CdW-HPnz.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 var axios = require('axios');
-var logger = require('./persistence-DrfN7TzY.cjs');
-var auth = require('./auth-BQvEuSs5.cjs');
+var logger = require('./persistence-D7zNFI-d.cjs');
+var auth = require('./auth-BqGkUXvq.cjs');
 var tweetnacl = require('tweetnacl');
 var fs = require('node:fs');
 var promises = require('node:fs/promises');

package/dist/{doctor-DznasgP3.cjs → doctor-D4xWXiE7.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
 var chalk = require('chalk');
-var logger = require('./persistence-DrfN7TzY.cjs');
-var controlClient = require('./controlClient-DgELDZgM.cjs');
+var logger = require('./persistence-D7zNFI-d.cjs');
+var controlClient = require('./controlClient-yTkpwcOq.cjs');
 var doctor = require('./doctor-C08m5Z9f.cjs');
 var fs = require('node:fs');
 var path = require('node:path');

package/dist/{doctor-B-LCMVN9.mjs → doctor-DDT2TXHH.mjs}

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
-import { p as packageJson, c as configuration, a as readSettings, r as readCredentials, m as readDaemonState } from './persistence-CIUFyOwz.mjs';
-import { checkIfDaemonRunningAndCleanupStaleState } from './controlClient-DgjVRN8D.mjs';
+import { p as packageJson, c as configuration, a as readSettings, r as readCredentials, m as readDaemonState } from './persistence-DbLMvLvk.mjs';
+import { checkIfDaemonRunningAndCleanupStaleState } from './controlClient-BzzTNSfl.mjs';
 import { findAllHappyProcesses } from './doctor-ON7pN5G5.mjs';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';