@zonease/happy 0.6.38 → 0.6.39

package/dist/{runCodex-skq0j05d.cjs → runCodex-82UrZLme.cjs}

@@ -2,51 +2,67 @@
 
 var ink = require('ink');
 var React = require('react');
-var persistence = require('./types-DvTsFaqR.cjs');
+var api = require('./api-CwOCQeLH.cjs');
 var node_child_process = require('node:child_process');
 var node_readline = require('node:readline');
-var loadableToolOutput = require('./loadableToolOutput-5vdQB98M.cjs');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var loadableToolOutput = require('./loadableToolOutput-DDCJjywt.cjs');
 var node_crypto = require('node:crypto');
-var index = require('./index-BbCDDvoB.cjs');
-var constants = require('./constants-B4x1K7by.cjs');
+var downloadImage = require('./downloadImage-MQMrUUxS.cjs');
+var run = require('./run-BDn2aE3Q.cjs');
+var constants = require('./constants-E_UWYTo3.cjs');
+var controlClient = require('./controlClient-DZMIsKsT.cjs');
 var node_util = require('node:util');
 var promises = require('node:fs/promises');
 var path = require('node:path');
 require('axios');
-require('chalk');
-require('fs');
-require('node:fs');
-require('node:os');
 require('node:events');
 require('socket.io-client');
 require('zod');
+require('./index-CDTNgfUf.cjs');
 require('@paralleldrive/cuid2');
-require('tweetnacl');
+require('./time-Bj2HRkKH.cjs');
+require('node:fs');
+require('node:os');
 require('child_process');
 require('util');
 require('fs/promises');
 require('path');
+require('./projectPath-ChLhdOyt.cjs');
 require('url');
 require('node:module');
 require('ws');
 require('crypto');
+require('tweetnacl');
 require('@stablelib/base64');
 require('expo-server-sdk');
-require('./mcpToolSchemas-f-kttjFw.cjs');
-require('node:url');
-require('ps-list');
-require('cross-spawn');
-require('os');
-require('tmp');
-require('qrcode-terminal');
-require('open');
-require('fastify');
-require('fastify-type-provider-zod');
+require('./sessionKeyCache-4Tp8pJ3N.cjs');
+require('chalk');
+require('fs');
 require('@modelcontextprotocol/sdk/server/mcp.js');
 require('node:http');
 require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 require('@modelcontextprotocol/sdk/types.js');
