very-happy-cli 0.2.156 → 0.2.157

package/dist/{types-BEVzYSoV.mjs → types-BrGJ7PJz.mjs}

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { R as AgentVersionsSchema, l as logger, w as encodeBase64, L as encrypt, N as decrypt, M as decodeBase64, c as configuration, e as createEnvelope, s as streamKeyOf, S as backoff, T as ReleaseDrainNoticeSchema, U as decryptBlob, V as RelayAssignmentResponseSchema, W as notifyDaemonTurnEvent, X as prepareClipboardText, Y as prepareClipboardHistoryText, g as delay, r as readSettings, d as readPersistedSessions, Z as credentialRelayProblem, F as packageJson, _ as RelayCandidatesResponseSchema, $ as readTrackedClaudeSessionIds, a0 as readTrackedCodexThreadIds, a1 as isValidTerminalId, a2 as exponentialBackoffDelay, a3 as libsodiumEncryptForPublicKey, a4 as libsodiumPublicKeyFromSecretKey, a5 as getRandomBytes, a6 as redactLogValue } from './limits-DmMdchTz.mjs';
+import { S as AgentVersionsSchema, l as logger, w as encodeBase64, L as encrypt, N as decrypt, M as decodeBase64, c as configuration, e as createEnvelope, s as streamKeyOf, T as backoff, U as ReleaseDrainNoticeSchema, V as decryptBlob, W as RelayAssignmentResponseSchema, X as notifyDaemonTurnEvent, Y as BackgroundTaskReporter, Z as notifyDaemonBackgroundTasks, _ as prepareClipboardText, $ as prepareClipboardHistoryText, g as delay, r as readSettings, d as readPersistedSessions, a0 as credentialRelayProblem, F as packageJson, a1 as RelayCandidatesResponseSchema, a2 as readTrackedClaudeSessionIds, a3 as readTrackedCodexThreadIds, a4 as isValidTerminalId, a5 as exponentialBackoffDelay, a6 as libsodiumEncryptForPublicKey, a7 as libsodiumPublicKeyFromSecretKey, a8 as getRandomBytes, a9 as redactLogValue } from './limits-A2c-3M-_.mjs';
 import { EventEmitter } from 'node:events';
 import { io } from 'socket.io-client';
 import { z } from 'zod';
@@ -417,6 +417,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;
@@ -441,14 +450,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) {
@@ -472,6 +498,25 @@ class RpcHandlerManager {
       return encodeBase64(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) {
@@ -2979,16 +3024,29 @@ class ApiSessionClient extends 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 notifyDaemonTurnEvent(this.sessionId, event).catch((error) => 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 BackgroundTaskReporter((tasks, now) => {
+    void notifyDaemonBackgroundTasks(this.sessionId, tasks).catch((error) => 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) {
       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 } : {}
     });
   }
   /**
@@ -14335,6 +14393,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,
@@ -15163,7 +15232,11 @@ class ApiMachineClient {
   }
   bindRpcRequestHandler(socket, transport) {
     socket.on("rpc-request", async (data, callback) => {
-      logger.debugLargeJson(`[API MACHINE] Received RPC request via ${transport}:`, data);
+      if (typeof data?.method === "string" && this.rpcHandlerManager.isPlainMethod(data.method)) {
+        logger.debug(`[API MACHINE] Received plain RPC request via ${transport}: ${data.method}`);
+      } else {
+        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.157",
   "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.157",
+    "very-happy-tools-x64-darwin": "0.2.157",
+    "very-happy-tools-arm64-linux": "0.2.157",
+    "very-happy-tools-x64-linux": "0.2.157",
+    "very-happy-tools-arm64-win32": "0.2.157",
+    "very-happy-tools-x64-win32": "0.2.157"
   },
   "devDependencies": {
     "@slopus/happy-wire": "workspace:*",