happy-coder 0.6.4 → 0.7.1-beta.1

package/dist/{types-Dz5kZrVh.mjs → types-BZC9-exR.mjs}

@@ -14,40 +14,32 @@ import { Expo } from '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 = join(process.cwd(), ".happy");
-      this.installationLocation = "local";
-    } else if (location === "global") {
-      this.happyDir = join(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(/^~/, homedir());
+      this.happyHomeDir = expandedPath;
     } else {
-      this.happyDir = join(location, ".happy");
-      this.installationLocation = "global";
+      this.happyHomeDir = join(homedir(), ".happy");
     }
-    this.logsDir = join(this.happyDir, "logs");
-    this.daemonLogsDir = join(this.happyDir, "logs-daemon");
-    this.settingsFile = join(this.happyDir, "settings.json");
-    this.privateKeyFile = join(this.happyDir, "access.key");
-    this.daemonMetadataFile = join(this.happyDir, "daemon-metadata.json");
+    this.logsDir = join(this.happyHomeDir, "logs");
+    this.daemonLogsDir = join(this.happyHomeDir, "logs-daemon");
+    this.settingsFile = join(this.happyHomeDir, "settings.json");
+    this.privateKeyFile = join(this.happyHomeDir, "access.key");
+    this.daemonStateFile = join(this.happyHomeDir, "daemon.state.json");
   }
 }
-let configuration = void 0;
-function initializeConfiguration(location) {
-  configuration = new Configuration(location);
-}
+const configuration = new Configuration();
 
 function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
   return date.toLocaleString("sv-SE", {
@@ -81,7 +73,12 @@ async function getSessionLogPath() {
 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() {
@@ -156,11 +153,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 {
         appendFileSync(logFilePath, logLine);
@@ -179,16 +203,7 @@ class Logger {
     });
   }
 }
-let logger;
-function initLoggerWithGlobalConfiguration() {
-  logger = new Logger();
-  if (process.env.DEBUG) {
-    logger.logFilePathPromise.then((logPath) => {
-      logger.info(chalk.yellow("[DEBUG MODE] Debug logging enabled"));
-      logger.info(chalk.gray(`Log file: ${logPath}`));
-    });
-  }
-}
+let logger = new Logger();
 
 const SessionMessageContentSchema = z.object({
   c: z.string(),
@@ -217,10 +232,26 @@ const UpdateSessionBodySchema = z.object({
     value: z.string()
   }).nullish()
 });
+const UpdateMachineBodySchema = z.object({
+  t: z.literal("update-machine"),
+  machineId: z.string(),
+  metadata: z.object({
+    version: z.number(),
+    value: z.string()
+  }).nullish(),
+  daemonState: z.object({
+    version: z.number(),
+    value: z.string()
+  }).nullish()
+});
 z.object({
   id: z.string(),
   seq: z.number(),
-  body: z.union([UpdateBodySchema, UpdateSessionBodySchema]),
+  body: z.union([
+    UpdateBodySchema,
+    UpdateSessionBodySchema,
+    UpdateMachineBodySchema
+  ]),
   createdAt: z.number()
 });
 z.object({
@@ -233,6 +264,44 @@ z.object({
   agentState: z.any().nullable(),
   agentStateVersion: z.number()
 });
+z.object({
+  host: z.string(),
+  platform: z.string(),
+  happyCliVersion: z.string(),
+  homeDir: z.string(),
+  happyHomeDir: z.string()
+});
+z.object({
+  status: z.union([
+    z.enum(["running", "shutting-down"]),
+    z.string()
+    // Forward compatibility
+  ]),
+  pid: z.number().optional(),
+  httpPort: z.number().optional(),
+  startedAt: z.number().optional(),
+  shutdownRequestedAt: z.number().optional(),
+  shutdownSource: z.union([
+    z.enum(["mobile-app", "cli", "os-signal", "unknown"]),
+    z.string()
+    // Forward compatibility
+  ]).optional()
+});
+z.object({
+  id: z.string(),
+  metadata: z.any(),
+  // Decrypted MachineMetadata
+  metadataVersion: z.number(),
+  daemonState: z.any().nullable(),
+  // Decrypted DaemonState
+  daemonStateVersion: z.number(),
+  // We don't really care about these on the CLI for now
+  // ApiMachineClient will not sync these
+  active: z.boolean(),
+  activeAt: z.number(),
+  createdAt: z.number(),
+  updatedAt: z.number()
+});
 z.object({
   content: SessionMessageContentSchema,
   createdAt: z.number(),
@@ -323,6 +392,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));
@@ -489,6 +559,8 @@ class ApiSessionClient extends 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);
         }
@@ -708,6 +780,243 @@ class ApiSessionClient extends 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 = 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;
@@ -859,7 +1168,9 @@ class ApiClient {
           headers: {
             "Authorization": `Bearer ${this.token}`,
             "Content-Type": "application/json"
-          }
+          },
+          timeout: 5e3
+          // 5 second timeout
         }
       );
       logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
@@ -881,17 +1192,76 @@ class ApiClient {
     }
   }
   /**
-   * 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;
   }
@@ -945,4 +1315,4 @@ const RawJSONLinesSchema = z.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
-export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, initializeConfiguration as b, configuration as c, backoff as d, delay as e, encodeBase64 as f, encodeBase64Url as g, decodeBase64 as h, initLoggerWithGlobalConfiguration as i, encrypt as j, logger as l };
+export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, backoff as b, configuration as c, delay as d, encodeBase64 as e, encodeBase64Url as f, decodeBase64 as g, logger as l };