-require('http');
+require('./deviceExec-CU1R9CRb.cjs');
+require('./auth-BIleVCw0.cjs');
+require('qrcode-terminal');
+require('./browser-Cc08m7of.cjs');
+require('open');
+require('./prompt-BTWDZZO0.cjs');
+require('./trimIdent-4gvk9Wk6.cjs');
+require('./common-CZvSRU4p.cjs');
+require('./mcpToolSchemas-DK42yoZ_.cjs');
+require('./types-DWeB7aqh.cjs');
+require('os');
+require('tmp');
+require('./doctor-Cya9YSA0.cjs');
+require('./doctor-C08m5Z9f.cjs');
+require('ps-list');
+require('cross-spawn');
+require('./spawnHappyCLI-D_V-AAoP.cjs');
+require('./install-BokHRgFW.cjs');
+require('fastify');
+require('fastify-type-provider-zod');
 
 class CodexJsonRpcPeer {
   process = null;
@@ -74,7 +90,7 @@ class CodexJsonRpcPeer {
       NODE_NO_WARNINGS: "1",
       NO_COLOR: "1"
     };
-    persistence.logger.debug(`[CodexRPC] Spawning: ${command} ${args.join(" ")} in ${opts.cwd}`);
+    logger.logger.debug(`[CodexRPC] Spawning: ${command} ${args.join(" ")} in ${opts.cwd}`);
     this.process = node_child_process.spawn(command, args, {
       cwd: opts.cwd,
       stdio: ["pipe", "pipe", "pipe"],
@@ -86,19 +102,19 @@ class CodexJsonRpcPeer {
     this.exitPromise = new Promise((resolve) => {
       this.process.on("close", (code) => {
         this.exited = true;
-        persistence.logger.debug(`[CodexRPC] Process exited with code ${code}`);
+        logger.logger.debug(`[CodexRPC] Process exited with code ${code}`);
         resolve(code);
       });
     });
     this.process.on("error", (err) => {
-      persistence.logger.warn(`[CodexRPC] Process error: ${err.message}`);
+      logger.logger.warn(`[CodexRPC] Process error: ${err.message}`);
       this.rejectAllPending(new Error(`Codex process error: ${err.message}`));
     });
     if (this.process.stderr) {
       this.process.stderr.on("data", (chunk) => {
         const text = chunk.toString().trim();
         if (text) {
-          persistence.logger.debug(`[CodexRPC] stderr: ${text}`);
+          logger.logger.debug(`[CodexRPC] stderr: ${text}`);
         }
       });
     }
@@ -113,7 +129,7 @@ class CodexJsonRpcPeer {
       this.handleLine(line);
     });
     this.readline.on("close", () => {
-      persistence.logger.debug("[CodexRPC] stdout closed");
+      logger.logger.debug("[CodexRPC] stdout closed");
       this.rejectAllPending(new Error("Codex process stdout closed"));
       this.closeHandler?.();
     });
@@ -149,7 +165,7 @@ class CodexJsonRpcPeer {
    */
   notify(method, params) {
     if (this.closed || !this.process?.stdin?.writable) {
-      persistence.logger.debug(`[CodexRPC] Cannot send notification '${method}' - peer is closed`);
+      logger.logger.debug(`[CodexRPC] Cannot send notification '${method}' - peer is closed`);
       return;
     }
     const msg = { method };
@@ -163,7 +179,7 @@ class CodexJsonRpcPeer {
    */
   respond(id, result) {
     if (this.closed || !this.process?.stdin?.writable) {
-      persistence.logger.debug(`[CodexRPC] Cannot respond to request ${id} - peer is closed`);
+      logger.logger.debug(`[CodexRPC] Cannot respond to request ${id} - peer is closed`);
       return;
     }
     this.writeLine(JSON.stringify({ id, result }));
@@ -173,7 +189,7 @@ class CodexJsonRpcPeer {
    */
   respondError(id, error) {
     if (this.closed || !this.process?.stdin?.writable) {
-      persistence.logger.debug(`[CodexRPC] Cannot respond error to request ${id} - peer is closed`);
+      logger.logger.debug(`[CodexRPC] Cannot respond error to request ${id} - peer is closed`);
       return;
     }
     this.writeLine(JSON.stringify({ id, error }));
@@ -216,7 +232,7 @@ class CodexJsonRpcPeer {
           new Promise((resolve) => setTimeout(() => resolve(false), 3e3))
         ]);
         if (!didExit) {
-          persistence.logger.debug("[CodexRPC] Process group did not exit after SIGTERM, sending SIGKILL");
+          logger.logger.debug("[CodexRPC] Process group did not exit after SIGTERM, sending SIGKILL");
           const killResult = this.killProcessGroup(child, pid, "SIGKILL");
           if (killResult !== "dead") {
             await Promise.race([
@@ -233,7 +249,7 @@ class CodexJsonRpcPeer {
         ]);
       }
       if (!this.exited) {
-        persistence.logger.warn(`[CodexRPC] Process ${pid} did not confirm exit \u2014 may have leaked`);
+        logger.logger.warn(`[CodexRPC] Process ${pid} did not confirm exit \u2014 may have leaked`);
       }
     }
     this.process = null;
@@ -256,7 +272,7 @@ class CodexJsonRpcPeer {
       this.process?.stdin?.write(json + "\n");
     } catch (err) {
       if (err.code !== "EPIPE") {
-        persistence.logger.debug(`[CodexRPC] Write error:`, err);
+        logger.logger.debug(`[CodexRPC] Write error:`, err);
       }
     }
   }
@@ -267,7 +283,7 @@ class CodexJsonRpcPeer {
     try {
       msg = JSON.parse(trimmed);
     } catch {
-      persistence.logger.debug(`[CodexRPC] Non-JSON stdout: ${trimmed.slice(0, 200)}`);
+      logger.logger.debug(`[CodexRPC] Non-JSON stdout: ${trimmed.slice(0, 200)}`);
       return;
     }
     if (typeof msg !== "object" || msg === null) return;
@@ -282,14 +298,14 @@ class CodexJsonRpcPeer {
     } else if (hasMethod && !hasId) {
       this.handleNotification(msg);
     } else {
-      persistence.logger.debug(`[CodexRPC] Unrecognized message shape:`, msg);
+      logger.logger.debug(`[CodexRPC] Unrecognized message shape:`, msg);
     }
   }
   handleResponse(msg) {
     const id = msg.id;
     const pending = this.pendingRequests.get(id);
     if (!pending) {
-      persistence.logger.debug(`[CodexRPC] Received response for unknown request id=${id}`);
+      logger.logger.debug(`[CodexRPC] Received response for unknown request id=${id}`);
       return;
     }
     this.pendingRequests.delete(id);
@@ -308,7 +324,7 @@ class CodexJsonRpcPeer {
     if (this.serverRequestHandler) {
       this.serverRequestHandler(method, params, id);
     } else {
-      persistence.logger.debug(`[CodexRPC] No handler for server request '${method}', responding with null`);
+      logger.logger.debug(`[CodexRPC] No handler for server request '${method}', responding with null`);
       this.respond(id, null);
     }
   }
@@ -318,7 +334,7 @@ class CodexJsonRpcPeer {
     if (this.notificationHandler) {
       this.notificationHandler(method, params);
     } else {
-      persistence.logger.debug(`[CodexRPC] No handler for notification '${method}'`);
+      logger.logger.debug(`[CodexRPC] No handler for notification '${method}'`);
     }
   }
   /**
@@ -339,7 +355,7 @@ class CodexJsonRpcPeer {
       if (code === "ESRCH") {
         return "dead";
       }
-      persistence.logger.warn(`[CodexRPC] process.kill(-${pid}, ${signal}) failed: ${code}, falling back to direct kill`);
+      logger.logger.warn(`[CodexRPC] process.kill(-${pid}, ${signal}) failed: ${code}, falling back to direct kill`);
       try {
         child.kill(signal);
       } catch {
@@ -362,7 +378,7 @@ class CodexJsonRpcPeer {
       if (status === 128) {
         return "dead";
       }
-      persistence.logger.warn(`[CodexRPC] taskkill failed for PID ${pid} (exit ${status}): ${err instanceof Error ? err.message : err}`);
+      logger.logger.warn(`[CodexRPC] taskkill failed for PID ${pid} (exit ${status}): ${err instanceof Error ? err.message : err}`);
       return "failed";
     }
   }
@@ -522,7 +538,7 @@ class CodexAppServerBackend {
         this.buildThreadParams()
       );
       threadId = newResult.thread.id;
-      persistence.logger.info(`[CodexBackend] New thread: id=${threadId}, model=${newResult.model}`);
+      logger.logger.info(`[CodexBackend] New thread: id=${threadId}, model=${newResult.model}`);
       this.handleSessionConfigured({
         sessionId: threadId,
         model: newResult.model,
@@ -553,7 +569,7 @@ class CodexAppServerBackend {
         turnId: this.currentTurnId ?? ""
       }, 5e3);
     } catch {
-      persistence.logger.debug("[CodexBackend] Interrupt failed (process may have already exited)");
+      logger.logger.debug("[CodexBackend] Interrupt failed (process may have already exited)");
     }
   }
   onMessage(handler) {
@@ -566,7 +582,7 @@ class CodexAppServerBackend {
   async respondToPermission(requestId, approved) {
     const pending = this.pendingApprovals.get(requestId);
     if (!pending) {
-      persistence.logger.debug(`[CodexBackend] No pending approval for requestId=${requestId}`);
+      logger.logger.debug(`[CodexBackend] No pending approval for requestId=${requestId}`);
       return;
     }
     this.pendingApprovals.delete(requestId);
@@ -703,7 +719,7 @@ class CodexAppServerBackend {
       try {
         handler(msg);
       } catch (err) {
-        persistence.logger.debug(`[CodexBackend] Message handler error: ${err}`);
+        logger.logger.debug(`[CodexBackend] Message handler error: ${err}`);
       }
     }
   }
@@ -782,16 +798,16 @@ class CodexAppServerBackend {
       // ── Deprecation & config warnings ──
       case Methods.NOTIFY_DEPRECATION:
       case Methods.NOTIFY_CONFIG_WARNING:
-        persistence.logger.debug(`[CodexBackend] ${method}: ${JSON.stringify(p)}`);
+        logger.logger.debug(`[CodexBackend] ${method}: ${JSON.stringify(p)}`);
         break;
       default:
-        persistence.logger.debug(`[CodexBackend] Unhandled notification: ${method}`);
+        logger.logger.debug(`[CodexBackend] Unhandled notification: ${method}`);
         break;
     }
   }
   handleSessionConfigured(params) {
     this.sessionId = params.sessionId;
-    persistence.logger.debug(`[CodexBackend] Session configured: model=${params.model}, sessionId=${params.sessionId}`);
+    logger.logger.debug(`[CodexBackend] Session configured: model=${params.model}, sessionId=${params.sessionId}`);
     this.emit({
       type: "event",
       name: "session_configured",
@@ -859,7 +875,7 @@ class CodexAppServerBackend {
       case "contextCompaction":
         break;
       default:
-        persistence.logger.debug(`[CodexBackend] Unhandled item/started type: ${item.type}`);
+        logger.logger.debug(`[CodexBackend] Unhandled item/started type: ${item.type}`);
         break;
     }
   }
@@ -921,7 +937,7 @@ class CodexAppServerBackend {
       case "imageGeneration":
         break;
       default:
-        persistence.logger.debug(`[CodexBackend] Unhandled item/completed type: ${item.type}`);
+        logger.logger.debug(`[CodexBackend] Unhandled item/completed type: ${item.type}`);
         break;
     }
   }
@@ -997,7 +1013,7 @@ class CodexAppServerBackend {
         this.peer.respond(id, { success: false, contentItems: [] });
         break;
       default:
-        persistence.logger.debug(`[CodexBackend] Unhandled server request: ${method}`);
+        logger.logger.debug(`[CodexBackend] Unhandled server request: ${method}`);
         this.peer.respond(id, null);
         break;
     }
@@ -1007,7 +1023,7 @@ class CodexAppServerBackend {
     const rawParams = params;
     const callId = this.getApprovalCallId(rawParams);
     if (!callId) {
-      persistence.logger.warn("[CodexBackend] applyPatchApproval missing callId/call_id; denying request");
+      logger.logger.warn("[CodexBackend] applyPatchApproval missing callId/call_id; denying request");
       this.peer.respond(jsonRpcId, { decision: "denied" });
       return;
     }
@@ -1041,7 +1057,7 @@ class CodexAppServerBackend {
     const rawParams = params;
     const callId = this.getApprovalCallId(rawParams);
     if (!callId) {
-      persistence.logger.warn("[CodexBackend] execCommandApproval missing callId/call_id; denying request");
+      logger.logger.warn("[CodexBackend] execCommandApproval missing callId/call_id; denying request");
       this.peer.respond(jsonRpcId, { decision: "denied" });
       return;
     }
@@ -1133,7 +1149,7 @@ class CodexAppServerBackend {
     const fullToolName = parsed.serverName && parsed.toolTitle ? buildMcpToolName(parsed.serverName, parsed.toolTitle) : parsed.toolTitle || parsed.serverName || "mcp_tool_call";
     const callId = `mcp-elicit-${String(jsonRpcId)}`;
     this.options.permissionHandler.handleToolCall(callId, fullToolName, parsed.toolParams).then((result) => {
-      persistence.logger.debug("[CodexBackend] MCP elicitation decision", { callId, decision: result.decision });
+      logger.logger.debug("[CodexBackend] MCP elicitation decision", { callId, decision: result.decision });
       if (result.decision !== "approved" && result.decision !== "approved_for_session") {
         this.peer.respond(jsonRpcId, { action: "decline" });
         return;
@@ -1141,7 +1157,7 @@ class CodexAppServerBackend {
       const response = result.decision === "approved_for_session" ? { action: "accept", meta: { persist: "session" } } : { action: "accept" };
       this.peer.respond(jsonRpcId, response);
     }).catch((err) => {
-      persistence.logger.warn("[CodexBackend] MCP elicitation permission handler rejected", err);
+      logger.logger.warn("[CodexBackend] MCP elicitation permission handler rejected", err);
       this.peer.respond(jsonRpcId, { action: "decline" });
     });
   }
@@ -1292,7 +1308,7 @@ function createCodexBackend(options) {
     resumeFile: options.resumeFile,
     signal: options.signal
   };
-  persistence.logger.debug("[Codex] Creating app-server backend with options:", {
+  logger.logger.debug("[Codex] Creating app-server backend with options:", {
     cwd: backendOptions.cwd,
     model: model ?? "(Codex CLI default)",
     reasoningEffort: options.reasoningEffort ?? "(Codex CLI default)",
@@ -1320,7 +1336,7 @@ class CodexPermissionHandler extends loadableToolOutput.BasePermissionHandler {
   }
   setPermissionMode(mode) {
     this.currentPermissionMode = mode;
-    persistence.logger.debug(`${this.getLogPrefix()} Permission mode set to: ${mode}`);
+    logger.logger.debug(`${this.getLogPrefix()} Permission mode set to: ${mode}`);
   }
   shouldAutoApprove(toolName, toolCallId) {
     const alwaysAutoApproveNames = ["change_title", "happy__change_title", "preview_html", "happy__preview_html", "CodexReasoning", "think", "save_memory"];
@@ -1354,7 +1370,7 @@ class CodexPermissionHandler extends loadableToolOutput.BasePermissionHandler {
    */
   async handleToolCall(toolCallId, toolName, input) {
     if (this.shouldAutoApprove(toolName, toolCallId)) {
-      persistence.logger.debug(`${this.getLogPrefix()} Auto-approving tool ${toolName} (${toolCallId}) in ${this.currentPermissionMode} mode`);
+      logger.logger.debug(`${this.getLogPrefix()} Auto-approving tool ${toolName} (${toolCallId}) in ${this.currentPermissionMode} mode`);
       this.session.updateAgentState((currentState) => ({
         ...currentState,
         completedRequests: {
@@ -1381,7 +1397,7 @@ class CodexPermissionHandler extends loadableToolOutput.BasePermissionHandler {
         input
       });
       this.addPendingRequestToState(toolCallId, toolName, input);
-      persistence.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId}) in ${this.currentPermissionMode} mode`);
+      logger.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId}) in ${this.currentPermissionMode} mode`);
     });
   }
 }
@@ -1489,7 +1505,7 @@ class DiffProcessor {
       this.rebuildPerFileMap(perFile);
       return;
     }
-    persistence.logger.debug(`[DiffProcessor] ${changedFiles.length} file(s) changed, sending CodexDiff tool call`);
+    logger.logger.debug(`[DiffProcessor] ${changedFiles.length} file(s) changed, sending CodexDiff tool call`);
     const callId = node_crypto.randomUUID();
     let totalAdditions = 0;
     let totalDeletions = 0;
@@ -1511,7 +1527,7 @@ class DiffProcessor {
         deletions: f.deletions,
         timestamp: Date.now()
       }));
-      persistence.saveDiffRecords(this.sessionId, records);
+      api.saveDiffRecords(this.sessionId, records);
     }
     const toolCall = {
       type: "tool-call",
@@ -1540,7 +1556,7 @@ class DiffProcessor {
    * Reset the processor state (called on task_complete or turn_aborted)
    */
   reset() {
-    persistence.logger.debug("[DiffProcessor] Resetting diff state");
+    logger.logger.debug("[DiffProcessor] Resetting diff state");
     this.previousPerFile.clear();
   }
   /**
@@ -1661,7 +1677,7 @@ const CodexDisplay = ({ messageBuffer, logPath, onExit }) => {
       alignItems: "center",
       flexDirection: "column"
     },
-    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", alignItems: "center" }, actionInProgress ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode ? /* @__PURE__ */ React.createElement(ink.Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.Text, { color: "green", bold: true }, "\u{1F916} Codex Agent Running \u2022 Ctrl-C to exit")), persistence.isDebug() && logPath && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", alignItems: "center" }, actionInProgress ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode ? /* @__PURE__ */ React.createElement(ink.Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.Text, { color: "green", bold: true }, "\u{1F916} Codex Agent Running \u2022 Ctrl-C to exit")), logger.isDebug() && logPath && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
   ));
 };
 
@@ -1702,7 +1718,7 @@ function resolveCodexSessionFile(sessionIdOrPath) {
   if (path.isAbsolute(sessionIdOrPath)) {
     return sessionIdOrPath;
   }
-  return persistence.findCodexSessionFile(sessionIdOrPath);
+  return api.findCodexSessionFile(sessionIdOrPath);
 }
 async function backfillCodexSessionHistory(opts) {
   const maxMessages = opts.maxMessages ?? 200;
@@ -1710,14 +1726,14 @@ async function backfillCodexSessionHistory(opts) {
   const maxBytes = opts.maxBytes ?? 3 * 1024 * 1024;
   const filePath = resolveCodexSessionFile(opts.sessionIdOrPath);
   if (!filePath) {
-    persistence.logger.debug(`[CODEX-BACKFILL] Session file not found for: ${opts.sessionIdOrPath}`);
+    logger.logger.debug(`[CODEX-BACKFILL] Session file not found for: ${opts.sessionIdOrPath}`);
     return;
   }
   let content;
   try {
     content = await promises.readFile(filePath, "utf-8");
   } catch (error) {
-    persistence.logger.debug(`[CODEX-BACKFILL] Failed to read file: ${filePath}`, error);
+    logger.logger.debug(`[CODEX-BACKFILL] Failed to read file: ${filePath}`, error);
     return;
   }
   const lines = content.split("\n");
@@ -1735,8 +1751,8 @@ async function backfillCodexSessionHistory(opts) {
     const payload = parsed.payload;
     const timestamp = parsed.timestamp || "";
     if (payload?.role === "user") {
-      const text = persistence.extractUserText(payload);
-      if (!text || persistence.isSystemMessage(text)) continue;
+      const text = api.extractUserText(payload);
+      if (!text || api.isSystemMessage(text)) continue;
       allMessages.push({
         role: "user",
         text,
@@ -1757,7 +1773,7 @@ async function backfillCodexSessionHistory(opts) {
     }
   }
   if (allMessages.length === 0) {
-    persistence.logger.debug("[CODEX-BACKFILL] No messages to backfill");
+    logger.logger.debug("[CODEX-BACKFILL] No messages to backfill");
     return;
   }
   const selected = [];
@@ -1778,10 +1794,10 @@ async function backfillCodexSessionHistory(opts) {
   }
   selected.reverse();
   const fileKey = path.basename(filePath, ".jsonl");
-  persistence.logger.debug(`[CODEX-BACKFILL] Backfilling ${selected.length} messages (users: ${userCount}, total: ${totalCount}, bytes: ${totalBytes})`);
+  logger.logger.debug(`[CODEX-BACKFILL] Backfilling ${selected.length} messages (users: ${userCount}, total: ${totalCount}, bytes: ${totalBytes})`);
   const batch = selected.map((msg) => ({
     content: buildMessageContent(msg),
-    localId: `codex-log:${fileKey}:${persistence.generateStableUuid(msg.timestamp, msg.index)}`
+    localId: `codex-log:${fileKey}:${api.generateStableUuid(msg.timestamp, msg.index)}`
   }));
   await opts.sendBatch(batch);
 }
@@ -1865,30 +1881,30 @@ function mapSandbox(permissionMode) {
 }
 async function runCodex(opts) {
   const sessionTag = node_crypto.randomUUID();
-  persistence.connectionState.setBackend("Codex");
-  const api = await persistence.ApiClient.create(opts.credentials);
-  persistence.logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}`);
-  const settings = await persistence.readSettings();
+  api.connectionState.setBackend("Codex");
+  const api$1 = await api.ApiClient.create(opts.credentials);
+  logger.logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}`);
+  const settings = await logger.readSettings();
   let machineId = settings?.machineId;
   if (!machineId) {
     console.error(`[START] No machine ID found in settings, which is unexpected since authAndSetupMachineIfNeeded should have created it. Please report this issue on https://github.com/ZonEaseTech/happy-wfs/issues`);
     process.exit(1);
   }
-  persistence.logger.debug(`Using machineId: ${machineId}`);
-  await api.getOrCreateMachine({
+  logger.logger.debug(`Using machineId: ${machineId}`);
+  await api$1.getOrCreateMachine({
     machineId,
-    metadata: index.initialMachineMetadata
+    metadata: run.initialMachineMetadata
   });
   const { state, metadata } = loadableToolOutput.createSessionMetadata({
     flavor: "codex",
     machineId,
     startedBy: opts.startedBy
   });
-  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  const response = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
   let session;
   let permissionHandler;
   const { session: initialSession, reconnectionHandle } = loadableToolOutput.setupOfflineReconnection({
-    api,
+    api: api$1,
     sessionTag,
     metadata,
     state,
@@ -1911,7 +1927,7 @@ async function runCodex(opts) {
       }
     }));
   }
-  const injectedMemories = await api.listMemories();
+  const injectedMemories = await api$1.listMemories();
   let initialMemoryAppendPrompt;
   if (injectedMemories.length > 0) {
     const memoryBlock = "<user_memory>\n" + injectedMemories.map((m) => m.content).join("\n\n") + "\n</user_memory>";
@@ -1921,22 +1937,22 @@ async function runCodex(opts) {
       ...currentMetadata,
       injectedMemoryIds
     }));
-    persistence.logger.debug(`[START] Injected ${injectedMemoryIds.length} memories into Codex session`);
+    logger.logger.debug(`[START] Injected ${injectedMemoryIds.length} memories into Codex session`);
   }
   if (response) {
     try {
-      persistence.logger.debug(`[START] Reporting session ${response.id} to daemon`);
-      const result = await index.notifyDaemonSessionStarted(response.id, metadata);
+      logger.logger.debug(`[START] Reporting session ${response.id} to daemon`);
+      const result = await controlClient.notifyDaemonSessionStarted(response.id, metadata);
       if (result.error) {
-        persistence.logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
+        logger.logger.debug(`[START] Failed to report to daemon (may not be running):`, result.error);
       } else {
-        persistence.logger.debug(`[START] Reported session ${response.id} to daemon`);
+        logger.logger.debug(`[START] Reported session ${response.id} to daemon`);
       }
     } catch (error) {
-      persistence.logger.debug("[START] Failed to report to daemon (may not be running):", error);
+      logger.logger.debug("[START] Failed to report to daemon (may not be running):", error);
     }
   }
-  const messageQueue = new index.MessageQueue2((mode) => index.hashObject({
+  const messageQueue = new downloadImage.MessageQueue2((mode) => downloadImage.hashObject({
     permissionMode: mode.permissionMode,
     model: mode.model,
     reasoningEffort: mode.reasoningEffort
@@ -1992,24 +2008,24 @@ async function runCodex(opts) {
     if (message.meta?.permissionMode) {
       messagePermissionMode = message.meta.permissionMode;
       currentPermissionMode = messagePermissionMode;
-      persistence.logger.debug(`[Codex] Permission mode updated from user message to: ${currentPermissionMode}`);
+      logger.logger.debug(`[Codex] Permission mode updated from user message to: ${currentPermissionMode}`);
     } else {
-      persistence.logger.debug(`[Codex] User message received with no permission mode override, using current: ${currentPermissionMode ?? "default (effective)"}`);
+      logger.logger.debug(`[Codex] User message received with no permission mode override, using current: ${currentPermissionMode ?? "default (effective)"}`);
     }
     let messageModel = currentModel;
     if (message.meta?.hasOwnProperty("model")) {
       messageModel = message.meta.model || void 0;
       currentModel = messageModel;
-      persistence.logger.debug(`[Codex] Model updated from user message: ${messageModel || "reset to default"}`);
+      logger.logger.debug(`[Codex] Model updated from user message: ${messageModel || "reset to default"}`);
     } else {
-      persistence.logger.debug(`[Codex] User message received with no model override, using current: ${currentModel || "default"}`);
+      logger.logger.debug(`[Codex] User message received with no model override, using current: ${currentModel || "default"}`);
     }
     let messageReasoningEffort = currentSessionReasoningEffort;
     if (message.meta?.hasOwnProperty("reasoningEffort")) {
       messageReasoningEffort = message.meta.reasoningEffort || void 0;
-      persistence.logger.debug(`[Codex] Reasoning effort updated from user message: ${messageReasoningEffort || "reset to default"}`);
+      logger.logger.debug(`[Codex] Reasoning effort updated from user message: ${messageReasoningEffort || "reset to default"}`);
     } else {
-      persistence.logger.debug(`[Codex] User message received with no reasoning effort override, using current: ${currentSessionReasoningEffort || "default"}`);
+      logger.logger.debug(`[Codex] User message received with no reasoning effort override, using current: ${currentSessionReasoningEffort || "default"}`);
     }
     syncSessionModelInfo({ model: messageModel, reasoningEffort: messageReasoningEffort });
     if (sessionSystemPrompt === void 0) {
@@ -2023,7 +2039,7 @@ async function runCodex(opts) {
     const messageText = message.content.text;
     const images = isMixedContent && "images" in message.content ? message.content.images : [];
     if (images.length > 0) {
-      persistence.logger.debug(`[Codex] Received mixed message with ${images.length} image(s)`);
+      logger.logger.debug(`[Codex] Received mixed message with ${images.length} image(s)`);
     }
     const enhancedMode = {
       permissionMode: messagePermissionMode || "default",
@@ -2049,13 +2065,13 @@ async function runCodex(opts) {
   const sendReady = () => {
     session.sendSessionEvent({ type: "ready" });
     try {
-      api.push().sendToAllDevices(
+      api$1.push().sendToAllDevices(
         "It's ready!",
         "Codex is waiting for your command",
         { sessionId: session.sessionId }
       );
     } catch (pushError) {
-      persistence.logger.debug("[Codex] Failed to send ready push", pushError);
+      logger.logger.debug("[Codex] Failed to send ready push", pushError);
     }
     session.flush().finally(() => {
       session.updateAgentState((state2) => ({
@@ -2065,14 +2081,14 @@ async function runCodex(opts) {
     });
   };
   function logActiveHandles(tag) {
-    if (!persistence.isDebug()) return;
+    if (!logger.isDebug()) return;
     const anyProc = process;
     const handles = typeof anyProc._getActiveHandles === "function" ? anyProc._getActiveHandles() : [];
     const requests = typeof anyProc._getActiveRequests === "function" ? anyProc._getActiveRequests() : [];
-    persistence.logger.debug(`[codex][handles] ${tag}: handles=${handles.length} requests=${requests.length}`);
+    logger.logger.debug(`[codex][handles] ${tag}: handles=${handles.length} requests=${requests.length}`);
     try {
       const kinds = handles.map((h) => h && h.constructor ? h.constructor.name : typeof h);
-      persistence.logger.debug(`[codex][handles] kinds=${JSON.stringify(kinds)}`);
+      logger.logger.debug(`[codex][handles] kinds=${JSON.stringify(kinds)}`);
     } catch {
     }
   }
@@ -2083,14 +2099,14 @@ async function runCodex(opts) {
   const envResumeFile = process.env.HAPPY_CODEX_RESUME_FILE || null;
   let backend = null;
   async function handleAbort() {
-    persistence.logger.debug("[Codex] Abort requested - stopping current task");
+    logger.logger.debug("[Codex] Abort requested - stopping current task");
     abortRequested = true;
     try {
       const b = backend;
       if (b?.isAlive) {
         const sid = b.getSessionId();
         if (sid) storedSessionIdForResume = sid;
-        persistence.logger.debug("[Codex] Stored session for resume:", storedSessionIdForResume);
+        logger.logger.debug("[Codex] Stored session for resume:", storedSessionIdForResume);
         if (b.getConversationId()) {
           b.cancel(b.getConversationId()).catch(() => {
           });
@@ -2102,20 +2118,20 @@ async function runCodex(opts) {
         if (backend === b) backend = null;
       }
       reasoningProcessor.abort();
-      persistence.logger.debug("[Codex] Abort completed");
+      logger.logger.debug("[Codex] Abort completed");
     } catch (error) {
-      persistence.logger.debug("[Codex] Error during abort:", error);
+      logger.logger.debug("[Codex] Error during abort:", error);
     }
   }
-  const mcp = await index.createMcpContext(session);
+  const mcp = await downloadImage.createMcpContext(session);
   const mcpServers = mcp.configForStdio();
   const handleKillSession = async () => {
     if (killInProgress) {
-      persistence.logger.debug("[Codex] Kill session already in progress");
+      logger.logger.debug("[Codex] Kill session already in progress");
       return;
     }
     killInProgress = true;
-    persistence.logger.debug("[Codex] Kill session requested - terminating process");
+    logger.logger.debug("[Codex] Kill session requested - terminating process");
     isTerminating = true;
     shouldExit = true;
     thinking = false;
@@ -2135,41 +2151,41 @@ async function runCodex(opts) {
         await session.close();
       }
     } catch (error) {
-      persistence.logger.debug("[Codex] Error while ending session during termination", error);
+      logger.logger.debug("[Codex] Error while ending session during termination", error);
     }
     try {
       await handleAbort();
-      persistence.logger.debug("[Codex] Abort completed, proceeding with backend disposal");
+      logger.logger.debug("[Codex] Abort completed, proceeding with backend disposal");
     } catch (error) {
-      persistence.logger.debug("[Codex] Error during abort in termination flow", error);
+      logger.logger.debug("[Codex] Error during abort in termination flow", error);
     }
     try {
       try {
         await backend?.dispose();
       } catch (e) {
-        persistence.logger.debug("[Codex] Error while disposing backend during termination", e);
+        logger.logger.debug("[Codex] Error while disposing backend during termination", e);
       }
-      index.stopCaffeinate();
+      run.stopCaffeinate();
       mcp.stop();
-      persistence.logger.debug("[Codex] Session termination complete, exiting");
+      logger.logger.debug("[Codex] Session termination complete, exiting");
       process.exit(0);
     } catch (error) {
-      persistence.logger.debug("[Codex] Error during session termination:", error);
+      logger.logger.debug("[Codex] Error during session termination:", error);
       process.exit(1);
     }
   };
   session.rpcHandlerManager.registerHandler("abort", handleAbort);
-  index.registerKillSessionHandler(session.rpcHandlerManager, handleKillSession);
-  const messageBuffer = new index.MessageBuffer();
+  downloadImage.registerKillSessionHandler(session.rpcHandlerManager, handleKillSession);
+  const messageBuffer = new downloadImage.MessageBuffer();
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
   let inkInstance = null;
   if (hasTTY) {
     console.clear();
     inkInstance = ink.render(React.createElement(CodexDisplay, {
       messageBuffer,
-      logPath: persistence.isDebug() ? persistence.logger.getLogPath() : void 0,
+      logPath: logger.isDebug() ? logger.logger.getLogPath() : void 0,
       onExit: async () => {
-        persistence.logger.debug("[codex]: Exiting agent via Ctrl-C");
+        logger.logger.debug("[codex]: Exiting agent via Ctrl-C");
         shouldExit = true;
         await handleAbort();
       }
@@ -2185,19 +2201,19 @@ async function runCodex(opts) {
     }
     process.stdin.setEncoding("utf8");
   }
-  permissionHandler = new CodexPermissionHandler(session, api.push());
+  permissionHandler = new CodexPermissionHandler(session, api$1.push());
   const validPermissionModes = ["default", "read-only", "safe-yolo", "yolo"];
   session.rpcHandlerManager.registerHandler(
     "permission-mode-changed",
     async (payload) => {
       const mode = payload?.mode;
       if (!mode || !validPermissionModes.includes(mode)) {
-        persistence.logger.debug("[Codex] Invalid permission mode via rpc", { mode });
+        logger.logger.debug("[Codex] Invalid permission mode via rpc", { mode });
         return false;
       }
       currentPermissionMode = mode;
       permissionHandler.setPermissionMode(mode);
-      persistence.logger.debug(`[Codex] Permission mode updated via rpc to ${mode}`);
+      logger.logger.debug(`[Codex] Permission mode updated via rpc to ${mode}`);
       return true;
     }
   );
@@ -2213,7 +2229,7 @@ async function runCodex(opts) {
   diffProcessor.setSessionId(session.sessionId);
   function handleAgentMessage(msg) {
     if (msg.type !== "model-output" && msg.type !== "terminal-output" && msg.type !== "event") {
-      persistence.logger.debug(`[Codex] AgentMessage: ${msg.type}`);
+      logger.logger.debug(`[Codex] AgentMessage: ${msg.type}`);
     }
     switch (msg.type) {
       case "model-output": {
@@ -2433,7 +2449,7 @@ async function runCodex(opts) {
   }
   function findCodexResumeFile(sessionId) {
     if (!sessionId) return null;
-    return persistence.findCodexSessionFile(sessionId);
+    return api.findCodexSessionFile(sessionId);
   }
   async function createBackend(opts2) {
     if (backend?.isAlive) {
@@ -2471,10 +2487,10 @@ async function runCodex(opts) {
           }
         });
       } else {
-        persistence.logger.debug("[Codex] Backfill skipped: socket not connected");
+        logger.logger.debug("[Codex] Backfill skipped: socket not connected");
       }
     } catch (error) {
-      persistence.logger.debug("[Codex] Backfill failed:", error);
+      logger.logger.debug("[Codex] Backfill failed:", error);
     }
   }
   try {
@@ -2490,17 +2506,17 @@ async function runCodex(opts) {
         const batch = await messageQueue.waitForMessagesAndGetAsString();
         if (!batch) {
           if (!shouldExit) {
-            persistence.logger.debug("[codex]: Wait returned null while not exiting; continuing");
+            logger.logger.debug("[codex]: Wait returned null while not exiting; continuing");
             continue;
           }
-          persistence.logger.debug(`[codex]: batch=${!!batch}, shouldExit=${shouldExit}`);
+          logger.logger.debug(`[codex]: batch=${!!batch}, shouldExit=${shouldExit}`);
           break;
         }
         message = batch;
       }
       if (!message) break;
-      if (index.parseClear(message.message).isClear) {
-        persistence.logger.debug("[Codex] /clear command detected - resetting session");
+      if (downloadImage.parseClear(message.message).isClear) {
+        logger.logger.debug("[Codex] /clear command detected - resetting session");
         messageBuffer.addMessage("Context was reset", "status");
         session.sendSessionEvent({ type: "message", message: "Context was reset" });
         if (backend) {
@@ -2523,18 +2539,18 @@ async function runCodex(opts) {
         continue;
       }
       if (wasCreated && currentModeHash && message.hash !== currentModeHash) {
-        persistence.logger.debug("[Codex] Mode changed \u2013 restarting Codex session");
+        logger.logger.debug("[Codex] Mode changed \u2013 restarting Codex session");
         messageBuffer.addMessage("\u2550".repeat(40), "status");
         messageBuffer.addMessage("Starting new Codex session (mode changed)...", "status");
         try {
           const prevSessionId = backend ? backend.getSessionId() : null;
           nextResumeFile = findCodexResumeFile(prevSessionId);
           if (nextResumeFile) {
-            persistence.logger.debug(`[Codex] Found resume file: ${nextResumeFile}`);
+            logger.logger.debug(`[Codex] Found resume file: ${nextResumeFile}`);
             messageBuffer.addMessage("Resuming previous context\u2026", "status");
           }
         } catch (e) {
-          persistence.logger.debug("[Codex] Error searching resume file", e);
+          logger.logger.debug("[Codex] Error searching resume file", e);
         }
         if (backend) {
           try {
@@ -2562,10 +2578,10 @@ async function runCodex(opts) {
         const sandbox = mapSandbox(message.mode.permissionMode);
         let promptOptions;
         if (message.mode.images?.length) {
-          persistence.logger.debug(`[Codex] Downloading ${message.mode.images.length} image(s)...`);
+          logger.logger.debug(`[Codex] Downloading ${message.mode.images.length} image(s)...`);
           const images = await Promise.all(
             message.mode.images.map(async (img) => {
-              const downloaded = await index.downloadImage(img.url);
+              const downloaded = await downloadImage.downloadImage(img.url);
               return {
                 data: downloaded.base64,
                 mimeType: downloaded.mimeType
@@ -2573,7 +2589,7 @@ async function runCodex(opts) {
             })
           );
           promptOptions = { images };
-          persistence.logger.debug(`[Codex] Downloaded ${images.length} image(s)`);
+          logger.logger.debug(`[Codex] Downloaded ${images.length} image(s)`);
         }
         if (!wasCreated || !backend?.isAlive) {
           wasCreated = false;
@@ -2582,16 +2598,16 @@ async function runCodex(opts) {
           if (nextResumeFile) {
             resumeFile = nextResumeFile;
             nextResumeFile = null;
-            persistence.logger.debug("[Codex] Using resume file from mode change:", resumeFile);
+            logger.logger.debug("[Codex] Using resume file from mode change:", resumeFile);
           } else if (first && envResumeFile) {
             resumeFile = envResumeFile;
-            persistence.logger.debug("[Codex] Using resume file from App-side resume:", resumeFile);
+            logger.logger.debug("[Codex] Using resume file from App-side resume:", resumeFile);
             messageBuffer.addMessage("Resuming from previous session...", "status");
           } else if (storedSessionIdForResume) {
             const abortResumeFile = findCodexResumeFile(storedSessionIdForResume);
             if (abortResumeFile) {
               resumeFile = abortResumeFile;
-              persistence.logger.debug("[Codex] Using resume file from aborted session:", resumeFile);
+              logger.logger.debug("[Codex] Using resume file from aborted session:", resumeFile);
               messageBuffer.addMessage("Resuming from aborted session...", "status");
             }
             storedSessionIdForResume = null;
@@ -2645,7 +2661,7 @@ async function runCodex(opts) {
         }
       } catch (error) {
         const errMsg = formatUnknownCodexError(error);
-        persistence.logger.warn("Error in codex session:", errMsg);
+        logger.logger.warn("Error in codex session:", errMsg);
         const isAbortError = error instanceof Error && error.name === "AbortError";
         const isUserAbort = isAbortError || abortRequested;
         if (isUserAbort && !abortFeedbackSent) {
@@ -2661,7 +2677,7 @@ async function runCodex(opts) {
           session.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
           if (backend && backend.isAlive) {
             storedSessionIdForResume = backend.getSessionId();
-            persistence.logger.debug("[Codex] Stored session after unexpected error:", storedSessionIdForResume);
+            logger.logger.debug("[Codex] Stored session after unexpected error:", storedSessionIdForResume);
           }
           session.sendAgentMessage("codex", {
             type: "task_complete",
@@ -2686,55 +2702,55 @@ async function runCodex(opts) {
       }
     }
   } finally {
-    persistence.logger.debug("[codex]: Final cleanup start");
+    logger.logger.debug("[codex]: Final cleanup start");
     logActiveHandles("cleanup-start");
     if (reconnectionHandle) {
-      persistence.logger.debug("[codex]: Cancelling offline reconnection");
+      logger.logger.debug("[codex]: Cancelling offline reconnection");
       reconnectionHandle.cancel();
     }
     try {
-      persistence.logger.debug("[codex]: sendSessionDeath");
+      logger.logger.debug("[codex]: sendSessionDeath");
       session.sendSessionDeath();
-      persistence.logger.debug("[codex]: flush begin");
+      logger.logger.debug("[codex]: flush begin");
       await session.flush();
-      persistence.logger.debug("[codex]: flush done");
-      persistence.logger.debug("[codex]: session.close begin");
+      logger.logger.debug("[codex]: flush done");
+      logger.logger.debug("[codex]: session.close begin");
       await session.close();
-      persistence.logger.debug("[codex]: session.close done");
+      logger.logger.debug("[codex]: session.close done");
     } catch (e) {
-      persistence.logger.debug("[codex]: Error while closing session", e);
+      logger.logger.debug("[codex]: Error while closing session", e);
     }
-    persistence.logger.debug("[codex]: backend.dispose begin");
+    logger.logger.debug("[codex]: backend.dispose begin");
     try {
       await backend?.dispose();
     } catch {
     }
-    persistence.logger.debug("[codex]: backend.dispose done");
-    persistence.logger.debug("[codex]: mcp.stop");
+    logger.logger.debug("[codex]: backend.dispose done");
+    logger.logger.debug("[codex]: mcp.stop");
     mcp.stop();
     if (process.stdin.isTTY) {
-      persistence.logger.debug("[codex]: setRawMode(false)");
+      logger.logger.debug("[codex]: setRawMode(false)");
       try {
         process.stdin.setRawMode(false);
       } catch {
       }
     }
     if (hasTTY) {
-      persistence.logger.debug("[codex]: stdin.pause()");
+      logger.logger.debug("[codex]: stdin.pause()");
       try {
         process.stdin.pause();
       } catch {
       }
     }
-    persistence.logger.debug("[codex]: clearInterval(keepAlive)");
+    logger.logger.debug("[codex]: clearInterval(keepAlive)");
     clearInterval(keepAliveInterval);
     if (inkInstance) {
-      persistence.logger.debug("[codex]: inkInstance.unmount()");
+      logger.logger.debug("[codex]: inkInstance.unmount()");
       inkInstance.unmount();
     }
     messageBuffer.clear();
     logActiveHandles("cleanup-end");
-    persistence.logger.debug("[codex]: Final cleanup completed");
+    logger.logger.debug("[codex]: Final cleanup completed");
   }
 }