flockbay 0.10.40 → 0.10.42

package/dist/{index-COD6HpzC.mjs → index-B6WkRhlp.mjs}

@@ -2,7 +2,7 @@ import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(im
 import * as os from 'node:os';
 import os__default, { homedir } from 'node:os';
 import { randomUUID, createCipheriv, randomBytes, createHash as createHash$1 } from 'node:crypto';
-import { l as logger, b as projectPath, d as backoff, e as delay, R as RawJSONLinesSchema, c as configuration, f as readDaemonState, g as clearDaemonState, p as packageJson, r as readSettings, h as readCredentials, u as updateSettings, w as writeCredentials, j as unrealMcpPythonDir, k as acquireDaemonLock, m as writeDaemonState, n as ApiMachineClient, o as releaseDaemonLock, s as sendUnrealMcpTcpCommand, A as ApiClient, v as validatePath, q as run, t as run$1, x as buildShellInvocation, y as clearCredentials, z as clearMachineId, i as installUnrealMcpPluginToEngine, B as buildAndInstallUnrealMcpPlugin, C as getLatestDaemonLog, D as normalizeServerUrlForNode } from './types-4acLcOdW.mjs';
+import { l as logger, b as projectPath, d as backoff, e as delay, R as RawJSONLinesSchema, c as configuration, f as readDaemonState, g as clearDaemonState, p as packageJson, r as readSettings, h as readCredentials, u as updateSettings, o as openBrowser, w as writeCredentials, j as unrealMcpPythonDir, k as acquireDaemonLock, m as writeDaemonState, n as ApiMachineClient, q as releaseDaemonLock, s as sendUnrealMcpTcpCommand, A as ApiClient, v as validatePath, t as run, x as run$1, y as buildShellInvocation, z as clearCredentials, B as clearMachineId, C as authenticateCodex, D as syncCodexCliAuth, E as authenticateClaude, F as authenticateGemini, i as installUnrealMcpPluginToEngine, G as buildAndInstallUnrealMcpPlugin, H as installUnrealMcpPluginToProject, I as getLatestDaemonLog, J as normalizeServerUrlForNode } from './types-D1UKSrkg.mjs';
 import { spawn, execFileSync, execSync } from 'node:child_process';
 import * as path from 'node:path';
 import path__default, { resolve, join, dirname } from 'node:path';
@@ -10,33 +10,32 @@ 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, readdir, stat, writeFile, copyFile, rename, open as open$1 } from 'node:fs/promises';
+import fs$1, { readFile, access as access$1, mkdir, readdir, stat, writeFile, copyFile, rename, open } from 'node:fs/promises';
 import fs$2, { watch, access, mkdir as mkdir$1, writeFile as writeFile$1, rm } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import { fileURLToPath } from 'node:url';
 import axios from 'axios';
-import { EventEmitter } from 'node:events';
 import 'socket.io-client';
-import { spawn as spawn$1, execFileSync as execFileSync$1, exec } from 'child_process';
-import { createHash, randomBytes as randomBytes$1 } from 'crypto';
+import { spawn as spawn$1, execFileSync as execFileSync$1 } from 'child_process';
+import { createHash } from 'crypto';
 import { join as join$1, basename, dirname as dirname$1 } from 'path';
 import os$1 from 'os';
 import 'node:net';
+import 'http';
+import 'open';
 import { readFileSync as readFileSync$1, mkdirSync as mkdirSync$1, writeFileSync as writeFileSync$1, existsSync as existsSync$1, unlinkSync as unlinkSync$1 } from 'fs';
 import psList from 'ps-list';
 import spawn$2 from 'cross-spawn';
 import * as tmp from 'tmp';
-import open from 'open';
 import fastify from 'fastify';
 import { z } from 'zod';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { EventEmitter } from 'node:events';
 import 'tweetnacl';
