flockbay 0.10.15 → 0.10.17

package/dist/{runCodex-o6PCbHQ7.mjs → runCodex-DudVDqNh.mjs}

@@ -1,6 +1,6 @@
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
-import { l as logger, A as ApiClient, r as readSettings, p as projectPath, c as configuration, b as packageJson } from './types-DGd6ea2Z.mjs';
+import { l as logger, A as ApiClient, r as readSettings, p as projectPath, c as configuration, b as packageJson } from './types-DuhcLxar.mjs';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { z } from 'zod';
@@ -10,15 +10,13 @@ import fs__default from 'node:fs';
 import os from 'node:os';
 import path, { resolve, join } from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { s as shouldCountToolCall, c as consumeToolQuota, f as formatQuotaDeniedReason, h as hashObject, i as initialMachineMetadata, E as ElicitationHub, n as notifyDaemonSessionStarted, M as MessageQueue2, P as PLATFORM_SYSTEM_PROMPT, a as setLatestUserImages, w as withUserImagesMarker, r as registerKillSessionHandler, b as MessageBuffer, d as startFlockbayServer, e as detectUnrealProject, g as buildProjectCapsule, t as trimIdent, j as autoFinalizeCoordinationWorkItem, k as applyCoordinationSideEffectsFromMcpToolResult, l as stopCaffeinate } from './index-CUp3juDS.mjs';
-import { d as detectScreenshotsForGate } from './flockbayScreenshotGate-DJX3Is5d.mjs';
+import { s as shouldCountToolCall, c as consumeToolQuota, f as formatQuotaDeniedReason, h as hashObject, i as initialMachineMetadata, E as ElicitationHub, n as notifyDaemonSessionStarted, M as MessageQueue2, P as PLATFORM_SYSTEM_PROMPT, a as setLatestUserImages, w as withUserImagesMarker, r as registerKillSessionHandler, b as MessageBuffer, d as startFlockbayServer, e as detectUnrealProject, g as buildProjectCapsule, t as trimIdent, j as autoFinalizeCoordinationWorkItem, k as detectScreenshotsForGate, l as applyCoordinationSideEffectsFromMcpToolResult, m as stopCaffeinate } from './index-CHm9r89K.mjs';
 import 'axios';
+import 'node:events';
+import 'socket.io-client';
 import 'chalk';
 import 'fs';
 import 'node:fs/promises';
-import 'tweetnacl';
-import 'node:events';
-import 'socket.io-client';
 import 'child_process';
 import 'fs/promises';
 import 'crypto';
@@ -27,19 +25,18 @@ import 'url';
 import 'node:process';
 import 'os';
 import 'node:net';
-import 'expo-server-sdk';
 import 'node:readline';
 import 'node:url';
 import 'ps-list';
 import 'cross-spawn';
 import 'tmp';
-import 'qrcode-terminal';
 import 'open';
 import 'fastify';
 import 'fastify-type-provider-zod';
 import '@modelcontextprotocol/sdk/server/mcp.js';
 import 'node:http';
 import '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import 'tweetnacl';
 import 'http';
 import 'util';
 
@@ -1286,6 +1283,27 @@ class CodexMcpClient {
     logger.debug("[CodexMCP] Storing conversation for potential resume:", this.conversationId);
     return this.conversationId;
   }
