happy-imou-cloud 2.0.10 → 2.0.11

package/dist/{runCodex-CUgOiIEz.mjs → runCodex-AnJUPIhX.mjs}

@@ -1,43 +1,44 @@
 import { randomUUID } from 'node:crypto';
-import { l as logger, b as connectionState, A as ApiClient, i as isAuthenticationRequiredError } from './api-BjxmW-0W.mjs';
-import { readSettings } from './persistence-BxP6Jw1f.mjs';
-import { f as formatDisplayMessage, v as validateCodexAcpSpawn, e as createCodexBackend, t as truncateDisplayMessage, b as stopCaffeinate, i as initialMachineMetadata, p as publishSessionRegistration } from './index-CzvgPwr1.mjs';
-import { B as BasePermissionHandler, g as getPendingInteractionTimeoutMs, I as INTERACTION_SUPERSEDED_ERROR, d as INTERACTION_TIMED_OUT_ERROR, a as BaseReasoningProcessor, b as attachToolHappierMetaV2, r as resolveCanonicalToolNameV2, i as inferToolResultError, c as createSessionMetadata, s as setupOfflineReconnection } from './names-CicSgRNg.mjs';
-import { h as hashObject, a as MessageBuffer, r as registerKillSessionHandler, M as MessageQueue2 } from './registerKillSessionHandler-ARQrPvnT.mjs';
-import React, { useState, useRef, useEffect, useCallback } from 'react';
-import { useStdout, useInput, Box, Text, render } from 'ink';
-import 'axios';
-import 'chalk';
+import { l as logger, b as connectionState, A as ApiClient } from './api-BcWf5v4i.mjs';
+import { B as BasePermissionHandler, h as hashObject, d as MessageBuffer, C as ConversationHistory$1, w as waitForResponseCompleteWithAbort, r as registerKillSessionHandler, l as launchRuntimeHandleWithFactoryResult, i as inferToolResultError, j as forwardAgentMessageToProviderSession, f as closeProviderSession, e as ensureManagedProviderMachine, M as MissingMachineIdError, b as MessageQueue2, s as syncControlledByUserState } from './registerKillSessionHandler-Dxwg4L4J.mjs';
+import { f as formatDisplayMessage, v as validateCodexAcpSpawn, d as createCodexBackend, t as truncateDisplayMessage, b as stopCaffeinate } from './index-DnsqY6I_.mjs';
+import 'cross-spawn';
+import '@agentclientprotocol/sdk';
+import 'ps-list';
 import 'fs';
+import 'path';
+import 'os';
+import 'child_process';
 import 'node:fs';
-import 'node:os';
 import 'node:path';
+import 'node:os';
+import './persistence-BMa6cyw9.mjs';
+import 'node:fs/promises';
+import 'fs/promises';
+import 'crypto';
+import 'node:child_process';
+import 'chalk';
 import 'node:events';
+import 'axios';
+import 'tweetnacl';
+import 'open';
+import React, { useState, useRef, useEffect, useCallback } from 'react';
+import { useStdout, useInput, Box, Text, render } from 'ink';
+import { c as createKeepAliveController, P as ProviderSelectionHandler, r as runModeLoop } from './ProviderSelectionHandler-BljOLMQn.mjs';
+import { B as BaseReasoningProcessor, b as bootstrapManagedProviderSession } from './BaseReasoningProcessor-5ACv9gKu.mjs';
 import 'socket.io-client';
 import 'zod';
-import 'tweetnacl';
-import 'child_process';
-import 'util';
-import 'fs/promises';
-import 'crypto';
-import 'path';
 import 'expo-server-sdk';
-import 'node:fs/promises';
-import 'os';
+import './types-CiliQpqS.mjs';
 import 'tmp';
 import 'qrcode-terminal';
 import 'node:module';
-import 'open';
 import 'url';
-import 'node:child_process';
-import 'ps-list';
-import 'cross-spawn';
 import 'fastify';
 import 'fastify-type-provider-zod';
 import 'node:readline';
 import 'http';
