very-happy-cli 0.2.159 → 0.2.161

package/dist/lib.cjs

@@ -1,40 +1,49 @@
 'use strict';
 
-var index = require('./types-BbvK1Tr_.cjs');
-var persistence = require('./limits-BH5CV5vR.cjs');
+var api = require('./api-B2vLMS-z.cjs');
+var logger = require('./logger-Bc8-u1w0.cjs');
+var configuration = require('./configuration-v9f8LM9T.cjs');
+var types = require('./types-CRS-srZK.cjs');
 require('axios');
 require('node:events');
 require('socket.io-client');
+require('./attachmentLimits-CzVrqgLR.cjs');
 require('zod');
+require('./index-DA7yINuk.cjs');
+require('@paralleldrive/cuid2');
+require('./authRelay-BdYkC1Po.cjs');
 require('node:crypto');
+require('tweetnacl');
+require('./limits-C-a7gr04.cjs');
+require('./time-CNRE4ChD.cjs');
+require('./lidState-KHHu1015.cjs');
+require('os');
 require('child_process');
+require('./registerCommonHandlers-BjSV2Skz.cjs');
 require('util');
 require('fs/promises');
 require('crypto');
 require('path');
 require('cross-spawn');
-require('./terminalTitleSuggest-Dji8I0Jy.cjs');
+require('./projectPath-ChLhdOyt.cjs');
 require('url');
-require('os');
-require('@paralleldrive/cuid2');
+require('./sync-CVk4QERO.cjs');
+require('./backgroundTaskActivity-CBvUdj39.cjs');
+require('./controlClient-fEHE85bH.cjs');
+require('./persistence-CBNMzSa8.cjs');
 require('node:fs/promises');
-require('node:path');
-require('node:os');
-require('node:child_process');
-require('node-pty');
 require('node:fs');
-require('fs');
-require('tweetnacl');
-require('node:readline');
-require('@anthropic-ai/sandbox-runtime');
-require('expo-server-sdk');
+require('./contentLogMetadata-ZSFk_NjQ.cjs');
 require('chalk');
 require('node:util');
+require('node:path');
+require('node:os');
+require('./package-Cl5BEP5x.cjs');
 
 
 
-exports.ApiClient = index.ApiClient;
-exports.ApiSessionClient = index.ApiSessionClient;
-exports.RawJSONLinesSchema = index.RawJSONLinesSchema;
-exports.configuration = persistence.configuration;
-exports.logger = persistence.logger;
+exports.ApiClient = api.ApiClient;
+exports.ApiSessionClient = api.ApiSessionClient;
+exports.logger = logger.logger;
+exports.configuration = configuration.configuration;
+exports.RawJSONLinesSchema = types.RawJSONLinesSchema;

package/dist/lib.d.cts

@@ -1043,6 +1043,15 @@ type ACPMessageData = {
     [key: string]: unknown;
 };
 declare class ApiSessionClient extends EventEmitter {
+    /**
+     * B-512: the session socket now connects before the runner has attached its
+     * `archived` listener (registerKillSessionHandler). An archive signal that
+     * fires in that window must not be lost: remember it and replay it to any
+     * listener attached later.
+     */
+    private archiveSignalled;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
     private readonly token;
     readonly sessionId: string;
     private metadata;
@@ -1680,8 +1689,9 @@ type SessionNotificationKind = 'done' | 'permission' | 'question';
 declare class PushNotificationClient {
     private readonly token;
     private readonly baseUrl;
-    private readonly expo;
+    private expoLoad;
     constructor(token: string, baseUrl?: string);
+    private loadExpo;
     /**
      * Fetch all push tokens for the authenticated user.
      * Retries up to 3 times with exponential backoff on transient errors.
@@ -1807,7 +1817,7 @@ declare class ApiClient {
     sessionSyncClient(session: Session, opts?: {
         initialSeq?: number;
     }): ApiSessionClient;
-    machineSyncClient(machine: Machine): ApiMachineClient;
+    machineSyncClient(machine: Machine): Promise<ApiMachineClient>;
     push(): PushNotificationClient;
     /**
      * Create an account-encrypted notification producer bound to a session.

package/dist/lib.d.mts

@@ -1043,6 +1043,15 @@ type ACPMessageData = {
     [key: string]: unknown;
 };
 declare class ApiSessionClient extends EventEmitter {
+    /**
+     * B-512: the session socket now connects before the runner has attached its
+     * `archived` listener (registerKillSessionHandler). An archive signal that
+     * fires in that window must not be lost: remember it and replay it to any
+     * listener attached later.
+     */
+    private archiveSignalled;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
     private readonly token;
     readonly sessionId: string;
     private metadata;
@@ -1680,8 +1689,9 @@ type SessionNotificationKind = 'done' | 'permission' | 'question';
 declare class PushNotificationClient {
     private readonly token;
     private readonly baseUrl;
-    private readonly expo;
+    private expoLoad;
     constructor(token: string, baseUrl?: string);
+    private loadExpo;
     /**
      * Fetch all push tokens for the authenticated user.
      * Retries up to 3 times with exponential backoff on transient errors.
@@ -1807,7 +1817,7 @@ declare class ApiClient {
     sessionSyncClient(session: Session, opts?: {
         initialSeq?: number;
     }): ApiSessionClient;
-    machineSyncClient(machine: Machine): ApiMachineClient;
+    machineSyncClient(machine: Machine): Promise<ApiMachineClient>;
     push(): PushNotificationClient;
     /**
      * Create an account-encrypted notification producer bound to a session.

package/dist/lib.mjs

@@ -1,30 +1,39 @@
-export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema } from './types-Dh-s4Lqs.mjs';
-export { c as configuration, l as logger } from './limits-CjRj8IX5.mjs';
+export { A as ApiClient, a as ApiSessionClient } from './api-SffjRQ1b.mjs';
+export { l as logger } from './logger-fXoNzNuB.mjs';
+export { c as configuration } from './configuration-DoWFJUPm.mjs';
+export { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
 import 'axios';
 import 'node:events';
 import 'socket.io-client';
+import './attachmentLimits-yba1uHFO.mjs';
 import 'zod';
+import './index-qdS1friN.mjs';
+import '@paralleldrive/cuid2';
+import './authRelay-DSAvg1uv.mjs';
 import 'node:crypto';
+import 'tweetnacl';
+import './limits-DIo7rEBR.mjs';
+import './time-BZNdNiIV.mjs';
+import './lidState-C2dI0FAN.mjs';
+import 'os';
 import 'child_process';
+import './registerCommonHandlers-CrgvJsOy.mjs';
 import 'util';
 import 'fs/promises';
 import 'crypto';
 import 'path';
 import 'cross-spawn';
-import './terminalTitleSuggest-DKgX3osW.mjs';
+import './projectPath-BTBIMB57.mjs';
 import 'url';
-import 'os';
-import '@paralleldrive/cuid2';
+import './sync-CxD-w_40.mjs';
+import './backgroundTaskActivity-8PdPxrvy.mjs';
+import './controlClient-DjoKTtgK.mjs';
+import './persistence-oET5n61f.mjs';
 import 'node:fs/promises';
-import 'node:path';
-import 'node:os';
-import 'node:child_process';
-import 'node-pty';
 import 'node:fs';
-import 'fs';
-import 'tweetnacl';
-import 'node:readline';
-import '@anthropic-ai/sandbox-runtime';
-import 'expo-server-sdk';
+import './contentLogMetadata-BlWI0egu.mjs';
 import 'chalk';
 import 'node:util';
+import 'node:path';
+import 'node:os';
+import './package-uOg9SCKi.mjs';

package/dist/lidState-C2dI0FAN.mjs

@@ -0,0 +1,297 @@
+import { l as logger } from './logger-fXoNzNuB.mjs';
+import { e as encodeBase64, g as encrypt, h as decrypt, d as decodeBase64 } from './authRelay-DSAvg1uv.mjs';
+import os from 'os';
+import { execSync } from 'child_process';
+
+function isRateQuotaCode(code) {
+  return typeof code === "string" && code.endsWith("_rate_quota_exceeded");
+}
+const RATE_RETRY_MIN_DELAY_MS = 2e3;
+const RATE_RETRY_MAX_DELAY_MS = 6e4;
+function rateRetryDelayMs(attempt, random = Math.random()) {
+  const exponent = Math.max(0, Math.min(attempt, 32) - 1);
+  const ceiling = Math.min(RATE_RETRY_MIN_DELAY_MS * 2 ** exponent, RATE_RETRY_MAX_DELAY_MS);
+  return Math.round(RATE_RETRY_MIN_DELAY_MS + random * (ceiling - RATE_RETRY_MIN_DELAY_MS));
+}
+async function pauseForRateQuota(opts) {
+  const ms = rateRetryDelayMs(opts.attempt);
+  opts.log?.(`[RATE] ${opts.label} write refused (${opts.code}), attempt ${opts.attempt} \u2014 waiting ${ms}ms`);
+  await opts.sleep(ms);
+  return ms;
+}
+
+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;
+  logger;
+  sockets = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.scopePrefix = config.scopePrefix;
+    this.encryptionKey = config.encryptionKey;
+    this.encryptionVariant = config.encryptionVariant;
+    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);
+    for (const socket of this.sockets) socket.emit("rpc-register", { method: prefixedMethod });
+  }
+  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) {
+        this.logger("[RPC] [ERROR] Method not found", { method: request.method });
+        const errorResponse = { error: "Method not found" };
+        const encryptedError = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, errorResponse));
+        return encryptedError;
+      }
+      const decryptedParams = decrypt(this.encryptionKey, this.encryptionVariant, decodeBase64(request.params));
+      this.logger("[RPC] Calling handler", { method: request.method });
+      const result = await handler(decryptedParams);
+      this.logger("[RPC] Handler returned", { method: request.method, hasResult: result !== void 0 });
+      const encryptedResponse = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, result));
+      this.logger("[RPC] Sending encrypted response", { method: request.method, responseLength: encryptedResponse.length });
+      return encryptedResponse;
+    } catch (error) {
+      this.logger("[RPC] [ERROR] Error handling request", { error });
+      const errorResponse = {
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+      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) {
+      socket.emit("rpc-register", { method: prefixedMethod });
+    }
+  }
+  /**
+   * Attach a candidate transport and wait until the server confirms every
+   * method before a release handover closes the old transport.
+   */
+  async onSocketConnectAndWait(socket, timeoutMs = 1e4) {
+    this.sockets.add(socket);
+    const pending = new Set(this.handlers.keys());
+    const acknowledged = /* @__PURE__ */ new Set();
+    await new Promise((resolve, reject) => {
+      let settleTimer = null;
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error(`RPC registration timed out (${pending.size} pending)`));
+      }, timeoutMs);
+      timer.unref?.();
+      const maybeSettle = () => {
+        if (pending.size > 0 || settleTimer) return;
+        settleTimer = setTimeout(() => {
+          settleTimer = null;
+          for (const prefixedMethod of this.handlers.keys()) {
+            if (acknowledged.has(prefixedMethod) || pending.has(prefixedMethod)) continue;
+            pending.add(prefixedMethod);
+            socket.emit("rpc-register", { method: prefixedMethod });
+          }
+          if (pending.size === 0) {
+            cleanup();
+            resolve();
+          }
+        }, 0);
+        settleTimer.unref?.();
+      };
+      const onRegistered = (data) => {
+        if (typeof data?.method !== "string") return;
+        acknowledged.add(data.method);
+        pending.delete(data.method);
+        maybeSettle();
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        if (settleTimer) clearTimeout(settleTimer);
+        socket.off("rpc-registered", onRegistered);
+      };
+      socket.on("rpc-registered", onRegistered);
+      for (const prefixedMethod of pending) socket.emit("rpc-register", { method: prefixedMethod });
+      maybeSettle();
+    }).catch((error) => {
+      this.sockets.delete(socket);
+      throw error;
+    });
+  }
+  onSocketDisconnect(socket) {
+    if (socket) this.sockets.delete(socket);
+    else this.sockets.clear();
+  }
+  /**
+   * 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}`;
+  }
+}
+
+function describeSocketAckDrop(drop) {
+  switch (drop.reason) {
+    case "no-ack":
+      return "no ack callback on the frame (re-delivered after a transport close?); response dropped";
+    case "handler-threw":
+      return `handler threw: ${drop.error instanceof Error ? drop.error.message : String(drop.error)}`;
+    case "ack-threw":
+      return `ack callback threw: ${drop.error instanceof Error ? drop.error.message : String(drop.error)}`;
+  }
+}
+function safeAck(ack, onDrop) {
+  return (value) => {
+    if (typeof ack !== "function") {
+      onDrop({ reason: "no-ack" });
+      return;
+    }
+    try {
+      ack(value);
+    } catch (error) {
+      onDrop({ reason: "ack-threw", error });
+    }
+  };
+}
+async function answerSocketRequest(ack, run, onDrop) {
+  let value;
+  try {
+    value = await run();
+  } catch (error) {
+    onDrop({ reason: "handler-threw", error });
+    return;
+  }
+  safeAck(ack, onDrop)(value);
+}
+
+function hasNetworkConnectivity() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name] || []) {
+      if (!iface.internal && iface.family === "IPv4") return true;
+    }
+  }
+  return false;
+}
+function isLidClosed() {
+  if (process.platform !== "darwin") return false;
+  try {
+    const output = execSync("ioreg -r -k AppleClamshellState -d 4", {
+      timeout: 5e3,
+      encoding: "utf-8"
+    });
+    return output.includes('"AppleClamshellState" = Yes');
+  } catch {
+    return false;
+  }
+}
+function hasExternalDisplay() {
+  if (process.platform !== "darwin") return false;
+  try {
+    const output = execSync("system_profiler SPDisplaysDataType -json 2>/dev/null", {
+      timeout: 1e4,
+      encoding: "utf-8"
+    });
+    const data = JSON.parse(output);
+    const gpus = data.SPDisplaysDataType || [];
+    for (const gpu of gpus) {
+      const displays = gpu.spdisplays_ndrvs || [];
+      for (const display of displays) {
+        const isBuiltIn = display.spdisplays_builtin === "spdisplays_yes" || display.spdisplays_connection_type === "spdisplays_internal";
+        if (!isBuiltIn) return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function shouldReconnect() {
+  if (!hasNetworkConnectivity()) return false;
+  if (isLidClosed() && !hasExternalDisplay()) return false;
+  return true;
+}
+
+export { RpcHandlerManager as R, answerSocketRequest as a, shouldReconnect as b, describeSocketAckDrop as d, isRateQuotaCode as i, pauseForRateQuota as p, safeAck as s };