+  /**
+   * Best-effort interrupt for an in-flight Codex request.
+   * Codex MCP does not currently support protocol-level cancellation, so we interrupt the
+   * underlying `codex` process. This should stop streaming and allow the UI abort button
+   * to actually halt the current turn.
+   */
+  interrupt() {
+    const pid = this.transport?.pid ?? null;
+    if (!pid) return false;
+    try {
+      logger.debug("[CodexMCP] Interrupt requested; sending SIGINT to child", { pid });
+      process.kill(pid, "SIGINT");
+      return true;
+    } catch (error) {
+      const e = error;
+      if (e?.code !== "ESRCH") {
+        logger.debug("[CodexMCP] Failed to SIGINT child process", { pid, error });
+      }
+      return false;
+    }
+  }
   async disconnect() {
     if (!this.connected) return;
     const pid = this.transport?.pid ?? null;
@@ -1331,6 +1349,8 @@ class CodexMcpClient {
     this.sessionId = null;
     this.conversationId = null;
     this.authSnapshot = null;
+    this.reconnectPromise = null;
+    this.client = this.createClient();
     logger.debug("[CodexMCP] Disconnected");
   }
 }
@@ -1548,11 +1568,14 @@ class CodexPermissionHandler {
     this.pendingRequests.clear();
     this.aliasToPrimary.clear();
     this.session.updateAgentState((currentState) => {
-      const pendingRequests = currentState.requests || {};
-      const completedRequests = { ...currentState.completedRequests };
+      const pendingRaw = currentState?.requests;
+      const pendingRequests = pendingRaw && typeof pendingRaw === "object" ? pendingRaw : {};
+      const completedRaw = currentState?.completedRequests;
+      const completedRequests = completedRaw && typeof completedRaw === "object" ? { ...completedRaw } : {};
       for (const [id, request] of Object.entries(pendingRequests)) {
+        const reqObj = request && typeof request === "object" ? request : { value: request };
         completedRequests[id] = {
-          ...request,
+          ...reqObj,
           completedAt: Date.now(),
           status: "canceled",
           reason: "Session reset"
@@ -2321,10 +2344,21 @@ async function runCodex(opts) {
     lifecycleStateSince: Date.now(),
     flavor: "codex"
   };
-  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  const response = opts.sessionId ? await api.getSessionById(opts.sessionId) : await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   const session = api.sessionSyncClient(response);
+  if (opts.sessionId) {
+    session.updateMetadata((currentMetadata) => ({
+      ...currentMetadata,
+      ...metadata,
+      // Preserve user-facing fields set by other clients.
+      name: currentMetadata?.name,
+      summary: currentMetadata?.summary
+    }));
+  }
   const elicitationHub = new ElicitationHub();
   const permissionHandler = new CodexPermissionHandler(session, { elicitationHub });
+  await session.connectAndWait(15e3);
+  session.keepAlive(false, "remote");
   try {
     logger.debug(`[START] Reporting session ${response.id} to daemon`);
     const result = await notifyDaemonSessionStarted(response.id, metadata);
@@ -2339,8 +2373,10 @@ async function runCodex(opts) {
   const messageQueue = new MessageQueue2((mode) => hashCodexSessionModeFromEnhancedMode(mode));
   const autoPrompt = String(process.env.FLOCKBAY_AUTO_PROMPT || "").trim();
   if (autoPrompt) {
+    const autoPromptPermissionModeRaw = String(process.env.FLOCKBAY_AUTO_PROMPT_PERMISSION_MODE || "").trim();
+    const autoPromptPermissionMode = autoPromptPermissionModeRaw === "safe-yolo" || autoPromptPermissionModeRaw === "yolo" || autoPromptPermissionModeRaw === "bypassPermissions" ? autoPromptPermissionModeRaw : "default";
     messageQueue.push(autoPrompt, {
-      permissionMode: "default",
+      permissionMode: autoPromptPermissionMode,
       model: void 0,
       appendSystemPrompt: PLATFORM_SYSTEM_PROMPT
     });
@@ -2435,13 +2471,46 @@ async function runCodex(opts) {
       logger.debug("[codex][handles] Failed to serialize active handles:", error);
     }
   }
+  let wasCreated = false;
+  let currentModeHash = null;
   let abortController = new AbortController();
   let shouldExit = false;
   let storedConversationIdForRecovery = null;
-  async function handleAbort() {
+  let abortNote = null;
+  let abortNoteSentToSession = false;
+  let abortRequested = false;
+  function normalizeCancelNote(input) {
+    if (typeof input === "string") return input.trim() ? input.trim() : null;
+    if (!input || typeof input !== "object") return null;
+    const note = typeof input.note === "string" ? String(input.note).trim() : "";
+    if (note) return note;
+    const reason = typeof input.reason === "string" ? String(input.reason).trim() : "";
+    if (reason) return reason;
+    return null;
+  }
+  async function handleAbort(note, options) {
     logger.debug("[Codex] Abort requested - stopping current task");
     try {
+      abortRequested = true;
+      const normalizedNote = normalizeCancelNote(note);
+      if (normalizedNote) {
+        abortNote = normalizedNote;
+        abortNoteSentToSession = Boolean(options?.alreadySentToSession);
+      }
       abortController.abort();
+      try {
+        storedConversationIdForRecovery = client.storeConversationForResume() || client.storeSessionForResume();
+        client.interrupt();
+        try {
+          await client.disconnect();
+        } catch (disconnectError) {
+          logger.debug("[Codex] Failed to disconnect Codex MCP after interrupt", disconnectError);
+        }
+        wasCreated = false;
+        currentModeHash = null;
+      } catch (error) {
+        logger.debug("[Codex] Failed to interrupt Codex process on abort", error);
+      }
       messageQueue.reset();
       permissionHandler.reset();
       reasoningProcessor.abort();
@@ -2479,7 +2548,10 @@ async function runCodex(opts) {
       process.exit(1);
     }
   };
-  session.rpcHandlerManager.registerHandler("abort", handleAbort);
+  async function handleCancelGeneration(params) {
+    await handleAbort(params);
+  }
+  session.rpcHandlerManager.registerHandler("cancel-generation", handleCancelGeneration);
   registerKillSessionHandler(session.rpcHandlerManager, handleKillSession);
   const messageBuffer = new MessageBuffer();
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
@@ -2507,6 +2579,57 @@ async function runCodex(opts) {
     process.stdin.setEncoding("utf8");
   }
   const client = new CodexMcpClient();
+  async function buildReplayPromptFromServerMessages() {
+    try {
+      const rows = await session.listMessages();
+      if (!Array.isArray(rows) || rows.length === 0) return null;
+      const lines = [];
+      const push = (role, text) => {
+        const t = String(text || "").trim();
+        if (!t) return;
+        lines.push(`${role === "user" ? "User" : "Assistant"}: ${t}`);
+      };
+      for (const row of rows.slice(-80)) {
+        const content = row?.content;
+        if (!content || typeof content !== "object") continue;
+        const role = content.role;
+        const payload = content.content;
+        if (role === "user") {
+          if (payload && typeof payload === "object" && payload.type === "text" && typeof payload.text === "string") {
+            push("user", payload.text);
+          }
+          continue;
+        }
+        if (role !== "agent") continue;
+        if (!payload || typeof payload !== "object") continue;
+        if (payload.type === "output") {
+          const data = payload.data;
+          if (data && typeof data === "object" && data.type === "assistant") {
+            const blocks = data.message?.content;
+            if (Array.isArray(blocks)) {
+              const txt = blocks.map((b) => b?.type === "text" && typeof b.text === "string" ? b.text : "").join("").trim();
+              if (txt) push("assistant", txt);
+            }
+          }
+        } else if (payload.type === "codex") {
+          const data = payload.data;
+          if (data && typeof data === "object" && data.type === "message" && typeof data.message === "string") {
+            push("assistant", data.message);
+          }
+        }
+      }
+      const compact = lines.filter((l) => l.length > 0).slice(-24).join("\n");
+      const clipped = compact.length > 1e4 ? compact.slice(compact.length - 1e4) : compact;
+      if (!clipped.trim()) return null;
+      return [
+        "Conversation so far (most recent last). Continue naturally; do not repeat it verbatim unless asked:",
+        clipped
+      ].join("\n");
+    } catch (e) {
+      logger.debug("[Codex] Failed to build replay prompt from server messages", e);
+      return null;
+    }
+  }
   function findCodexResumeFile(conversationId) {
     if (!conversationId) return null;
     try {
@@ -2616,9 +2739,13 @@ async function runCodex(opts) {
             Before doing anything else, call \`mcp__flockbay__read_images\` with:
             ${toolArgs}
 
-            Then visually inspect EVERY screenshot and report:
-            - One short bullet per image ("Image N: ...") describing what you see
-            - Whether the screenshots match the user's request
+            Then visually inspect EVERY screenshot and report (this is for YOUR validation, not ceremony):
+            1) List 2\u20135 concrete acceptance criteria for the user's request.
+            2) One short bullet per image ("Image N: ...") describing what you see.
+            3) For each acceptance criterion: mark it as Verified / Not visible / Failed based ONLY on the screenshots.
+               - If "Not visible", say what evidence is missing.
+               - If "Failed", say what is wrong.
+            4) If anything is not Verified: state the next tool/action you will take to fix or validate it (do not claim completion yet).
 
             Do not run any other tools in this step.
         `);
@@ -2626,6 +2753,28 @@ async function runCodex(opts) {
   client.setPermissionHandler(permissionHandler);
   const execInflight = /* @__PURE__ */ new Set();
   const execAliasToCallId = /* @__PURE__ */ new Map();
+  const execToolCallEmitted = /* @__PURE__ */ new Set();
+  const forceCloseInflightExecCalls = (opts2) => {
+    if (execInflight.size === 0) return;
+    for (const callId of Array.from(execInflight)) {
+      try {
+        session.sendCodexMessage({
+          type: "tool-call-result",
+          callId,
+          output: { ok: !opts2.isError, reason: opts2.reason, missing_exec_command_end: true },
+          is_error: opts2.isError,
+          id: randomUUID()
+        });
+      } catch (err) {
+        logger.debug("[codex] Failed to force-close exec tool-call", {
+          callId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    execInflight.clear();
+    execAliasToCallId.clear();
+  };
   client.setHandler((msg) => {
     try {
       const preview = typeof msg?.type === "string" ? msg.type : "unknown";
@@ -2735,8 +2884,7 @@ async function runCodex(opts) {
       const out = [];
       const seen = /* @__PURE__ */ new Set();
       for (const v of raw) {
-        if (typeof v !== "string") continue;
-        const s = v.trim();
+        const s = typeof v === "string" ? v.trim() : typeof v === "number" && Number.isFinite(v) ? String(v) : typeof v === "bigint" ? String(v) : "";
         if (!s || s === "undefined") continue;
         if (seen.has(s)) continue;
         seen.add(s);
@@ -3060,30 +3208,30 @@ async function runCodex(opts) {
         id: randomUUID()
       });
     }
-    if (msg.type === "exec_command_begin" || msg.type === "exec_approval_request") {
+    if (msg.type === "exec_command_begin") {
       const callId = resolveExecCallId(msg, true);
       if (!callId) {
-        console.error("[codexbash-diag] Missing call id for exec begin/approval event", {
-          type: msg.type,
+        console.error("[codexbash-diag] Missing call id for exec begin event", {
           keys: Object.keys(msg || {})
         });
-        throw new Error("Missing call id for exec begin/approval event");
+        throw new Error("Missing call id for exec begin event");
       }
-      if (msg.type === "exec_command_begin") {
-        try {
-          console.error("[codexbash-diag] exec begin callId", { callId, aliases: getCallIdAliases(msg) });
-        } catch {
-        }
+      try {
+        console.error("[codexbash-diag] exec begin callId", { callId, aliases: getCallIdAliases(msg) });
+      } catch {
       }
       markExecStarted(callId, msg);
-      let { call_id, callId: _callId, type, ...inputs } = msg;
-      session.sendCodexMessage({
-        type: "tool-call",
-        name: "CodexBash",
-        callId,
-        input: inputs,
-        id: randomUUID()
-      });
+      if (!execToolCallEmitted.has(callId)) {
+        execToolCallEmitted.add(callId);
+        let { call_id, callId: _callId, type, ...inputs } = msg;
+        session.sendCodexMessage({
+          type: "tool-call",
+          name: "CodexBash",
+          callId,
+          input: inputs,
+          id: randomUUID()
+        });
+      }
     }
     if (msg.type === "exec_command_end") {
       const callId = resolveExecCallId(msg, false);
@@ -3098,6 +3246,24 @@ async function runCodex(opts) {
         console.error("[codexbash-diag] exec end callId", { callId, aliases: getCallIdAliases(msg) });
       } catch {
       }
+      if (!execToolCallEmitted.has(callId)) {
+        execToolCallEmitted.add(callId);
+        try {
+          let { call_id: call_id2, callId: _callId2, type: type2, ...inputs } = msg;
+          session.sendCodexMessage({
+            type: "tool-call",
+            name: "CodexBash",
+            callId,
+            input: inputs,
+            id: randomUUID()
+          });
+        } catch (err) {
+          logger.debug("[codex] Failed to synthesize exec tool-call begin", {
+            callId,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
       let { call_id, callId: _callId, type, ...output } = msg;
       const sanitized = sanitizeExecCommandEndOutput(output);
       collectScreenshotsForGate({ ...sanitized, cwd: output?.cwd ?? sanitized?.cwd ?? msg?.cwd });
@@ -3172,6 +3338,21 @@ async function runCodex(opts) {
     }
   });
   const flockbayServer = await startFlockbayServer(session, { elicitationHub });
+  const unsubscribeUnrealIssue = (() => {
+    const onIssue = flockbayServer?.unreal?.onIssue;
+    if (typeof onIssue !== "function") return null;
+    return onIssue((event) => {
+      try {
+        const kind = typeof event?.kind === "string" ? event.kind : "unreachable";
+        const base = typeof event?.message === "string" && event.message.trim() ? event.message.trim() : "Unreal Editor issue detected.";
+        const msg = kind === "process_exit" ? `Unreal Editor crashed. ${base}` : `Unreal Editor is not reachable. ${base}`;
+        session.sendSessionEvent({ type: "message", message: msg });
+        void handleAbort(msg, { alreadySentToSession: true });
+      } catch (err) {
+        logger.debug("[Codex] Failed to handle Unreal issue event", err);
+      }
+    });
+  })();
   const bridgeCommand = join(projectPath(), "bin", "flockbay-mcp.mjs");
   const mcpServers = {
     flockbay: {
@@ -3205,8 +3386,8 @@ Error: ${message}`,
       return;
     }
     logger.debug("[codex]: client.connect done");
-    let wasCreated = false;
-    let currentModeHash = null;
+    wasCreated = false;
+    currentModeHash = null;
     let pending = null;
     let nextExperimentalResume = null;
     while (!shouldExit) {
@@ -3259,6 +3440,8 @@ Error: ${message}`,
       messageBuffer.addMessage(message.message, "user");
       currentModeHash = message.hash;
       let skipAutoFinalize = false;
+      let turnCleanupExecIsError = false;
+      let turnCleanupExecReason = "turn_cleanup";
       try {
         resetScreenshotGateForTurn();
         const overrides = { approvalPolicy: "untrusted", sandbox: "workspace-write" };
@@ -3298,18 +3481,35 @@ Error: ${message}`,
             ].filter((v) => typeof v === "string" && v.trim().length > 0).join("\n\n")
           );
           let resumeFile = null;
+          let resumeSource = null;
           if (nextExperimentalResume) {
             resumeFile = nextExperimentalResume;
+            resumeSource = "mode-change";
             nextExperimentalResume = null;
             logger.debug("[Codex] Using resume file from mode change:", resumeFile);
           } else if (storedConversationIdForRecovery) {
             const recoveryResumeFile = findCodexResumeFile(storedConversationIdForRecovery);
             if (recoveryResumeFile) {
               resumeFile = recoveryResumeFile;
+              resumeSource = "recovery";
               logger.debug("[Codex] Using resume file from previous session (error recovery):", resumeFile);
             }
             storedConversationIdForRecovery = null;
           }
+          const replay = await buildReplayPromptFromServerMessages();
+          if (replay) {
+            const escapedUser = String(message.message || "").trim();
+            const replayTrimmed = replay.trimEnd();
+            const needle = escapedUser ? `User: ${escapedUser}` : "";
+            const replayDeduped = needle && replayTrimmed.endsWith(needle) ? replayTrimmed.slice(0, replayTrimmed.length - needle.length).trimEnd() : replayTrimmed;
+            startConfig.prompt = escapedUser ? `${replayDeduped}
+
+User: ${escapedUser}` : replayDeduped;
+            if (resumeSource === "recovery") {
+              resumeFile = null;
+              resumeSource = null;
+            }
+          }
           if (resumeFile) {
             startConfig.config.experimental_resume = resumeFile;
           }
@@ -3336,10 +3536,19 @@ Error: ${message}`,
       } catch (error) {
         logger.warn("Error in codex session:", error);
         const isAbortError = error instanceof Error && error.name === "AbortError";
-        if (isAbortError) {
+        const treatAsAbort = abortRequested || isAbortError;
+        if (treatAsAbort) {
           skipAutoFinalize = true;
-          messageBuffer.addMessage("Aborted by user", "status");
-          session.sendSessionEvent({ type: "message", message: "Aborted by user" });
+          turnCleanupExecIsError = true;
+          turnCleanupExecReason = "turn_aborted";
+          const note = abortNote || "Aborted by user";
+          abortNote = null;
+          const alreadySent = abortNoteSentToSession;
+          abortNoteSentToSession = false;
+          abortRequested = false;
+          messageBuffer.addMessage(note, "status");
+          if (!alreadySent) session.sendSessionEvent({ type: "message", message: note });
+          session.sendSessionEvent({ type: "ready" });
           if (!client.hasActiveSession()) {
             wasCreated = false;
             currentModeHash = null;
@@ -3349,6 +3558,8 @@ Error: ${message}`,
             logger.debug("[Codex] Abort completed; keeping active session for next message");
           }
         } else {
+          turnCleanupExecIsError = true;
+          turnCleanupExecReason = "turn_error";
           const errorMessage = error instanceof Error ? error.message : String(error);
           messageBuffer.addMessage(`Error: ${errorMessage}`, "status");
           session.sendSessionEvent({ type: "message", message: `Error: ${errorMessage}` });
@@ -3364,8 +3575,14 @@ Error: ${message}`,
         permissionHandler.reset();
         reasoningProcessor.abort();
         diffProcessor.reset();
+        forceCloseInflightExecCalls({ isError: turnCleanupExecIsError, reason: turnCleanupExecReason });
+        abortRequested = false;
         thinking = false;
         session.keepAlive(thinking, "remote");
+        try {
+          session.flush();
+        } catch {
+        }
         if (!skipAutoFinalize) {
           try {
             const finalizeRes = await autoFinalizeCoordinationWorkItem({
@@ -3396,6 +3613,10 @@ Error: ${message}`,
   } finally {
     logger.debug("[codex]: Final cleanup start");
     logActiveHandles("cleanup-start");
+    try {
+      if (typeof unsubscribeUnrealIssue === "function") unsubscribeUnrealIssue();
+    } catch {
+    }
     try {
       logger.debug("[codex]: sendSessionDeath");
       session.sendSessionDeath();