@elizaos/cli 1.2.0 → 1.2.2

package/dist/{chunk-RXPGZT6Z.js → chunk-YKFBLIQD.js}

@@ -3,22 +3,27 @@ import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 
 import {
+  bunExec,
+  bunExecInherit,
+  bunExecSimple,
+  commandExists,
   displayBunInstallationTipCompact,
   emoji,
+  require_execa,
   runBunCommand
-} from "./chunk-7PPBVSWE.js";
+} from "./chunk-GRPGGUED.js";
 import {
   getAgentRuntimeUrl,
   getAgentsBaseUrl
 } from "./chunk-F24MS2YR.js";
 import {
-  __require
-} from "./chunk-AQ6OMR2A.js";
+  __require,
+  __toESM
+} from "./chunk-XB5JBFO6.js";
 
 // src/utils/build-project.ts
 import * as fs3 from "fs";
 import * as path4 from "path";
-import { execa as execa3 } from "execa";
 
 // src/utils/directory-detection.ts
 import * as fs2 from "fs";
@@ -30,7 +35,7 @@ import fs from "fs/promises";
 import path2 from "path";
 import * as semver from "semver";
 import { fileURLToPath } from "url";
-import { logger as logger3 } from "@elizaos/core";
+import { logger as logger2 } from "@elizaos/core";
 import { existsSync as existsSync2, statSync, readFileSync } from "fs";
 import { execSync } from "child_process";
 
@@ -87,65 +92,80 @@ async function resolvePgliteDir(dir, fallbackDir, targetProjectDir) {
 }
 
 // src/utils/auto-install-bun.ts
-import { logger as logger2 } from "@elizaos/core";
-import { execa } from "execa";
-async function autoInstallBun() {
-  const platform = process.platform;
+import { logger } from "@elizaos/core";
+import { homedir } from "os";
+import { join } from "path";
+var INSTALLATION_VERIFICATION_DELAY_MS = 2e3;
+function updatePathForBun() {
+  const home = homedir();
+  const bunBinPath = join(home, ".bun", "bin");
+  const currentPath = process.env.PATH || "";
+  const pathSeparator = process.platform === "win32" ? ";" : ":";
+  const pathDirs = currentPath.split(pathSeparator);
+  const bunBinPathNormalized = bunBinPath.replace(/[/\\]+$/, "");
+  const isInPath = pathDirs.some((dir) => {
+    const dirNormalized = dir.replace(/[/\\]+$/, "");
+    return dirNormalized === bunBinPathNormalized;
+  });
+  if (!isInPath) {
+    process.env.PATH = `${bunBinPath}${pathSeparator}${currentPath}`;
+    logger.debug(`Added ${bunBinPath} to PATH for current process`);
+  } else {
+    logger.debug(`${bunBinPath} is already in PATH`);
+  }
+}
+async function isBunInstalled() {
   try {
-    await execa("bun", ["--version"], { stdio: "ignore" });
+    const exists = await commandExists("bun");
+    if (!exists) {
+      return false;
+    }
+    const result = await bunExec("bun", ["--version"], { stdio: "ignore" });
+    return result.success;
+  } catch (error) {
+    logger.debug("Error checking if Bun is installed:", error);
+    return false;
+  }
+}
+async function autoInstallBun() {
+  if (await isBunInstalled()) {
+    logger.info("Bun is already installed.");
     return true;
-  } catch {
   }
-  logger2.info(`${emoji.rocket("Bun is required for ElizaOS CLI. Installing automatically...")}`);
+  const platform = process.platform;
   try {
     if (platform === "win32") {
-      logger2.info("Installing Bun on Windows...");
-      await execa("powershell", ["-c", "irm bun.sh/install.ps1 | iex"], {
-        stdio: "inherit"
-      });
+      await bunExecInherit("powershell", ["-c", "irm bun.sh/install.ps1 | iex"]);
     } else {
-      logger2.info("Installing Bun on Linux/macOS...");
-      await execa("sh", ["-c", "curl -fsSL https://bun.sh/install | bash"], {
-        stdio: "inherit"
-      });
-    }
-    const bunPath = platform === "win32" ? `${process.env.USERPROFILE}\\.bun\\bin` : `${process.env.HOME}/.bun/bin`;
-    if (bunPath && !process.env.PATH?.includes(bunPath)) {
-      process.env.PATH = `${bunPath}${platform === "win32" ? ";" : ":"}${process.env.PATH}`;
+      await bunExecInherit("sh", ["-c", "curl -fsSL https://bun.sh/install | bash"]);
     }
-    await execa("bun", ["--version"], { stdio: "ignore" });
-    logger2.success(`${emoji.success("Bun installed successfully!")}`);
-    return true;
-  } catch (error) {
-    logger2.error(`${emoji.error("Failed to automatically install Bun:")}`);
-    logger2.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
-    logger2.info(`
-${emoji.info("Please install Bun manually:")}`);
-    if (platform === "win32") {
-      logger2.info('   Windows: powershell -c "irm bun.sh/install.ps1 | iex"');
+    logger.info("Bun installation script executed successfully.");
+    updatePathForBun();
+    await new Promise((resolve2) => setTimeout(resolve2, INSTALLATION_VERIFICATION_DELAY_MS));
+    if (await isBunInstalled()) {
+      logger.success("Bun has been successfully installed!");
+      return true;
     } else {
-      logger2.info("   Linux/macOS: curl -fsSL https://bun.sh/install | bash");
-      if (platform === "darwin") {
-        logger2.info("   macOS (Homebrew): brew install bun");
-      }
+      logger.error("Bun installation completed but the command is not available in PATH.");
+      logger.error("Please restart your terminal or source your shell profile.");
+      return false;
     }
-    logger2.info(`
-${emoji.link("More options: https://bun.sh/docs/installation")}`);
-    logger2.info(
-      `
-${emoji.tip("After installation, restart your terminal or source your shell profile")}`
+  } catch (error) {
+    logger.error(
+      `Failed to auto-install Bun: ${error instanceof Error ? error.message : String(error)}`
     );
     return false;
   }
 }
 function shouldAutoInstall() {
-  if (process.env.CI === "true" || process.env.CI === "1") {
+  const autoInstallEnv = process.env.ELIZA_AUTO_INSTALL_BUN;
+  if (autoInstallEnv === "false" || autoInstallEnv === "0") {
     return false;
   }
-  if (process.env.ELIZA_NO_AUTO_INSTALL === "true") {
+  if (process.env.CI || process.env.CONTINUOUS_INTEGRATION) {
     return false;
   }
-  if (process.argv.includes("--no-auto-install")) {
+  if (process.env.CONTAINER || process.env.DOCKER_CONTAINER) {
     return false;
   }
   return true;
@@ -164,7 +184,7 @@ var UserEnvironment = class _UserEnvironment {
    * Gets operating system information
    */
   async getOSInfo() {
-    logger3.debug("[UserEnvironment] Detecting OS information");
+    logger2.debug("[UserEnvironment] Detecting OS information");
     return {
       platform: os.platform(),
       release: os.release(),
@@ -178,7 +198,7 @@ var UserEnvironment = class _UserEnvironment {
    * Gets CLI version and package information
    */
   async getCLIInfo() {
-    logger3.debug("[UserEnvironment] Getting CLI information");
+    logger2.debug("[UserEnvironment] Getting CLI information");
     try {
       const __filename2 = fileURLToPath(import.meta.url);
       const __dirname2 = path2.dirname(__filename2);
@@ -194,7 +214,7 @@ var UserEnvironment = class _UserEnvironment {
         path: process.argv[1] || ""
       };
     } catch (error) {
-      logger3.warn(
+      logger2.warn(
         `[UserEnvironment] Error getting CLI info: ${error instanceof Error ? error.message : String(error)}`
       );
       return {
@@ -208,30 +228,28 @@ var UserEnvironment = class _UserEnvironment {
    * Detects the active package manager - always returns bun for ElizaOS CLI
    */
   async getPackageManagerInfo() {
-    logger3.debug("[UserEnvironment] Using bun as the package manager for ElizaOS CLI");
+    logger2.debug("[UserEnvironment] Using bun as the package manager for ElizaOS CLI");
     const isNpx = process.env.npm_execpath?.includes("npx");
     const isBunx = process.argv[0]?.includes("bun");
     let version = null;
     try {
-      const { stdout } = await import("execa").then(({ execa: execa10 }) => execa10("bun", ["--version"]));
+      const { stdout } = await bunExecSimple("bun", ["--version"]);
       version = stdout.trim();
-      logger3.debug(`[UserEnvironment] Bun version: ${version}`);
+      logger2.debug(`[UserEnvironment] Bun version: ${version}`);
     } catch (e) {
-      logger3.debug(
+      logger2.debug(
         `[UserEnvironment] Could not get bun version: ${e instanceof Error ? e.message : String(e)}`
       );
       if (shouldAutoInstall()) {
-        logger3.info(`${emoji.info("Attempting to automatically install Bun...")}`);
+        logger2.info(`${emoji.info("Attempting to automatically install Bun...")}`);
         const installSuccess = await autoInstallBun();
         if (installSuccess) {
           try {
-            const { stdout } = await import("execa").then(
-              ({ execa: execa10 }) => execa10("bun", ["--version"])
-            );
+            const { stdout } = await bunExecSimple("bun", ["--version"]);
             version = stdout.trim();
-            logger3.debug(`[UserEnvironment] Bun version after auto-install: ${version}`);
+            logger2.debug(`[UserEnvironment] Bun version after auto-install: ${version}`);
           } catch (retryError) {
-            logger3.error(
+            logger2.error(
               `Failed to verify Bun installation after auto-install: ${retryError instanceof Error ? retryError.message : String(retryError)}`
             );
           }
@@ -239,27 +257,27 @@ var UserEnvironment = class _UserEnvironment {
       }
       if (!version) {
         const platform = process.platform;
-        logger3.error(
+        logger2.error(
           `${emoji.error("Bun is required for ElizaOS CLI but is not installed or not found in PATH.")}`
         );
-        logger3.error("");
-        logger3.error(
+        logger2.error("");
+        logger2.error(
           `${emoji.rocket("Install Bun using the appropriate command for your system:")}`
         );
-        logger3.error("");
+        logger2.error("");
         if (platform === "win32") {
-          logger3.error('   Windows: powershell -c "irm bun.sh/install.ps1 | iex"');
+          logger2.error('   Windows: powershell -c "irm bun.sh/install.ps1 | iex"');
         } else {
-          logger3.error("   Linux/macOS: curl -fsSL https://bun.sh/install | bash");
+          logger2.error("   Linux/macOS: curl -fsSL https://bun.sh/install | bash");
           if (platform === "darwin") {
-            logger3.error("   macOS (Homebrew): brew install bun");
+            logger2.error("   macOS (Homebrew): brew install bun");
           }
         }
-        logger3.error("");
-        logger3.error("   More options: https://bun.sh/docs/installation");
-        logger3.error("   After installation, restart your terminal or source your shell profile");
-        logger3.error("");
-        logger3.error("\u{1F534} Exiting: Bun installation is required to continue.");
+        logger2.error("");
+        logger2.error("   More options: https://bun.sh/docs/installation");
+        logger2.error("   After installation, restart your terminal or source your shell profile");
+        logger2.error("");
+        logger2.error("\u{1F534} Exiting: Bun installation is required to continue.");
         process.exit(1);
       }
     }
@@ -326,7 +344,7 @@ var UserEnvironment = class _UserEnvironment {
     const projectRootForPaths = monorepoRoot || process.cwd();
     const elizaDir = path2.join(projectRootForPaths, ".eliza");
     const envFilePath = resolveEnvFile(process.cwd(), monorepoRoot ?? void 0);
-    logger3.debug("[UserEnvironment] Detected monorepo root:", monorepoRoot || "Not in monorepo");
+    logger2.debug("[UserEnvironment] Detected monorepo root:", monorepoRoot || "Not in monorepo");
     return {
       elizaDir,
       envFilePath,
@@ -344,7 +362,7 @@ var UserEnvironment = class _UserEnvironment {
     if (this.cachedInfo[cacheKey]) {
       return this.cachedInfo[cacheKey];
     }
-    logger3.debug(`[UserEnvironment] Gathering environment information for directory: ${cacheKey}`);
+    logger2.debug(`[UserEnvironment] Gathering environment information for directory: ${cacheKey}`);
     const [os2, cli, packageManager, paths, env] = await Promise.all([
       this.getOSInfo(),
       this.getCLIInfo(),
@@ -398,7 +416,7 @@ var UserEnvironment = class _UserEnvironment {
           if (minVer) {
             return minVer.version;
           } else {
-            logger3.warn(
+            logger2.warn(
               `Could not parse semver range '${versionRange}' for package ${packageName}. Falling back to original string.`
             );
             return versionRange;
@@ -406,18 +424,17 @@ var UserEnvironment = class _UserEnvironment {
         }
       }
       try {
-        const { execa: execa10 } = await import("execa");
-        const { stdout } = await execa10("npm", ["view", packageName, "version"]);
+        const { stdout } = await bunExecSimple("npm", ["view", packageName, "version"]);
         if (stdout?.trim()) {
-          logger3.info(`Found latest version of ${packageName} from npm: ${stdout.trim()}`);
+          logger2.info(`Found latest version of ${packageName} from npm: ${stdout.trim()}`);
           return stdout.trim();
         }
       } catch (npmError) {
-        logger3.warn(`Could not get latest version from npm: ${npmError}`);
+        logger2.warn(`Could not get latest version from npm: ${npmError}`);
       }
       return "0.25.9";
     } catch (error) {
-      logger3.warn(`Error getting package version for ${packageName}: ${error}`);
+      logger2.warn(`Error getting package version for ${packageName}: ${error}`);
       return "0.25.9";
     }
   }
@@ -434,7 +451,7 @@ var UserEnvironment = class _UserEnvironment {
       const pluginPackages = packagesDirEntries.filter((entry) => entry.isDirectory() && entry.name.startsWith("plugin-")).map((entry) => `@elizaos/${entry.name}`);
       return pluginPackages;
     } catch (error) {
-      logger3.warn(`Error getting local packages: ${error}`);
+      logger2.warn(`Error getting local packages: ${error}`);
       return [];
     }
   }
@@ -613,10 +630,10 @@ function isValidForUpdates(info) {
 }
 
 // src/utils/spinner-utils.ts
-import { execa as execa2 } from "execa";
+var import_execa = __toESM(require_execa(), 1);
 import * as clack from "@clack/prompts";
 import colors from "yoctocolors";
-import { parseBooleanFromText } from "@elizaos/core";
+import { parseBooleanFromText, logger as logger3 } from "@elizaos/core";
 function isQuietMode() {
   return parseBooleanFromText(process.env.QUIET_MODE);
 }
@@ -624,7 +641,7 @@ async function runCommandWithSpinner(command, args, options) {
   const spinner3 = clack.spinner();
   try {
     spinner3.start(options.spinnerText);
-    const result = await execa2(command, args, {
+    const result = await (0, import_execa.execa)(command, args, {
       cwd: options.cwd || process.cwd(),
       stdio: "pipe",
       reject: false
@@ -710,7 +727,7 @@ async function installPluginWithSpinner(pluginName, targetDir, purpose = "") {
   const spinner3 = clack.spinner();
   spinner3.start(`Installing ${packageName}${purposeText}...`);
   try {
-    const result = await execa2("bun", ["add", packageName], {
+    const result = await (0, import_execa.execa)("bun", ["add", packageName], {
       cwd: targetDir,
       stdio: "pipe",
       reject: false
@@ -719,7 +736,7 @@ async function installPluginWithSpinner(pluginName, targetDir, purpose = "") {
       spinner3.stop(colors.green(`\u2713 ${packageName} installed successfully`));
     } else {
       spinner3.stop(colors.yellow(`\u26A0 Failed to install ${packageName} (optional)`));
-      logger.debug(`Plugin installation failed: ${packageName}`, {
+      logger3.debug(`Plugin installation failed: ${packageName}`, {
         exitCode: result.exitCode,
         stderr: result.stderr,
         stdout: result.stdout
@@ -727,7 +744,7 @@ async function installPluginWithSpinner(pluginName, targetDir, purpose = "") {
     }
   } catch (error) {
     spinner3.stop(colors.yellow(`\u26A0 Failed to install ${packageName} (optional)`));
-    logger.debug(`Plugin installation error: ${packageName}`, error);
+    logger3.debug(`Plugin installation error: ${packageName}`, error);
   }
 }
 function createTask(title, fn) {
@@ -780,12 +797,10 @@ async function buildProject(cwd = process.cwd(), isPlugin = false) {
     const tsconfigPath = path4.join(cwd, "tsconfig.json");
     if (fs3.existsSync(tsconfigPath)) {
       try {
-        const result = await execa3("bunx", ["tsc", "--build"], {
-          cwd,
-          stdio: "pipe",
-          reject: false
+        const result = await bunExec("bunx", ["tsc", "--build"], {
+          cwd
         });
-        if (result.exitCode === 0) {
+        if (result.success) {
           return;
         } else {
           throw new Error(`bunx tsc build failed: ${result.stderr || result.stdout}`);
@@ -801,11 +816,11 @@ async function buildProject(cwd = process.cwd(), isPlugin = false) {
 }
 
 // src/utils/cli-bun-migration.ts
+var import_execa2 = __toESM(require_execa(), 1);
 import { logger as logger4 } from "@elizaos/core";
-import { execa as execa4 } from "execa";
 async function isBunAvailable() {
   try {
-    await execa4("bun", ["--version"], { stdio: "ignore" });
+    await (0, import_execa2.execa)("bun", ["--version"], { stdio: "ignore" });
     return true;
   } catch (error) {
     return false;
@@ -813,13 +828,13 @@ async function isBunAvailable() {
 }
 async function isCliInstalledViaNpm() {
   try {
-    const { stdout } = await execa4("npm", ["list", "-g", "@elizaos/cli", "--depth=0"], {
+    const { stdout } = await (0, import_execa2.execa)("npm", ["list", "-g", "@elizaos/cli", "--depth=0"], {
       stdio: "pipe"
     });
     return stdout.includes("@elizaos/cli");
   } catch (error) {
     try {
-      const { stdout: whichOutput } = await execa4("which", ["elizaos"], { stdio: "pipe" });
+      const { stdout: whichOutput } = await (0, import_execa2.execa)("which", ["elizaos"], { stdio: "pipe" });
       return whichOutput.includes("node_modules") || whichOutput.includes(".nvm");
     } catch {
       return false;
@@ -828,15 +843,15 @@ async function isCliInstalledViaNpm() {
 }
 async function removeNpmInstallation() {
   logger4.info("Removing npm installation of @elizaos/cli...");
-  await execa4("npm", ["uninstall", "-g", "@elizaos/cli"], { stdio: "inherit" });
+  await (0, import_execa2.execa)("npm", ["uninstall", "-g", "@elizaos/cli"], { stdio: "inherit" });
 }
 async function installCliWithBun(version) {
   logger4.info("Installing CLI with bun...");
-  await execa4("bun", ["add", "-g", `@elizaos/cli@${version}`], { stdio: "inherit" });
+  await (0, import_execa2.execa)("bun", ["add", "-g", `@elizaos/cli@${version}`], { stdio: "inherit" });
 }
 async function verifyCliInstallation(expectedVersion) {
   try {
-    const { stdout } = await execa4("elizaos", ["-v"], { stdio: "pipe" });
+    const { stdout } = await (0, import_execa2.execa)("elizaos", ["-v"], { stdio: "pipe" });
     const output = stdout.trim();
     const versionMatch = output.match(/(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?)/);
     if (!versionMatch) {
@@ -871,7 +886,7 @@ async function migrateCliToBun(targetVersion) {
     logger4.error("Your original npm installation is still intact.");
     try {
       logger4.info("Cleaning up failed bun installation...");
-      await execa4("bun", ["remove", "-g", "@elizaos/cli"], { stdio: "ignore" });
+      await (0, import_execa2.execa)("bun", ["remove", "-g", "@elizaos/cli"], { stdio: "ignore" });
     } catch {
     }
     throw error;
@@ -1171,7 +1186,6 @@ async function replacePluginNameInFiles(targetDir, pluginName) {
 import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
 import path7, { dirname } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { execa as execa5 } from "execa";
 function isRunningFromNodeModules() {
   const __filename2 = fileURLToPath3(import.meta.url);
   return __filename2.includes("node_modules");
@@ -1229,7 +1243,7 @@ async function getLatestCliVersion(currentVersion) {
     if (versionCheckCache && Date.now() - versionCheckCache.timestamp < CACHE_DURATION) {
       return versionCheckCache.latestVersion;
     }
-    const { stdout } = await execa5("npm", ["view", "@elizaos/cli", "time", "--json"]);
+    const { stdout } = await bunExecSimple("npm", ["view", "@elizaos/cli", "time", "--json"]);
     const timeData = JSON.parse(stdout);
     delete timeData.created;
     delete timeData.modified;
@@ -2377,11 +2391,11 @@ async function getPackageInfo() {
 }
 
 // src/utils/github.ts
+var import_execa3 = __toESM(require_execa(), 1);
 import { promises as fs8 } from "fs";
 import path10 from "path";
 import { logger as logger10 } from "@elizaos/core";
 import { existsSync as existsSync9 } from "fs";
-import { execa as execa6 } from "execa";
 import * as clack4 from "@clack/prompts";
 var GITHUB_API_URL = "https://api.github.com";
 async function validateGitHubToken(token) {
@@ -2757,7 +2771,7 @@ async function getGitHubCredentials() {
     }
     logger10.warn("Invalid GitHub token found in environment variables");
   }
-  const { getGitHubToken: getGitHubToken2 } = await import("./registry-3LKJUU3X.js");
+  const { getGitHubToken: getGitHubToken2 } = await import("./registry-WOGFPQNY.js");
   const token = await getGitHubToken2() || void 0;
   if (token) {
     const isValid2 = await validateGitHubToken(token);
@@ -2976,7 +2990,7 @@ async function pushToGitHub(cwd, repoUrl, branch = "main") {
     let hasCorrectRemote = false;
     if (gitDirExists) {
       try {
-        const { stdout: remoteUrl } = await execa6("git", ["remote", "get-url", "origin"], { cwd });
+        const { stdout: remoteUrl } = await (0, import_execa3.execa)("git", ["remote", "get-url", "origin"], { cwd });
         const sanitizedRepoUrl = repoUrl.replace(/https:\/\/.*?@/, "https://");
         const sanitizedRemoteUrl = remoteUrl.replace(/https:\/\/.*?@/, "https://");
         hasCorrectRemote = sanitizedRemoteUrl.includes(
@@ -2989,39 +3003,39 @@ async function pushToGitHub(cwd, repoUrl, branch = "main") {
     if (!gitDirExists || !hasCorrectRemote) {
       if (gitDirExists) {
         logger10.info("Existing git repository has incorrect remote, reinitializing...");
-        await execa6("rm", ["-rf", ".git"], { cwd });
+        await (0, import_execa3.execa)("rm", ["-rf", ".git"], { cwd });
       }
-      await execa6("git", ["init"], { cwd });
-      await execa6("git", ["checkout", "-b", "main"], { cwd });
+      await (0, import_execa3.execa)("git", ["init"], { cwd });
+      await (0, import_execa3.execa)("git", ["checkout", "-b", "main"], { cwd });
       logger10.info("Git repository initialized with main branch");
-      await execa6("git", ["remote", "add", "origin", repoUrl], { cwd });
+      await (0, import_execa3.execa)("git", ["remote", "add", "origin", repoUrl], { cwd });
       logger10.info(`Added remote: ${repoUrl.replace(/\/\/.*?@/, "//***@")}`);
     } else {
       try {
-        await execa6("git", ["rev-parse", "--verify", branch], { cwd });
-        await execa6("git", ["checkout", branch], { cwd });
+        await (0, import_execa3.execa)("git", ["rev-parse", "--verify", branch], { cwd });
+        await (0, import_execa3.execa)("git", ["checkout", branch], { cwd });
       } catch (error) {
-        await execa6("git", ["checkout", "-b", branch], { cwd });
+        await (0, import_execa3.execa)("git", ["checkout", "-b", branch], { cwd });
         logger10.info(`Created and switched to ${branch} branch`);
       }
     }
-    await execa6("git", ["add", "."], { cwd });
+    await (0, import_execa3.execa)("git", ["add", "."], { cwd });
     logger10.info("Added files to git");
     try {
-      await execa6("git", ["config", "user.email"], { cwd });
+      await (0, import_execa3.execa)("git", ["config", "user.email"], { cwd });
     } catch (error) {
-      await execa6("git", ["config", "user.email", "plugindev@elizaos.com"], { cwd });
-      await execa6("git", ["config", "user.name", "ElizaOS Plugin Dev"], { cwd });
+      await (0, import_execa3.execa)("git", ["config", "user.email", "plugindev@elizaos.com"], { cwd });
+      await (0, import_execa3.execa)("git", ["config", "user.name", "ElizaOS Plugin Dev"], { cwd });
       logger10.info("Set git user info for commit");
     }
     try {
-      await execa6("git", ["commit", "-m", "Initial commit from ElizaOS CLI"], { cwd });
+      await (0, import_execa3.execa)("git", ["commit", "-m", "Initial commit from ElizaOS CLI"], { cwd });
       logger10.info("Committed changes");
     } catch (error) {
       logger10.info("No changes to commit");
     }
     try {
-      await execa6("git", ["push", "-u", "origin", branch], { cwd });
+      await (0, import_execa3.execa)("git", ["push", "-u", "origin", branch], { cwd });
       logger10.success(`Pushed to GitHub repository: ${repoUrl}`);
       return true;
     } catch (error) {
@@ -3030,7 +3044,7 @@ async function pushToGitHub(cwd, repoUrl, branch = "main") {
       );
       try {
         logger10.info("Attempting force push...");
-        await execa6("git", ["push", "-u", "origin", "main", "--force-with-lease"], {
+        await (0, import_execa3.execa)("git", ["push", "-u", "origin", "main", "--force-with-lease"], {
           cwd,
           stdio: "pipe"
         });
@@ -3919,7 +3933,6 @@ async function loadPluginModule(repository) {
 import { logger as logger16 } from "@elizaos/core";
 import { existsSync as existsSync13 } from "fs";
 import path16 from "path";
-import { execa as execa7 } from "execa";
 async function getPackageManager() {
   logger16.debug("[PackageManager] Using bun as the package manager for ElizaOS CLI");
   return "bun";
@@ -3946,18 +3959,22 @@ async function removeFromBunLock(packageName, directory) {
     return;
   }
   try {
-    await execa7("bun", ["remove", packageName], {
-      cwd: directory,
-      stdio: "pipe"
-      // Don't show output for cleanup operation
+    const result = await bunExec("bun", ["remove", packageName], {
+      cwd: directory
     });
-    logger16.debug(`Successfully removed ${packageName} from bun.lock`);
-  } catch (error) {
-    if (error.message?.includes("not found") || error.message?.includes("No such package")) {
-      logger16.debug(`Package ${packageName} not found in lockfile (expected for cleanup)`);
+    if (result.success) {
+      logger16.debug(`Successfully removed ${packageName} from bun.lock`);
     } else {
-      logger16.warn(`Failed to remove ${packageName} from bun.lock: ${error.message}`);
+      if (result.stderr?.includes("not found") || result.stderr?.includes("No such package")) {
+        logger16.debug(`Package ${packageName} not found in lockfile (expected for cleanup)`);
+      } else {
+        logger16.warn(
+          `Failed to remove ${packageName} from bun.lock: ${result.stderr || "Unknown error"}`
+        );
+      }
     }
+  } catch (error) {
+    logger16.warn(`Unexpected error removing ${packageName} from bun.lock: ${error.message}`);
   }
 }
 async function executeInstallation(packageName, versionOrTag = "", directory = process.cwd()) {
@@ -4193,16 +4210,16 @@ async function findNextAvailablePort(startPort) {
 }
 
 // src/utils/publisher.ts
-import { execa as execa8 } from "execa";
+var import_execa4 = __toESM(require_execa(), 1);
 import { logger as logger19 } from "@elizaos/core";
 async function testPublishToNpm(cwd) {
   try {
-    await execa8("npm", ["whoami"]);
+    await (0, import_execa4.execa)("npm", ["whoami"]);
     logger19.info("[\u2713] Logged in to npm");
     logger19.info("Testing build...");
-    await execa8("npm", ["run", "build", "--dry-run"], { cwd });
+    await (0, import_execa4.execa)("npm", ["run", "build", "--dry-run"], { cwd });
     logger19.info("[\u2713] Build test successful");
-    await execa8("npm", ["access", "ls-packages"], { cwd });
+    await (0, import_execa4.execa)("npm", ["access", "ls-packages"], { cwd });
     logger19.info("[\u2713] Have publish permissions");
     return true;
   } catch (error) {
@@ -4297,11 +4314,11 @@ async function testPublishToGitHub(packageJson, username) {
 }
 async function publishToNpm(cwd) {
   try {
-    await execa8("npm", ["whoami"]);
+    await (0, import_execa4.execa)("npm", ["whoami"]);
     logger19.info("Building package...");
-    await execa8("npm", ["run", "build"], { cwd, stdio: "inherit" });
+    await (0, import_execa4.execa)("npm", ["run", "build"], { cwd, stdio: "inherit" });
     logger19.info("Publishing to npm...");
-    await execa8("npm", ["publish"], { cwd, stdio: "inherit" });
+    await (0, import_execa4.execa)("npm", ["publish"], { cwd, stdio: "inherit" });
     return true;
   } catch (error) {
     logger19.error("Failed to publish to npm:", error);
@@ -4807,9 +4824,9 @@ Test Summary: ${this.stats.passed} passed, ${this.stats.failed} failed, ${this.s
 };
 
 // src/utils/registry/index.ts
+var import_execa5 = __toESM(require_execa(), 1);
 import { logger as logger21 } from "@elizaos/core";
 import dotenv3 from "dotenv";
-import { execa as execa9 } from "execa";
 import { HttpsProxyAgent } from "https-proxy-agent";
 import { existsSync as existsSync16, promises as fs10 } from "fs";
 import path19 from "path";
@@ -5102,7 +5119,7 @@ async function getPluginRepository(pluginName) {
 }
 async function repoHasBranch(repoUrl, branchName) {
   try {
-    const { stdout } = await execa9("git", ["ls-remote", "--heads", repoUrl, branchName]);
+    const { stdout } = await (0, import_execa5.execa)("git", ["ls-remote", "--heads", repoUrl, branchName]);
     return stdout.includes(branchName);
   } catch (error) {
     logger21.warn(

package/dist/commands/agent/actions/index.js

@@ -9,10 +9,10 @@ import {
   setAgentConfig,
   startAgent,
   stopAgent
-} from "../../../chunk-RXPGZT6Z.js";
-import "../../../chunk-7PPBVSWE.js";
+} from "../../../chunk-YKFBLIQD.js";
+import "../../../chunk-GRPGGUED.js";
 import "../../../chunk-F24MS2YR.js";
-import "../../../chunk-AQ6OMR2A.js";
+import "../../../chunk-XB5JBFO6.js";
 export {
   clearAgentMemories,
   getAgent,