flockbay 0.10.49 → 0.10.52

package/dist/{types-DNr0xwSy.cjs → types-5z8UADAi.cjs}

@@ -44,7 +44,7 @@ function _interopNamespaceDefault(e) {
 var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
 var name = "flockbay";
-var version = "0.10.49";
+var version = "0.10.52";
 var description = "Flockbay CLI (local agent + daemon)";
 var author = "Eduardo Orellana";
 var license = "UNLICENSED";
@@ -832,7 +832,7 @@ class RpcHandlerManager {
   }
 }
 
-const __dirname$1 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-DNr0xwSy.cjs', document.baseURI).href))));
+const __dirname$1 = path$1.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-5z8UADAi.cjs', document.baseURI).href))));
 function projectPath() {
   const path = path$1.resolve(__dirname$1, "..");
   return path;
@@ -3269,6 +3269,9 @@ class ApiSessionClient extends node_events.EventEmitter {
     this.socket.on("connect", () => {
       logger.debug("[session] socket connected");
       this.rpcHandlerManager.onSocketConnect(this.socket);
+      if (this.agentStateVersion <= 0) {
+        this.updateAgentState((s) => ({ ...s || {} }));
+      }
       this.flush();
       this.emit("connect");
     });
@@ -3484,6 +3487,105 @@ function isInstalledEngineRoot(engineRootRaw) {
   return false;
 }
 
+function findFilesNamedUnderDir$2(options) {
+  const rootDir = options.rootDir;
+  const filename = options.filename;
+  const maxDepth = Math.max(0, Math.floor(options.maxDepth));
+  const results = [];
+  const visit = (dir, depth) => {
+    if (depth > maxDepth) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === ".DS_Store") continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        visit(full, depth + 1);
+        continue;
+      }
+      if (entry.isFile() && entry.name === filename) results.push(full);
+    }
+  };
+  visit(rootDir, 0);
+  return results;
+}
+function readJsonIfPossible$2(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function isRespacedFlockbayMcpPlugin(upluginJson) {
+  const friendlyName = typeof upluginJson?.FriendlyName === "string" ? upluginJson.FriendlyName : "";
+  const createdBy = typeof upluginJson?.CreatedBy === "string" ? upluginJson.CreatedBy : "";
+  return friendlyName === "Flockbay MCP" && createdBy === "Respaced Inc.";
+}
+function looksLikeLegacyBrokenEngineCopy(upluginJson) {
+  const enabledByDefault = Boolean(upluginJson?.EnabledByDefault);
+  const installed = Boolean(upluginJson?.Installed);
+  const hasEngineVersion = typeof upluginJson?.EngineVersion === "string" && upluginJson.EngineVersion.length > 0;
+  return enabledByDefault || installed || hasEngineVersion;
+}
+function quarantineLegacyEnginePlugins(engineRootRaw) {
+  const engineRoot = (engineRootRaw || "").trim();
+  if (!engineRoot) {
+    return { ok: true, disabledUpluginPaths: [], ignoredUpluginPaths: [] };
+  }
+  const enginePluginsDir = path.join(engineRoot, "Engine", "Plugins");
+  const candidates = findFilesNamedUnderDir$2({ rootDir: enginePluginsDir, filename: "FlockbayMCP.uplugin", maxDepth: 6 }).map((p) => path.resolve(p)).filter((p, idx, arr) => arr.indexOf(p) === idx);
+  const disabled = [];
+  const ignored = [];
+  for (const upluginPath of candidates) {
+    const parsed = readJsonIfPossible$2(upluginPath);
+    if (!parsed || typeof parsed !== "object") {
+      ignored.push(upluginPath);
+      continue;
+    }
+    if (!isRespacedFlockbayMcpPlugin(parsed)) {
+      ignored.push(upluginPath);
+      continue;
+    }
+    if (!looksLikeLegacyBrokenEngineCopy(parsed)) {
+      ignored.push(upluginPath);
+      continue;
+    }
+    const disabledPath = `${upluginPath}.disabled`;
+    if (fs.existsSync(disabledPath)) {
+      try {
+        fs.rmSync(upluginPath, { force: true });
+      } catch {
+      }
+      continue;
+    }
+    try {
+      fs.renameSync(upluginPath, disabledPath);
+      disabled.push(upluginPath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        ok: false,
+        disabledUpluginPaths: disabled,
+        ignoredUpluginPaths: ignored,
+        errorMessage: `Detected a legacy engine-scope FlockbayMCP plugin install that can break builds on Installed Build engines, but failed to disable it.
+
+Path: ${upluginPath}
+Error: ${message}
+
+Fix:
+- Close Unreal Editor
+- Rename "${upluginPath}" to "${disabledPath}" (or delete the plugin folder)
+- Re-run the Flockbay MCP project install`
+      };
+    }
+  }
+  return { ok: true, disabledUpluginPaths: disabled, ignoredUpluginPaths: ignored };
+}
+
 function looksLikeEngineRoot$1(engineRoot) {
   if (!engineRoot) return false;
   return fs.existsSync(path.join(engineRoot, "Engine")) && fs.existsSync(path.join(engineRoot, "Engine", "Plugins"));
@@ -3523,6 +3625,14 @@ function installUnrealMcpPluginToEngine(engineRootRaw) {
     };
   }
   if (isInstalledEngineRoot(engineRoot)) {
+    const quarantine = quarantineLegacyEnginePlugins(engineRoot);
+    if (!quarantine.ok) {
+      return { ok: false, errorMessage: quarantine.errorMessage };
+    }
+    const disabledMeta = quarantine.disabledUpluginPaths.length ? `
+
+Detected and disabled legacy engine plugin descriptor(s) to unblock builds:
+` + quarantine.disabledUpluginPaths.map((p) => `- ${p}`).join("\n") : "";
     return {
       ok: false,
       errorMessage: [
@@ -3537,7 +3647,7 @@ function installUnrealMcpPluginToEngine(engineRootRaw) {
         "If you are using the Flockbay UI/CLI, choose a project-scope install or pass a project path.",
         "Example:",
         "  flockbay unreal-mcp migrate --engine-root <ENGINE_ROOT> --project <PATH_TO_.UPROJECT> --remove-legacy"
-      ].join("\n")
+      ].join("\n") + disabledMeta
     };
   }
   const srcDir = unrealMcpPluginSourceDir();
@@ -3891,20 +4001,107 @@ Expected: ${binariesDir}
 Log: ${buildLogPath}`
     };
   }
-  const setEnabled = setEnabledByDefault(pluginUpluginPath, true);
-  if (!setEnabled.ok) {
-    return {
-      ok: false,
-      buildLogPath,
-      errorMessage: `Built the plugin, but failed to enable it.
+  if (options.enableByDefault) {
+    const setEnabled = setEnabledByDefault(pluginUpluginPath, true);
+    if (!setEnabled.ok) {
+      return {
+        ok: false,
+        buildLogPath,
+        errorMessage: `Built the plugin, but failed to enable it.
 Plugin: ${pluginUpluginPath}
 Error: ${setEnabled.error}
 Log: ${buildLogPath}`
-    };
+      };
+    }
   }
   return { ok: true, buildLogPath };
 }
 
+function normalizeWindowsPath(value) {
+  return path.win32.normalize(String(value || "").trim()).replace(/[\\/]+$/, "");
+}
+function equalsIgnoreCaseWindows(a, b) {
+  return normalizeWindowsPath(a || "").toLowerCase() === normalizeWindowsPath(b || "").toLowerCase();
+}
+function extractUprojectPathFromCommandLine(commandLine) {
+  const raw = String(commandLine || "").trim();
+  if (!raw) return null;
+  const matches = Array.from(raw.matchAll(/"([^"\r\n]+?\.uproject)"|([^\s"]+?\.uproject)/gi));
+  for (const match of matches) {
+    const candidate = String(match[1] || match[2] || "").trim();
+    if (!candidate) continue;
+    return normalizeWindowsPath(candidate);
+  }
+  return null;
+}
+function inferEngineRootFromExecutablePath(executablePath) {
+  const normalized = normalizeWindowsPath(executablePath);
+  if (!normalized) return null;
+  const marker = `${path.win32.sep}Engine${path.win32.sep}Binaries${path.win32.sep}`;
+  const idx = normalized.toLowerCase().indexOf(marker.toLowerCase());
+  if (idx === -1) return null;
+  return normalized.slice(0, idx);
+}
+function compareCreationDateDesc(a, b) {
+  const aa = String(a || "").trim();
+  const bb = String(b || "").trim();
+  return bb.localeCompare(aa);
+}
+function parseRunningUnrealEditorProjectsFromWindowsJson(input) {
+  const engineRoot = String(input.engineRoot || "").trim();
+  const wantedEngineRoot = engineRoot ? normalizeWindowsPath(engineRoot) : "";
+  const raw = String(input.raw || "").trim();
+  if (!raw) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const records = (Array.isArray(parsed) ? parsed : [parsed]).filter(Boolean);
+  const out = [];
+  for (const record of records) {
+    const uprojectPath = extractUprojectPathFromCommandLine(String(record?.CommandLine || ""));
+    if (!uprojectPath) continue;
+    const executablePath = record?.ExecutablePath ? normalizeWindowsPath(record.ExecutablePath) : null;
+    const inferredEngineRoot = executablePath ? inferEngineRootFromExecutablePath(executablePath) : null;
+    if (wantedEngineRoot && !equalsIgnoreCaseWindows(inferredEngineRoot, wantedEngineRoot)) continue;
+    const processIdNumber = Number(record?.ProcessId);
+    out.push({
+      processId: Number.isFinite(processIdNumber) && processIdNumber > 0 ? processIdNumber : null,
+      executablePath,
+      engineRoot: inferredEngineRoot,
+      uprojectPath,
+      commandLine: record?.CommandLine ? String(record.CommandLine) : null,
+      creationDate: record?.CreationDate ? String(record.CreationDate) : null
+    });
+  }
+  out.sort((a, b) => compareCreationDateDesc(a.creationDate, b.creationDate));
+  return out;
+}
+function detectRunningUnrealEditorProject(options) {
+  if (process.platform !== "win32") return null;
+  const execFileSyncImpl = options?.execFileSyncImpl || node_child_process.execFileSync;
+  const script = [
+    '$ErrorActionPreference = "Stop"',
+    `$procs = Get-CimInstance Win32_Process -Filter "Name = 'UnrealEditor.exe'" | Select-Object ProcessId, ExecutablePath, CommandLine, CreationDate`,
+    'if ($null -eq $procs) { "[]" } else { $procs | ConvertTo-Json -Compress -Depth 3 }'
+  ].join("; ");
+  try {
+    const raw = execFileSyncImpl("powershell.exe", ["-NoProfile", "-Command", script], {
+      encoding: "utf8",
+      windowsHide: true
+    });
+    const matches = parseRunningUnrealEditorProjectsFromWindowsJson({
+      raw: typeof raw === "string" ? raw : String(raw || ""),
+      engineRoot: options?.engineRoot
+    });
+    return matches[0] || null;
+  } catch {
+    return null;
+  }
+}
+
 function canWriteDir$1(dir) {
   const root = String(dir || "").trim();
   if (!root) return false;
@@ -3980,11 +4177,14 @@ function getUnrealMcpPluginDiskStatus(params) {
   const checkedAtMs = Date.now();
   const engineRoot = String(params?.engineRoot || "").trim();
   const installScope = String(params?.installScope || "auto");
-  const projectUprojectPathRaw = typeof params?.projectUprojectPath === "string" ? params.projectUprojectPath.trim() : "";
+  const requestedProjectUprojectPath = typeof params?.projectUprojectPath === "string" ? params.projectUprojectPath.trim() : "";
   if (!engineRoot) return { success: false, error: "Missing engineRoot." };
   if (!looksLikeEngineRoot(engineRoot)) {
     return { success: false, error: `Invalid engine root (expected an Unreal Engine install folder containing Engine/Plugins): ${engineRoot}` };
   }
+  const installedEngine = isInstalledEngineRoot(engineRoot);
+  const runningProject = detectRunningUnrealEditorProject({ engineRoot });
+  const projectUprojectPathRaw = runningProject?.uprojectPath || requestedProjectUprojectPath;
   const enginePluginsDir = path.join(engineRoot, "Engine", "Plugins");
   const enginePluginDir = path.join(enginePluginsDir, "FlockbayMCP");
   const engineUpluginPath = path.join(enginePluginDir, "FlockbayMCP.uplugin");
@@ -4052,7 +4252,7 @@ function getUnrealMcpPluginDiskStatus(params) {
   }
   const engineInstalled = engineInfo.exists && engineInfo.descriptorOk && engineInfo.hasBinaries;
   const projectInstalled = Boolean(project && project.exists && project.descriptorOk && project.enabledInUproject);
-  const effectiveScope = installScope === "engine" ? "engine" : installScope === "project" ? "project" : engineInstalled ? "engine" : project && !engineInfo.enginePluginsWritable ? "project" : "engine";
+  const effectiveScope = installScope === "engine" ? "engine" : installScope === "project" ? "project" : installedEngine && project ? "project" : engineInstalled ? "engine" : project && !engineInfo.enginePluginsWritable ? "project" : "engine";
   const conflict = engineInfo.conflicts.length > 0;
   const legacyConflict = engineInfo.legacy.length > 0;
   const baseInstalled = effectiveScope === "engine" ? engineInstalled : projectInstalled;
@@ -4767,12 +4967,18 @@ class ApiMachineClient {
       async (params) => {
         const engineRoot = String(params?.engineRoot || "").trim();
         const scope = String(params?.installScope || "auto");
-        const projectUprojectPath = typeof params?.projectUprojectPath === "string" ? params.projectUprojectPath.trim() : "";
+        const requestedProjectUprojectPath = typeof params?.projectUprojectPath === "string" ? params.projectUprojectPath.trim() : "";
         const enginePluginsDir = path.join(engineRoot, "Engine", "Plugins");
         const enginePluginDir = path.join(enginePluginsDir, "FlockbayMCP");
         const enginePluginUplugin = path.join(enginePluginDir, "FlockbayMCP.uplugin");
         const enginePluginHasBinaries = fs.existsSync(path.join(enginePluginDir, "Binaries"));
         const installedEngine = isInstalledEngineRoot(engineRoot);
+        const runningProject = installedEngine ? detectRunningUnrealEditorProject({ engineRoot }) : null;
+        const projectUprojectPath = runningProject?.uprojectPath || requestedProjectUprojectPath;
+        if (installedEngine) {
+          const quarantine = quarantineLegacyEnginePlugins(engineRoot);
+          if (!quarantine.ok) return { success: false, error: quarantine.errorMessage };
+        }
         if (scope === "engine" && installedEngine) {
           return {
             success: false,
@@ -4809,7 +5015,8 @@ class ApiMachineClient {
             const built = await buildAndInstallUnrealMcpPlugin({
               engineRoot,
               flockbayHomeDir: this.machine?.metadata?.flockbayHomeDir || os.homedir(),
-              pluginDir: installedProject.destDir
+              pluginDir: installedProject.destDir,
+              enableByDefault: false
             });
             if (!built.ok) return { success: false, error: built.errorMessage };
             return { success: true, engineRoot, destDir: installedProject.destDir, buildLogPath: built.buildLogPath };
@@ -4824,7 +5031,8 @@ class ApiMachineClient {
           }
           const built = await buildAndInstallUnrealMcpPlugin({
             engineRoot: result.engineRoot,
-            flockbayHomeDir: this.machine?.metadata?.flockbayHomeDir || os.homedir()
+            flockbayHomeDir: this.machine?.metadata?.flockbayHomeDir || os.homedir(),
+            enableByDefault: true
           });
           if (!built.ok) return { success: false, error: built.errorMessage };
           return { success: true, engineRoot: result.engineRoot, destDir: result.destDir, buildLogPath: built.buildLogPath };
@@ -5391,6 +5599,7 @@ exports.normalizeServerUrlForNode = normalizeServerUrlForNode;
 exports.openBrowser = openBrowser;
 exports.packageJson = packageJson;
 exports.projectPath = projectPath;
+exports.quarantineLegacyEnginePlugins = quarantineLegacyEnginePlugins;
 exports.readCredentials = readCredentials;
 exports.readDaemonState = readDaemonState;
 exports.readSettings = readSettings;