flockbay 0.10.40 → 0.10.41

package/dist/{index-COD6HpzC.mjs → index-4XOVLZZ1.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 getLatestDaemonLog, I as normalizeServerUrlForNode } from './types-DQ-HKKy4.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,7 +10,7 @@ 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';
@@ -18,16 +18,17 @@ 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';
@@ -35,8 +36,6 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 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);
@@ -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);
@@ -15540,7 +15017,7 @@ async function authAndSetupMachineIfNeeded() {
         process.exit(1);
       }
       try {
-        const { migrateUnrealMcpToFlockbayMcp } = await import('./migratePlugin-Beo3Vgvz.mjs');
+        const { migrateUnrealMcpToFlockbayMcp } = await import('./migratePlugin-D-oSS5d1.mjs');
         const result = migrateUnrealMcpToFlockbayMcp({
           engineRoot,
           projectUprojectPath: project || void 0,
@@ -15679,7 +15156,7 @@ ${engineRoot}`, {
   } else if (subcommand === "codex") {
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runCodex } = await import('./runCodex-BAbRZt7Y.mjs');
+      const { runCodex } = await import('./runCodex-B10NJHEL.mjs');
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {
@@ -15781,7 +15258,7 @@ ${engineRoot}`, {
     }
     try {
       await chdirToNearestUprojectRootIfPresent();
-      const { runGemini } = await import('./runGemini-D9WGwILY.mjs');
+      const { runGemini } = await import('./runGemini-B4kutwSV.mjs');
       let startedBy = void 0;
       let sessionId = void 0;
       for (let i = 1; i < args.length; i++) {