flockbay 0.10.40 → 0.10.42

package/dist/{index-hc8sYVfl.cjs → index-F8r81l86.cjs}

@@ -3,7 +3,7 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var types = require('./types-2Bs_CNcy.cjs');
+var types = require('./types-wdJcHT5x.cjs');
 var node_child_process = require('node:child_process');
 var path = require('node:path');
 var node_readline = require('node:readline');
@@ -15,27 +15,26 @@ var ink = require('ink');
 var React = require('react');
 var node_url = require('node:url');
 var axios = require('axios');
-var node_events = require('node:events');
 require('socket.io-client');
 var child_process = require('child_process');
 var crypto = require('crypto');
 var path$1 = require('path');
 var os$1 = require('os');
 require('node:net');
+require('http');
+require('open');
 var fs$3 = require('fs');
 var psList = require('ps-list');
 var spawn = require('cross-spawn');
 var tmp = require('tmp');
-var open = require('open');
 var fastify = require('fastify');
 var z = require('zod');
 var fastifyTypeProviderZod = require('fastify-type-provider-zod');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var node_http = require('node:http');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+var node_events = require('node:events');
 require('tweetnacl');
-var http = require('http');
-var util = require('util');
 var node_zlib = require('node:zlib');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -1317,7 +1316,7 @@ function buildDaemonSafeEnv(baseEnv, binPath) {
   env[pathKey] = [...prepend, ...existingParts].join(pathSep);
   return env;
 }
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-hc8sYVfl.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-F8r81l86.cjs', document.baseURI).href)));
 const __dirname$1 = path.join(__filename$1, "..");
 function getGlobalClaudeVersion(claudeExecutable) {
   try {
@@ -5202,23 +5201,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)) {
-      types.logger.debug("[browser] Headless/non-interactive environment detected, skipping browser open");
-      return false;
-    }
-    types.logger.debug(`[browser] Attempting to open URL: ${url}`);
-    await open(url, { wait: false });
-    types.logger.debug("[browser] Browser opened successfully");
-    return true;
-  } catch (error) {
-    types.logger.debug("[browser] Failed to open browser:", error);
-    return false;
-  }
-}
-
 async function loginWithClerkAndPairMachine() {
   types.logger.debug("[AUTH] Starting Clerk-based CLI login + machine pairing");
   const settings = await types.updateSettings(async (s) => {
@@ -5251,7 +5233,7 @@ async function loginWithClerkAndPairMachine() {
   console.log("Open this link to sign in with Clerk and approve this machine:");
   console.log(approveUrl);
   console.log("");
-  void openBrowser(approveUrl).catch(() => null);
+  void types.openBrowser(approveUrl).catch(() => null);
   const deadline = Date.now() + 10 * 6e4;
   while (Date.now() < deadline) {
     await types.delay(1e3);
@@ -13186,7 +13168,7 @@ Update: ${updateCommand}`);
       summary: currentMetadata?.summary
     }));
   }
-  await session.connectAndWait(15e3);
+  await session.connectAndWait();
   session.keepAlive(false, options.startingMode === "remote" ? "remote" : "local");
   try {
     types.logger.debug(`[START] Reporting session ${response.id} to daemon`);
@@ -13828,511 +13810,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 = crypto.randomBytes(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
-  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-  return { verifier, challenge };
-}
-function generateState$2() {
-  return crypto.randomBytes(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 = http.createServer();
-    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 = http.createServer();
-    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 = http.createServer(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 = crypto.randomBytes(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
-  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-  return { verifier, challenge };
-}
-function generateState$1() {
-  return crypto.randomBytes(32).toString("base64url");
-}
-async function findAvailablePort$1() {
-  return new Promise((resolve) => {
-    const server = http.createServer();
-    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 = http.createServer();
-    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 = http.createServer(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 = util.promisify(child_process.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 = crypto.randomBytes(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
-  const challenge = crypto.createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-  return { verifier, challenge };
-}
-function generateState() {
-  return crypto.randomBytes(32).toString("hex");
-}
-async function findAvailablePort() {
-  return new Promise((resolve) => {
-    const server = http.createServer();
-    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 = http.createServer();
-    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 = http.createServer(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.join(os.homedir(), ".codex", "auth.json");
-  const authDir = path.dirname(authFilePath);
-  let previousAccountId;
-  let previousApiKey = null;
-  try {
-    const existingRaw = await fs$2.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$2.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$2.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);
@@ -14408,13 +13885,13 @@ async function handleConnectVendor(vendor, displayName, flags) {
   const api = await types.ApiClient.create(credentials);
   if (vendor === "codex") {
     console.log("\u{1F680} Registering Codex token with server");
-    const codexAuthTokens = await authenticateCodex();
+    const codexAuthTokens = await types.authenticateCodex();
     await api.registerVendorToken("openai", { oauth: codexAuthTokens });
     console.log("\u2705 Codex token registered with server");
     const shouldSyncLocal = !noLocal;
     if (shouldSyncLocal) {
       try {
-        const result = await syncCodexCliAuth(codexAuthTokens);
+        const result = await types.syncCodexCliAuth(codexAuthTokens);
         const from = result.previousAccountId ? `from ${result.previousAccountId} ` : "";
         const to = result.newAccountId ? `to ${result.newAccountId}` : "to an unknown account";
         console.log(chalk.gray(`\u{1F501} Synced local Codex CLI login ${from}${to} (${result.authFilePath})`));
@@ -14426,13 +13903,13 @@ async function handleConnectVendor(vendor, displayName, flags) {
     process.exit(0);
   } else if (vendor === "claude") {
     console.log("\u{1F680} Registering Anthropic token with server");
-    const anthropicAuthTokens = await authenticateClaude();
+    const anthropicAuthTokens = await types.authenticateClaude();
     await api.registerVendorToken("anthropic", { oauth: anthropicAuthTokens });
     console.log("\u2705 Anthropic token registered with server");
     process.exit(0);
   } else if (vendor === "gemini") {
     console.log("\u{1F680} Registering Gemini token with server");
-    const geminiAuthTokens = await authenticateGemini();
+    const geminiAuthTokens = await types.authenticateGemini();
     await api.registerVendorToken("gemini", { oauth: geminiAuthTokens });
     console.log("\u2705 Gemini token registered with server");
     process.exit(0);
@@ -14672,7 +14149,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;
@@ -14720,7 +14198,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 () => {
@@ -14825,7 +14303,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)
@@ -14889,6 +14367,18 @@ function splitList(value) {
 function ensureDir(dir) {
   fs.mkdirSync(dir, { recursive: true });
 }
+function canWriteDir(dir) {
+  const root = (dir || "").trim();
+  if (!root) return false;
+  try {
+    const tmp = path.join(root, `.__flockbay_write_test_${Date.now()}_${Math.random().toString(16).slice(2)}.tmp`);
+    fs.writeFileSync(tmp, "ok", "utf8");
+    fs.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) {
@@ -14907,7 +14397,7 @@ async function waitForUnreal(options) {
   while (Date.now() - startedAt < options.timeoutMs) {
     try {
       const res = await types.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);
@@ -14955,22 +14445,23 @@ async function runRuntimeSmoke(options) {
   }
   try {
     const pluginInfo = await types.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",
@@ -14990,7 +14481,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 types.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 types.sendUnrealMcpTcpCommand({ type: "stop_play_in_editor", host: options.host, port: options.port, timeoutMs: options.timeoutMs });
     }
@@ -15017,7 +14509,9 @@ Expected FriendlyName="Unreal MCP Plugin" CreatedBy="Respaced Inc."`
     const bpName = `BP_Smoke_${Date.now()}`;
     await types.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)
@@ -15084,26 +14578,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 = types.installUnrealMcpPluginToEngine(engineRoot);
-      if (!installed.ok) {
-        failures.push({ engineRoot, phase: "build", error: installed.errorMessage });
-        console.log(chalk.red(`Build: failed (install)
+      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 projectUprojectPath = project ? path.resolve(project) : null;
+      if (fs.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 = types.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 types.buildAndInstallUnrealMcpPlugin({ engineRoot, flockbayHomeDir: types.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 types.buildAndInstallUnrealMcpPlugin({ engineRoot, flockbayHomeDir: types.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 = types.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 types.buildAndInstallUnrealMcpPlugin({
+            engineRoot,
+            flockbayHomeDir: types.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) {
@@ -15562,7 +15103,7 @@ async function authAndSetupMachineIfNeeded() {
         process.exit(1);
       }
       try {
-        const { migrateUnrealMcpToFlockbayMcp } = await Promise.resolve().then(function () { return require('./migratePlugin-DNHywpj6.cjs'); });
+        const { migrateUnrealMcpToFlockbayMcp } = await Promise.resolve().then(function () { return require('./migratePlugin-T0MOGk0T.cjs'); });
         const result = migrateUnrealMcpToFlockbayMcp({
           engineRoot,
           projectUprojectPath: project || void 0,
@@ -15701,7 +15242,7 @@ ${engineRoot}`, {
   } else if (subcommand === "codex") {
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-B3Qjwkr6.cjs'); });
+      const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-Bx4E0ukk.cjs'); });
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {
@@ -15803,7 +15344,7 @@ ${engineRoot}`, {
     }
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-BED5hBNz.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-xvROo10g.cjs'); });
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {