happy-coder 0.10.0-0 → 0.10.0-2

package/dist/index.mjs

@@ -1,27 +1,25 @@
 import chalk from 'chalk';
 import os$1, { homedir } from 'node:os';
 import { randomUUID, randomBytes } from 'node:crypto';
-import { l as logger, b as backoff, d as delay, R as RawJSONLinesSchema, e as AsyncLock, r as readDaemonState, f as clearDaemonState, p as packageJson, c as configuration, g as readSettings, h as readCredentials, i as encodeBase64, u as updateSettings, j as encodeBase64Url, k as decodeBase64, w as writeCredentials, m as acquireDaemonLock, n as writeDaemonState, A as ApiClient, o as releaseDaemonLock, q as clearCredentials, s as clearMachineId, t as getLatestDaemonLog } from './types-CGbH1LGX.mjs';
+import { l as logger, p as projectPath, b as backoff, d as delay, R as RawJSONLinesSchema, e as AsyncLock, r as readDaemonState, f as clearDaemonState, g as packageJson, c as configuration, h as readSettings, i as readCredentials, j as encodeBase64, u as updateSettings, k as encodeBase64Url, m as decodeBase64, w as writeCredentials, n as acquireDaemonLock, o as writeDaemonState, A as ApiClient, q as releaseDaemonLock, s as clearCredentials, t as clearMachineId, v as getLatestDaemonLog } from './types-xfXKJHdM.mjs';
 import { spawn, execSync, execFileSync } from 'node:child_process';
 import { resolve, join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { existsSync, readFileSync, mkdirSync, watch, readdirSync, statSync, rmSync } from 'node:fs';
-import { dirname, resolve as resolve$1, join as join$1 } from 'path';
-import { fileURLToPath } from 'url';
 import { readFile } from 'node:fs/promises';
-import fs, { watch as watch$1, access, readFile as readFile$1, stat, writeFile, readdir } from 'fs/promises';
+import fs, { watch as watch$1, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
-import { fileURLToPath as fileURLToPath$1 } from 'node:url';
+import { fileURLToPath } from 'node:url';
 import axios from 'axios';
 import 'node:events';
 import 'socket.io-client';
 import tweetnacl from 'tweetnacl';
 import 'expo-server-sdk';
-import { spawn as spawn$1, exec, execSync as execSync$1 } from 'child_process';
-import { promisify } from 'util';
 import { createHash, randomBytes as randomBytes$1 } from 'crypto';
+import { spawn as spawn$1, execSync as execSync$1, exec } from 'child_process';
 import { readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSync, chmodSync, unlinkSync } from 'fs';
+import { join as join$1 } from 'path';
 import psList from 'ps-list';
 import spawn$2 from 'cross-spawn';
 import os from 'os';
@@ -34,6 +32,8 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { createServer as createServer$1 } from 'http';
+import { promisify } from 'util';
+import 'url';
 
 class Session {
   path;
@@ -145,12 +145,6 @@ function claudeCheckSession(sessionId, path) {
   return hasGoodMessage;
 }
 
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-function projectPath() {
-  const path = resolve$1(__dirname$1, "..");
-  return path;
-}
-
 function trimIdent(text) {
   const lines = text.split("\n");
   while (lines.length > 0 && lines[0].trim() === "") {
@@ -611,8 +605,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();
     });
@@ -658,9 +652,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();
@@ -927,7 +921,7 @@ class AbortError extends Error {
   }
 }
 
-const __filename = fileURLToPath$1(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
 const __dirname = join(__filename, "..");
 function getDefaultClaudeCodePath() {
   return join(__dirname, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
@@ -1922,7 +1916,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) => {
       logger.debug(`Permission response: ${JSON.stringify(message)}`);
       const id = message.id;
       const pending = this.pendingRequests.get(id);
@@ -2492,8 +2486,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)
@@ -2809,255 +2803,6 @@ async function loop(opts) {
   }
 }
 
-function run(args, options) {
-  const RUNNER_PATH = resolve$1(join$1(projectPath(), "scripts", "ripgrep_launcher.cjs"));
-  return new Promise((resolve2, reject) => {
-    const child = spawn$1("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 = promisify(exec);
-function registerHandlers(session) {
-  session.setHandler("bash", async (data) => {
-    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) => {
-    logger.debug("Read file request:", data.path);
-    try {
-      const buffer = await readFile$1(data.path);
-      const content = buffer.toString("base64");
-      return { success: true, content };
-    } catch (error) {
-      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) => {
-    logger.debug("Write file request:", data.path);
-    try {
-      if (data.expectedHash !== null && data.expectedHash !== void 0) {
-        try {
-          const existingBuffer = await readFile$1(data.path);
-          const existingHash = 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 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 writeFile(data.path, buffer);
-      const hash = createHash("sha256").update(buffer).digest("hex");
-      return { success: true, hash };
-    } catch (error) {
-      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) => {
-    logger.debug("List directory request:", data.path);
-    try {
-      const entries = await readdir(data.path, { withFileTypes: true });
-      const directoryEntries = await Promise.all(
-        entries.map(async (entry) => {
-          const fullPath = join$1(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 stat(fullPath);
-            size = stats.size;
-            modified = stats.mtime.getTime();
-          } catch (error) {
-            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) {
-      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) => {
-    logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
-    async function buildTree(path, name, currentDepth) {
-      try {
-        const stats = await stat(path);
-        const node = {
-          name,
-          path,
-          type: stats.isDirectory() ? "directory" : "file",
-          size: stats.size,
-          modified: stats.mtime.getTime()
-        };
-        if (stats.isDirectory() && currentDepth < data.maxDepth) {
-          const entries = await readdir(path, { withFileTypes: true });
-          const children = [];
-          await Promise.all(
-            entries.map(async (entry) => {
-              if (entry.isSymbolicLink()) {
-                logger.debug(`Skipping symlink: ${join$1(path, entry.name)}`);
-                return;
-              }
-              const childPath = join$1(path, 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) {
-        logger.debug(`Failed to process ${path}:`, 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) {
-      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) => {
-    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) {
-      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 () => {
-    logger.debug("Kill session request received");
-    void killThisHappy();
-    return {
-      success: true,
-      message: "Killing happy-cli process"
-    };
-  });
-}
-
 class MessageQueue2 {
   queue = [];
   // Made public for testing
@@ -4621,7 +4366,7 @@ async function startDaemon() {
       startedAt: Date.now()
     };
     const api = new ApiClient(credentials.token, credentials.secret);
-    const machine = await api.createMachineOrGetExistingAsIs({
+    const machine = await api.getOrCreateMachine({
       machineId,
       metadata: initialMachineMetadata,
       daemonState: initialDaemonState
@@ -4803,6 +4548,17 @@ async function startHappyServer(client) {
   };
 }
 
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    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 = randomUUID();
@@ -4821,7 +4577,7 @@ async function start(credentials, options = {}) {
     process.exit(1);
   }
   logger.debug(`Using machineId: ${machineId}`);
-  await api.createMachineOrGetExistingAsIs({
+  await api.getOrCreateMachine({
     machineId,
     metadata: initialMachineMetadata
   });
@@ -4889,7 +4645,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;
@@ -5036,7 +4791,7 @@ async function start(credentials, options = {}) {
     logger.debug("[START] Unhandled rejection:", reason);
     cleanup();
   });
-  registerKillSessionHandler(session, cleanup);
+  registerKillSessionHandler(session.rpcHandlerManager, cleanup);
   await loop({
     path: workingDirectory,
     model: options.model,

package/dist/lib.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var types = require('./types-fU2E-jQl.cjs');
+var types = require('./types-WP9wteZE.cjs');
 require('axios');
 require('chalk');
 require('fs');
@@ -13,6 +13,12 @@ require('node:crypto');
 require('tweetnacl');
 require('node:events');
 require('socket.io-client');
+require('child_process');
+require('util');
+require('fs/promises');
+require('crypto');
+require('path');
+require('url');
 require('expo-server-sdk');
 
 

package/dist/lib.d.cts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { EventEmitter } from 'node:events';
+import { Socket } from 'socket.io-client';
 import { ExpoPushMessage } from 'expo-server-sdk';
 
 /**
@@ -287,7 +288,80 @@ declare const RawJSONLinesSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
 }, z.ZodTypeAny, "passthrough">>]>;
 type RawJSONLines = z.infer<typeof RawJSONLinesSchema>;
 
-type RpcHandler<T = any, R = any> = (data: T) => R | Promise<R>;
+/**
+ * Common RPC types and interfaces for both session and machine clients
+ */
+/**
+ * Generic RPC handler function type
+ * @template TRequest - The request data type
+ * @template TResponse - The response data type
+ */
+type RpcHandler<TRequest = any, TResponse = any> = (data: TRequest) => TResponse | Promise<TResponse>;
+/**
+ * RPC request data from server
+ */
+interface RpcRequest {
+    method: string;
+    params: string;
+}
+/**
+ * Configuration for RPC handler manager
+ */
+interface RpcHandlerConfig {
+    /** Prefix to add to all method names (e.g., sessionId or machineId) */
+    scopePrefix: string;
+    /** Secret key for encryption/decryption */
+    secret: Uint8Array;
+    /** Logger function for debugging */
+    logger?: (message: string, data?: any) => void;
+}
+
+/**
+ * Generic RPC handler manager for session and machine clients
+ * Manages RPC method registration, encryption/decryption, and handler execution
+ */
+
+declare class RpcHandlerManager {
+    private handlers;
+    private readonly scopePrefix;
+    private readonly secret;
+    private readonly logger;
+    private socket;
+    constructor(config: RpcHandlerConfig);
+    /**
+     * Register an RPC handler for a specific method
+     * @param method - The method name (without prefix)
+     * @param handler - The handler function
+     */
+    registerHandler<TRequest = any, TResponse = any>(method: string, handler: RpcHandler<TRequest, TResponse>): void;
+    /**
+     * Handle an incoming RPC request
+     * @param request - The RPC request data
+     * @param callback - The response callback
+     */
+    handleRequest(request: RpcRequest): Promise<any>;
+    onSocketConnect(socket: Socket): void;
+    onSocketDisconnect(): void;
+    /**
+     * Get the number of registered handlers
+     */
+    getHandlerCount(): number;
+    /**
+     * Check if a handler is registered
+     * @param method - The method name (without prefix)
+     */
+    hasHandler(method: string): boolean;
+    /**
+     * Clear all handlers
+     */
+    clearHandlers(): void;
+    /**
+     * Get the prefixed method name
+     * @param method - The method name
+     */
+    private getPrefixedMethod;
+}
+
 declare class ApiSessionClient extends EventEmitter {
     private readonly token;
     private readonly secret;
@@ -299,7 +373,7 @@ declare class ApiSessionClient extends EventEmitter {
     private socket;
     private pendingMessages;
     private pendingMessageCallback;
-    private rpcHandlers;
+    readonly rpcHandlerManager: RpcHandlerManager;
     private agentStateLock;
     private metadataLock;
     constructor(token: string, secret: Uint8Array, session: Session);
@@ -343,16 +417,6 @@ declare class ApiSessionClient extends EventEmitter {
      * @param handler - Handler function that returns the updated agent state
      */
     updateAgentState(handler: (metadata: AgentState) => AgentState): void;
-    /**
-     * Set a custom RPC handler for a specific method with encrypted arguments and responses
-     * @param method - The method name to handle
-     * @param handler - The handler function to call when the method is invoked
-     */
-    setHandler<T = any, R = any>(method: string, handler: RpcHandler<T, R>): void;
-    /**
-     * Re-register all RPC handlers after reconnection
-     */
-    private reregisterHandlers;
     /**
      * Wait for socket buffer to flush
      */
@@ -642,11 +706,6 @@ type AgentState = {
     };
 };
 
-/**
- * RPC handlers for API session communication
- * Handles remote procedure calls from mobile clients
- */
-
 interface SpawnSessionOptions {
     machineId?: string;
     directory: string;
@@ -680,9 +739,7 @@ declare class ApiMachineClient {
     private machine;
     private socket;
     private keepAliveInterval;
-    private spawnSession?;
-    private stopSession?;
-    private requestShutdown?;
+    private rpcHandlerManager;
     constructor(token: string, secret: Uint8Array, machine: Machine);
     setRPCHandlers({ spawnSession, stopSession, requestShutdown }: MachineRpcHandlers): void;
     /**
@@ -753,7 +810,7 @@ declare class ApiClient {
      * Register or update machine with the server
      * Returns the current machine state from the server with decrypted metadata and daemonState
      */
-    createMachineOrGetExistingAsIs(opts: {
+    getOrCreateMachine(opts: {
         machineId: string;
         metadata: MachineMetadata;
         daemonState?: DaemonState;