-import '@agentclientprotocol/sdk';
-import './types-CiliQpqS.mjs';
+import 'util';
 
 const DEFAULT_CAPABILITIES = {
   committedMessageAcks: false,
@@ -127,7 +128,7 @@ class CodexSession {
   sessionId;
   mode;
   thinking = false;
-  keepAliveInterval;
+  keepAliveController;
   onModeChangeCallback;
   clientSwapCallbacks = [];
   constructor(opts) {
@@ -143,13 +144,16 @@ class CodexSession {
     this.queue = opts.messageQueue;
     this.codexArgs = opts.codexArgs;
     this.onModeChangeCallback = opts.onModeChange;
-    this.client.keepAlive(this.thinking, this.mode);
-    this.keepAliveInterval = setInterval(() => {
-      this.client.keepAlive(this.thinking, this.mode);
-    }, 2e3);
+    this.keepAliveController = createKeepAliveController({
+      initialMode: this.mode,
+      initialThinking: this.thinking,
+      send: (thinking, mode) => {
+        this.client.keepAlive(thinking, mode);
+      }
+    });
   }
   cleanup() {
-    clearInterval(this.keepAliveInterval);
+    this.keepAliveController.dispose();
     logger.debug("[CodexSession] Cleaned up resources");
   }
   updateClient = (client) => {
@@ -172,11 +176,11 @@ class CodexSession {
   };
   onThinkingChange = (thinking) => {
     this.thinking = thinking;
-    this.client.keepAlive(thinking, this.mode);
+    this.keepAliveController.setThinking(thinking);
   };
   onModeChange = async (mode) => {
     this.mode = mode;
-    this.client.keepAlive(this.thinking, mode);
+    this.keepAliveController.setMode(mode);
     await this.onModeChangeCallback(mode);
   };
   onSessionFound = (sessionId) => {
@@ -329,208 +333,9 @@ class CodexPermissionHandler extends BasePermissionHandler {
   }
 }
 
-class CodexSelectionHandler {
-  pendingRequests = /* @__PURE__ */ new Map();
-  session;
+class CodexSelectionHandler extends ProviderSelectionHandler {
   constructor(session) {
-    this.session = session;
-    this.setupRpcHandler();
-  }
-  updateSession(newSession) {
-    this.session = newSession;
-    this.setupRpcHandler();
-  }
-  async requestSelection(request) {
-    return new Promise((resolve, reject) => {
-      const pending = {
-        resolve,
-        reject,
-        request
-      };
-      pending.timeoutHandle = setTimeout(() => {
-        this.handleSelectionTimeout(request.id, pending);
-      }, getPendingInteractionTimeoutMs());
-      this.pendingRequests.set(request.id, pending);
-      this.session.updateAgentState((currentState) => ({
-        ...currentState,
-        requests: {
-          ...currentState.requests,
-          [request.id]: {
-            tool: "AskUserQuestion",
-            arguments: {
-              requestKind: "selection",
-              questions: [
-                {
-                  header: "Codex",
-                  question: request.message,
-                  multiSelect: false,
-                  options: request.options.map((option) => ({
-                    label: option.label,
-                    description: option.description || option.optionId,
-                    optionId: option.optionId
-                  }))
-                }
-              ]
-            },
-            createdAt: Date.now(),
-            requestKind: "selection",
-            options: request.options,
-            defaultOptionId: request.defaultOptionId
-          }
-        }
-      }));
-      logger.debug(`[Codex] Selection request sent (${request.id}) with ${request.options.length} options`);
-    });
-  }
-  hasPendingRequests() {
-    return this.pendingRequests.size > 0;
-  }
-  supersedePendingRequests(reason = INTERACTION_SUPERSEDED_ERROR) {
-    const pendingSnapshot = Array.from(this.pendingRequests.entries());
-    if (pendingSnapshot.length === 0) {
-      return 0;
-    }
-    this.pendingRequests.clear();
-    const completedAt = Date.now();
-    for (const [, pending] of pendingSnapshot) {
-      this.clearPendingRequestTimeout(pending);
-      pending.reject(new Error(reason));
-    }
-    this.session.updateAgentState((currentState) => {
-      const requests = { ...currentState.requests || {} };
-      const completedRequests = { ...currentState.completedRequests || {} };
-      for (const [id, request] of Object.entries(requests)) {
-        if (request.requestKind !== "selection") {
-          continue;
-        }
-        completedRequests[id] = {
-          ...request,
-          completedAt,
-          status: "canceled",
-          reason,
-          requestKind: "selection"
-        };
-        delete requests[id];
-      }
-      return {
-        ...currentState,
-        requests,
-        completedRequests
-      };
-    });
-    logger.debug(`[Codex] Superseded ${pendingSnapshot.length} pending selection request(s)`);
-    return pendingSnapshot.length;
-  }
-  reset(reason = "Session reset") {
-    const pendingSnapshot = Array.from(this.pendingRequests.entries());
-    this.pendingRequests.clear();
-    for (const [, pending] of pendingSnapshot) {
-      this.clearPendingRequestTimeout(pending);
-      pending.reject(new Error(reason));
-    }
-    this.session.updateAgentState((currentState) => {
-      const requests = { ...currentState.requests || {} };
-      const completedRequests = { ...currentState.completedRequests || {} };
-      for (const [id, request] of Object.entries(requests)) {
-        if (request.requestKind !== "selection") {
-          continue;
-        }
-        completedRequests[id] = {
-          ...request,
-          completedAt: Date.now(),
-          status: "canceled",
-          reason,
-          requestKind: "selection"
-        };
-        delete requests[id];
-      }
-      return {
-        ...currentState,
-        requests,
-        completedRequests
-      };
-    });
-  }
-  setupRpcHandler() {
-    this.session.rpcHandlerManager.registerHandler("selection", async (response) => {
-      const pending = this.pendingRequests.get(response.id);
-      if (!pending) {
-        logger.debug("[Codex] Selection request not found or already resolved");
-        return;
-      }
-      this.pendingRequests.delete(response.id);
-      this.clearPendingRequestTimeout(pending);
-      pending.resolve(response);
-      this.session.updateAgentState((currentState) => {
-        const request = currentState.requests?.[response.id];
-        if (!request) {
-          return currentState;
-        }
-        const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
-        return {
-          ...currentState,
-          requests: remainingRequests,
-          completedRequests: {
-            ...currentState.completedRequests,
-            [response.id]: {
-              ...request,
-              completedAt: Date.now(),
-              status: "approved",
-              requestKind: "selection",
-              selectedOptionId: response.optionId
-            }
-          }
-        };
-      });
-    });
-  }
-  clearPendingRequestTimeout(pending) {
-    if (pending?.timeoutHandle) {
-      clearTimeout(pending.timeoutHandle);
-      pending.timeoutHandle = void 0;
-    }
-  }
-  handleSelectionTimeout(requestId, pending) {
-    const active = this.pendingRequests.get(requestId);
-    if (!active || active !== pending) {
-      return;
-    }
-    this.pendingRequests.delete(requestId);
-    this.clearPendingRequestTimeout(active);
-    active.reject(new Error(INTERACTION_TIMED_OUT_ERROR));
-    this.session.updateAgentState((currentState) => {
-      const request = currentState.requests?.[requestId] || {
-        tool: "AskUserQuestion",
-        arguments: {
-          requestKind: "selection",
-          questions: []
-        },
-        createdAt: Date.now(),
-        requestKind: "selection",
-        options: active.request.options,
-        defaultOptionId: active.request.defaultOptionId
-      };
-      const { [requestId]: _, ...remainingRequests } = currentState.requests || {};
-      return {
-        ...currentState,
-        requests: remainingRequests,
-        completedRequests: {
-          ...currentState.completedRequests,
-          [requestId]: {
-            ...request,
-            completedAt: Date.now(),
-            status: "canceled",
-            reason: INTERACTION_TIMED_OUT_ERROR,
-            requestKind: "selection"
-          }
-        }
-      };
-    });
-    this.session.sendSessionEvent({
-      type: "message",
-      message: "Pending interaction timed out waiting for a response. Send a new message to continue."
-    });
-    logger.debug(`[Codex] Selection request timed out (${requestId})`);
+    super(session, "Codex");
   }
 }
 
@@ -558,101 +363,6 @@ class ReasoningProcessor extends BaseReasoningProcessor {
   }
 }
 
-class ConversationHistory {
-  messages = [];
-  maxMessages;
-  maxCharacters;
-  constructor(options = {}) {
-    this.maxMessages = options.maxMessages ?? 20;
-    this.maxCharacters = options.maxCharacters ?? 5e4;
-  }
-  isDuplicate(role, content) {
-    if (this.messages.length === 0) {
-      return false;
-    }
-    for (let index = this.messages.length - 1; index >= 0; index -= 1) {
-      const message = this.messages[index];
-      if (message.role !== role) {
-        continue;
-      }
-      const normalizedIncoming = content.trim().replace(/\s+/g, " ");
-      const normalizedExisting = message.content.replace(/\s+/g, " ");
-      return normalizedIncoming === normalizedExisting;
-    }
-    return false;
-  }
-  addUserMessage(content) {
-    this.addMessage("user", content);
-  }
-  addAssistantMessage(content) {
-    this.addMessage("assistant", content);
-  }
-  hasHistory() {
-    return this.messages.length > 0;
-  }
-  size() {
-    return this.messages.length;
-  }
-  clear() {
-    this.messages = [];
-    logger.debug("[CodexConversationHistory] History cleared");
-  }
-  getContextForNewSession() {
-    if (this.messages.length === 0) {
-      return "";
-    }
-    const formattedMessages = this.messages.map((message) => {
-      const role = message.role === "user" ? "User" : "Assistant";
-      const content = message.content.length > 2e3 ? `${message.content.slice(0, 2e3)}... [truncated]` : message.content;
-      return `${role}: ${content}`;
-    }).join("\n\n");
-    return [
-      "[PREVIOUS CONVERSATION CONTEXT]",
-      "Continue from the prior Codex session using the conversation below as context.",
-      "",
-      formattedMessages,
-      "",
-      "[END OF PREVIOUS CONTEXT]",
-      ""
-    ].join("\n");
-  }
-  getSummary() {
-    const totalChars = this.messages.reduce((sum, message) => sum + message.content.length, 0);
-    const userCount = this.messages.filter((message) => message.role === "user").length;
-    const assistantCount = this.messages.filter((message) => message.role === "assistant").length;
-    return `${this.messages.length} messages (${userCount} user, ${assistantCount} assistant), ${totalChars} chars`;
-  }
-  addMessage(role, content) {
-    const trimmedContent = content.trim();
-    if (!trimmedContent) {
-      return;
-    }
-    if (this.isDuplicate(role, trimmedContent)) {
-      logger.debug(`[CodexConversationHistory] Skipping duplicate ${role} message (${trimmedContent.length} chars)`);
-      return;
-    }
-    this.messages.push({
-      role,
-      content: trimmedContent,
-      timestamp: Date.now()
-    });
-    this.trimHistory();
-    logger.debug(`[CodexConversationHistory] Added ${role} message (${trimmedContent.length} chars), total: ${this.messages.length}`);
-  }
-  trimHistory() {
-    while (this.messages.length > this.maxMessages) {
-      this.messages.shift();
-    }
-    let totalChars = this.messages.reduce((sum, message) => sum + message.content.length, 0);
-    while (totalChars > this.maxCharacters && this.messages.length > 1) {
-      const removed = this.messages.shift();
-      if (removed) {
-        totalChars -= removed.content.length;
-      }
-    }
-  }
-}
-
 function resolveCodexAcpExecutionMode(mode) {
   const approvalPolicy = (() => {
     switch (mode.permissionMode) {
@@ -704,26 +414,6 @@ function getCodexExecutionFingerprint(mode) {
   return hashObject(resolveCodexAcpExecutionMode(mode));
 }
 
-function createAbortError() {
-  const error = new Error("Operation aborted");
-  error.name = "AbortError";
-  return error;
-}
-async function waitForResponseCompleteWithAbort(backend, signal, timeoutMs = 12e4) {
-  if (!backend.waitForResponseComplete) {
-    return;
-  }
-  if (signal.aborted) {
-    throw createAbortError();
-  }
-  await new Promise((resolve, reject) => {
-    const onAbort = () => reject(createAbortError());
-    signal.addEventListener("abort", onAbort, { once: true });
-    backend.waitForResponseComplete(timeoutMs).then(resolve).catch(reject).finally(() => {
-      signal.removeEventListener("abort", onAbort);
-    });
-  });
-}
 function normalizeCodexBackendError(error) {
   const record = typeof error === "object" && error !== null ? error : null;
   const text = formatDisplayMessage(error).trim();
@@ -780,15 +470,14 @@ function registerCodexRemoteRpcHandlers(clientSession, handlers) {
   registerKillSessionHandler(clientSession.rpcHandlerManager, handlers.handleKillSession);
 }
 async function codexRemoteLauncher(session) {
-  const messageBuffer = new MessageBuffer();
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
+  const messageBuffer = new MessageBuffer({ enabled: hasTTY });
   let inkInstance = null;
   let shouldExit = false;
   let abortController = new AbortController();
   let turnInFlight = false;
-  let backend = null;
-  let acpSessionId = null;
-  let wasSessionCreated = false;
+  let runtimeHandle = null;
+  let unsubscribeRuntimeMessages = null;
   let currentModeHash = null;
   let pending = null;
   let readyAlreadySent = false;
@@ -801,7 +490,7 @@ async function codexRemoteLauncher(session) {
   let currentThinkingMessageId = null;
   const permissionHandler = new CodexPermissionHandler(session.client);
   const selectionHandler = new CodexSelectionHandler(session.client);
-  const conversationHistory = new ConversationHistory({ maxMessages: 20, maxCharacters: 5e4 });
+  const conversationHistory = new ConversationHistory$1({ maxMessages: 20, maxCharacters: 5e4 });
   const reasoningProcessor = new ReasoningProcessor((message) => {
     session.runtimeSession.sendCodexMessage(message);
   });
@@ -837,22 +526,22 @@ async function codexRemoteLauncher(session) {
     activeController.abort();
     reasoningProcessor.abort();
     session.onThinkingChange(false);
-    if (backend && acpSessionId) {
-      void backend.cancel(acpSessionId).catch((error) => {
+    if (runtimeHandle) {
+      void runtimeHandle.cancel().catch((error) => {
         logger.debug("[Codex] Error cancelling ACP session:", error);
       });
     }
   };
-  const disposeBackend = async () => {
-    if (!backend) {
+  const disposeRuntimeHandle = async () => {
+    if (!runtimeHandle) {
       return;
     }
-    const currentBackend = backend;
-    backend = null;
-    acpSessionId = null;
-    wasSessionCreated = false;
+    const activeRuntimeHandle = runtimeHandle;
+    runtimeHandle = null;
+    unsubscribeRuntimeMessages?.();
+    unsubscribeRuntimeMessages = null;
     try {
-      await currentBackend.dispose();
+      await activeRuntimeHandle.dispose();
     } catch (error) {
       logger.debug("[Codex] Error disposing ACP backend:", error);
     }
@@ -893,8 +582,16 @@ async function codexRemoteLauncher(session) {
     accumulatedResponse = "";
     isResponseInProgress = false;
   };
-  const setupBackendMessageHandler = (currentBackend) => {
-    currentBackend.onMessage((msg) => {
+  const setupRuntimeMessageHandler = (activeRuntimeHandle) => {
+    const forwardAgentMessage = (agentMessage) => {
+      forwardAgentMessageToProviderSession(agentMessage, {
+        provider: "codex",
+        send: (body) => session.runtimeSession.sendCodexMessage(body),
+        toolResultType: "tool-call-result"
+      });
+    };
+    unsubscribeRuntimeMessages?.();
+    unsubscribeRuntimeMessages = activeRuntimeHandle.onMessage((msg) => {
       switch (msg.type) {
         case "model-output": {
           const text = msg.textDelta ?? msg.fullText ?? "";
@@ -945,24 +642,11 @@ async function codexRemoteLauncher(session) {
         }
         case "tool-call": {
           const toolArgs = msg.args ? truncateDisplayMessage(msg.args, 100) : "";
-          const canonicalToolName = resolveCanonicalToolNameV2(msg.toolName);
           messageBuffer.addMessage(
             `Executing: ${msg.toolName}${toolArgs ? ` ${toolArgs}` : ""}`,
             "tool"
           );
-          session.runtimeSession.sendCodexMessage({
-            type: "tool-call",
-            name: canonicalToolName,
-            callId: msg.callId,
-            input: attachToolHappierMetaV2(msg.args, {
-              v: 2,
-              protocol: "acp",
-              provider: "codex",
-              rawToolName: msg.toolName,
-              canonicalToolName
-            }),
-            id: randomUUID()
-          });
+          forwardAgentMessage(msg);
           return;
         }
         case "tool-result": {
@@ -972,95 +656,37 @@ async function codexRemoteLauncher(session) {
             `${isError ? "Error:" : "Result:"} ${resultText}`.trim(),
             "result"
           );
-          session.runtimeSession.sendCodexMessage({
-            type: "tool-call-result",
-            callId: msg.callId,
-            output: attachToolHappierMetaV2(msg.result, {
-              v: 2,
-              protocol: "acp",
-              provider: "codex",
-              rawToolName: msg.toolName,
-              canonicalToolName: resolveCanonicalToolNameV2(msg.toolName)
-            }),
-            id: randomUUID(),
-            isError
-          });
+          forwardAgentMessage(msg);
           return;
         }
         case "fs-edit": {
           messageBuffer.addMessage(`File edit: ${msg.description}`, "tool");
-          session.runtimeSession.sendCodexMessage({
-            type: "file-edit",
-            description: msg.description,
-            filePath: msg.path || "unknown",
-            diff: msg.diff,
-            id: randomUUID()
-          });
+          forwardAgentMessage(msg);
           return;
         }
         case "terminal-output": {
           const terminalOutput = formatDisplayMessage(msg.data);
           messageBuffer.addMessage(terminalOutput, "result");
-          session.runtimeSession.sendCodexMessage({
-            type: "terminal-output",
-            data: terminalOutput,
-            callId: msg.callId ?? randomUUID()
+          forwardAgentMessage({
+            ...msg,
+            data: terminalOutput
           });
           return;
         }
         case "permission-request": {
-          const payload = msg.payload || {};
-          session.runtimeSession.sendCodexMessage({
-            type: "permission-request",
-            permissionId: msg.id,
-            toolName: typeof payload.toolName === "string" ? payload.toolName : msg.reason,
-            description: msg.reason,
-            options: payload
-          });
+          forwardAgentMessage(msg);
           return;
         }
         case "exec-approval-request": {
-          const { call_id, type, ...inputs } = msg;
-          messageBuffer.addMessage(`Exec approval requested: ${call_id}`, "tool");
-          const rawToolName = "CodexBash";
-          const canonicalToolName = resolveCanonicalToolNameV2(rawToolName);
-          session.runtimeSession.sendCodexMessage({
-            type: "tool-call",
-            name: canonicalToolName,
-            callId: call_id,
-            input: attachToolHappierMetaV2(inputs, {
-              v: 2,
-              protocol: "acp",
-              provider: "codex",
-              rawToolName,
-              canonicalToolName
-            }),
-            id: randomUUID()
-          });
+          messageBuffer.addMessage(`Exec approval requested: ${msg.call_id}`, "tool");
+          forwardAgentMessage(msg);
           return;
         }
         case "patch-apply-begin": {
           const changeCount = Object.keys(msg.changes || {}).length;
           const filesMsg = changeCount === 1 ? "1 file" : `${changeCount} files`;
           messageBuffer.addMessage(`Modifying ${filesMsg}...`, "tool");
-          const rawToolName = "CodexPatch";
-          const canonicalToolName = resolveCanonicalToolNameV2(rawToolName);
-          session.runtimeSession.sendCodexMessage({
-            type: "tool-call",
-            name: canonicalToolName,
-            callId: msg.call_id,
-            input: attachToolHappierMetaV2({
-              auto_approved: msg.auto_approved,
-              changes: msg.changes
-            }, {
-              v: 2,
-              protocol: "acp",
-              provider: "codex",
-              rawToolName,
-              canonicalToolName
-            }),
-            id: randomUUID()
-          });
+          forwardAgentMessage(msg);
           return;
         }
         case "patch-apply-end": {
@@ -1069,30 +695,11 @@ async function codexRemoteLauncher(session) {
           } else {
             messageBuffer.addMessage(`Error: ${truncateDisplayMessage(msg.stderr || "Failed to modify files", 200)}`, "result");
           }
-          session.runtimeSession.sendCodexMessage({
-            type: "tool-call-result",
-            callId: msg.call_id,
-            output: attachToolHappierMetaV2({
-              stdout: msg.stdout,
-              stderr: msg.stderr,
-              success: msg.success
-            }, {
-              v: 2,
-              protocol: "acp",
-              provider: "codex",
-              rawToolName: "CodexPatch",
-              canonicalToolName: resolveCanonicalToolNameV2("CodexPatch")
-            }),
-            id: randomUUID(),
-            isError: !msg.success
-          });
+          forwardAgentMessage(msg);
           return;
         }
         case "token-count": {
-          session.runtimeSession.sendCodexMessage({
-            ...msg,
-            id: randomUUID()
-          });
+          forwardAgentMessage(msg);
           return;
         }
         case "event": {
@@ -1118,7 +725,7 @@ async function codexRemoteLauncher(session) {
       }
     });
   };
-  const createBackend = (mode) => {
+  const createRuntimeHandle = async (mode) => {
     const executionMode = resolveCodexAcpExecutionMode(mode);
     const validation = validateCodexAcpSpawn({
       command: process.env.HAPPY_CODEX_ACP_COMMAND,
@@ -1130,20 +737,25 @@ async function codexRemoteLauncher(session) {
     if (!validation.ok) {
       throw new Error(validation.errorMessage);
     }
-    const result = createCodexBackend({
+    const { session: nextRuntimeHandle } = await launchRuntimeHandleWithFactoryResult({
+      provider: "codex",
       cwd: session.path,
-      baseArgs: session.codexArgs,
-      model: executionMode.model,
-      sandbox: executionMode.sandbox,
-      approvalPolicy: executionMode.approvalPolicy,
-      permissionHandler,
-      selectionHandler: {
-        handleSelection: (request) => selectionHandler.requestSelection(request)
-      }
+      createBackendResult: (opts) => createCodexBackend({
+        ...opts,
+        baseArgs: session.codexArgs,
+        model: executionMode.model,
+        sandbox: executionMode.sandbox,
+        approvalPolicy: executionMode.approvalPolicy,
+        permissionHandler,
+        selectionHandler: {
+          handleSelection: (request) => selectionHandler.requestSelection(request)
+        }
+      })
     });
-    backend = result.backend;
-    setupBackendMessageHandler(result.backend);
-    return result.backend;
+    runtimeHandle = nextRuntimeHandle;
+    setupRuntimeMessageHandler(nextRuntimeHandle);
+    session.onSessionFound(nextRuntimeHandle.sessionId);
+    return nextRuntimeHandle;
   };
   const handleSwitchToLocal = async () => {
     const message = getCodexLegacySwitchIgnoredMessage();
@@ -1162,17 +774,10 @@ async function codexRemoteLauncher(session) {
     logger.debug("[Codex] Kill session requested - terminating process");
     await handleAbort();
     try {
-      session.runtimeSession.updateMetadata((currentMetadata) => ({
-        ...currentMetadata,
-        lifecycleState: "archived",
-        lifecycleStateSince: Date.now(),
-        archivedBy: "cli",
+      await closeProviderSession(session.runtimeSession, {
         archiveReason: "User terminated"
-      }));
-      session.runtimeSession.sendSessionDeath();
-      await session.runtimeSession.flush();
-      await session.runtimeSession.close();
-      await disposeBackend();
+      });
+      await disposeRuntimeHandle();
       stopCaffeinate();
       process.exit(0);
     } catch (error) {
@@ -1236,9 +841,9 @@ async function codexRemoteLauncher(session) {
       if (!message) {
         break;
       }
-      if (wasSessionCreated && currentModeHash && message.hash !== currentModeHash) {
+      if (runtimeHandle && currentModeHash && message.hash !== currentModeHash) {
         queueHistoryInjectionForRestart("Starting new Codex session (execution settings changed)...");
-        await disposeBackend();
+        await disposeRuntimeHandle();
         session.clearSessionId();
         currentModeHash = null;
         pending = message;
@@ -1254,16 +859,10 @@ async function codexRemoteLauncher(session) {
       try {
         turnInFlight = true;
         shouldCommitAccumulatedResponse = false;
-        const activeBackend = backend ?? createBackend(message.mode);
-        if (!activeBackend) {
+        const activeRuntimeHandle = runtimeHandle ?? await createRuntimeHandle(message.mode);
+        if (!activeRuntimeHandle) {
           throw new Error("Failed to create Codex ACP backend");
         }
-        if (!acpSessionId) {
-          const { sessionId } = await activeBackend.startSession();
-          acpSessionId = sessionId;
-          wasSessionCreated = true;
-          session.onSessionFound(sessionId);
-        }
         session.onThinkingChange(true);
         let promptToSend = message.message;
         if (shouldInjectHistoryOnNextSession && conversationHistory.hasHistory()) {
@@ -1272,8 +871,8 @@ async function codexRemoteLauncher(session) {
           logger.debug(`[Codex] Injected conversation history context (${historyContext.length} chars)`);
         }
         conversationHistory.addUserMessage(message.message);
-        await activeBackend.sendPrompt(acpSessionId, promptToSend);
-        await waitForResponseCompleteWithAbort(activeBackend, turnSignal);
+        await activeRuntimeHandle.sendPrompt(promptToSend);
+        await waitForResponseCompleteWithAbort(activeRuntimeHandle.backend, turnSignal);
         reasoningProcessor.completeCurrent();
         shouldCommitAccumulatedResponse = true;
         shouldInjectHistoryOnNextSession = false;
@@ -1293,7 +892,7 @@ async function codexRemoteLauncher(session) {
           if (conversationHistory.hasHistory()) {
             shouldInjectHistoryOnNextSession = true;
           }
-          await disposeBackend();
+          await disposeRuntimeHandle();
           session.clearSessionId();
         }
       } finally {
@@ -1322,7 +921,7 @@ async function codexRemoteLauncher(session) {
       }
     }
   } finally {
-    await disposeBackend();
+    await disposeRuntimeHandle();
     permissionHandler.reset();
     selectionHandler.reset();
     session.removeClientSwapCallback(handleClientSwap);
@@ -1353,49 +952,24 @@ async function codexRemoteLauncher(session) {
 
 async function codexLoop(opts) {
   const displayMode = opts.startingMode ?? "local";
-  await opts.session.onModeChange(displayMode);
   logger.debug(`[codex-loop] Starting ACP-only Codex launcher with display mode: ${displayMode}`);
-  await codexRemoteLauncher(opts.session);
-  return 0;
-}
-
-function supportsAgentStateUpdateEvents(sessionClient) {
-  return typeof sessionClient.once === "function" && typeof sessionClient.off === "function";
-}
-async function syncControlledByUserState(sessionClient, controlledByUser) {
-  if (!supportsAgentStateUpdateEvents(sessionClient)) {
-    sessionClient.updateAgentState((currentState) => ({
-      ...currentState,
-      controlledByUser
-    }));
-    return;
-  }
-  await new Promise((resolve) => {
-    let settled = false;
-    const handleUpdated = () => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timeout);
-      sessionClient.off("agent-state-updated", handleUpdated);
-      resolve();
-    };
-    const timeout = setTimeout(() => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      sessionClient.off("agent-state-updated", handleUpdated);
-      resolve();
-    }, 1500);
-    sessionClient.once("agent-state-updated", handleUpdated);
-    sessionClient.updateAgentState((currentState) => ({
-      ...currentState,
-      controlledByUser
-    }));
+  const launchCurrentMode = async () => {
+    await codexRemoteLauncher(opts.session);
+    return { type: "exit", value: 0 };
+  };
+  return await runModeLoop({
+    startingMode: displayMode,
+    notifyInitialMode: true,
+    onModeChange: async (mode) => {
+      await opts.session.onModeChange(mode);
+    },
+    launchers: {
+      local: launchCurrentMode,
+      remote: launchCurrentMode
+    }
   });
 }
+
 function resolveInitialCodexPermissionMode(opts) {
   if (opts.permissionMode) {
     return opts.permissionMode;
@@ -1434,48 +1008,38 @@ async function runCodex(opts) {
   }
   const api = await ApiClient.create(opts.credentials);
   logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}, requestedStartingMode=${requestedStartingMode}, executionMode=acp-only`);
-  const settings = await readSettings();
-  const machineId = settings?.machineId;
-  if (!machineId) {
-    console.error("[START] No machine ID found in settings.");
-    process.exit(1);
-  }
-  await api.getOrCreateMachine({
-    machineId,
-    metadata: initialMachineMetadata
-  });
-  const { state, metadata } = createSessionMetadata({
-    flavor: "codex",
-    machineId,
-    startedBy: opts.startedBy
-  });
-  let response = null;
+  let machineId;
   try {
-    response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+    machineId = await ensureManagedProviderMachine({
+      api,
+      missingMachineIdMessage: "[START] No machine ID found in settings."
+    });
   } catch (error) {
-    if (!isAuthenticationRequiredError(error)) {
-      throw error;
+    if (error instanceof MissingMachineIdError) {
+      console.error(error.message);
+      process.exit(1);
     }
-    logger.debug("[codex] Falling back to offline session stub after authentication failure");
+    throw error;
   }
   let sessionClient;
   let codexSession = null;
-  const { session: initialSession, reconnectionHandle } = setupOfflineReconnection({
+  const { metadata, session: initialSession, reconnectionHandle } = await bootstrapManagedProviderSession({
     api,
     sessionTag,
-    metadata,
-    state,
-    response,
+    flavor: "codex",
+    machineId,
+    startedBy: opts.startedBy,
+    authFallbackLogMessage: "[codex] Falling back to offline session stub after authentication failure",
     onSessionSwap: (newSession) => {
       sessionClient = newSession;
       codexSession?.updateClient(newSession);
-      void publishSessionRegistration(newSession.sessionId, metadata);
+      void syncControlledByUserState(
+        newSession,
+        (codexSession?.mode ?? requestedStartingMode) === "local"
+      );
     }
   });
   sessionClient = initialSession;
-  if (response) {
-    await publishSessionRegistration(response.id, metadata);
-  }
   const messageQueue = new MessageQueue2(getCodexExecutionFingerprint);
   let currentPermissionMode = initialPermissionMode;
   let currentModel;
@@ -1515,20 +1079,33 @@ async function runCodex(opts) {
       await syncControlledByUserState(sessionClient, mode === "local");
     }
   });
+  let exitCode = null;
+  let loopError;
+  let closeError;
   try {
-    const exitCode = await codexLoop({
+    exitCode = await codexLoop({
       session: codexSession,
       startingMode: requestedStartingMode
     });
-    sessionClient.sendSessionDeath();
-    await sessionClient.flush();
-    await sessionClient.close();
-    stopCaffeinate();
-    process.exit(exitCode);
+  } catch (error) {
+    loopError = error;
   } finally {
+    try {
+      await closeProviderSession(sessionClient);
+    } catch (error) {
+      closeError = error;
+    }
+    stopCaffeinate();
     reconnectionHandle?.cancel();
     codexSession.cleanup();
   }
+  if (loopError !== void 0) {
+    throw loopError;
+  }
+  if (closeError !== void 0) {
+    throw closeError;
+  }
+  process.exit(exitCode ?? 1);
 }
 
-export { resolveIncomingCodexPermissionMode, resolveInitialCodexPermissionMode, resolveQueuedCodexPermissionMode, runCodex, supportsAgentStateUpdateEvents, syncControlledByUserState };
+export { resolveIncomingCodexPermissionMode, resolveInitialCodexPermissionMode, resolveQueuedCodexPermissionMode, runCodex };