very-happy-cli 0.2.165 → 0.2.167

package/dist/{codexCommand-C3gdjMAw.mjs → codexCommand-BZSr4MKI.mjs}

@@ -1,94 +1,96 @@
-import { a as authAndSetupMachineIfNeeded } from './auth-BY5ujhGn.mjs';
-import { e as createEnvelope, l as BUILTIN_TODO_DISCOVERY, P as PROMPT_QUEUE_CAPABILITY } from './index-vVWpCoTr.mjs';
+import { a as authAndSetupMachineIfNeeded } from './auth-CFS9Lfgv.mjs';
+import { c as createEnvelope, o as BUILTIN_TODO_DISCOVERY, P as PROMPT_QUEUE_CAPABILITY } from './index-B0HEEYGh.mjs';
 import { p as publishForkBackfillWhenCommitted, F as FORK_BACKFILL_CAPABILITY } from './forkBackfill-DYIjlN1Z.mjs';
 import { randomUUID } from 'node:crypto';
 import { createId } from '@paralleldrive/cuid2';
 import { r as registerAgentAttachmentDownloads } from './agentAttachments-M_B5qEF2.mjs';
-import { C as CLAUDE_ATTACHMENT_KINDS, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-dzIs-wis.mjs';
+import { C as CLAUDE_ATTACHMENT_KINDS, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-j875mwU7.mjs';
 import { useStdout, useInput, Box, Text, render } from 'ink';
-import { c as claimSessionOrExit, a as applyServerSnapshot, w as withoutServerSnapshot, m as mergeReconnectMetadata } from './sessionLock-Dm8QyGo4.mjs';
+import { c as claimSessionOrExit, a as applyServerSnapshot, b as applyHibernationReplay, w as withoutServerSnapshot, m as mergeReconnectMetadata } from './sessionLock-AwOYsKT7.mjs';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
-import { c as connectionState, A as ApiClient } from './api-DTVPUE7g.mjs';
-import { C as CodexAppServerClient } from './codexAppServerClient-B0QaMQsC.mjs';
-import { l as logger } from './logger-CknSVkIe.mjs';
-import { B as BasePermissionHandler } from './BasePermissionHandler-CwJ48yiB.mjs';
-import { B as BaseReasoningProcessor } from './BaseReasoningProcessor-ClF2g1qz.mjs';
+import { c as connectionState, A as ApiClient } from './api-CReZazeT.mjs';
+import { C as CodexAppServerClient } from './codexAppServerClient-Dd_4TxHv.mjs';
+import { p as parseSpecialCommand, w as wrapperRateLimitReporter } from './specialCommands-DisVxagO.mjs';
+import { l as logger } from './logger-CbBv3q_b.mjs';
+import { B as BasePermissionHandler } from './BasePermissionHandler-DS0kRTNI.mjs';
+import { B as BaseReasoningProcessor } from './BaseReasoningProcessor-BRtCCt7q.mjs';
 import { execSync } from 'node:child_process';
-import { readSettings } from './persistence-DujtUH94.mjs';
-import { g as getInitialMachineMetadata } from './machineMetadata-Cj1DoFot.mjs';
-import { c as configuration } from './configuration-L1qcGTFM.mjs';
-import { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-Czz0tdki.mjs';
+import { r as readSettings, l as latchKeepAwake, e as evaluateWrapperIdle, a as resolveCheckMs, H as HIBERNATION_CAPABILITY } from './persistence-ON0zpHfb.mjs';
+import { g as getInitialMachineMetadata } from './machineMetadata-DHg238U4.mjs';
+import { c as configuration } from './configuration-WspKd2C2.mjs';
+import { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-BJMHJHXe.mjs';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
 import { join } from 'node:path';
-import { c as createSessionMetadata } from './createSessionMetadata-CWR-AB2A.mjs';
-import { h as hashObject, s as startHappyServer } from './deterministicJson-BBwG-Ase.mjs';
+import { c as createSessionMetadata } from './createSessionMetadata-BEZ4DIDA.mjs';
+import { h as hashObject, s as startHappyServer } from './deterministicJson-BMMifViN.mjs';
 import { M as MessageBuffer } from './messageBuffer-BWlGgR3A.mjs';
-import { n as notifyDaemonSessionStarted, g as reportSessionEditToDaemon } from './controlClient-Ci7HTMII.mjs';
+import { n as notifyDaemonSessionStarted, j as reportSessionEditToDaemon, c as checkDaemonHibernation } from './controlClient-DTheOlvC.mjs';
+import { a as HibernationExitLatch, H as HibernationProbe, c as commitHibernation, b as DEFAULT_CODEX_PERMISSION_MODE } from './defaultPermissionMode-Cif_RHGb.mjs';
 import { d as decodeBase64, e as encodeBase64 } from './authRelay-DSAvg1uv.mjs';
-import { s as setupOfflineReconnection } from './setupOfflineReconnection-_MoZtsro.mjs';
+import { s as setupOfflineReconnection } from './setupOfflineReconnection-BfDBxNdo.mjs';
 import { t as trimIdent } from './trimIdent-BAjmv_TG.mjs';
-import { p as parseSpecialCommand } from './specialCommands-BSqhYg5X.mjs';
 import { C as CHANGE_TITLE_INSTRUCTION } from './constants-BC4St0xd.mjs';
-import { a as DEFAULT_CODEX_PERMISSION_MODE } from './defaultPermissionMode-BnxJPVHT.mjs';
 import { E as EditReportThrottle, a as extractCodexPatchPaths } from './editPaths-BVfS_FFL.mjs';
-import { a as extractNoSandboxFlag, e as ensureDaemonRunning } from './ensureDaemonRunning-b1pvEFcS.mjs';
+import { a as extractNoSandboxFlag, e as ensureDaemonRunning } from './ensureDaemonRunning-Ba5fYoxb.mjs';
 import 'tweetnacl';
 import 'axios';
-import './time-v1Y_qEJp.mjs';
-import './browser-mwzpOmcw.mjs';
+import './time-PG5Dfwdv.mjs';
+import './browser-BCFIHOvo.mjs';
 import 'open';
 import 'zod';
 import 'node:fs/promises';
-import './attachmentLimits-B8nzhw-i.mjs';
+import './attachmentLimits-CxG3T18E.mjs';
 import 'node:fs';
-import './lidState-BLHLmhwd.mjs';
+import './lidState-B2ZxdREe.mjs';
 import 'os';
 import 'child_process';
 import 'node:events';
 import 'socket.io-client';
 import './limits-DIo7rEBR.mjs';
-import './registerCommonHandlers-BR0J4g64.mjs';
+import './registerCommonHandlers-B0PVff2U.mjs';
 import 'util';
 import 'fs/promises';
 import 'crypto';
 import 'path';
 import 'cross-spawn';
-import './sync-Dfm6K2te.mjs';
+import './sync-CCwYpJMS.mjs';
 import './backgroundTaskActivity-8PdPxrvy.mjs';
 import './contentLogMetadata-BlWI0egu.mjs';
 import 'chalk';
 import 'node:readline';
-import './manager-BQ4flvQZ.mjs';
+import './manager-BEsI4qt3.mjs';
 import '@anthropic-ai/sandbox-runtime';
 import 'node:os';
-import './package-VIUXrYZ1.mjs';
+import './package-DU1DxhH9.mjs';
+import './rateLimitWindows-vZ9Bo7aT.mjs';
 import 'node:util';
 import './detectCLI-CSGMlV51.mjs';
 import 'fs';
-import './localHappyAgentAuth-BWvmc_Hg.mjs';
+import './localHappyAgentAuth-B5XPEMwk.mjs';
 import './types-CkqAACXx.mjs';
 import 'url';
-import './client-BwaWdlCm.mjs';
-import './context-DaCCB4cm.mjs';
-import './sessionOps-DG5MMEp_.mjs';
+import './client-Dsfy_SAb.mjs';
+import './context-Cr6a3NTg.mjs';
+import './sessionOps-DZRH4-hV.mjs';
 import './resources-BdFBQi8r.mjs';
-import './tools-jof0Bu54.mjs';
-import './tools-BVRoGcQH.mjs';
-import './client-CJZKBZCE.mjs';
-import './peerTools-SWITnkqz.mjs';
+import './tools-D91mq5Ib.mjs';
+import './reportProgressTool-BvB13EwC.mjs';
+import './client-C7FYMer0.mjs';
+import './precheckCompat-DeEbilbr.mjs';
+import './agentGuidance-BDYt2Qy2.mjs';
+import './peerTools-os2DVjA0.mjs';
 import './ids-DU6sLx4C.mjs';
-import './remoteSessionClient-DCAUHgPz.mjs';
+import './remoteSessionClient-BzPXSC21.mjs';
 import '@modelcontextprotocol/sdk/server/mcp.js';
 import 'node:http';
 import '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import './assistantTools-DPGga5lM.mjs';
+import './downloadTarget-Cp48jrIP.mjs';
 import './terminals-Dlg0x3nY.mjs';
 import './terminalTitleSuggest-CeKsX_V6.mjs';
 import './tmuxSocket-B8Yx20sT.mjs';
-import './bootstrap-D_ExGrY2.mjs';
-import './agentGuidance-CQuNlNx8.mjs';
+import './bootstrap-BSOxYpaP.mjs';
 import './previewPath-CXN4Vag0.mjs';
-import './spawnHappyCLI-Dc4xYm8P.mjs';
+import './spawnHappyCLI-B2h0P4b5.mjs';
 import './doctorReadiness-C208SMN9.mjs';
 
 function getStartedSubagents(state) {
@@ -650,20 +652,29 @@ async function readChildThread(client, childId) {
   return { envelopes: mapCodexThreadToSessionEnvelopes(thread) };
 }
 
+const HAPPY_MCP_SERVER_NAME = "happy";
 class CodexPermissionHandler extends BasePermissionHandler {
   // Exact tool names that should always be auto-approved. Include the bare
   // form (used by Codex elicitation messages like `tool "change_title"`)
-  // and the MCP-qualified form for defense in depth.
+  // and the MCP-qualified form for defense in depth. A BARE name (and an ID
+  // prefix) only counts when the request comes from our own server: any
+  // other MCP server may expose a tool with the same name.
+  // B-556: report_progress only writes this session's own board line (same
+  // trust as change_title); an approval prompt per report would park the
+  // session in "waiting for you" at every milestone.
   static ALWAYS_AUTO_APPROVE_NAMES = /* @__PURE__ */ new Set([
     "change_title",
-    "mcp__happy__change_title"
+    "mcp__happy__change_title",
+    "report_progress",
+    "mcp__happy__report_progress"
   ]);
   // Tool-call IDs that should auto-approve when they exactly match one of
   // these values or start with `<name>-` (e.g. `change_title-1765385846663`).
   // Substring matching was a bypass vector — any tool whose ID happened to
   // contain `change_title` as a substring would be silently approved.
   static ALWAYS_AUTO_APPROVE_ID_PREFIXES = [
-    "change_title"
+    "change_title",
+    "report_progress"
   ];
   constructor(session) {
     super(session);
@@ -671,7 +682,11 @@ class CodexPermissionHandler extends BasePermissionHandler {
   getLogPrefix() {
     return "[Codex]";
   }
-  shouldAutoApprove(toolName, toolCallId) {
+  shouldAutoApprove(toolName, toolCallId, serverName) {
+    if (toolName.startsWith(`mcp__${HAPPY_MCP_SERVER_NAME}__`)) {
+      return CodexPermissionHandler.ALWAYS_AUTO_APPROVE_NAMES.has(toolName);
+    }
+    if (serverName !== HAPPY_MCP_SERVER_NAME) return false;
     if (CodexPermissionHandler.ALWAYS_AUTO_APPROVE_NAMES.has(toolName)) {
       return true;
     }
@@ -687,10 +702,11 @@ class CodexPermissionHandler extends BasePermissionHandler {
    * @param toolCallId - The unique ID of the tool call
    * @param toolName - The name of the tool being called
    * @param input - The input parameters for the tool
+   * @param serverName - MCP server of an elicitation (`mcpServer/elicitation/request`); undefined for exec/patch
    * @returns Promise resolving to permission result
    */
-  async handleToolCall(toolCallId, toolName, input) {
-    if (this.shouldAutoApprove(toolName, toolCallId)) {
+  async handleToolCall(toolCallId, toolName, input, serverName) {
+    if (this.shouldAutoApprove(toolName, toolCallId, serverName)) {
       logger.debug(`${this.getLogPrefix()} Auto-approving tool ${toolName} (${toolCallId})`);
       this.session.updateAgentState((currentState) => ({
         ...currentState,
@@ -913,6 +929,29 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit }) => {
   ));
 };
 
+async function settleCodexSession(session, intent, deactivate, log = () => {
+}) {
+  if (intent === "archive") {
+    session.updateMetadata((currentMetadata) => ({
+      ...currentMetadata,
+      lifecycleState: "archived",
+      lifecycleStateSince: Date.now(),
+      archivedBy: "cli",
+      archiveReason: "User terminated"
+    }));
+  }
+  session.sendSessionDeath();
+  await session.flush();
+  if (intent === "offline") {
+    try {
+      await deactivate(session.sessionId);
+    } catch (error) {
+      log("[Codex] deactivate on signal failed", error);
+    }
+  }
+  await session.close();
+}
+
 function resolveCodexExecutionPolicy(permissionMode, sandboxManagedByHappy) {
   if (sandboxManagedByHappy) {
     return {
@@ -1277,7 +1316,7 @@ async function runCodex(opts) {
     dangerouslySkipPermissions: initialPermissionMode === "yolo" || initialPermissionMode === "bypassPermissions",
     ...forkedFromSessionId ? { parentSessionId: forkedFromSessionId } : {},
     ...forkedFromMessageId ? { forkedFromMessageId } : {},
-    capabilities: [PROMPT_QUEUE_CAPABILITY, FORK_BACKFILL_CAPABILITY]
+    capabilities: [PROMPT_QUEUE_CAPABILITY, FORK_BACKFILL_CAPABILITY, HIBERNATION_CAPABILITY]
   });
   metadata.attachmentKinds = [...CLAUDE_ATTACHMENT_KINDS];
   const importCodexThreadId = process.env[IMPORT_CODEX_THREAD_ENV];
@@ -1315,12 +1354,16 @@ async function runCodex(opts) {
     throw new Error(`Failed to reactivate archived session ${response.id}`);
   }
   let reconnectSeeded = false;
+  let wakingFromHibernation = false;
   if (reconnectSessionId && response) {
     const snapshot = await api.getSession(response.id, response.encryptionKey, response.encryptionVariant);
     if (snapshot.ok) {
       response = applyServerSnapshot(response, snapshot.session);
       reconnectSeeded = true;
       logger.debug(`[START] Reconnect seeded from server: seq=${snapshot.session.seq} metadataVersion=${snapshot.session.metadataVersion}`);
+      const wake = applyHibernationReplay(response);
+      response = wake.response;
+      wakingFromHibernation = wake.replaying;
     } else {
       response = withoutServerSnapshot(response);
       logger.debug(`[START] Reconnect without server snapshot (${snapshot.reason}); skipping existing messages`);
@@ -1351,7 +1394,7 @@ async function runCodex(opts) {
   if (reconnectSessionId) {
     session.suppressNextArchiveSignal();
     if (!reconnectSeeded) session.skipExistingMessages();
-    void session.cancelUndeliveredQueuedInputs();
+    if (!wakingFromHibernation) void session.cancelUndeliveredQueuedInputs();
     session.updateMetadata((meta) => mergeReconnectMetadata(meta, metadata, Date.now()));
   }
   if (response) {
@@ -1515,7 +1558,10 @@ async function runCodex(opts) {
   }
   let abortController = new AbortController();
   let shouldExit = false;
-  async function handleAbort() {
+  const hibernationExit = new HibernationExitLatch((a, b) => a === "archive" && b !== "archive");
+  let hibernationStamp = null;
+  let hibernationProbe = null;
+  async function handleAbort(source) {
     if (abortInProgress) {
       await abortInProgress;
       return;
@@ -1531,6 +1577,9 @@ async function runCodex(opts) {
             gracePeriodMs: 3e3,
             forceRestartOnTimeout: true
           });
+          if (source === "user" && abortResult.hadActiveTurn && abortResult.aborted) {
+            session.sendSessionEvent({ type: "message", message: "Aborted by user" });
+          }
           if (abortResult.forcedRestart) {
             logger.warn("[Codex] Forced app-server restart after interrupt timeout");
             session.sendSessionEvent({
@@ -1554,23 +1603,16 @@ async function runCodex(opts) {
     await abortInProgress;
     abortInProgress = null;
   }
-  const handleKillSession = async () => {
+  const handleKillSession = async (intent = "archive") => {
+    if (hibernationExit.intercept(intent)) {
+      logger.debug(`[Codex] ${intent} exit deferred: hibernation in progress`);
+      return;
+    }
     logger.debug("[Codex] Kill session requested - terminating process");
-    await handleAbort();
+    await handleAbort("kill");
     logger.debug("[Codex] Abort completed, proceeding with termination");
     try {
-      if (session) {
-        session.updateMetadata((currentMetadata) => ({
-          ...currentMetadata,
-          lifecycleState: "archived",
-          lifecycleStateSince: Date.now(),
-          archivedBy: "cli",
-          archiveReason: "User terminated"
-        }));
-        session.sendSessionDeath();
-        await session.flush();
-        await session.close();
-      }
+      if (session) await settleCodexSession(session, intent, (id) => api.deactivateSession(id), (m, e) => logger.debug(m, safeCodexErrorMetadata(e)));
       try {
         await client.disconnect();
       } catch (e) {
@@ -1591,8 +1633,8 @@ async function runCodex(opts) {
       return { error: error instanceof Error ? error.message : "Child read failed" };
     }
   });
-  session.rpcHandlerManager.registerHandler("abort", handleAbort);
-  const disposeTermination = registerKillSessionHandler(session.rpcHandlerManager, handleKillSession, session, { processSignals: true });
+  session.rpcHandlerManager.registerHandler("abort", () => handleAbort("user"));
+  const disposeTermination = registerKillSessionHandler(session.rpcHandlerManager, () => handleKillSession("archive"), session, { processSignals: true, onSignal: () => handleKillSession("offline") });
   const messageBuffer = new MessageBuffer();
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
   let inkInstance = null;
@@ -1604,7 +1646,7 @@ async function runCodex(opts) {
       onExit: async () => {
         logger.debug("[codex]: Exiting agent via Ctrl-C");
         shouldExit = true;
-        await handleAbort();
+        await handleAbort("exit");
       }
     }), {
       exitOnCtrlC: false,
@@ -1653,7 +1695,7 @@ async function runCodex(opts) {
     const toolName = params.type === "exec" ? "CodexBash" : params.type === "patch" ? "CodexPatch" : params.toolName ?? "McpTool";
     const input = params.type === "exec" ? { command: params.command, cwd: params.cwd } : params.type === "patch" ? { changes: params.fileChanges } : params.input ?? {};
     try {
-      const result = await permissionHandler.handleToolCall(params.callId, toolName, input);
+      const result = await permissionHandler.handleToolCall(params.callId, toolName, input, params.type === "mcp" ? params.serverName : void 0);
       logger.debug("[Codex] Permission request resolved");
       return result.decision;
     } catch (error) {
@@ -1662,6 +1704,7 @@ async function runCodex(opts) {
     }
   });
   const editThrottle = new EditReportThrottle();
+  client.setRateLimitHandler((snapshot) => wrapperRateLimitReporter().observeCodex(snapshot));
   client.setEventHandler((msg) => {
     if (msg.type === "token_count") {
       session.sendAgentUsageSnapshot("codex", msg);
@@ -1766,7 +1809,7 @@ async function runCodex(opts) {
   const happyServer = await startHappyServer(session);
   const bridgeEntrypoint = join(projectPath(), "bin", "very-happy-mcp.mjs");
   const mcpServers = {
-    happy: {
+    [HAPPY_MCP_SERVER_NAME]: {
       command: process.execPath,
       args: ["--no-warnings", "--no-deprecation", bridgeEntrypoint, "--url", happyServer.url]
     }
@@ -1843,6 +1886,54 @@ async function runCodex(opts) {
       }
     }
     let pending = null;
+    if (opts.startedBy === "daemon" && !hasTTY && process.env.HAPPY_SESSION_VARIANT !== "assistant") {
+      let keepAwakeLatch = false;
+      const hibernationSnapshot = () => {
+        const meta = session.getMetadata();
+        return {
+          flavor: "codex",
+          resumable: typeof meta?.codexThreadId === "string" && meta.codexThreadId.length > 0,
+          uiSession: true,
+          ...process.env.HAPPY_SPAWNED_BY ? { spawnedBy: process.env.HAPPY_SPAWNED_BY } : {},
+          ...meta?.tags ? { tags: meta.tags } : {},
+          keepAwake: keepAwakeLatch = latchKeepAwake(meta?.keepAwake, keepAwakeLatch),
+          ...typeof meta?.keepAwake === "boolean" ? { keepAwakeSetting: meta.keepAwake } : {},
+          thinking: thinking || turnActive,
+          queuedInputs: messageQueue.size() + (session.promptQueueHasPending() ? 1 : 0),
+          waitingForInput: messageQueue.isWaiting(),
+          pendingRequests: Object.keys(session.getAgentState()?.requests ?? {}).length,
+          backgroundTasks: codexActiveSubagents.size,
+          lastActivityAt: session.lastActivityAt,
+          ...shouldExit && !hibernationExit.hibernating ? { exiting: true } : {}
+        };
+      };
+      hibernationProbe = new HibernationProbe({
+        onKeepAwakeLatched: () => {
+          if (session.getMetadata()?.keepAwake === void 0) session.updateMetadata((m) => m.keepAwake === void 0 ? { ...m, keepAwake: true } : m);
+        },
+        checkMs: resolveCheckMs(),
+        snapshot: hibernationSnapshot,
+        ask: (report) => checkDaemonHibernation({ sessionId: session.sessionId, pid: process.pid, report }),
+        commit: (idleMs) => commitHibernation({
+          client: session,
+          claimExit: () => !shouldExit && hibernationExit.begin(),
+          exitRequested: () => hibernationExit.exitRequested,
+          markCommitted: () => hibernationExit.commit(),
+          releaseExit: () => {
+            const deferred = hibernationExit.release();
+            if (deferred) void handleKillSession(deferred);
+          },
+          recheck: () => evaluateWrapperIdle(hibernationSnapshot(), idleMs, Date.now()),
+          idleMs,
+          finish: async (stamp) => {
+            hibernationStamp = stamp;
+            shouldExit = true;
+            abortController.abort();
+          }
+        })
+      });
+      hibernationProbe.start();
+    }
     idleRelease.arm();
     while (!shouldExit) {
       logActiveHandles("loop-top");
@@ -1979,6 +2070,7 @@ async function runCodex(opts) {
     }
   } finally {
     disposeTermination?.();
+    hibernationProbe?.stop();
     session.closePromptQueueDrain();
     logger.debug("[codex]: Final cleanup start");
     logActiveHandles("cleanup-start");
@@ -2027,6 +2119,15 @@ async function runCodex(opts) {
     messageBuffer.clear();
     logActiveHandles("cleanup-end");
     logger.debug("[codex]: Final cleanup completed");
+    if (hibernationExit.hibernating && hibernationStamp) {
+      try {
+        await api.deactivateSession(session.sessionId);
+      } catch (error) {
+        logger.debug("[codex]: deactivate after hibernation failed", safeCodexErrorMetadata(error));
+      }
+      logger.debug("[codex]: hibernated; exiting");
+      process.exit(0);
+    }
   }
 }