-import { createServer as createServer$1 } from 'http';
-import { promisify } from 'util';
 import { deflateSync } from 'node:zlib';
 
 class Session {
@@ -5180,23 +5179,6 @@ ${typeLabels[type] || type}:`));
   console.log(chalk.green("\n\u2705 Doctor diagnosis complete!\n"));
 }
 
-async function openBrowser(url) {
-  try {
-    const forceOpen = process.env.FLOCKBAY_FORCE_BROWSER === "1" || process.env.FLOCKBAY_FORCE_BROWSER === "true";
-    if (!forceOpen && (!process.stdout.isTTY || process.env.CI || process.env.HEADLESS)) {
-      logger.debug("[browser] Headless/non-interactive environment detected, skipping browser open");
-      return false;
-    }
-    logger.debug(`[browser] Attempting to open URL: ${url}`);
-    await open(url, { wait: false });
-    logger.debug("[browser] Browser opened successfully");
-    return true;
-  } catch (error) {
-    logger.debug("[browser] Failed to open browser:", error);
-    return false;
-  }
-}
-
 async function loginWithClerkAndPairMachine() {
   logger.debug("[AUTH] Starting Clerk-based CLI login + machine pairing");
   const settings = await updateSettings(async (s) => {
@@ -7877,7 +7859,7 @@ function detectImageMimeTypeFromBuffer$1(buf) {
   return null;
 }
 async function readFileHeader(filePath, bytes) {
-  const fh = await open$1(filePath, "r");
+  const fh = await open(filePath, "r");
   try {
     const maxBytes = Math.max(1, Math.floor(bytes));
     const buf = Buffer.allocUnsafe(maxBytes);
@@ -13164,7 +13146,7 @@ Update: ${updateCommand}`);
       summary: currentMetadata?.summary
     }));
   }
