flockbay 0.10.17 → 0.10.20

package/dist/codex/flockbayMcpStdioBridge.cjs

@@ -614,6 +614,14 @@ async function main() {
     "Unreal Editor: Launch Project",
     "Launch Unreal Editor for a given .uproject (no auto-restart). If the editor later crashes or becomes unreachable, Flockbay will abort the current agent run and report it in the chat."
   );
+  forwardTool(
+    "unreal_editor_relaunch_last",
+    {
+      extraArgs: z.z.array(z.z.string()).optional().describe("Optional replacement UnrealEditor command-line args (advanced).")
+    },
+    "Unreal Editor: Relaunch Last Project",
+    "Relaunch the last Unreal project previously launched via unreal_editor_launch in this session (no auto-restart). Use this after a crash once you\u2019ve fixed files."
+  );
   forwardTool(
     "unreal_headless_screenshot",
     {

package/dist/codex/flockbayMcpStdioBridge.mjs

@@ -612,6 +612,14 @@ async function main() {
     "Unreal Editor: Launch Project",
     "Launch Unreal Editor for a given .uproject (no auto-restart). If the editor later crashes or becomes unreachable, Flockbay will abort the current agent run and report it in the chat."
   );
+  forwardTool(
+    "unreal_editor_relaunch_last",
+    {
+      extraArgs: z.array(z.string()).optional().describe("Optional replacement UnrealEditor command-line args (advanced).")
+    },
+    "Unreal Editor: Relaunch Last Project",
+    "Relaunch the last Unreal project previously launched via unreal_editor_launch in this session (no auto-restart). Use this after a crash once you\u2019ve fixed files."
+  );
   forwardTool(
     "unreal_headless_screenshot",
     {

package/dist/{index-CHm9r89K.mjs → index-CX0Z8pmz.mjs}

@@ -1,14 +1,14 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
 import os, { homedir } from 'node:os';
 import { randomUUID, createCipheriv, randomBytes } from 'node:crypto';
-import { l as logger, p as projectPath, d as backoff, e as delay, R as RawJSONLinesSchema, c as configuration, f as readDaemonState, g as clearDaemonState, b as packageJson, r as readSettings, h as readCredentials, u as updateSettings, w as writeCredentials, i as unrealMcpPythonDir, j as acquireDaemonLock, k as writeDaemonState, m as ApiMachineClient, n as releaseDaemonLock, s as sendUnrealMcpTcpCommand, A as ApiClient, o as clearCredentials, q as clearMachineId, t as installUnrealMcpPluginToEngine, v as getLatestDaemonLog } from './types-DuhcLxar.mjs';
+import { l as logger, p as projectPath, d as backoff, e as delay, R as RawJSONLinesSchema, c as configuration, f as readDaemonState, g as clearDaemonState, b as packageJson, r as readSettings, h as readCredentials, u as updateSettings, w as writeCredentials, i as unrealMcpPythonDir, j as acquireDaemonLock, k as writeDaemonState, m as ApiMachineClient, n as releaseDaemonLock, s as sendUnrealMcpTcpCommand, A as ApiClient, o as clearCredentials, q as clearMachineId, t as installUnrealMcpPluginToEngine, v as getLatestDaemonLog, x as normalizeServerUrlForNode } from './types-C4QeUggl.mjs';
 import { spawn, execFileSync, execSync } from 'node:child_process';
 import path, { resolve, join, dirname } from 'node:path';
 import { createInterface } from 'node:readline';
 import * as fs from 'node:fs';
 import fs__default, { existsSync, readFileSync, mkdirSync, readdirSync, accessSync, constants, statSync, createReadStream, writeFileSync, unlinkSync } from 'node:fs';
 import process$1 from 'node:process';
-import fs$1, { readFile, access as access$1, mkdir, stat, readdir } from 'node:fs/promises';
+import fs$1, { readFile, access as access$1, mkdir, readdir, stat } from 'node:fs/promises';
 import fs$2, { watch, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
@@ -4581,7 +4581,13 @@ async function checkIfDaemonRunningAndCleanupStaleState() {
       return false;
     }
   }
-  return false;
+  const lockPid = readDaemonLockPid();
+  if (!lockPid) return false;
+  if (!isProcessAlive(lockPid)) {
+    await cleanupDaemonState();
+    return false;
+  }
+  return true;
 }
 async function isDaemonRunningCurrentCliVersion() {
   logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
@@ -4637,7 +4643,43 @@ async function stopDaemon() {
       await cleanupDaemonState();
       return;
     }
-    logger.debug("No daemon state found");
+    const lockPid = readDaemonLockPid();
+    if (!lockPid) {
+      logger.debug("No daemon state found");
+      return;
+    }
+    if (!isProcessAlive(lockPid)) {
+      logger.debug("[DAEMON RUN] Daemon lock PID not running, cleaning up state");
+      await cleanupDaemonState();
+      return;
+    }
+    const cmd = readProcessCommand(lockPid);
+    const looksLikeDaemon = looksLikeFlockbayDaemonCommand(cmd, configuration.profile);
+    if (!looksLikeDaemon) {
+      logger.debug("[DAEMON RUN] Daemon lock is held by an unexpected process; refusing to kill", {
+        lockPid,
+        cmd: cmd || null
+      });
+      return;
+    }
+    logger.debug(`[DAEMON RUN] Stopping daemon by lock PID ${lockPid} (state file missing)`);
+    try {
+      process.kill(lockPid, "SIGTERM");
+    } catch (error) {
+      logger.debug("[DAEMON RUN] Failed to SIGTERM lock PID", { lockPid, error });
+    }
+    try {
+      await waitForProcessDeath(lockPid, 2e3);
+    } catch {
+    }
+    if (isProcessAlive(lockPid)) {
+      try {
+        process.kill(lockPid, "SIGKILL");
+      } catch (error) {
+        logger.debug("[DAEMON RUN] Failed to SIGKILL lock PID", { lockPid, error });
+      }
+    }
+    await cleanupDaemonState();
   } catch (error) {
     logger.debug("Error stopping daemon", error);
   }
@@ -4654,6 +4696,39 @@ async function waitForProcessDeath(pid, timeout) {
   }
   throw new Error("Process did not die within timeout");
 }
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readDaemonLockPid() {
+  try {
+    const raw = readFileSync$1(configuration.daemonLockFile, "utf-8").trim();
+    const pid = Number(raw);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function readProcessCommand(pid) {
+  try {
+    return String(execFileSync("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8" }) || "").trim();
+  } catch {
+    return null;
+  }
+}
+function looksLikeFlockbayDaemonCommand(command, profile) {
+  const cmd = String(command || "").trim();
+  if (!cmd) return false;
+  if (!cmd.includes("flockbay")) return false;
+  if (!cmd.includes("daemon")) return false;
+  if (!cmd.includes("start-sync")) return false;
+  if (!cmd.includes("--profile")) return false;
+  return cmd.includes(profile);
+}
 
 async function findAllFlockbayProcesses() {
   try {
@@ -4938,8 +5013,8 @@ async function loginWithClerkAndPairMachine() {
   logger.debug("[AUTH] Starting Clerk-based CLI login + machine pairing");
   const settings = await updateSettings(async (s) => {
     const machineId2 = s.machineId || randomUUID();
-    const serverUrl2 = s.serverUrl || configuration.serverUrl;
-    const webappUrl = s.webappUrl || configuration.webappUrl;
+    const serverUrl2 = configuration.serverUrl;
+    const webappUrl = configuration.webappUrl;
     return { ...s, machineId: machineId2, serverUrl: serverUrl2, webappUrl };
   });
   const serverUrl = configuration.serverUrl.replace(/\/+$/, "");
@@ -7133,7 +7208,8 @@ async function startFlockbayServer(client, options) {
       lastReachableAtMs: 0,
       lastIssueAtMs: 0,
       lastIssueKey: "",
-      launched: null
+      launched: null,
+      lastLaunch: null
     };
     const emitIssue = (event) => {
       const key = `${event.kind}:${event.severity}:${event.message}`;
@@ -7158,6 +7234,93 @@ async function startFlockbayServer(client, options) {
         }
       }
     };
+    const tailText = (text, maxChars) => {
+      const t = String(text || "").trim();
+      if (!t) return "";
+      if (t.length <= maxChars) return t;
+      return t.slice(t.length - maxChars);
+    };
+    const findLatestFile = async (dir, filter) => {
+      try {
+        const entries = await readdir(dir);
+        let best = null;
+        for (const name of entries) {
+          if (!filter(name)) continue;
+          const full = path.join(dir, name);
+          let st;
+          try {
+            st = await stat(full);
+          } catch {
+            continue;
+          }
+          if (!st?.isFile?.()) continue;
+          const mtimeMs = Number(st.mtimeMs || 0);
+          if (!best || mtimeMs > best.mtimeMs) best = { path: full, mtimeMs };
+        }
+        return best?.path ?? null;
+      } catch {
+        return null;
+      }
+    };
+    const findLatestCrashDir = async (projectRoot) => {
+      const crashesDir = path.join(projectRoot, "Saved", "Crashes");
+      try {
+        const entries = await readdir(crashesDir);
+        let best = null;
+        for (const name of entries) {
+          const full = path.join(crashesDir, name);
+          let st;
+          try {
+            st = await stat(full);
+          } catch {
+            continue;
+          }
+          if (!st?.isDirectory?.()) continue;
+          const mtimeMs = Number(st.mtimeMs || 0);
+          if (!best || mtimeMs > best.mtimeMs) best = { path: full, mtimeMs };
+        }
+        return best?.path ?? null;
+      } catch {
+        return null;
+      }
+    };
+    const readFileTail = async (filePath, maxBytes) => {
+      try {
+        const buf = await readFile(filePath);
+        const slice = buf.length > maxBytes ? buf.subarray(buf.length - maxBytes) : buf;
+        return slice.toString("utf8");
+      } catch {
+        return null;
+      }
+    };
+    const gatherCrashDiagnosticsBestEffort = async (uprojectPath) => {
+      const projectRoot = path.dirname(uprojectPath);
+      const summary = [];
+      const detail = { uprojectPath, projectRoot };
+      const latestLog = await findLatestFile(path.join(projectRoot, "Saved", "Logs"), (n) => n.toLowerCase().endsWith(".log"));
+      if (latestLog) {
+        detail.projectLogPath = latestLog;
+        const tail = await readFileTail(latestLog, 24e3);
+        if (tail) {
+          detail.projectLogTail = tailText(tail, 12e3);
+          summary.push(`Latest log: ${latestLog}`);
+        }
+      }
+      const latestCrashDir = await findLatestCrashDir(projectRoot);
+      if (latestCrashDir) {
+        detail.latestCrashDir = latestCrashDir;
+        const crashContext = await findLatestFile(latestCrashDir, (n) => n.toLowerCase().includes("crashcontext") && n.toLowerCase().endsWith(".xml"));
+        if (crashContext) {
+          detail.crashContextPath = crashContext;
+          const tail = await readFileTail(crashContext, 24e3);
+          if (tail) {
+            detail.crashContextTail = tailText(tail, 12e3);
+            summary.push(`CrashContext: ${crashContext}`);
+          }
+        }
+      }
+      return { detail, summary };
+    };
     const getUnrealEditorExe = (engineRoot) => {
       const root = engineRoot.trim().replace(/[\\/]+$/, "");
       if (process.platform === "darwin") {
@@ -7213,7 +7376,7 @@ ${res.stderr}`;
         kind: "unreachable",
         severity: "warning",
         detectedAtMs: now,
-        message: "Unreal Editor is no longer reachable (it was reachable earlier). It may have crashed or been closed.",
+        message: "Unreal Editor is no longer reachable (it was reachable earlier). It may have crashed or been closed.\nNext: fix the issue, then relaunch via unreal_editor_relaunch_last (if you launched from this session) or unreal_editor_launch.",
         detail: {
           lastReachableAtMs: state.lastReachableAtMs
         }
@@ -7245,20 +7408,35 @@ ${res.stderr}`;
         engineRoot,
         startedAtMs: Date.now()
       };
+      state.lastLaunch = {
+        uprojectPath,
+        engineRoot,
+        extraArgs,
+        startedAtMs: Date.now()
+      };
       child.on("exit", (code, signal) => {
-        const now = Date.now();
-        const exitCode = typeof code === "number" ? code : null;
-        const sig = typeof signal === "string" ? signal : null;
-        const isCrash = sig !== null || exitCode !== null && exitCode !== 0;
-        state.launched = null;
-        if (!isCrash) return;
-        emitIssue({
-          kind: "process_exit",
-          severity: "crash",
-          detectedAtMs: now,
-          message: `Unreal Editor process exited unexpectedly (code=${exitCode ?? "null"} signal=${sig ?? "null"}).`,
-          detail: { exitCode, signal: sig, pid, uprojectPath }
-        });
+        void (async () => {
+          const now = Date.now();
+          const exitCode = typeof code === "number" ? code : null;
+          const sig = typeof signal === "string" ? signal : null;
+          const isCrash = sig !== null || exitCode !== null && exitCode !== 0;
+          state.launched = null;
+          if (!isCrash) return;
+          const diag = await gatherCrashDiagnosticsBestEffort(uprojectPath).catch(() => ({ detail: {}, summary: [] }));
+          const msgParts = [
+            `Unreal Editor process exited unexpectedly (code=${exitCode ?? "null"} signal=${sig ?? "null"}).`,
+            `Project: ${uprojectPath}`,
+            ...diag.summary,
+            `Next: fix the issue, then relaunch via unreal_editor_relaunch_last (or unreal_editor_launch).`
+          ];
+          emitIssue({
+            kind: "process_exit",
+            severity: "crash",
+            detectedAtMs: now,
+            message: msgParts.filter(Boolean).join("\n"),
+            detail: { exitCode, signal: sig, pid, uprojectPath, ...diag.detail }
+          });
+        })();
       });
       child.on("error", (err) => {
         const now = Date.now();
@@ -7267,7 +7445,9 @@ ${res.stderr}`;
           kind: "process_exit",
           severity: "crash",
           detectedAtMs: now,
-          message: `Failed to launch Unreal Editor: ${err instanceof Error ? err.message : String(err)}`,
+          message: `Failed to launch Unreal Editor: ${err instanceof Error ? err.message : String(err)}
+Project: ${uprojectPath}
+Next: fix the issue, then relaunch via unreal_editor_relaunch_last (or unreal_editor_launch).`,
           detail: { pid, uprojectPath }
         });
       });
@@ -7277,6 +7457,12 @@ ${res.stderr}`;
       noteUnrealActivity,
       noteUnrealReachable,
       launchEditor,
+      relaunchLast: async (extraArgs) => {
+        const last = state.lastLaunch;
+        if (!last) throw new Error("No known prior Unreal launch in this session. Use unreal_editor_launch with an explicit uprojectPath.");
+        const mergedArgs = Array.isArray(extraArgs) && extraArgs.length > 0 ? extraArgs.filter((a) => typeof a === "string" && a.trim()) : last.extraArgs;
+        return launchEditor({ uprojectPath: last.uprojectPath, engineRoot: last.engineRoot, extraArgs: mergedArgs });
+      },
       stop: () => {
         try {
           interval.unref();
@@ -8783,6 +8969,32 @@ ${String(st.stdout || "").trim()}`
       isError: false
     };
   }));
+  mcp.registerTool("unreal_editor_relaunch_last", {
+    title: "Unreal Editor: Relaunch Last Project",
+    description: "Relaunch the last Unreal project previously launched via unreal_editor_launch in this session (no auto-restart). Use this after a crash once you\u2019ve fixed files. If it crashes again, Flockbay will abort and report again.",
+    inputSchema: {
+      extraArgs: z.array(z.string()).optional().describe("Optional replacement UnrealEditor command-line args (advanced).")
+    }
+  }, async (args) => runWithMcpToolCard("unreal_editor_relaunch_last", args, async () => {
+    const extraArgs = Array.isArray(args?.extraArgs) ? args.extraArgs : void 0;
+    unrealEditorSupervisor.noteUnrealActivity();
+    try {
+      const launched = await unrealEditorSupervisor.relaunchLast(extraArgs);
+      return {
+        content: [
+          { type: "text", text: `Relaunched Unreal Editor (last project).` },
+          { type: "text", text: JSON.stringify({ pid: launched.pid, exePath: launched.exePath }, null, 2) },
+          { type: "text", text: "Next: wait for the editor to finish loading, then re-run UnrealMCP tools." }
+        ],
+        isError: false
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+        isError: true
+      };
+    }
+  }));
   mcp.registerTool("unreal_build_project", {
     title: "Unreal Build Project (UBT)",
     description: "Build the project via Unreal Build Tool (via Engine/Build/BatchFiles/Build.*). Returns structured errors (file/line) and a log path for deep debugging.",
@@ -10208,6 +10420,7 @@ Fix: ${res.hint}` : "";
       "unreal_headless_screenshot",
       "unreal_latest_screenshots",
       "unreal_editor_launch",
+      "unreal_editor_relaunch_last",
       "unreal_build_project",
       "unreal_mcp_command",
       "unreal_mcp_list_capabilities",
@@ -11575,6 +11788,51 @@ async function reauthForCurrentServerKeepingMachineId() {
   await clearCredentials();
   await loginWithClerkAndPairMachine();
 }
+function isLocalDevServerUrl(url) {
+  try {
+    const u = new URL(String(url || "").trim());
+    const host = u.hostname.toLowerCase();
+    return host === "localhost" || host === "127.0.0.1" || host === "0.0.0.0" || host.endsWith(".localhost");
+  } catch {
+    return false;
+  }
+}
+async function isServerReachable(url) {
+  const base = String(url || "").trim().replace(/\/+$/, "");
+  if (!base) return false;
+  try {
+    const res = await fetch(`${base}/healthz`, { method: "GET", signal: AbortSignal.timeout(1200) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function ensureProdServerWhenLocalDevUnreachable() {
+  if ((process.env.FLOCKBAY_SERVER_URL || "").trim()) return;
+  const settings = await readSettings().catch(() => null);
+  const configured = String(settings?.serverUrl || "").trim();
+  if (!configured) return;
+  const normalized = normalizeServerUrlForNode(configured);
+  if (!isLocalDevServerUrl(normalized)) return;
+  const reachable = await isServerReachable(normalized);
+  if (reachable) return;
+  const shouldSwitch = await promptYesNo(
+    `This profile is configured to use a local server (${normalized}), but it isn't reachable.
+
+Switch this profile to production (https://api.flockbay.com) and re-authenticate?`,
+    { defaultYes: true }
+  );
+  if (!shouldSwitch) return;
+  const nextWebappUrl = String(settings?.webappUrl || "").trim() || "https://flockbay.com";
+  await updateSettings((s) => ({
+    ...s,
+    serverUrl: "https://api.flockbay.com",
+    webappUrl: nextWebappUrl
+  }));
+  configuration.serverUrl = "https://api.flockbay.com";
+  configuration.webappUrl = nextWebappUrl;
+  await reauthForCurrentServerKeepingMachineId();
+}
 function openUrlBestEffort(url) {
   const u = String(url || "").trim();
   if (!u) return;
@@ -11693,11 +11951,19 @@ async function startDaemonDetachedOrExit(opts) {
       }
       console.error("");
       console.error(chalk.red("Daemon is running but not connected to the server."));
+      console.error(chalk.gray(`Profile: ${configuration.profile}`));
+      console.error(chalk.gray(`Server:  ${configuration.serverUrl}`));
       if (typeof status?.connection?.lastHttpUpsertError === "string" && status.connection.lastHttpUpsertError.trim()) {
         console.error(chalk.gray(`Last upsert error: ${status.connection.lastHttpUpsertError.trim()}`));
       }
       if (lastConnectError) console.error(chalk.gray(`Last connect error: ${lastConnectError}`));
-      console.error(chalk.gray("Tip: if the backend is restarting, wait a moment and re-run `flockbay start`."));
+      if (isLocalDevServerUrl(configuration.serverUrl)) {
+        console.error(chalk.gray("Tip: if you meant to run against production, set the server URL or use a prod profile:"));
+        console.error(chalk.gray("  FLOCKBAY_SERVER_URL=https://api.flockbay.com flockbay start"));
+        console.error(chalk.gray("  flockbay start --profile prod"));
+      } else {
+        console.error(chalk.gray("Tip: if the backend is restarting, wait a moment and re-run `flockbay start`."));
+      }
       process.exit(1);
     }
   }
@@ -11901,6 +12167,7 @@ async function authAndSetupMachineIfNeeded() {
       return;
     }
     try {
+      await ensureProdServerWhenLocalDevUnreachable();
       await ensureMachineAuthOrLogin();
       const skipUnreal = startArgs.includes("--skip-unreal");
       if (!skipUnreal) {
@@ -11935,7 +12202,7 @@ ${engineRoot}`, {
   } else if (subcommand === "codex") {
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runCodex } = await import('./runCodex-DudVDqNh.mjs');
+      const { runCodex } = await import('./runCodex-Biis9GFw.mjs');
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {
@@ -12030,7 +12297,7 @@ ${engineRoot}`, {
     }
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runGemini } = await import('./runGemini-Ddu8UCOS.mjs');
+      const { runGemini } = await import('./runGemini-BSH4b0wu.mjs');
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {