flockbay 0.10.15 → 0.10.16

package/dist/{runCodex-D3eT-TvB.cjs → runCodex-DzP3VUa-.cjs}

@@ -2,7 +2,7 @@
 
 var ink = require('ink');
 var React = require('react');
-var types = require('./types-C-jnUdn_.cjs');
+var types = require('./types-SUAKq-K0.cjs');
 var index_js = require('@modelcontextprotocol/sdk/client/index.js');
 var stdio_js = require('@modelcontextprotocol/sdk/client/stdio.js');
 var z = require('zod');
@@ -12,15 +12,13 @@ var fs = require('node:fs');
 var os = require('node:os');
 var path = require('node:path');
 var node_child_process = require('node:child_process');
-var index = require('./index--o4BPz5o.cjs');
-var flockbayScreenshotGate = require('./flockbayScreenshotGate-DkxU24cR.cjs');
+var index = require('./index-Cau-_Qvn.cjs');
 require('axios');
+require('node:events');
+require('socket.io-client');
 require('chalk');
 require('fs');
 require('node:fs/promises');
-require('tweetnacl');
-require('node:events');
-require('socket.io-client');
 require('child_process');
 require('fs/promises');
 require('crypto');
@@ -29,19 +27,18 @@ require('url');
 require('node:process');
 require('os');
 require('node:net');
-require('expo-server-sdk');
 require('node:readline');
 require('node:url');
 require('ps-list');
 require('cross-spawn');
 require('tmp');
-require('qrcode-terminal');
 require('open');
 require('fastify');
 require('fastify-type-provider-zod');
 require('@modelcontextprotocol/sdk/server/mcp.js');
 require('node:http');
 require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+require('tweetnacl');
 require('http');
 require('util');
 
@@ -1288,6 +1285,27 @@ class CodexMcpClient {
     types.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 {
+      types.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") {
+        types.logger.debug("[CodexMCP] Failed to SIGINT child process", { pid, error });
+      }
+      return false;
+    }
+  }
   async disconnect() {
     if (!this.connected) return;
     const pid = this.transport?.pid ?? null;
@@ -1333,6 +1351,8 @@ class CodexMcpClient {
     this.sessionId = null;
     this.conversationId = null;
     this.authSnapshot = null;
+    this.reconnectPromise = null;
+    this.client = this.createClient();
     types.logger.debug("[CodexMCP] Disconnected");
   }
 }
@@ -1550,11 +1570,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"
@@ -2323,10 +2346,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 index.ElicitationHub();
   const permissionHandler = new CodexPermissionHandler(session, { elicitationHub });
+  await session.connectAndWait(15e3);
+  session.keepAlive(false, "remote");
   try {
     types.logger.debug(`[START] Reporting session ${response.id} to daemon`);
     const result = await index.notifyDaemonSessionStarted(response.id, metadata);
@@ -2341,8 +2375,10 @@ async function runCodex(opts) {
   const messageQueue = new index.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: index.PLATFORM_SYSTEM_PROMPT
     });
@@ -2437,13 +2473,46 @@ async function runCodex(opts) {
       types.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) {
     types.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) {
+          types.logger.debug("[Codex] Failed to disconnect Codex MCP after interrupt", disconnectError);
+        }
+        wasCreated = false;
+        currentModeHash = null;
+      } catch (error) {
+        types.logger.debug("[Codex] Failed to interrupt Codex process on abort", error);
+      }
       messageQueue.reset();
       permissionHandler.reset();
       reasoningProcessor.abort();
@@ -2481,7 +2550,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);
   index.registerKillSessionHandler(session.rpcHandlerManager, handleKillSession);
   const messageBuffer = new index.MessageBuffer();
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
@@ -2509,6 +2581,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) {
+      types.logger.debug("[Codex] Failed to build replay prompt from server messages", e);
+      return null;
+    }
+  }
   function findCodexResumeFile(conversationId) {
     if (!conversationId) return null;
     try {
@@ -2593,7 +2716,7 @@ async function runCodex(opts) {
     if (!output) return;
     const cwdHint = output?.cwd;
     const cwd = typeof cwdHint === "string" && cwdHint.trim().length > 0 ? cwdHint.trim() : process.cwd();
-    const detected = flockbayScreenshotGate.detectScreenshotsForGate({ output, cwd });
+    const detected = index.detectScreenshotsForGate({ output, cwd });
     if (detected.paths.length === 0) return;
     if (detected.hasImageBlocks) screenshotGate.hasImageBlocks = true;
     for (const p of detected.paths) {
@@ -2618,9 +2741,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.
         `);
@@ -2628,6 +2755,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: node_crypto.randomUUID()
+        });
+      } catch (err) {
+        types.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";
@@ -2737,8 +2886,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);
@@ -3062,30 +3210,30 @@ async function runCodex(opts) {
         id: node_crypto.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: node_crypto.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: node_crypto.randomUUID()
+        });
+      }
     }
     if (msg.type === "exec_command_end") {
       const callId = resolveExecCallId(msg, false);
@@ -3100,6 +3248,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: node_crypto.randomUUID()
+          });
+        } catch (err) {
+          types.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 });
@@ -3174,6 +3340,21 @@ async function runCodex(opts) {
     }
   });
   const flockbayServer = await index.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) {
+        types.logger.debug("[Codex] Failed to handle Unreal issue event", err);
+      }
+    });
+  })();
   const bridgeCommand = path.join(types.projectPath(), "bin", "flockbay-mcp.mjs");
   const mcpServers = {
     flockbay: {
@@ -3207,8 +3388,8 @@ Error: ${message}`,
       return;
     }
     types.logger.debug("[codex]: client.connect done");
-    let wasCreated = false;
-    let currentModeHash = null;
+    wasCreated = false;
+    currentModeHash = null;
     let pending = null;
     let nextExperimentalResume = null;
     while (!shouldExit) {
@@ -3261,6 +3442,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" };
@@ -3300,18 +3483,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;
             types.logger.debug("[Codex] Using resume file from mode change:", resumeFile);
           } else if (storedConversationIdForRecovery) {
             const recoveryResumeFile = findCodexResumeFile(storedConversationIdForRecovery);
             if (recoveryResumeFile) {
               resumeFile = recoveryResumeFile;
+              resumeSource = "recovery";
               types.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;
           }
@@ -3338,10 +3538,19 @@ Error: ${message}`,
       } catch (error) {
         types.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;
@@ -3351,6 +3560,8 @@ Error: ${message}`,
             types.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}` });
@@ -3366,8 +3577,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 index.autoFinalizeCoordinationWorkItem({
@@ -3398,6 +3615,10 @@ Error: ${message}`,
   } finally {
     types.logger.debug("[codex]: Final cleanup start");
     logActiveHandles("cleanup-start");
+    try {
+      if (typeof unsubscribeUnrealIssue === "function") unsubscribeUnrealIssue();
+    } catch {
+    }
     try {
       types.logger.debug("[codex]: sendSessionDeath");
       session.sendSessionDeath();