happy-coder 0.6.3 → 0.7.1-beta.1

package/dist/{types-BDtHM1DY.cjs → types-CzvFvJwf.cjs}

@@ -16,40 +16,32 @@ var expoServerSdk = require('expo-server-sdk');
 
 class Configuration {
   serverUrl;
-  installationLocation;
   isDaemonProcess;
   // Directories and paths (from persistence)
-  happyDir;
+  happyHomeDir;
   logsDir;
   daemonLogsDir;
   settingsFile;
   privateKeyFile;
-  daemonMetadataFile;
-  constructor(location) {
-    this.serverUrl = process.env.HANDY_SERVER_URL || "https://handy-api.korshakov.org";
+  daemonStateFile;
+  constructor() {
+    this.serverUrl = process.env.HAPPY_SERVER_URL || "https://handy-api.korshakov.org";
     const args = process.argv.slice(2);
-    this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && (args[1] === "start" || args[1] === "stop");
-    if (location === "local") {
-      this.happyDir = node_path.join(process.cwd(), ".happy");
-      this.installationLocation = "local";
-    } else if (location === "global") {
-      this.happyDir = node_path.join(os.homedir(), ".happy");
-      this.installationLocation = "global";
+    this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && args[1] === "start-sync";
+    if (process.env.HAPPY_HOME_DIR) {
+      const expandedPath = process.env.HAPPY_HOME_DIR.replace(/^~/, os.homedir());
+      this.happyHomeDir = expandedPath;
     } else {
-      this.happyDir = node_path.join(location, ".happy");
-      this.installationLocation = "global";
+      this.happyHomeDir = node_path.join(os.homedir(), ".happy");
     }
-    this.logsDir = node_path.join(this.happyDir, "logs");
-    this.daemonLogsDir = node_path.join(this.happyDir, "logs-daemon");
-    this.settingsFile = node_path.join(this.happyDir, "settings.json");
-    this.privateKeyFile = node_path.join(this.happyDir, "access.key");
-    this.daemonMetadataFile = node_path.join(this.happyDir, "daemon-metadata.json");
+    this.logsDir = node_path.join(this.happyHomeDir, "logs");
+    this.daemonLogsDir = node_path.join(this.happyHomeDir, "logs-daemon");
+    this.settingsFile = node_path.join(this.happyHomeDir, "settings.json");
+    this.privateKeyFile = node_path.join(this.happyHomeDir, "access.key");
+    this.daemonStateFile = node_path.join(this.happyHomeDir, "daemon.state.json");
   }
 }
-exports.configuration = void 0;
-function initializeConfiguration(location) {
-  exports.configuration = new Configuration(location);
-}
+const configuration = new Configuration();
 
 function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
   return date.toLocaleString("sv-SE", {
@@ -73,17 +65,22 @@ function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
   });
 }
 async function getSessionLogPath() {
-  if (!node_fs.existsSync(exports.configuration.logsDir)) {
-    await promises.mkdir(exports.configuration.logsDir, { recursive: true });
+  if (!node_fs.existsSync(configuration.logsDir)) {
+    await promises.mkdir(configuration.logsDir, { recursive: true });
   }
   const timestamp = createTimestampForFilename();
-  const filename = exports.configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
-  return node_path.join(exports.configuration.logsDir, filename);
+  const filename = configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
+  return node_path.join(configuration.logsDir, filename);
 }
 class Logger {
   constructor(logFilePathPromise = getSessionLogPath()) {
     this.logFilePathPromise = logFilePathPromise;
+    if (process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING && process.env.HAPPY_SERVER_URL) {
+      this.dangerouslyUnencryptedServerLoggingUrl = process.env.HAPPY_SERVER_URL;
+      console.log(chalk.yellow("[REMOTE LOGGING] Sending logs to server for AI debugging"));
+    }
   }
+  dangerouslyUnencryptedServerLoggingUrl;
   // Use local timezone for simplicity of locating the logs,
   // in practice you will not need absolute timestamps
   localTimezoneTimestamp() {
@@ -158,11 +155,38 @@ class Logger {
       }
     }
   }
+  async sendToRemoteServer(level, message, ...args) {
+    if (!this.dangerouslyUnencryptedServerLoggingUrl) return;
+    try {
+      await fetch(this.dangerouslyUnencryptedServerLoggingUrl + "/logs-combined-from-cli-and-mobile-for-simple-ai-debugging", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level,
+          message: `${message} ${args.map(
+            (a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)
+          ).join(" ")}`,
+          source: "cli",
+          platform: process.platform
+        })
+      });
+    } catch (error) {
+    }
+  }
   logToFile(prefix, message, ...args) {
     const logLine = `${prefix} ${message} ${args.map(
       (arg) => typeof arg === "string" ? arg : JSON.stringify(arg)
     ).join(" ")}
 `;
+    if (this.dangerouslyUnencryptedServerLoggingUrl) {
+      let level = "info";
+      if (prefix.includes(this.localTimezoneTimestamp())) {
+        level = "debug";
+      }
+      this.sendToRemoteServer(level, message, ...args).catch(() => {
+      });
+    }
     this.logFilePathPromise.then((logFilePath) => {
       try {
         fs.appendFileSync(logFilePath, logLine);
@@ -181,16 +205,7 @@ class Logger {
     });
   }
 }
-exports.logger = void 0;
-function initLoggerWithGlobalConfiguration() {
-  exports.logger = new Logger();
-  if (process.env.DEBUG) {
-    exports.logger.logFilePathPromise.then((logPath) => {
-      exports.logger.info(chalk.yellow("[DEBUG MODE] Debug logging enabled"));
-      exports.logger.info(chalk.gray(`Log file: ${logPath}`));
-    });
-  }
-}
+let logger = new Logger();
 
 const SessionMessageContentSchema = z.z.object({
   c: z.z.string(),
@@ -219,10 +234,26 @@ const UpdateSessionBodySchema = z.z.object({
     value: z.z.string()
   }).nullish()
 });
+const UpdateMachineBodySchema = z.z.object({
+  t: z.z.literal("update-machine"),
+  machineId: z.z.string(),
+  metadata: z.z.object({
+    version: z.z.number(),
+    value: z.z.string()
+  }).nullish(),
+  daemonState: z.z.object({
+    version: z.z.number(),
+    value: z.z.string()
+  }).nullish()
+});
 z.z.object({
   id: z.z.string(),
   seq: z.z.number(),
-  body: z.z.union([UpdateBodySchema, UpdateSessionBodySchema]),
+  body: z.z.union([
+    UpdateBodySchema,
+    UpdateSessionBodySchema,
+    UpdateMachineBodySchema
+  ]),
   createdAt: z.z.number()
 });
 z.z.object({
@@ -235,6 +266,44 @@ z.z.object({
   agentState: z.z.any().nullable(),
   agentStateVersion: z.z.number()
 });
+z.z.object({
+  host: z.z.string(),
+  platform: z.z.string(),
+  happyCliVersion: z.z.string(),
+  homeDir: z.z.string(),
+  happyHomeDir: z.z.string()
+});
+z.z.object({
+  status: z.z.union([
+    z.z.enum(["running", "shutting-down"]),
+    z.z.string()
+    // Forward compatibility
+  ]),
+  pid: z.z.number().optional(),
+  httpPort: z.z.number().optional(),
+  startedAt: z.z.number().optional(),
+  shutdownRequestedAt: z.z.number().optional(),
+  shutdownSource: z.z.union([
+    z.z.enum(["mobile-app", "cli", "os-signal", "unknown"]),
+    z.z.string()
+    // Forward compatibility
+  ]).optional()
+});
+z.z.object({
+  id: z.z.string(),
+  metadata: z.z.any(),
+  // Decrypted MachineMetadata
+  metadataVersion: z.z.number(),
+  daemonState: z.z.any().nullable(),
+  // Decrypted DaemonState
+  daemonStateVersion: z.z.number(),
+  // We don't really care about these on the CLI for now
+  // ApiMachineClient will not sync these
+  active: z.z.boolean(),
+  activeAt: z.z.number(),
+  createdAt: z.z.number(),
+  updatedAt: z.z.number()
+});
 z.z.object({
   content: SessionMessageContentSchema,
   createdAt: z.z.number(),
@@ -325,6 +394,7 @@ function decrypt(data, secret) {
   const encrypted = data.slice(tweetnacl.secretbox.nonceLength);
   const decrypted = tweetnacl.secretbox.open(encrypted, nonce, secret);
   if (!decrypted) {
+    logger.debug("[ERROR] Decryption failed");
     return null;
   }
   return JSON.parse(new TextDecoder().decode(decrypted));
@@ -415,7 +485,7 @@ class ApiSessionClient extends node_events.EventEmitter {
     this.metadataVersion = session.metadataVersion;
     this.agentState = session.agentState;
     this.agentStateVersion = session.agentStateVersion;
-    this.socket = socket_ioClient.io(exports.configuration.serverUrl, {
+    this.socket = socket_ioClient.io(configuration.serverUrl, {
       auth: {
         token: this.token,
         clientType: "session-scoped",
@@ -431,7 +501,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       autoConnect: false
     });
     this.socket.on("connect", () => {
-      exports.logger.debug("Socket connected successfully");
+      logger.debug("Socket connected successfully");
       this.reregisterHandlers();
     });
     this.socket.on("rpc-request", async (data, callback) => {
@@ -439,7 +509,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         const method = data.method;
         const handler = this.rpcHandlers.get(method);
         if (!handler) {
-          exports.logger.debug("[SOCKET] [RPC] [ERROR] method not found", { method });
+          logger.debug("[SOCKET] [RPC] [ERROR] method not found", { method });
           const errorResponse = { error: "Method not found" };
           const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
           callback(encryptedError);
@@ -450,28 +520,28 @@ class ApiSessionClient extends node_events.EventEmitter {
         const encryptedResponse = encodeBase64(encrypt(result, this.secret));
         callback(encryptedResponse);
       } catch (error) {
-        exports.logger.debug("[SOCKET] [RPC] [ERROR] Error handling RPC request", { 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);
       }
     });
     this.socket.on("disconnect", (reason) => {
-      exports.logger.debug("[API] Socket disconnected:", reason);
+      logger.debug("[API] Socket disconnected:", reason);
     });
     this.socket.on("connect_error", (error) => {
-      exports.logger.debug("[API] Socket connection error:", error);
+      logger.debug("[API] Socket connection error:", error);
     });
     this.socket.on("update", (data) => {
       try {
-        exports.logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", data);
+        logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", data);
         if (!data.body) {
-          exports.logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
+          logger.debug("[SOCKET] [UPDATE] [ERROR] No body in update!");
           return;
         }
         if (data.body.t === "new-message" && data.body.message.content.t === "encrypted") {
           const body = decrypt(decodeBase64(data.body.message.content.c), this.secret);
-          exports.logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
+          logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
           const userResult = UserMessageSchema.safeParse(body);
           if (userResult.success) {
             if (this.pendingMessageCallback) {
@@ -491,15 +561,17 @@ class ApiSessionClient extends node_events.EventEmitter {
             this.agentState = data.body.agentState.value ? decrypt(decodeBase64(data.body.agentState.value), this.secret) : null;
             this.agentStateVersion = data.body.agentState.version;
           }
+        } else if (data.body.t === "update-machine") {
+          logger.debug(`[SOCKET] WARNING: Session client received unexpected machine update - ignoring`);
         } else {
           this.emit("message", data.body);
         }
       } catch (error) {
-        exports.logger.debug("[SOCKET] [UPDATE] [ERROR] Error handling update", { error });
+        logger.debug("[SOCKET] [UPDATE] [ERROR] Error handling update", { error });
       }
     });
     this.socket.on("error", (error) => {
-      exports.logger.debug("[API] Socket error:", error);
+      logger.debug("[API] Socket error:", error);
     });
     this.socket.connect();
   }
@@ -539,7 +611,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         }
       };
     }
-    exports.logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
+    logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
     const encrypted = encodeBase64(encrypt(content, this.secret));
     this.socket.emit("message", {
       sid: this.sessionId,
@@ -549,7 +621,7 @@ class ApiSessionClient extends node_events.EventEmitter {
       try {
         this.sendUsageData(body.message.usage);
       } catch (error) {
-        exports.logger.debug("[SOCKET] Failed to send usage data:", error);
+        logger.debug("[SOCKET] Failed to send usage data:", error);
       }
     }
     if (body.type === "summary" && "summary" in body && "leafUuid" in body) {
@@ -617,7 +689,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         output: 0
       }
     };
-    exports.logger.debugLargeJson("[SOCKET] Sending usage data:", usageReport);
+    logger.debugLargeJson("[SOCKET] Sending usage data:", usageReport);
     this.socket.emit("usage-report", usageReport);
   }
   /**
@@ -647,7 +719,7 @@ class ApiSessionClient extends node_events.EventEmitter {
    * @param handler - Handler function that returns the updated agent state
    */
   updateAgentState(handler) {
-    exports.logger.debugLargeJson("Updating agent state", this.agentState);
+    logger.debugLargeJson("Updating agent state", this.agentState);
     this.agentStateLock.inLock(async () => {
       await backoff(async () => {
         let updated = handler(this.agentState || {});
@@ -655,7 +727,7 @@ class ApiSessionClient extends node_events.EventEmitter {
         if (answer.result === "success") {
           this.agentState = answer.agentState ? decrypt(decodeBase64(answer.agentState), this.secret) : null;
           this.agentStateVersion = answer.version;
-          exports.logger.debug("Agent state updated", this.agentState);
+          logger.debug("Agent state updated", this.agentState);
         } else if (answer.result === "version-mismatch") {
           if (answer.version > this.agentStateVersion) {
             this.agentStateVersion = answer.version;
@@ -675,18 +747,18 @@ class ApiSessionClient extends node_events.EventEmitter {
     const prefixedMethod = `${this.sessionId}:${method}`;
     this.rpcHandlers.set(prefixedMethod, handler);
     this.socket.emit("rpc-register", { method: prefixedMethod });
-    exports.logger.debug("Registered RPC handler", { method, prefixedMethod });
+    logger.debug("Registered RPC handler", { method, prefixedMethod });
   }
   /**
    * Re-register all RPC handlers after reconnection
    */
   reregisterHandlers() {
-    exports.logger.debug("Re-registering RPC handlers after reconnection", {
+    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 });
-      exports.logger.debug("Re-registered method", { prefixedMethod });
+      logger.debug("Re-registered method", { prefixedMethod });
     }
   }
   /**
@@ -710,6 +782,243 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
 }
 
+class ApiMachineClient {
+  constructor(token, secret, machine) {
+    this.token = token;
+    this.secret = secret;
+    this.machine = machine;
+  }
+  socket;
+  keepAliveInterval = null;
+  // RPC handlers
+  spawnSession;
+  stopSession;
+  requestShutdown;
+  setRPCHandlers({
+    spawnSession,
+    stopSession,
+    requestShutdown
+  }) {
+    this.spawnSession = spawnSession;
+    this.stopSession = stopSession;
+    this.requestShutdown = requestShutdown;
+  }
+  /**
+   * Update machine metadata
+   * Currently unused, changes from the mobile client are more likely
+   * for example to set a custom name.
+   */
+  async updateMachineMetadata(handler) {
+    await backoff(async () => {
+      const updated = handler(this.machine.metadata);
+      const answer = await this.socket.emitWithAck("machine-update-metadata", {
+        machineId: this.machine.id,
+        metadata: encodeBase64(encrypt(updated, this.secret)),
+        expectedVersion: this.machine.metadataVersion
+      });
+      if (answer.result === "success") {
+        this.machine.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+        this.machine.metadataVersion = answer.version;
+        logger.debug("[API MACHINE] Metadata updated successfully");
+      } else if (answer.result === "version-mismatch") {
+        if (answer.version > this.machine.metadataVersion) {
+          this.machine.metadataVersion = answer.version;
+          this.machine.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+        }
+        throw new Error("Metadata version mismatch");
+      }
+    });
+  }
+  /**
+   * Update daemon state (runtime info) - similar to session updateAgentState
+   * Simplified without lock - relies on backoff for retry
+   */
+  async updateDaemonState(handler) {
+    await backoff(async () => {
+      const updated = handler(this.machine.daemonState);
+      const answer = await this.socket.emitWithAck("machine-update-state", {
+        machineId: this.machine.id,
+        daemonState: encodeBase64(encrypt(updated, this.secret)),
+        expectedVersion: this.machine.daemonStateVersion
+      });
+      if (answer.result === "success") {
+        this.machine.daemonState = decrypt(decodeBase64(answer.daemonState), this.secret);
+        this.machine.daemonStateVersion = answer.version;
+        logger.debug("[API MACHINE] Daemon state updated successfully");
+      } else if (answer.result === "version-mismatch") {
+        if (answer.version > this.machine.daemonStateVersion) {
+          this.machine.daemonStateVersion = answer.version;
+          this.machine.daemonState = decrypt(decodeBase64(answer.daemonState), this.secret);
+        }
+        throw new Error("Daemon state version mismatch");
+      }
+    });
+  }
+  connect() {
+    const serverUrl = configuration.serverUrl.replace(/^http/, "ws");
+    logger.debug(`[API MACHINE] Connecting to ${serverUrl}`);
+    this.socket = socket_ioClient.io(serverUrl, {
+      transports: ["websocket"],
+      auth: {
+        token: this.token,
+        clientType: "machine-scoped",
+        machineId: this.machine.id
+      },
+      path: "/v1/updates",
+      reconnection: true,
+      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) => ({
+        ...state,
+        status: "running",
+        pid: process.pid,
+        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.startKeepAlive();
+    });
+    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");
+          }
+          logger.debug(`[API MACHINE] Spawned session ${session.happySessionId || "pending"} 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 };
+          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)));
+      }
+    });
+    this.socket.on("update", (data) => {
+      if (data.body.t === "update-machine" && data.body.machineId === this.machine.id) {
+        const update = data.body;
+        if (update.metadata) {
+          logger.debug("[API MACHINE] Received external metadata update");
+          this.machine.metadata = decrypt(decodeBase64(update.metadata.value), this.secret);
+          this.machine.metadataVersion = update.metadata.version;
+        }
+        if (update.daemonState) {
+          logger.debug("[API MACHINE] Received external daemon state update");
+          this.machine.daemonState = decrypt(decodeBase64(update.daemonState.value), this.secret);
+          this.machine.daemonStateVersion = update.daemonState.version;
+        }
+      } else {
+        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}`);
+    });
+    this.socket.io.on("error", (error) => {
+      logger.debug("[API MACHINE] Socket error:", error);
+    });
+  }
+  startKeepAlive() {
+    this.stopKeepAlive();
+    this.keepAliveInterval = setInterval(() => {
+      const payload = {
+        machineId: this.machine.id,
+        time: Date.now()
+      };
+      if (process.env.VERBOSE) {
+        logger.debugLargeJson(`[API MACHINE] Emitting machine-alive`, payload);
+      }
+      this.socket.emit("machine-alive", payload);
+    }, 2e4);
+    logger.debug("[API MACHINE] Keep-alive started (20s interval)");
+  }
+  stopKeepAlive() {
+    if (this.keepAliveInterval) {
+      clearInterval(this.keepAliveInterval);
+      this.keepAliveInterval = null;
+      logger.debug("[API MACHINE] Keep-alive stopped");
+    }
+  }
+  shutdown() {
+    logger.debug("[API MACHINE] Shutting down");
+    this.stopKeepAlive();
+    if (this.socket) {
+      this.socket.close();
+      logger.debug("[API MACHINE] Socket closed");
+    }
+  }
+}
+
 class PushNotificationClient {
   token;
   baseUrl;
@@ -733,13 +1042,13 @@ class PushNotificationClient {
           }
         }
       );
-      exports.logger.debug(`Fetched ${response.data.tokens.length} push tokens`);
+      logger.debug(`Fetched ${response.data.tokens.length} push tokens`);
       response.data.tokens.forEach((token, index) => {
-        exports.logger.debug(`[PUSH] Token ${index + 1}: id=${token.id}, token=${token.token}, created=${new Date(token.createdAt).toISOString()}, updated=${new Date(token.updatedAt).toISOString()}`);
+        logger.debug(`[PUSH] Token ${index + 1}: id=${token.id}, token=${token.token}, created=${new Date(token.createdAt).toISOString()}, updated=${new Date(token.updatedAt).toISOString()}`);
       });
       return response.data.tokens;
     } catch (error) {
-      exports.logger.debug("[PUSH] [ERROR] Failed to fetch push tokens:", error);
+      logger.debug("[PUSH] [ERROR] Failed to fetch push tokens:", error);
       throw new Error(`Failed to fetch push tokens: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
@@ -748,7 +1057,7 @@ class PushNotificationClient {
    * @param messages - Array of push messages to send
    */
   async sendPushNotifications(messages) {
-    exports.logger.debug(`Sending ${messages.length} push notifications`);
+    logger.debug(`Sending ${messages.length} push notifications`);
     const validMessages = messages.filter((message) => {
       if (Array.isArray(message.to)) {
         return message.to.every((token) => expoServerSdk.Expo.isExpoPushToken(token));
@@ -756,7 +1065,7 @@ class PushNotificationClient {
       return expoServerSdk.Expo.isExpoPushToken(message.to);
     });
     if (validMessages.length === 0) {
-      exports.logger.debug("No valid Expo push tokens found");
+      logger.debug("No valid Expo push tokens found");
       return;
     }
     const chunks = this.expo.chunkPushNotifications(validMessages);
@@ -770,7 +1079,7 @@ class PushNotificationClient {
           const errors = ticketChunk.filter((ticket) => ticket.status === "error");
           if (errors.length > 0) {
             const errorDetails = errors.map((e) => ({ message: e.message, details: e.details }));
-            exports.logger.debug("[PUSH] Some notifications failed:", errorDetails);
+            logger.debug("[PUSH] Some notifications failed:", errorDetails);
           }
           if (errors.length === ticketChunk.length) {
             throw new Error("All push notifications in chunk failed");
@@ -779,7 +1088,7 @@ class PushNotificationClient {
         } catch (error) {
           const elapsed = Date.now() - startTime;
           if (elapsed >= timeout) {
-            exports.logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
+            logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
             break;
           }
           attempt++;
@@ -787,13 +1096,13 @@ class PushNotificationClient {
           const remainingTime = timeout - elapsed;
           const waitTime = Math.min(delay, remainingTime);
           if (waitTime > 0) {
-            exports.logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
+            logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
             await new Promise((resolve) => setTimeout(resolve, waitTime));
           }
         }
       }
     }
-    exports.logger.debug(`Push notifications sent successfully`);
+    logger.debug(`Push notifications sent successfully`);
   }
   /**
    * Send a push notification to all registered devices for the user
@@ -802,21 +1111,21 @@ class PushNotificationClient {
    * @param data - Additional data to send with the notification
    */
   sendToAllDevices(title, body, data) {
-    exports.logger.debug(`[PUSH] sendToAllDevices called with title: "${title}", body: "${body}"`);
+    logger.debug(`[PUSH] sendToAllDevices called with title: "${title}", body: "${body}"`);
     (async () => {
       try {
-        exports.logger.debug("[PUSH] Fetching push tokens...");
+        logger.debug("[PUSH] Fetching push tokens...");
         const tokens = await this.fetchPushTokens();
-        exports.logger.debug(`[PUSH] Fetched ${tokens.length} push tokens`);
+        logger.debug(`[PUSH] Fetched ${tokens.length} push tokens`);
         tokens.forEach((token, index) => {
-          exports.logger.debug(`[PUSH] Using token ${index + 1}: id=${token.id}, token=${token.token}`);
+          logger.debug(`[PUSH] Using token ${index + 1}: id=${token.id}, token=${token.token}`);
         });
         if (tokens.length === 0) {
-          exports.logger.debug("No push tokens found for user");
+          logger.debug("No push tokens found for user");
           return;
         }
         const messages = tokens.map((token, index) => {
-          exports.logger.debug(`[PUSH] Creating message ${index + 1} for token: ${token.token}`);
+          logger.debug(`[PUSH] Creating message ${index + 1} for token: ${token.token}`);
           return {
             to: token.token,
             title,
@@ -826,11 +1135,11 @@ class PushNotificationClient {
             priority: "high"
           };
         });
-        exports.logger.debug(`[PUSH] Sending ${messages.length} push notifications...`);
+        logger.debug(`[PUSH] Sending ${messages.length} push notifications...`);
         await this.sendPushNotifications(messages);
-        exports.logger.debug("[PUSH] Push notifications sent successfully");
+        logger.debug("[PUSH] Push notifications sent successfully");
       } catch (error) {
-        exports.logger.debug("[PUSH] Error sending to all devices:", error);
+        logger.debug("[PUSH] Error sending to all devices:", error);
       }
     })();
   }
@@ -851,7 +1160,7 @@ class ApiClient {
   async getOrCreateSession(opts) {
     try {
       const response = await axios.post(
-        `${exports.configuration.serverUrl}/v1/sessions`,
+        `${configuration.serverUrl}/v1/sessions`,
         {
           tag: opts.tag,
           metadata: encodeBase64(encrypt(opts.metadata, this.secret)),
@@ -861,10 +1170,12 @@ class ApiClient {
           headers: {
             "Authorization": `Bearer ${this.token}`,
             "Content-Type": "application/json"
-          }
+          },
+          timeout: 5e3
+          // 5 second timeout
         }
       );
-      exports.logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
+      logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
       let raw = response.data.session;
       let session = {
         id: raw.id,
@@ -878,22 +1189,81 @@ class ApiClient {
       };
       return session;
     } catch (error) {
-      exports.logger.debug("[API] [ERROR] Failed to get or create session:", error);
+      logger.debug("[API] [ERROR] Failed to get or create session:", error);
       throw new Error(`Failed to get or create session: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
   /**
-   * Start realtime session client
-   * @param id - Session ID
-   * @returns Session client
+   * Get machine by ID from the server
+   * Returns the current machine state from the server with decrypted metadata and daemonState
    */
-  session(session) {
-    return new ApiSessionClient(this.token, this.secret, session);
+  async getMachine(machineId) {
+    const response = await axios.get(`${configuration.serverUrl}/v1/machines/${machineId}`, {
+      headers: {
+        "Authorization": `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      timeout: 2e3
+    });
+    const raw = response.data.machine;
+    if (!raw) {
+      return null;
+    }
+    logger.debug(`[API] Machine ${machineId} fetched from server`);
+    const machine = {
+      id: raw.id,
+      metadata: raw.metadata ? decrypt(decodeBase64(raw.metadata), this.secret) : null,
+      metadataVersion: raw.metadataVersion || 0,
+      daemonState: raw.daemonState ? decrypt(decodeBase64(raw.daemonState), this.secret) : null,
+      daemonStateVersion: raw.daemonStateVersion || 0,
+      active: raw.active,
+      activeAt: raw.activeAt,
+      createdAt: raw.createdAt,
+      updatedAt: raw.updatedAt
+    };
+    return machine;
   }
   /**
-   * Get push notification client
-   * @returns Push notification client
+   * Register or update machine with the server
+   * Returns the current machine state from the server with decrypted metadata and daemonState
    */
+  async createOrReturnExistingAsIs(opts) {
+    const response = await axios.post(
+      `${configuration.serverUrl}/v1/machines`,
+      {
+        id: opts.machineId,
+        metadata: encodeBase64(encrypt(opts.metadata, this.secret)),
+        daemonState: opts.daemonState ? encodeBase64(encrypt(opts.daemonState, this.secret)) : void 0
+      },
+      {
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        },
+        timeout: 5e3
+      }
+    );
+    const raw = response.data.machine;
+    logger.debug(`[API] Machine ${opts.machineId} registered/updated with server`);
+    const machine = {
+      id: raw.id,
+      metadata: raw.metadata ? decrypt(decodeBase64(raw.metadata), this.secret) : null,
+      metadataVersion: raw.metadataVersion || 0,
+      daemonState: raw.daemonState ? decrypt(decodeBase64(raw.daemonState), this.secret) : null,
+      daemonStateVersion: raw.daemonStateVersion || 0,
+      active: raw.active,
+      activeAt: raw.activeAt,
+      createdAt: raw.createdAt,
+      updatedAt: raw.updatedAt
+    };
+    return machine;
+  }
+  sessionSyncClient(session) {
+    return new ApiSessionClient(this.token, this.secret, session);
+  }
+  machineSyncClient(machine) {
+    return new ApiMachineClient(this.token, this.secret, machine);
+  }
   push() {
     return this.pushClient;
   }
@@ -951,10 +1321,9 @@ exports.ApiClient = ApiClient;
 exports.ApiSessionClient = ApiSessionClient;
 exports.RawJSONLinesSchema = RawJSONLinesSchema;
 exports.backoff = backoff;
+exports.configuration = configuration;
 exports.decodeBase64 = decodeBase64;
 exports.delay = delay;
 exports.encodeBase64 = encodeBase64;
 exports.encodeBase64Url = encodeBase64Url;
-exports.encrypt = encrypt;
-exports.initLoggerWithGlobalConfiguration = initLoggerWithGlobalConfiguration;
-exports.initializeConfiguration = initializeConfiguration;
+exports.logger = logger;