happy-coder 0.9.1 → 0.10.0-1

package/dist/{types-DNUk09Np.cjs → types-D9P2bndj.cjs}

@@ -12,8 +12,15 @@ var node_crypto = require('node:crypto');
 var tweetnacl = require('tweetnacl');
 var node_events = require('node:events');
 var socket_ioClient = require('socket.io-client');
+var child_process = require('child_process');
+var util = require('util');
+var fs$1 = require('fs/promises');
+var crypto = require('crypto');
+var path = require('path');
+var url = require('url');
 var expoServerSdk = require('expo-server-sdk');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
   if (e) {
@@ -34,7 +41,7 @@ function _interopNamespaceDefault(e) {
 var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
 var name = "happy-coder";
-var version = "0.9.1";
+var version = "0.10.0-1";
 var description = "Claude Code session sharing CLI";
 var author = "Kirill Dubovitskiy";
 var license = "MIT";
@@ -97,8 +104,11 @@ var dependencies = {
 	"@types/http-proxy": "^1.17.16",
 	"@types/qrcode-terminal": "^0.12.2",
 	"@types/react": "^19.1.9",
+	"@types/ps-list": "^6.2.1",
+	"@types/cross-spawn": "^6.0.6",
 	axios: "^1.10.0",
 	chalk: "^5.4.1",
+	"cross-spawn": "^7.0.6",
 	"expo-server-sdk": "^3.15.0",
 	fastify: "^5.5.0",
 	"fastify-type-provider-zod": "4.0.2",
@@ -106,6 +116,7 @@ var dependencies = {
 	"http-proxy-middleware": "^3.0.5",
 	ink: "^6.1.0",
 	open: "^10.2.0",
+	"ps-list": "^8.1.1",
 	"qrcode-terminal": "^0.12.0",
 	react: "^19.1.1",
 	"socket.io-client": "^4.8.1",
@@ -852,6 +863,340 @@ class AsyncLock {
   }
 }
 
+class RpcHandlerManager {
+  handlers = /* @__PURE__ */ new Map();
+  scopePrefix;
+  secret;
+  logger;
+  socket = null;
+  constructor(config) {
+    this.scopePrefix = config.scopePrefix;
+    this.secret = config.secret;
+    this.logger = config.logger || ((msg, data) => logger.debug(msg, data));
+  }
+  /**
+   * Register an RPC handler for a specific method
+   * @param method - The method name (without prefix)
+   * @param handler - The handler function
+   */
+  registerHandler(method, handler) {
+    const prefixedMethod = this.getPrefixedMethod(method);
+    this.handlers.set(prefixedMethod, handler);
+    if (this.socket) {
+      this.socket.emit("rpc-register", { method: prefixedMethod });
+    }
+  }
+  /**
+   * Handle an incoming RPC request
+   * @param request - The RPC request data
+   * @param callback - The response callback
+   */
+  async handleRequest(request) {
+    try {
+      const handler = this.handlers.get(request.method);
+      if (!handler) {
+        this.logger("[RPC] [ERROR] Method not found", { method: request.method });
+        const errorResponse = { error: "Method not found" };
+        const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
+        return encryptedError;
+      }
+      const decryptedParams = decrypt(decodeBase64(request.params), this.secret);
+      const result = await handler(decryptedParams);
+      const encryptedResponse = encodeBase64(encrypt(result, this.secret));
+      return encryptedResponse;
+    } catch (error) {
+      this.logger("[RPC] [ERROR] Error handling request", { error });
+      const errorResponse = {
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+      const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
+      return encryptedError;
+    }
+  }
+  onSocketConnect(socket) {
+    this.socket = socket;
+    for (const [prefixedMethod] of this.handlers) {
+      socket.emit("rpc-register", { method: prefixedMethod });
+    }
+  }
+  onSocketDisconnect() {
+    this.socket = null;
+  }
+  /**
+   * Get the number of registered handlers
+   */
+  getHandlerCount() {
+    return this.handlers.size;
+  }
+  /**
+   * Check if a handler is registered
+   * @param method - The method name (without prefix)
+   */
+  hasHandler(method) {
+    const prefixedMethod = this.getPrefixedMethod(method);
+    return this.handlers.has(prefixedMethod);
+  }
+  /**
+   * Clear all handlers
+   */
+  clearHandlers() {
+    this.handlers.clear();
+    this.logger("Cleared all RPC handlers");
+  }
+  /**
+   * Get the prefixed method name
+   * @param method - The method name
+   */
+  getPrefixedMethod(method) {
+    return `${this.scopePrefix}:${method}`;
+  }
+}
+
+const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-D9P2bndj.cjs', document.baseURI).href))));
+function projectPath() {
+  const path$1 = path.resolve(__dirname$1, "..");
+  return path$1;
+}
+
+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 = util.promisify(child_process.exec);
+function registerCommonHandlers(rpcHandlerManager) {
+  rpcHandlerManager.registerHandler("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(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"
+      };
+    }
+  });
+  rpcHandlerManager.registerHandler("readFile", async (data) => {
+    logger.debug("Read file request:", data.path);
+    try {
+      const buffer = await fs$1.readFile(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" };
+    }
+  });
+  rpcHandlerManager.registerHandler("writeFile", async (data) => {
+    logger.debug("Write file request:", data.path);
+    try {
+      if (data.expectedHash !== null && data.expectedHash !== void 0) {
+        try {
+          const existingBuffer = await fs$1.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$1.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$1.writeFile(data.path, buffer);
+      const hash = crypto.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" };
+    }
+  });
+  rpcHandlerManager.registerHandler("listDirectory", async (data) => {
+    logger.debug("List directory request:", data.path);
+    try {
+      const entries = await fs$1.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$1.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" };
+    }
+  });
+  rpcHandlerManager.registerHandler("getDirectoryTree", async (data) => {
+    logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
+    async function buildTree(path$1, name, currentDepth) {
+      try {
+        const stats = await fs$1.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$1.readdir(path$1, { withFileTypes: true });
+          const children = [];
+          await Promise.all(
+            entries.map(async (entry) => {
+              if (entry.isSymbolicLink()) {
+                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) {
+        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) {
+      logger.debug("Failed to get directory tree:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
+    }
+  });
+  rpcHandlerManager.registerHandler("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"
+      };
+    }
+  });
+}
+
 class ApiSessionClient extends node_events.EventEmitter {
   token;
   secret;
@@ -863,7 +1208,7 @@ class ApiSessionClient extends node_events.EventEmitter {
   socket;
   pendingMessages = [];
   pendingMessageCallback = null;
-  rpcHandlers = /* @__PURE__ */ new Map();
+  rpcHandlerManager;
   agentStateLock = new AsyncLock();
   metadataLock = new AsyncLock();
   constructor(token, secret, session) {
@@ -875,6 +1220,12 @@ class ApiSessionClient extends node_events.EventEmitter {
     this.metadataVersion = session.metadataVersion;
     this.agentState = session.agentState;
     this.agentStateVersion = session.agentStateVersion;
+    this.rpcHandlerManager = new RpcHandlerManager({
+      scopePrefix: this.sessionId,
+      secret: this.secret,
+      logger: (msg, data) => logger.debug(msg, data)
+    });
+    registerCommonHandlers(this.rpcHandlerManager);
     this.socket = socket_ioClient.io(configuration.serverUrl, {
       auth: {
         token: this.token,
@@ -892,35 +1243,18 @@ class ApiSessionClient extends node_events.EventEmitter {
     });
     this.socket.on("connect", () => {
       logger.debug("Socket connected successfully");
-      this.reregisterHandlers();
+      this.rpcHandlerManager.onSocketConnect(this.socket);
     });
     this.socket.on("rpc-request", async (data, callback) => {
-      try {
-        const method = data.method;
-        const handler = this.rpcHandlers.get(method);
-        if (!handler) {
-          logger.debug("[SOCKET] [RPC] [ERROR] method not found", { method });
-          const errorResponse = { error: "Method not found" };
-          const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
-          callback(encryptedError);
-          return;
-        }
-        const decryptedParams = decrypt(decodeBase64(data.params), this.secret);
-        const result = await handler(decryptedParams);
-        const encryptedResponse = encodeBase64(encrypt(result, this.secret));
-        callback(encryptedResponse);
-      } catch (error) {
-        logger.debug("[SOCKET] [RPC] [ERROR] Error handling RPC request", { error });
-        const errorResponse = { error: error instanceof Error ? error.message : "Unknown error" };
-        const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
-        callback(encryptedError);
-      }
+      callback(await this.rpcHandlerManager.handleRequest(data));
     });
     this.socket.on("disconnect", (reason) => {
       logger.debug("[API] Socket disconnected:", reason);
+      this.rpcHandlerManager.onSocketDisconnect();
     });
     this.socket.on("connect_error", (error) => {
       logger.debug("[API] Socket connection error:", error);
+      this.rpcHandlerManager.onSocketDisconnect();
     });
     this.socket.on("update", (data) => {
       try {
@@ -1131,29 +1465,6 @@ class ApiSessionClient extends node_events.EventEmitter {
       });
     });
   }
-  /**
-   * 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(method, handler) {
-    const prefixedMethod = `${this.sessionId}:${method}`;
-    this.rpcHandlers.set(prefixedMethod, handler);
-    this.socket.emit("rpc-register", { method: prefixedMethod });
-    logger.debug("Registered RPC handler", { method, prefixedMethod });
-  }
-  /**
-   * Re-register all RPC handlers after reconnection
-   */
-  reregisterHandlers() {
-    logger.debug("Re-registering RPC handlers after reconnection", {
-      totalMethods: this.rpcHandlers.size
-    });
-    for (const [prefixedMethod] of this.rpcHandlers) {
-      this.socket.emit("rpc-register", { method: prefixedMethod });
-      logger.debug("Re-registered method", { prefixedMethod });
-    }
-  }
   /**
    * Wait for socket buffer to flush
    */
@@ -1180,21 +1491,58 @@ class ApiMachineClient {
     this.token = token;
     this.secret = secret;
     this.machine = machine;
+    this.rpcHandlerManager = new RpcHandlerManager({
+      scopePrefix: this.machine.id,
+      secret: this.secret,
+      logger: (msg, data) => logger.debug(msg, data)
+    });
+    registerCommonHandlers(this.rpcHandlerManager);
   }
   socket;
   keepAliveInterval = null;
-  // RPC handlers
-  spawnSession;
-  stopSession;
-  requestShutdown;
+  rpcHandlerManager;
   setRPCHandlers({
     spawnSession,
     stopSession,
     requestShutdown
   }) {
-    this.spawnSession = spawnSession;
-    this.stopSession = stopSession;
-    this.requestShutdown = requestShutdown;
+    this.rpcHandlerManager.registerHandler("spawn-happy-session", async (params) => {
+      const { directory, sessionId, machineId, approvedNewDirectoryCreation } = params || {};
+      if (!directory) {
+        throw new Error("Directory is required");
+      }
+      const result = await spawnSession({ directory, sessionId, machineId, approvedNewDirectoryCreation });
+      switch (result.type) {
+        case "success":
+          logger.debug(`[API MACHINE] Spawned session ${result.sessionId}`);
+          return { type: "success", sessionId: result.sessionId };
+        case "requestToApproveDirectoryCreation":
+          logger.debug(`[API MACHINE] Requesting directory creation approval for: ${result.directory}`);
+          return { type: "requestToApproveDirectoryCreation", directory: result.directory };
+        case "error":
+          throw new Error(result.errorMessage);
+      }
+    });
+    this.rpcHandlerManager.registerHandler("stop-session", (params) => {
+      const { sessionId } = params || {};
+      if (!sessionId) {
+        throw new Error("Session ID is required");
+      }
+      const success = stopSession(sessionId);
+      if (!success) {
+        throw new Error("Session not found or failed to stop");
+      }
+      logger.debug(`[API MACHINE] Stopped session ${sessionId}`);
+      return { message: "Session stopped" };
+    });
+    this.rpcHandlerManager.registerHandler("stop-daemon", () => {
+      logger.debug("[API MACHINE] Received stop-daemon RPC request");
+      setTimeout(() => {
+        logger.debug("[API MACHINE] Initiating daemon shutdown from RPC");
+        requestShutdown();
+      }, 100);
+      return { message: "Daemon stop request acknowledged, starting shutdown sequence..." };
+    });
   }
   /**
    * Update machine metadata
@@ -1262,9 +1610,6 @@ class ApiMachineClient {
       reconnectionDelay: 1e3,
       reconnectionDelayMax: 5e3
     });
-    const spawnMethod = `${this.machine.id}:spawn-happy-session`;
-    const stopMethod = `${this.machine.id}:stop-session`;
-    const stopDaemonMethod = `${this.machine.id}:stop-daemon`;
     this.socket.on("connect", () => {
       logger.debug("[API MACHINE] Connected to server");
       this.updateDaemonState((state) => ({
@@ -1274,84 +1619,17 @@ class ApiMachineClient {
         httpPort: this.machine.daemonState?.httpPort,
         startedAt: Date.now()
       }));
-      this.socket.emit("rpc-register", { method: spawnMethod });
-      this.socket.emit("rpc-register", { method: stopMethod });
-      this.socket.emit("rpc-register", { method: stopDaemonMethod });
-      logger.debug(`[API MACHINE] Registered RPC methods: ${spawnMethod}, ${stopMethod}, ${stopDaemonMethod}`);
+      this.rpcHandlerManager.onSocketConnect(this.socket);
       this.startKeepAlive();
     });
+    this.socket.on("disconnect", () => {
+      logger.debug("[API MACHINE] Disconnected from server");
+      this.rpcHandlerManager.onSocketDisconnect();
+      this.stopKeepAlive();
+    });
     this.socket.on("rpc-request", async (data, callback) => {
       logger.debugLargeJson(`[API MACHINE] Received RPC request:`, data);
-      try {
-        const spawnMethod2 = `${this.machine.id}:spawn-happy-session`;
-        const stopMethod2 = `${this.machine.id}:stop-session`;
-        const stopDaemonMethod2 = `${this.machine.id}:stop-daemon`;
-        if (data.method === spawnMethod2) {
-          if (!this.spawnSession) {
-            throw new Error("Spawn session handler not set");
-          }
-          const { directory, sessionId } = decrypt(decodeBase64(data.params), this.secret) || {};
-          if (!directory) {
-            throw new Error("Directory is required");
-          }
-          const session = await this.spawnSession(directory, sessionId);
-          if (!session) {
-            throw new Error("Failed to spawn session");
-          }
-          if (session.error) {
-            throw new Error(session.error);
-          }
-          logger.debug(`[API MACHINE] Spawned session ${session.happySessionId || "WARNING - not session Id recieved in webhook"} with PID ${session.pid}`);
-          if (!session.happySessionId) {
-            throw new Error(`Session spawned (PID ${session.pid}) but no sessionId received from webhook. The session process may still be initializing.`);
-          }
-          const response = {
-            sessionId: session.happySessionId,
-            message: session.message
-          };
-          logger.debug(`[API MACHINE] Sending RPC response:`, response);
-          callback(encodeBase64(encrypt(response, this.secret)));
-          return;
-        }
-        if (data.method === stopMethod2) {
-          logger.debug("[API MACHINE] Received stop-session RPC request");
-          const decryptedParams = decrypt(decodeBase64(data.params), this.secret);
-          const { sessionId } = decryptedParams || {};
-          if (!this.stopSession) {
-            throw new Error("Stop session handler not set");
-          }
-          if (!sessionId) {
-            throw new Error("Session ID is required");
-          }
-          const success = this.stopSession(sessionId);
-          if (!success) {
-            throw new Error("Session not found or failed to stop");
-          }
-          logger.debug(`[API MACHINE] Stopped session ${sessionId}`);
-          const response = { message: "Session stopped" };
-          const encryptedResponse = encodeBase64(encrypt(response, this.secret));
-          callback(encryptedResponse);
-          return;
-        }
-        if (data.method === stopDaemonMethod2) {
-          logger.debug("[API MACHINE] Received stop-daemon RPC request");
-          callback(encodeBase64(encrypt({
-            message: "Daemon stop request acknowledged, starting shutdown sequence..."
-          }, this.secret)));
-          setTimeout(() => {
-            logger.debug("[API MACHINE] Initiating daemon shutdown from RPC");
-            if (this.requestShutdown) {
-              this.requestShutdown();
-            }
-          }, 100);
-          return;
-        }
-        throw new Error(`Unknown RPC method: ${data.method}`);
-      } catch (error) {
-        logger.debug(`[API MACHINE] RPC handler failed:`, error.message || error);
-        logger.debug(`[API MACHINE] Error stack:`, error.stack);
-        callback(encodeBase64(encrypt({ error: error.message || String(error) }, this.secret)));
-      }
+      callback(await this.rpcHandlerManager.handleRequest(data));
     });
     this.socket.on("update", (data) => {
       if (data.body.t === "update-machine" && data.body.machineId === this.machine.id) {
@@ -1370,16 +1648,6 @@ class ApiMachineClient {
         logger.debug(`[API MACHINE] Received unknown update type: ${data.body.t}`);
       }
     });
-    this.socket.on("disconnect", () => {
-      logger.debug("[API MACHINE] Disconnected from server");
-      this.stopKeepAlive();
-    });
-    this.socket.io.on("reconnect", () => {
-      logger.debug("[API MACHINE] Reconnected to server");
-      this.socket.emit("rpc-register", { method: spawnMethod });
-      this.socket.emit("rpc-register", { method: stopMethod });
-      this.socket.emit("rpc-register", { method: stopDaemonMethod });
-    });
     this.socket.on("connect_error", (error) => {
       logger.debug(`[API MACHINE] Connection error: ${error.message}`);
     });
@@ -1626,7 +1894,7 @@ class ApiClient {
    * Register or update machine with the server
    * Returns the current machine state from the server with decrypted metadata and daemonState
    */
-  async createMachineOrGetExistingAsIs(opts) {
+  async getOrCreateMachine(opts) {
     const response = await axios.post(
       `${configuration.serverUrl}/v1/machines`,
       {
@@ -1671,6 +1939,34 @@ class ApiClient {
   push() {
     return this.pushClient;
   }
+  /**
+   * Register a vendor API token with the server
+   * The token is sent as a JSON string - server handles encryption
+   */
+  async registerVendorToken(vendor, apiKey) {
+    try {
+      const response = await axios.post(
+        `${configuration.serverUrl}/v1/connect/${vendor}/register`,
+        {
+          token: JSON.stringify(apiKey)
+        },
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`,
+            "Content-Type": "application/json"
+          },
+          timeout: 5e3
+        }
+      );
+      if (response.status !== 200 && response.status !== 201) {
+        throw new Error(`Server returned status ${response.status}`);
+      }
+      logger.debug(`[API] Vendor token for ${vendor} registered successfully`);
+    } catch (error) {
+      logger.debug(`[API] [ERROR] Failed to register vendor token:`, error);
+      throw new Error(`Failed to register vendor token: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
 }
 
 const UsageSchema = z.z.object({
@@ -1738,6 +2034,7 @@ exports.encodeBase64Url = encodeBase64Url;
 exports.getLatestDaemonLog = getLatestDaemonLog;
 exports.logger = logger;
 exports.packageJson = packageJson;
+exports.projectPath = projectPath;
 exports.readCredentials = readCredentials;
 exports.readDaemonState = readDaemonState;
 exports.readSettings = readSettings;