happy-coder 0.10.0-0 → 0.10.0-2

package/dist/index.cjs

@@ -3,13 +3,11 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var types = require('./types-fU2E-jQl.cjs');
+var types = require('./types-WP9wteZE.cjs');
 var node_child_process = require('node:child_process');
 var node_path = require('node:path');
 var node_readline = require('node:readline');
 var node_fs = require('node:fs');
-var path = require('path');
-var url = require('url');
 var promises = require('node:fs/promises');
 var fs = require('fs/promises');
 var ink = require('ink');
@@ -20,10 +18,10 @@ require('node:events');
 require('socket.io-client');
 var tweetnacl = require('tweetnacl');
 require('expo-server-sdk');
-var child_process = require('child_process');
-var util = require('util');
 var crypto = require('crypto');
+var child_process = require('child_process');
 var fs$1 = require('fs');
+var path = require('path');
 var psList = require('ps-list');
 var spawn = require('cross-spawn');
 var os$1 = require('os');
@@ -36,6 +34,8 @@ 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 http = require('http');
+var util = require('util');
+require('url');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 class Session {
@@ -148,12 +148,6 @@ function claudeCheckSession(sessionId, path) {
   return hasGoodMessage;
 }
 
-const __dirname$2 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
-function projectPath() {
-  const path$1 = path.resolve(__dirname$2, "..");
-  return path$1;
-}
-
 function trimIdent(text) {
   const lines = text.split("\n");
   while (lines.length > 0 && lines[0].trim() === "") {
@@ -187,7 +181,7 @@ const systemPrompt = trimIdent(`
     Co-Authored-By: Happy <yesreply@happy.engineering>
 `);
 
-const claudeCliPath = node_path.resolve(node_path.join(projectPath(), "scripts", "claude_local_launcher.cjs"));
+const claudeCliPath = node_path.resolve(node_path.join(types.projectPath(), "scripts", "claude_local_launcher.cjs"));
 async function claudeLocal(opts) {
   const projectDir = getProjectPath(opts.path);
   node_fs.mkdirSync(projectDir, { recursive: true });
@@ -614,8 +608,8 @@ async function claudeLocalLauncher(session) {
       }
       await abort();
     }
-    session.client.setHandler("abort", doAbort);
-    session.client.setHandler("switch", doSwitch);
+    session.client.rpcHandlerManager.registerHandler("abort", doAbort);
+    session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
     session.queue.setOnMessage((message, mode) => {
       doSwitch();
     });
@@ -661,9 +655,9 @@ async function claudeLocalLauncher(session) {
     }
   } finally {
     exutFuture.resolve(void 0);
-    session.client.setHandler("abort", async () => {
+    session.client.rpcHandlerManager.registerHandler("abort", async () => {
     });
-    session.client.setHandler("switch", async () => {
+    session.client.rpcHandlerManager.registerHandler("switch", async () => {
     });
     session.queue.setOnMessage(null);
     await scanner.cleanup();
@@ -1510,7 +1504,7 @@ async function claudeRemote(opts) {
     executable: "node",
     abort: opts.signal,
     pathToClaudeCodeExecutable: (() => {
-      return node_path.resolve(node_path.join(projectPath(), "scripts", "claude_remote_launcher.cjs"));
+      return node_path.resolve(node_path.join(types.projectPath(), "scripts", "claude_remote_launcher.cjs"));
     })()
   };
   let thinking = false;
@@ -1925,7 +1919,7 @@ class PermissionHandler {
    * Sets up the client handler for permission responses
    */
   setupClientHandler() {
-    this.session.client.setHandler("permission", async (message) => {
+    this.session.client.rpcHandlerManager.registerHandler("permission", async (message) => {
       types.logger.debug(`Permission response: ${JSON.stringify(message)}`);
       const id = message.id;
       const pending = this.pendingRequests.get(id);
@@ -2495,8 +2489,8 @@ async function claudeRemoteLauncher(session) {
     }
     await abort();
   }
-  session.client.setHandler("abort", doAbort);
-  session.client.setHandler("switch", doSwitch);
+  session.client.rpcHandlerManager.registerHandler("abort", doAbort);
+  session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
   const permissionHandler = new PermissionHandler(session);
   const messageQueue = new OutgoingMessageQueue(
     (logMessage) => session.client.sendClaudeSessionMessage(logMessage)
@@ -2812,255 +2806,6 @@ async function loop(opts) {
   }
 }
 
-function run(args, options) {
-  const RUNNER_PATH = path.resolve(path.join(projectPath(), "scripts", "ripgrep_launcher.cjs"));
-  return new Promise((resolve2, reject) => {
-    const child = child_process.spawn("node", [RUNNER_PATH, JSON.stringify(args)], {
-      stdio: ["pipe", "pipe", "pipe"],
-      cwd: options?.cwd
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    child.on("close", (code) => {
-      resolve2({
-        exitCode: code || 0,
-        stdout,
-        stderr
-      });
-    });
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-
-const execAsync$1 = util.promisify(child_process.exec);
-function registerHandlers(session) {
-  session.setHandler("bash", async (data) => {
-    types.logger.debug("Shell command request:", data.command);
-    try {
-      const options = {
-        cwd: data.cwd,
-        timeout: data.timeout || 3e4
-        // Default 30 seconds timeout
-      };
-      const { stdout, stderr } = await execAsync$1(data.command, options);
-      return {
-        success: true,
-        stdout: stdout ? stdout.toString() : "",
-        stderr: stderr ? stderr.toString() : "",
-        exitCode: 0
-      };
-    } catch (error) {
-      const execError = error;
-      if (execError.code === "ETIMEDOUT" || execError.killed) {
-        return {
-          success: false,
-          stdout: execError.stdout || "",
-          stderr: execError.stderr || "",
-          exitCode: typeof execError.code === "number" ? execError.code : -1,
-          error: "Command timed out"
-        };
-      }
-      return {
-        success: false,
-        stdout: execError.stdout ? execError.stdout.toString() : "",
-        stderr: execError.stderr ? execError.stderr.toString() : execError.message || "Command failed",
-        exitCode: typeof execError.code === "number" ? execError.code : 1,
-        error: execError.message || "Command failed"
-      };
-    }
-  });
-  session.setHandler("readFile", async (data) => {
-    types.logger.debug("Read file request:", data.path);
-    try {
-      const buffer = await fs.readFile(data.path);
-      const content = buffer.toString("base64");
-      return { success: true, content };
-    } catch (error) {
-      types.logger.debug("Failed to read file:", error);
-      return { success: false, error: error instanceof Error ? error.message : "Failed to read file" };
-    }
-  });
-  session.setHandler("writeFile", async (data) => {
-    types.logger.debug("Write file request:", data.path);
-    try {
-      if (data.expectedHash !== null && data.expectedHash !== void 0) {
-        try {
-          const existingBuffer = await fs.readFile(data.path);
-          const existingHash = crypto.createHash("sha256").update(existingBuffer).digest("hex");
-          if (existingHash !== data.expectedHash) {
-            return {
-              success: false,
-              error: `File hash mismatch. Expected: ${data.expectedHash}, Actual: ${existingHash}`
-            };
-          }
-        } catch (error) {
-          const nodeError = error;
-          if (nodeError.code !== "ENOENT") {
-            throw error;
-          }
-          return {
-            success: false,
-            error: "File does not exist but hash was provided"
-          };
-        }
-      } else {
-        try {
-          await fs.stat(data.path);
-          return {
-            success: false,
-            error: "File already exists but was expected to be new"
-          };
-        } catch (error) {
-          const nodeError = error;
-          if (nodeError.code !== "ENOENT") {
-            throw error;
-          }
-        }
-      }
-      const buffer = Buffer.from(data.content, "base64");
-      await fs.writeFile(data.path, buffer);
-      const hash = crypto.createHash("sha256").update(buffer).digest("hex");
-      return { success: true, hash };
-    } catch (error) {
-      types.logger.debug("Failed to write file:", error);
-      return { success: false, error: error instanceof Error ? error.message : "Failed to write file" };
-    }
-  });
-  session.setHandler("listDirectory", async (data) => {
-    types.logger.debug("List directory request:", data.path);
-    try {
-      const entries = await fs.readdir(data.path, { withFileTypes: true });
-      const directoryEntries = await Promise.all(
-        entries.map(async (entry) => {
-          const fullPath = path.join(data.path, entry.name);
-          let type = "other";
-          let size;
-          let modified;
-          if (entry.isDirectory()) {
-            type = "directory";
-          } else if (entry.isFile()) {
-            type = "file";
-          }
-          try {
-            const stats = await fs.stat(fullPath);
-            size = stats.size;
-            modified = stats.mtime.getTime();
-          } catch (error) {
-            types.logger.debug(`Failed to stat ${fullPath}:`, error);
-          }
-          return {
-            name: entry.name,
-            type,
-            size,
-            modified
-          };
-        })
-      );
-      directoryEntries.sort((a, b) => {
-        if (a.type === "directory" && b.type !== "directory") return -1;
-        if (a.type !== "directory" && b.type === "directory") return 1;
-        return a.name.localeCompare(b.name);
-      });
-      return { success: true, entries: directoryEntries };
-    } catch (error) {
-      types.logger.debug("Failed to list directory:", error);
-      return { success: false, error: error instanceof Error ? error.message : "Failed to list directory" };
-    }
-  });
-  session.setHandler("getDirectoryTree", async (data) => {
-    types.logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
-    async function buildTree(path$1, name, currentDepth) {
-      try {
-        const stats = await fs.stat(path$1);
-        const node = {
-          name,
-          path: path$1,
-          type: stats.isDirectory() ? "directory" : "file",
-          size: stats.size,
-          modified: stats.mtime.getTime()
-        };
-        if (stats.isDirectory() && currentDepth < data.maxDepth) {
-          const entries = await fs.readdir(path$1, { withFileTypes: true });
-          const children = [];
-          await Promise.all(
-            entries.map(async (entry) => {
-              if (entry.isSymbolicLink()) {
-                types.logger.debug(`Skipping symlink: ${path.join(path$1, entry.name)}`);
-                return;
-              }
-              const childPath = path.join(path$1, entry.name);
-              const childNode = await buildTree(childPath, entry.name, currentDepth + 1);
-              if (childNode) {
-                children.push(childNode);
-              }
-            })
-          );
-          children.sort((a, b) => {
-            if (a.type === "directory" && b.type !== "directory") return -1;
-            if (a.type !== "directory" && b.type === "directory") return 1;
-            return a.name.localeCompare(b.name);
-          });
-          node.children = children;
-        }
-        return node;
-      } catch (error) {
-        types.logger.debug(`Failed to process ${path$1}:`, error instanceof Error ? error.message : String(error));
-        return null;
-      }
-    }
-    try {
-      if (data.maxDepth < 0) {
-        return { success: false, error: "maxDepth must be non-negative" };
-      }
-      const baseName = data.path === "/" ? "/" : data.path.split("/").pop() || data.path;
-      const tree = await buildTree(data.path, baseName, 0);
-      if (!tree) {
-        return { success: false, error: "Failed to access the specified path" };
-      }
-      return { success: true, tree };
-    } catch (error) {
-      types.logger.debug("Failed to get directory tree:", error);
-      return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
-    }
-  });
-  session.setHandler("ripgrep", async (data) => {
-    types.logger.debug("Ripgrep request with args:", data.args, "cwd:", data.cwd);
-    try {
-      const result = await run(data.args, { cwd: data.cwd });
-      return {
-        success: true,
-        exitCode: result.exitCode,
-        stdout: result.stdout.toString(),
-        stderr: result.stderr.toString()
-      };
-    } catch (error) {
-      types.logger.debug("Failed to run ripgrep:", error);
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to run ripgrep"
-      };
-    }
-  });
-}
-function registerKillSessionHandler(session, killThisHappy) {
-  session.setHandler("killSession", async () => {
-    types.logger.debug("Kill session request received");
-    void killThisHappy();
-    return {
-      success: true,
-      message: "Killing happy-cli process"
-    };
-  });
-}
-
 class MessageQueue2 {
   queue = [];
   // Made public for testing
@@ -3607,7 +3352,7 @@ async function isDaemonRunningCurrentlyInstalledHappyVersion() {
     return false;
   }
   try {
-    const packageJsonPath = path.join(projectPath(), "package.json");
+    const packageJsonPath = path.join(types.projectPath(), "package.json");
     const packageJson = JSON.parse(fs$1.readFileSync(packageJsonPath, "utf-8"));
     const currentCliVersion = packageJson.version;
     types.logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
@@ -3784,7 +3529,7 @@ async function runDoctorCommand(filter) {
     console.log(`Node.js Version: ${chalk.green(process.version)}`);
     console.log("");
     console.log(chalk.bold("\u{1F527} Daemon Spawn Diagnostics"));
-    const projectRoot = projectPath();
+    const projectRoot = types.projectPath();
     const wrapperPath = node_path.join(projectRoot, "bin", "happy.mjs");
     const cliEntrypoint = node_path.join(projectRoot, "dist", "index.mjs");
     console.log(`Project Root: ${chalk.blue(projectRoot)}`);
@@ -4157,7 +3902,7 @@ async function authAndSetupMachineIfNeeded() {
 }
 
 function spawnHappyCLI(args, options = {}) {
-  const projectRoot = projectPath();
+  const projectRoot = types.projectPath();
   const entrypoint = node_path.join(projectRoot, "dist", "index.mjs");
   let directory;
   if ("cwd" in options) {
@@ -4624,7 +4369,7 @@ async function startDaemon() {
       startedAt: Date.now()
     };
     const api = new types.ApiClient(credentials.token, credentials.secret);
-    const machine = await api.createMachineOrGetExistingAsIs({
+    const machine = await api.getOrCreateMachine({
       machineId,
       metadata: initialMachineMetadata,
       daemonState: initialDaemonState
@@ -4655,7 +4400,7 @@ async function startDaemon() {
           pidToTrackedSession.delete(pid);
         }
       }
-      const projectVersion = JSON.parse(fs$1.readFileSync(path.join(projectPath(), "package.json"), "utf-8")).version;
+      const projectVersion = JSON.parse(fs$1.readFileSync(path.join(types.projectPath(), "package.json"), "utf-8")).version;
       if (projectVersion !== types.configuration.currentCliVersion) {
         types.logger.debug("[DAEMON RUN] Daemon is outdated, triggering self-restart with latest version, clearing heartbeat interval");
         clearInterval(restartOnStaleVersionAndHeartbeat);
@@ -4806,6 +4551,17 @@ async function startHappyServer(client) {
   };
 }
 
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    types.logger.debug("Kill session request received");
+    void killThisHappy();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
+  });
+}
+
 async function start(credentials, options = {}) {
   const workingDirectory = process.cwd();
   const sessionTag = node_crypto.randomUUID();
@@ -4824,7 +4580,7 @@ async function start(credentials, options = {}) {
     process.exit(1);
   }
   types.logger.debug(`Using machineId: ${machineId}`);
-  await api.createMachineOrGetExistingAsIs({
+  await api.getOrCreateMachine({
     machineId,
     metadata: initialMachineMetadata
   });
@@ -4892,7 +4648,6 @@ async function start(credentials, options = {}) {
     allowedTools: mode.allowedTools,
     disallowedTools: mode.disallowedTools
   }));
-  registerHandlers(session);
   let currentPermissionMode = options.permissionMode;
   let currentModel = options.model;
   let currentFallbackModel = void 0;
@@ -5039,7 +4794,7 @@ async function start(credentials, options = {}) {
     types.logger.debug("[START] Unhandled rejection:", reason);
     cleanup();
   });
-  registerKillSessionHandler(session, cleanup);
+  registerKillSessionHandler(session.rpcHandlerManager, cleanup);
   await loop({
     path: workingDirectory,
     model: options.model,