happy-coder 0.9.1 → 0.10.0-1

package/dist/{types-BS8Pr3Im.mjs → types-BUXwivpV.mjs}

@@ -11,10 +11,16 @@ import { randomBytes, randomUUID } from 'node:crypto';
 import tweetnacl from 'tweetnacl';
 import { EventEmitter } from 'node:events';
 import { io } from 'socket.io-client';
+import { spawn, exec } from 'child_process';
+import { promisify } from 'util';
+import { readFile as readFile$1, stat as stat$1, writeFile as writeFile$1, readdir } from 'fs/promises';
+import { createHash } from 'crypto';
+import { dirname, resolve, join as join$1 } from 'path';
+import { fileURLToPath } from 'url';
 import { Expo } from 'expo-server-sdk';
 
 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";
@@ -77,8 +83,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",
@@ -86,6 +95,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",
@@ -832,6 +842,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 = dirname(fileURLToPath(import.meta.url));
+function projectPath() {
+  const path = resolve(__dirname, "..");
+  return path;
+}
+
+function run(args, options) {
+  const RUNNER_PATH = resolve(join$1(projectPath(), "scripts", "ripgrep_launcher.cjs"));
+  return new Promise((resolve2, reject) => {
+    const child = 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 = promisify(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 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" };
+    }
+  });
+  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 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$1(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$1(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" };
+    }
+  });
+  rpcHandlerManager.registerHandler("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$1(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, name, currentDepth) {
+      try {
+        const stats = await stat$1(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" };
+    }
+  });
+  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 EventEmitter {
   token;
   secret;
@@ -843,7 +1187,7 @@ class ApiSessionClient extends EventEmitter {
   socket;
   pendingMessages = [];
   pendingMessageCallback = null;
-  rpcHandlers = /* @__PURE__ */ new Map();
+  rpcHandlerManager;
   agentStateLock = new AsyncLock();
   metadataLock = new AsyncLock();
   constructor(token, secret, session) {
@@ -855,6 +1199,12 @@ class ApiSessionClient extends 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 = io(configuration.serverUrl, {
       auth: {
         token: this.token,
@@ -872,35 +1222,18 @@ class ApiSessionClient extends 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 {
@@ -1111,29 +1444,6 @@ class ApiSessionClient extends 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
    */
@@ -1160,21 +1470,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
@@ -1242,9 +1589,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) => ({
@@ -1254,84 +1598,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) {
@@ -1350,16 +1627,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}`);
     });
@@ -1606,7 +1873,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`,
       {
@@ -1651,6 +1918,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$1.object({
@@ -1701,4 +1996,4 @@ const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
-export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, backoff as b, configuration as c, delay as d, AsyncLock as e, clearDaemonState as f, readSettings as g, readCredentials as h, encodeBase64 as i, encodeBase64Url as j, decodeBase64 as k, logger as l, acquireDaemonLock as m, writeDaemonState as n, releaseDaemonLock as o, packageJson as p, clearCredentials as q, readDaemonState as r, clearMachineId as s, getLatestDaemonLog as t, updateSettings as u, writeCredentials as w };
+export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, backoff as b, configuration as c, delay as d, AsyncLock as e, clearDaemonState as f, packageJson as g, readSettings as h, readCredentials as i, encodeBase64 as j, encodeBase64Url as k, logger as l, decodeBase64 as m, acquireDaemonLock as n, writeDaemonState as o, projectPath as p, releaseDaemonLock as q, readDaemonState as r, clearCredentials as s, clearMachineId as t, updateSettings as u, getLatestDaemonLog as v, writeCredentials as w };