-  await session.connectAndWait(15e3);
+  await session.connectAndWait();
   session.keepAlive(false, options.startingMode === "remote" ? "remote" : "local");
   try {
     logger.debug(`[START] Reporting session ${response.id} to daemon`);
@@ -13806,511 +13788,6 @@ ${chalk.bold("Usage:")}
 `);
 }
 
-const CLIENT_ID$2 = "app_EMoamEEZ73f0CkXaXp7hrann";
-const AUTH_BASE_URL = "https://auth.openai.com";
-const DEFAULT_PORT$2 = 1455;
-function generatePKCE$2() {
-  const verifier = randomBytes$1(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
-  const challenge = createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-  return { verifier, challenge };
-}
-function generateState$2() {
-  return randomBytes$1(16).toString("hex");
-}
-function parseJWT(token) {
-  const parts = token.split(".");
-  if (parts.length !== 3) {
-    throw new Error("Invalid JWT format");
-  }
-  const payload = Buffer.from(parts[1], "base64url").toString();
-  return JSON.parse(payload);
-}
-async function findAvailablePort$2() {
-  return new Promise((resolve) => {
-    const server = createServer$1();
-    server.listen(0, "127.0.0.1", () => {
-      const port = server.address().port;
-      server.close(() => resolve(port));
-    });
-  });
-}
-async function isPortAvailable$2(port) {
-  return new Promise((resolve) => {
-    const testServer = createServer$1();
-    testServer.once("error", () => {
-      testServer.close();
-      resolve(false);
-    });
-    testServer.listen(port, "127.0.0.1", () => {
-      testServer.close(() => resolve(true));
-    });
-  });
-}
-async function exchangeCodeForTokens$2(code, verifier, port) {
-  const response = await fetch(`${AUTH_BASE_URL}/oauth/token`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: new URLSearchParams({
-      grant_type: "authorization_code",
-      client_id: CLIENT_ID$2,
-      code,
-      code_verifier: verifier,
-      redirect_uri: `http://localhost:${port}/auth/callback`
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Token exchange failed: ${error}`);
-  }
-  const data = await response.json();
-  const idTokenPayload = parseJWT(data.id_token);
-  let accountId = idTokenPayload.chatgpt_account_id;
-  if (!accountId) {
-    const authClaim = idTokenPayload["https://api.openai.com/auth"];
-    if (authClaim && typeof authClaim === "object") {
-      accountId = authClaim.chatgpt_account_id || authClaim.account_id;
-    }
-  }
-  return {
-    id_token: data.id_token,
-    access_token: data.access_token || data.id_token,
-    refresh_token: data.refresh_token,
-    account_id: accountId
-  };
-}
-async function startCallbackServer$2(state, verifier, port) {
-  return new Promise((resolve, reject) => {
-    const server = createServer$1(async (req, res) => {
-      const url = new URL(req.url, `http://localhost:${port}`);
-      if (url.pathname === "/auth/callback") {
-        const code = url.searchParams.get("code");
-        const receivedState = url.searchParams.get("state");
-        if (receivedState !== state) {
-          res.writeHead(400);
-          res.end("Invalid state parameter");
-          server.close();
-          reject(new Error("Invalid state parameter"));
-          return;
-        }
-        if (!code) {
-          res.writeHead(400);
-          res.end("No authorization code received");
-          server.close();
-          reject(new Error("No authorization code received"));
-          return;
-        }
-        try {
-          const tokens = await exchangeCodeForTokens$2(code, verifier, port);
-          res.writeHead(200, { "Content-Type": "text/html" });
-          res.end(`
-                        <html>
-                        <body style="font-family: sans-serif; padding: 20px;">
-                            <h2>\u2705 Authentication Successful!</h2>
-                            <p>You can close this window and return to your terminal.</p>
-                            <script>setTimeout(() => window.close(), 3000);<\/script>
-                        </body>
-                        </html>
-                    `);
-          server.close();
-          resolve(tokens);
-        } catch (error) {
-          res.writeHead(500);
-          res.end("Token exchange failed");
-          server.close();
-          reject(error);
-        }
-      }
-    });
-    server.listen(port, "127.0.0.1", () => {
-    });
-    setTimeout(() => {
-      server.close();
-      reject(new Error("Authentication timeout"));
-    }, 5 * 60 * 1e3);
-  });
-}
-async function authenticateCodex() {
-  const { verifier, challenge } = generatePKCE$2();
-  const state = generateState$2();
-  let port = DEFAULT_PORT$2;
-  const portAvailable = await isPortAvailable$2(port);
-  if (!portAvailable) {
-    port = await findAvailablePort$2();
-  }
-  const serverPromise = startCallbackServer$2(state, verifier, port);
-  await new Promise((resolve) => setTimeout(resolve, 100));
-  const redirect_uri = `http://localhost:${port}/auth/callback`;
-  const params = [
-    ["response_type", "code"],
-    ["client_id", CLIENT_ID$2],
-    ["redirect_uri", redirect_uri],
-    ["scope", "openid profile email offline_access"],
-    ["code_challenge", challenge],
-    ["code_challenge_method", "S256"],
-    ["id_token_add_organizations", "true"],
-    ["codex_cli_simplified_flow", "true"],
-    ["state", state]
-  ];
-  const queryString = params.map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
-  const authUrl = `${AUTH_BASE_URL}/oauth/authorize?${queryString}`;
-  console.log("\u{1F4CB} Opening browser for authentication...");
-  console.log(`If browser doesn't open, visit:
-${authUrl}
-`);
-  await openBrowser(authUrl);
-  const tokens = await serverPromise;
-  console.log("\u{1F389} Authentication successful!");
-  return tokens;
-}
-
-const CLIENT_ID$1 = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-const CLAUDE_AI_AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
-const TOKEN_URL$1 = "https://console.anthropic.com/v1/oauth/token";
-const DEFAULT_PORT$1 = 54545;
-const SCOPE = "user:inference";
-function generatePKCE$1() {
-  const verifier = randomBytes$1(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
-  const challenge = createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-  return { verifier, challenge };
-}
-function generateState$1() {
-  return randomBytes$1(32).toString("base64url");
-}
-async function findAvailablePort$1() {
-  return new Promise((resolve) => {
-    const server = createServer$1();
-    server.listen(0, "127.0.0.1", () => {
-      const port = server.address().port;
-      server.close(() => resolve(port));
-    });
-  });
-}
-async function isPortAvailable$1(port) {
-  return new Promise((resolve) => {
-    const testServer = createServer$1();
-    testServer.once("error", () => {
-      testServer.close();
-      resolve(false);
-    });
-    testServer.listen(port, "127.0.0.1", () => {
-      testServer.close(() => resolve(true));
-    });
-  });
-}
-async function exchangeCodeForTokens$1(code, verifier, port, state) {
-  const tokenResponse = await fetch(TOKEN_URL$1, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      grant_type: "authorization_code",
-      code,
-      redirect_uri: `http://localhost:${port}/callback`,
-      client_id: CLIENT_ID$1,
-      code_verifier: verifier,
-      state
-    })
-  });
-  if (!tokenResponse.ok) {
-    throw new Error(`Token exchange failed: ${tokenResponse.statusText}`);
-  }
-  const tokenData = await tokenResponse.json();
-  return {
-    raw: tokenData,
-    token: tokenData.access_token,
-    expires: Date.now() + tokenData.expires_in * 1e3
-  };
-}
-async function startCallbackServer$1(state, verifier, port) {
-  return new Promise((resolve, reject) => {
-    const server = createServer$1(async (req, res) => {
-      const url = new URL(req.url, `http://localhost:${port}`);
-      if (url.pathname === "/callback") {
-        const code = url.searchParams.get("code");
-        const receivedState = url.searchParams.get("state");
-        if (receivedState !== state) {
-          res.writeHead(400);
-          res.end("Invalid state parameter");
-          server.close();
-          reject(new Error("Invalid state parameter"));
-          return;
-        }
-        if (!code) {
-          res.writeHead(400);
-          res.end("No authorization code received");
-          server.close();
-          reject(new Error("No authorization code received"));
-          return;
-        }
-        try {
-          const tokens = await exchangeCodeForTokens$1(code, verifier, port, state);
-          res.writeHead(302, {
-            "Location": "https://console.anthropic.com/oauth/code/success?app=claude-code"
-          });
-          res.end();
-          server.close();
-          resolve(tokens);
-        } catch (error) {
-          res.writeHead(500);
-          res.end("Token exchange failed");
-          server.close();
-          reject(error);
-        }
-      }
-    });
-    server.listen(port, "127.0.0.1", () => {
-    });
-    setTimeout(() => {
-      server.close();
-      reject(new Error("Authentication timeout"));
-    }, 5 * 60 * 1e3);
-  });
-}
-async function authenticateClaude() {
-  console.log("\u{1F680} Starting Anthropic Claude authentication...");
-  const { verifier, challenge } = generatePKCE$1();
-  const state = generateState$1();
-  let port = DEFAULT_PORT$1;
-  const portAvailable = await isPortAvailable$1(port);
-  if (!portAvailable) {
-    console.log(`Port ${port} is in use, finding an available port...`);
-    port = await findAvailablePort$1();
-  }
-  console.log(`\u{1F4E1} Using callback port: ${port}`);
-  const serverPromise = startCallbackServer$1(state, verifier, port);
-  await new Promise((resolve) => setTimeout(resolve, 100));
-  const redirect_uri = `http://localhost:${port}/callback`;
-  const params = new URLSearchParams({
-    code: "true",
-    // This tells Claude.ai to show the code AND redirect
-    client_id: CLIENT_ID$1,
-    response_type: "code",
-    redirect_uri,
-    scope: SCOPE,
-    code_challenge: challenge,
-    code_challenge_method: "S256",
-    state
-  });
-  const authUrl = `${CLAUDE_AI_AUTHORIZE_URL}?${params}`;
-  console.log("\u{1F4CB} Opening browser for authentication...");
-  console.log("If browser doesn't open, visit this URL:");
-  console.log();
-  console.log(`${authUrl}`);
-  console.log();
-  await openBrowser(authUrl);
-  try {
-    const tokens = await serverPromise;
-    console.log("\u{1F389} Authentication successful!");
-    console.log("\u2705 OAuth tokens received");
-    return tokens;
-  } catch (error) {
-    console.error("\n\u274C Failed to authenticate with Anthropic");
-    throw error;
-  }
-}
-
-const execAsync = promisify(exec);
-const CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
-const CLIENT_SECRET = "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";
-const AUTHORIZE_URL = "https://accounts.google.com/o/oauth2/v2/auth";
-const TOKEN_URL = "https://oauth2.googleapis.com/token";
-const DEFAULT_PORT = 54545;
-const SCOPES = [
-  "https://www.googleapis.com/auth/cloud-platform",
-  "https://www.googleapis.com/auth/userinfo.email",
-  "https://www.googleapis.com/auth/userinfo.profile"
-].join(" ");
-function generatePKCE() {
-  const verifier = randomBytes$1(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
-  const challenge = createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-  return { verifier, challenge };
-}
-function generateState() {
-  return randomBytes$1(32).toString("hex");
-}
-async function findAvailablePort() {
-  return new Promise((resolve) => {
-    const server = createServer$1();
-    server.listen(0, "127.0.0.1", () => {
-      const port = server.address().port;
-      server.close(() => resolve(port));
-    });
-  });
-}
-async function isPortAvailable(port) {
-  return new Promise((resolve) => {
-    const testServer = createServer$1();
-    testServer.once("error", () => {
-      testServer.close();
-      resolve(false);
-    });
-    testServer.listen(port, "127.0.0.1", () => {
-      testServer.close(() => resolve(true));
-    });
-  });
-}
-async function exchangeCodeForTokens(code, verifier, port) {
-  const response = await fetch(TOKEN_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: new URLSearchParams({
-      grant_type: "authorization_code",
-      client_id: CLIENT_ID,
-      client_secret: CLIENT_SECRET,
-      code,
-      code_verifier: verifier,
-      redirect_uri: `http://localhost:${port}/oauth2callback`
-    })
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(`Token exchange failed: ${error}`);
-  }
-  const data = await response.json();
-  return data;
-}
-async function startCallbackServer(state, verifier, port) {
-  return new Promise((resolve, reject) => {
-    const server = createServer$1(async (req, res) => {
-      const url = new URL(req.url, `http://localhost:${port}`);
-      if (url.pathname === "/oauth2callback") {
-        const code = url.searchParams.get("code");
-        const receivedState = url.searchParams.get("state");
-        const error = url.searchParams.get("error");
-        if (error) {
-          res.writeHead(302, {
-            "Location": "https://developers.google.com/gemini-code-assist/auth_failure_gemini"
-          });
-          res.end();
-          server.close();
-          reject(new Error(`Authentication error: ${error}`));
-          return;
-        }
-        if (receivedState !== state) {
-          res.writeHead(400);
-          res.end("State mismatch. Possible CSRF attack");
-          server.close();
-          reject(new Error("Invalid state parameter"));
-          return;
-        }
-        if (!code) {
-          res.writeHead(400);
-          res.end("No authorization code received");
-          server.close();
-          reject(new Error("No authorization code received"));
-          return;
-        }
-        try {
-          const tokens = await exchangeCodeForTokens(code, verifier, port);
-          res.writeHead(302, {
-            "Location": "https://developers.google.com/gemini-code-assist/auth_success_gemini"
-          });
-          res.end();
-          server.close();
-          resolve(tokens);
-        } catch (error2) {
-          res.writeHead(500);
-          res.end("Token exchange failed");
-          server.close();
-          reject(error2);
-        }
-      }
-    });
-    server.listen(port, "127.0.0.1", () => {
-    });
-    setTimeout(() => {
-      server.close();
-      reject(new Error("Authentication timeout"));
-    }, 5 * 60 * 1e3);
-  });
-}
-async function authenticateGemini() {
-  console.log("\u{1F680} Starting Google Gemini authentication...");
-  const { verifier, challenge } = generatePKCE();
-  const state = generateState();
-  let port = DEFAULT_PORT;
-  const portAvailable = await isPortAvailable(port);
-  if (!portAvailable) {
-    console.log(`Port ${port} is in use, finding an available port...`);
-    port = await findAvailablePort();
-  }
-  console.log(`\u{1F4E1} Using callback port: ${port}`);
-  const serverPromise = startCallbackServer(state, verifier, port);
-  await new Promise((resolve) => setTimeout(resolve, 100));
-  const redirect_uri = `http://localhost:${port}/oauth2callback`;
-  const params = new URLSearchParams({
-    client_id: CLIENT_ID,
-    response_type: "code",
-    redirect_uri,
-    scope: SCOPES,
-    access_type: "offline",
-    // To get refresh token
-    code_challenge: challenge,
-    code_challenge_method: "S256",
-    state,
-    prompt: "consent"
-    // Force consent to get refresh token
-  });
-  const authUrl = `${AUTHORIZE_URL}?${params}`;
-  console.log("\n\u{1F4CB} Opening browser for authentication...");
-  console.log("If browser doesn't open, visit this URL:");
-  console.log(`
-${authUrl}
-`);
-  const platform = process.platform;
-  const openCommand = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
-  try {
-    await execAsync(`${openCommand} "${authUrl}"`);
-  } catch {
-    console.log("\u26A0\uFE0F  Could not open browser automatically");
-  }
-  try {
-    const tokens = await serverPromise;
-    console.log("\n\u{1F389} Authentication successful!");
-    console.log("\u2705 OAuth tokens received");
-    return tokens;
-  } catch (error) {
-    console.error("\n\u274C Failed to authenticate with Google");
-    throw error;
-  }
-}
-
-async function syncCodexCliAuth(tokens) {
-  const authFilePath = path__default.join(os__default.homedir(), ".codex", "auth.json");
-  const authDir = path__default.dirname(authFilePath);
-  let previousAccountId;
-  let previousApiKey = null;
-  try {
-    const existingRaw = await fs$1.readFile(authFilePath, "utf8");
-    const existing = JSON.parse(existingRaw);
-    previousAccountId = existing?.tokens?.account_id;
-    previousApiKey = typeof existing?.OPENAI_API_KEY === "string" ? existing.OPENAI_API_KEY : null;
-  } catch {
-  }
-  await fs$1.mkdir(authDir, { recursive: true });
-  const next = {
-    OPENAI_API_KEY: previousApiKey,
-    tokens: {
-      id_token: tokens.id_token,
-      access_token: tokens.access_token,
-      refresh_token: tokens.refresh_token,
-      account_id: tokens.account_id
-    },
-    last_refresh: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  await fs$1.writeFile(authFilePath, JSON.stringify(next, null, 2) + "\n", "utf8");
-  return {
-    authFilePath,
-    previousAccountId,
-    newAccountId: tokens.account_id
-  };
-}
-
 async function handleConnectCommand(args) {
   const subcommand = args[0];
   const flags = args.slice(1);
@@ -14650,7 +14127,8 @@ async function runSmokeForAgent(agent, args) {
   const skipUnreal = !readFlag(args, "--with-unreal");
   const baseDir = readArgValue$2(args, "--directory") || readArgValue$2(args, "--dir");
   const timeoutMsRaw = readArgValue$2(args, "--timeout-ms");
-  const timeoutMs = timeoutMsRaw && Number.isFinite(Number(timeoutMsRaw)) ? Number(timeoutMsRaw) : 9e4;
+  const defaultTimeoutMs = process.platform === "win32" ? 24e4 : 9e4;
+  const timeoutMs = timeoutMsRaw && Number.isFinite(Number(timeoutMsRaw)) ? Number(timeoutMsRaw) : defaultTimeoutMs;
   let sessionId;
   let directory;
   let sessionClient = null;
@@ -14698,7 +14176,7 @@ Update: ${updateCommand}`);
       throw new Error(msg);
     }
     sessionClient = api.sessionSyncClient(session);
-    await sessionClient.connectAndWait(15e3);
+    await sessionClient.connectAndWait();
     await ensureSessionActive(api, sessionId, 25e3);
     const permissionMode = permissionModeForAgent(agent);
     scenarios.push(await runScenario("basic-message", async () => {
@@ -14803,7 +14281,7 @@ Options:
   --agent, -a           Run a single agent
   --agents              Comma-separated list of agents
   --directory, --dir    Directory to run the session in (defaults to a temp folder)
-  --timeout-ms          Per-scenario timeout (default 90000)
+  --timeout-ms          Per-scenario timeout (default 90000; Windows default 240000)
   --keep                Do not stop session or delete temp dir
   --json                Write results JSON to a file
   --with-unreal         Allow Unreal MCP prompts (off by default)
@@ -14867,6 +14345,18 @@ function splitList(value) {
 function ensureDir(dir) {
   fs__default.mkdirSync(dir, { recursive: true });
 }
+function canWriteDir(dir) {
+  const root = (dir || "").trim();
+  if (!root) return false;
+  try {
+    const tmp = path__default.join(root, `.__flockbay_write_test_${Date.now()}_${Math.random().toString(16).slice(2)}.tmp`);
+    fs__default.writeFileSync(tmp, "ok", "utf8");
+    fs__default.unlinkSync(tmp);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function detectImageMimeTypeFromBuffer(buf) {
   if (!buf || buf.length < 12) return null;
   if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71 && buf[4] === 13 && buf[5] === 10 && buf[6] === 26 && buf[7] === 10) {
@@ -14885,7 +14375,7 @@ async function waitForUnreal(options) {
   while (Date.now() - startedAt < options.timeoutMs) {
     try {
       const res = await sendUnrealMcpTcpCommand({ type: "ping", host: options.host, port: options.port, timeoutMs: 2e3 });
-      const msg = typeof res?.message === "string" ? res.message : null;
+      const msg = typeof res?.message === "string" ? res.message : typeof res?.result?.message === "string" ? res.result.message : null;
       if (msg === "pong") return { ok: true };
     } catch (err) {
       lastErr = err instanceof Error ? err.message : String(err);
@@ -14933,22 +14423,23 @@ async function runRuntimeSmoke(options) {
   }
   try {
     const pluginInfo = await sendUnrealMcpTcpCommand({ type: "get_plugin_info", host: options.host, port: options.port, timeoutMs: options.timeoutMs });
-    const createdBy = String(pluginInfo?.createdBy || "").trim();
-    const friendlyName = String(pluginInfo?.friendlyName || "").trim();
-    const baseDir = String(pluginInfo?.baseDir || "").trim();
-    const schemaVersion = Number(pluginInfo?.schemaVersion);
-    const commands = Array.isArray(pluginInfo?.commands) ? pluginInfo.commands.filter((c) => typeof c === "string") : [];
-    if (friendlyName !== "Unreal MCP Plugin" || createdBy !== "Respaced Inc.") {
+    const pluginInfoResult = pluginInfo?.result && typeof pluginInfo.result === "object" ? pluginInfo.result : pluginInfo;
+    const createdBy = String(pluginInfoResult?.createdBy || "").trim();
+    const friendlyName = String(pluginInfoResult?.friendlyName || "").trim();
+    const baseDir = String(pluginInfoResult?.baseDir || "").trim();
+    const schemaVersion = Number(pluginInfoResult?.schemaVersion);
+    const commands = Array.isArray(pluginInfoResult?.commands) ? pluginInfoResult.commands.filter((c) => typeof c === "string") : [];
+    if (friendlyName !== "Flockbay MCP" || createdBy !== "Respaced Inc.") {
       return {
         ok: false,
         error: `Unexpected plugin identity loaded by Unreal.
 friendlyName=${friendlyName || "(missing)"} createdBy=${createdBy || "(missing)"}
 baseDir=${baseDir || "(missing)"}
-Expected FriendlyName="Unreal MCP Plugin" CreatedBy="Respaced Inc."`
+Expected FriendlyName="Flockbay MCP" CreatedBy="Respaced Inc."`
       };
     }
     if (!Number.isFinite(schemaVersion) || schemaVersion <= 0) {
-      return { ok: false, error: `Invalid schemaVersion from get_plugin_info: ${String(pluginInfo?.schemaVersion)}` };
+      return { ok: false, error: `Invalid schemaVersion from get_plugin_info: ${String(pluginInfoResult?.schemaVersion)}` };
     }
     const requireCommands = [
       "ping",
@@ -14968,7 +14459,8 @@ Expected FriendlyName="Unreal MCP Plugin" CreatedBy="Respaced Inc."`
       return { ok: false, error: `Missing required commands in this Unreal MCP build: ${missing.join(", ")}` };
     }
     const playStatus0 = await sendUnrealMcpTcpCommand({ type: "get_play_in_editor_status", host: options.host, port: options.port, timeoutMs: options.timeoutMs });
-    const isPlaying = Boolean(playStatus0?.isPlaySessionInProgress);
+    const playStatusResult = playStatus0?.result && typeof playStatus0.result === "object" ? playStatus0.result : playStatus0;
+    const isPlaying = Boolean(playStatusResult?.isPlaySessionInProgress);
     if (isPlaying) {
       await sendUnrealMcpTcpCommand({ type: "stop_play_in_editor", host: options.host, port: options.port, timeoutMs: options.timeoutMs });
     }
@@ -14995,7 +14487,9 @@ Expected FriendlyName="Unreal MCP Plugin" CreatedBy="Respaced Inc."`
     const bpName = `BP_Smoke_${Date.now()}`;
     await sendUnrealMcpTcpCommand({
       type: "create_blueprint",
-      params: { name: bpName, path: "/Game/FlockbaySmoke/", parent_class: "Actor" },
+      // Important: pass only the name so the plugin's default (/Game/Blueprints/) is used.
+      // The plugin's "compile_blueprint" name-only lookup searches /Game/Blueprints by design.
+      params: { name: bpName, parent_class: "Actor" },
       host: options.host,
       port: options.port,
       timeoutMs: Math.max(options.timeoutMs, 2e4)
@@ -15062,26 +14556,73 @@ async function runUnrealMcpMatrixSmoke(args) {
     if (!engineRoot) continue;
     console.log(chalk.bold(`== Engine: ${engineRoot} ==`));
     if (doBuild) {
-      console.log(chalk.cyan("Build: installing Flockbay MCP plugin sources (folder: FlockbayMCP)..."));
-      const installed = installUnrealMcpPluginToEngine(engineRoot);
-      if (!installed.ok) {
-        failures.push({ engineRoot, phase: "build", error: installed.errorMessage });
-        console.log(chalk.red(`Build: failed (install)
+      const enginePluginsDir = path__default.join(engineRoot, "Engine", "Plugins");
+      const enginePluginDir = path__default.join(enginePluginsDir, "FlockbayMCP");
+      const enginePluginUplugin = path__default.join(enginePluginDir, "FlockbayMCP.uplugin");
+      const enginePluginHasBinaries = fs__default.existsSync(path__default.join(enginePluginDir, "Binaries"));
+      const projectUprojectPath = project ? path__default.resolve(project) : null;
+      if (fs__default.existsSync(enginePluginUplugin) && enginePluginHasBinaries) {
+        console.log(chalk.green(`Build: engine plugin already installed + built (${enginePluginDir})`));
+      } else if (canWriteDir(enginePluginsDir)) {
+        console.log(chalk.cyan("Build: installing Flockbay MCP plugin sources into the engine (folder: FlockbayMCP)..."));
+        const installed = installUnrealMcpPluginToEngine(engineRoot);
+        if (!installed.ok) {
+          failures.push({ engineRoot, phase: "build", error: installed.errorMessage });
+          console.log(chalk.red(`Build: failed (install)
 ${installed.errorMessage}
 `));
-        if (!doRuntime) continue;
-      } else {
-        console.log(chalk.green(`Build: sources installed to ${installed.destDir}`));
-        console.log(chalk.cyan("Build: compiling plugin via RunUAT BuildPlugin..."));
-        const built = await buildAndInstallUnrealMcpPlugin({ engineRoot, flockbayHomeDir: configuration.flockbayHomeDir });
-        if (!built.ok) {
-          failures.push({ engineRoot, phase: "build", error: built.errorMessage });
-          console.log(chalk.red(`Build: failed
+          if (!doRuntime) continue;
+        } else {
+          console.log(chalk.green(`Build: sources installed to ${installed.destDir}`));
+          console.log(chalk.cyan("Build: compiling plugin via RunUAT BuildPlugin..."));
+          const built = await buildAndInstallUnrealMcpPlugin({ engineRoot, flockbayHomeDir: configuration.flockbayHomeDir });
+          if (!built.ok) {
+            failures.push({ engineRoot, phase: "build", error: built.errorMessage });
+            console.log(chalk.red(`Build: failed
 ${built.errorMessage}
 `));
+          } else {
+            console.log(chalk.green(`Build: ok (log: ${built.buildLogPath})`));
+          }
+        }
+      } else if (projectUprojectPath) {
+        console.log(chalk.cyan("Build: engine install not writable; installing plugin into the project instead..."));
+        const installedProject = installUnrealMcpPluginToProject(projectUprojectPath);
+        if (!installedProject.ok) {
+          failures.push({ engineRoot, phase: "build", error: installedProject.errorMessage });
+          console.log(chalk.red(`Build: failed (project install)
+${installedProject.errorMessage}
+`));
+          if (!doRuntime) continue;
         } else {
-          console.log(chalk.green(`Build: ok (log: ${built.buildLogPath})`));
+          console.log(chalk.green(`Build: sources installed to ${installedProject.destDir}`));
+          console.log(chalk.cyan("Build: compiling plugin via RunUAT BuildPlugin..."));
+          const built = await buildAndInstallUnrealMcpPlugin({
+            engineRoot,
+            flockbayHomeDir: configuration.flockbayHomeDir,
+            pluginDir: installedProject.destDir
+          });
+          if (!built.ok) {
+            failures.push({ engineRoot, phase: "build", error: built.errorMessage });
+            console.log(chalk.red(`Build: failed
+${built.errorMessage}
+`));
+          } else {
+            console.log(chalk.green(`Build: ok (log: ${built.buildLogPath})`));
+          }
         }
+      } else {
+        const error = `Engine plugins folder is not writable:
+${enginePluginsDir}
+
+Fix:
+- Re-run with --project "<path-to-your-project>.uproject" so we can install the plugin into the project (no admin), OR
+- Run the installer with Windows admin permissions.`;
+        failures.push({ engineRoot, phase: "build", error });
+        console.log(chalk.red(`Build: failed
+${error}
+`));
+        if (!doRuntime) continue;
       }
     }
     if (doRuntime) {
@@ -15540,7 +15081,7 @@ async function authAndSetupMachineIfNeeded() {
         process.exit(1);
       }
       try {
-        const { migrateUnrealMcpToFlockbayMcp } = await import('./migratePlugin-Beo3Vgvz.mjs');
+        const { migrateUnrealMcpToFlockbayMcp } = await import('./migratePlugin-CCepAUqm.mjs');
         const result = migrateUnrealMcpToFlockbayMcp({
           engineRoot,
           projectUprojectPath: project || void 0,
@@ -15679,7 +15220,7 @@ ${engineRoot}`, {
   } else if (subcommand === "codex") {
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runCodex } = await import('./runCodex-BAbRZt7Y.mjs');
+      const { runCodex } = await import('./runCodex-7GeFJuM_.mjs');
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {
@@ -15781,7 +15322,7 @@ ${engineRoot}`, {
     }
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runGemini } = await import('./runGemini-D9WGwILY.mjs');
+      const { runGemini } = await import('./runGemini-9LGJaWVk.mjs');
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {