very-happy-cli 0.2.156 → 0.2.158

package/dist/{types-CphWjqHc.cjs → types-DnrPeN80.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var axios = require('axios');
-var persistence = require('./limits-o29KXBgj.cjs');
+var persistence = require('./limits-kqFqhfsh.cjs');
 var node_events = require('node:events');
 var socket_ioClient = require('socket.io-client');
 var z = require('zod');
@@ -438,6 +438,15 @@ async function deriveKey$1(master, usage, path) {
 
 class RpcHandlerManager {
   handlers = /* @__PURE__ */ new Map();
+  /**
+   * B-506: methods whose params/result are PLAINTEXT JSON strings instead of
+   * machine-key ciphertext. The caller is a CLI on another machine of the
+   * same account, which holds neither this machine's key nor the account
+   * content key; the trusted relay sees the payload either way (this fork
+   * is server-trusted, not e2e). Only `registerPlainHandler` puts a method
+   * here; everything else keeps decrypting.
+   */
+  plainMethods = /* @__PURE__ */ new Set();
   scopePrefix;
   encryptionKey;
   encryptionVariant;
@@ -462,14 +471,31 @@ class RpcHandlerManager {
   unregisterHandler(method) {
     const prefixedMethod = this.getPrefixedMethod(method);
     this.handlers.delete(prefixedMethod);
+    this.plainMethods.delete(prefixedMethod);
     for (const socket of this.sockets) socket.emit("rpc-unregister", { method: prefixedMethod });
   }
+  /**
+   * B-506: register a method whose request is a plaintext JSON string and
+   * whose response is returned as a plaintext JSON string (see
+   * `plainMethods`). The handler receives the parsed params; a throw is
+   * answered with `{ error }` like the encrypted path.
+   */
+  registerPlainHandler(method, handler) {
+    this.plainMethods.add(this.getPrefixedMethod(method));
+    this.registerHandler(method, handler);
+  }
+  isPlainMethod(prefixedMethod) {
+    return this.plainMethods.has(prefixedMethod);
+  }
   /**
    * Handle an incoming RPC request
    * @param request - The RPC request data
    * @param callback - The response callback
    */
   async handleRequest(request) {
+    if (this.plainMethods.has(request.method)) {
+      return this.handlePlainRequest(request);
+    }
     try {
       const handler = this.handlers.get(request.method);
       if (!handler) {
@@ -493,6 +519,25 @@ class RpcHandlerManager {
       return persistence.encodeBase64(persistence.encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
     }
   }
+  /** Plaintext variant of handleRequest (B-506). Never throws; never encrypts. */
+  async handlePlainRequest(request) {
+    const handler = this.handlers.get(request.method);
+    if (!handler) return JSON.stringify({ error: "Method not found" });
+    let params;
+    try {
+      params = typeof request.params === "string" && request.params.length > 0 ? JSON.parse(request.params) : {};
+    } catch {
+      return JSON.stringify({ error: "Invalid JSON params" });
+    }
+    try {
+      this.logger("[RPC] Calling plain handler", { method: request.method });
+      const result = await handler(params);
+      return JSON.stringify(result === void 0 ? null : result);
+    } catch (error) {
+      this.logger("[RPC] [ERROR] Error handling plain request", { error });
+      return JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" });
+    }
+  }
   onSocketConnect(socket) {
     this.sockets.add(socket);
     for (const [prefixedMethod] of this.handlers) {
@@ -2772,7 +2817,7 @@ class ApiSessionClient extends node_events.EventEmitter {
           const persisted = await axios.post(
             `${persistence.configuration.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`,
             { messages: batch },
-            { headers: this.authHeaders(), timeout: 6e4 }
+            { headers: { ...this.authHeaders(), "X-Happy-Message-Origin": "relay-client" }, timeout: 6e4 }
           );
           const stored = Array.isArray(persisted.data.messages) ? persisted.data.messages : [];
           const storedLocalIds = new Set(stored.map((message) => message.localId));
@@ -3000,16 +3045,29 @@ class ApiSessionClient extends node_events.EventEmitter {
   /** B-466: turn edges (and a periodic lease) reported to the local daemon so
    *  auto-update waits for "no turn in flight" instead of "no sessions". */
   turnReporter = new TurnReporter((event) => void persistence.notifyDaemonTurnEvent(this.sessionId, event).catch((error) => persistence.logger.debug("[API] Failed to report turn event to daemon:", error)));
-  keepAlive(thinking, mode) {
+  /** B-507: background tasks in flight, published on change and renewed every
+   *  60s to the daemon (`/session-event background_tasks`) and into agentState
+   *  (`backgroundTasks: { updatedAt, tasks }`) — the two readers that outlive a
+   *  single heartbeat. The heartbeat itself carries only the count. */
+  backgroundTaskReporter = new persistence.BackgroundTaskReporter((tasks, now) => {
+    void persistence.notifyDaemonBackgroundTasks(this.sessionId, tasks).catch((error) => persistence.logger.debug("[API] Failed to report background tasks to daemon:", error));
+    this.updateAgentState((state) => ({
+      ...state,
+      backgroundTasks: tasks.length > 0 ? { updatedAt: now, tasks } : void 0
+    }));
+  });
+  keepAlive(thinking, mode, backgroundTasks) {
     if (process.env.DEBUG) {
       persistence.logger.debug(`[API] Sending keep alive message: ${thinking}`);
     }
     this.turnReporter.observe(thinking);
+    if (backgroundTasks) this.backgroundTaskReporter.observe(backgroundTasks);
     this.socket.volatile.emit("session-alive", {
       sid: this.sessionId,
       time: Date.now(),
       thinking,
-      mode
+      mode,
+      ...backgroundTasks ? { backgroundTasks: backgroundTasks.length } : {}
     });
   }
   /**
@@ -14356,6 +14414,17 @@ class ApiMachineClient {
       return { claudeAuth };
     });
   }
+  /**
+   * B-506: the five `sessions.*` methods a CLI on ANOTHER machine of this
+   * account calls to read / message sessions this daemon spawned. Plaintext
+   * on purpose (no shared key with the caller); see
+   * `api/rpc/RpcHandlerManager.ts` `registerPlainHandler`.
+   */
+  setRemoteSessionOpsHandlers(handlers) {
+    for (const [method, handler] of Object.entries(handlers)) {
+      this.rpcHandlerManager.registerPlainHandler(method, handler);
+    }
+  }
   setRPCHandlers({
     spawnSession,
     resumeSession,
@@ -15184,7 +15253,11 @@ class ApiMachineClient {
   }
   bindRpcRequestHandler(socket, transport) {
     socket.on("rpc-request", async (data, callback) => {
-      persistence.logger.debugLargeJson(`[API MACHINE] Received RPC request via ${transport}:`, data);
+      if (typeof data?.method === "string" && this.rpcHandlerManager.isPlainMethod(data.method)) {
+        persistence.logger.debug(`[API MACHINE] Received plain RPC request via ${transport}: ${data.method}`);
+      } else {
+        persistence.logger.debugLargeJson(`[API MACHINE] Received RPC request via ${transport}:`, data);
+      }
       await answerSocketRequest(
         callback,
         () => this.rpcHandlerManager.handleRequest(data),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "very-happy-cli",
-  "version": "0.2.156",
+  "version": "0.2.158",
   "description": "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.",
   "author": "Kirill Dubovitskiy",
   "contributors": [
@@ -117,12 +117,12 @@
     "zod": "^4.0.0"
   },
   "optionalDependencies": {
-    "very-happy-tools-arm64-darwin": "0.2.156",
-    "very-happy-tools-x64-darwin": "0.2.156",
-    "very-happy-tools-arm64-linux": "0.2.156",
-    "very-happy-tools-x64-linux": "0.2.156",
-    "very-happy-tools-arm64-win32": "0.2.156",
-    "very-happy-tools-x64-win32": "0.2.156"
+    "very-happy-tools-arm64-darwin": "0.2.158",
+    "very-happy-tools-x64-darwin": "0.2.158",
+    "very-happy-tools-arm64-linux": "0.2.158",
+    "very-happy-tools-x64-linux": "0.2.158",
+    "very-happy-tools-arm64-win32": "0.2.158",
+    "very-happy-tools-x64-win32": "0.2.158"
   },
   "devDependencies": {
     "@slopus/happy-wire": "workspace:*",