@elizaos/cli 1.2.4 → 1.2.7

package/dist/index.js

@@ -5,11 +5,10 @@ const require = createRequire(import.meta.url);
 
 import {
   create
-} from "./chunk-JZG5QBNT.js";
+} from "./chunk-E54G6FI7.js";
 import {
   getElizaCharacter
-} from "./chunk-2XI6N7KN.js";
-import "./chunk-ZWDXDKSA.js";
+} from "./chunk-2ZF5OAMV.js";
 import {
   TestRunner,
   UserEnvironment,
@@ -46,29 +45,19 @@ import {
   testPublishToGitHub,
   testPublishToNpm,
   validateDataDir
-} from "./chunk-PSSTO76B.js";
+} from "./chunk-KKAK7OQA.js";
 import {
-  bunExec,
-  bunExecInherit,
-  bunExecSimple,
   configureEmojis,
   emoji,
-  require_execa,
   runBunCommand
-} from "./chunk-5DYKNYEY.js";
+} from "./chunk-Y5IA2UZ2.js";
 import "./chunk-F24MS2YR.js";
 import {
-  __toESM
-} from "./chunk-XB5JBFO6.js";
-
-// src/utils/port-validation.ts
-function validatePort(value) {
-  const port = Number.parseInt(value, 10);
-  if (Number.isNaN(port) || port <= 0 || port > 65535) {
-    throw new Error("Port must be a number between 1 and 65535");
-  }
-  return port;
-}
+  bunExec,
+  bunExecInherit,
+  bunExecSimple
+} from "./chunk-3YTIOEFK.js";
+import "./chunk-AQ6OMR2A.js";
 
 // src/commands/dev/index.ts
 import { Command, Option } from "commander";
@@ -266,6 +255,7 @@ var DevServerManager = class {
   process = null;
   /**
    * Stops the currently running server process
+   * @returns true if a server was stopped, false if no server was running
    */
   async stop() {
     if (this.process) {
@@ -277,7 +267,9 @@ var DevServerManager = class {
       }
       this.process = null;
       await new Promise((resolve2) => setTimeout(resolve2, 500));
+      return true;
     }
+    return false;
   }
   /**
    * Starts the server process with the given arguments
@@ -326,8 +318,13 @@ function getServerManager() {
   }
   return serverInstance;
 }
+async function stopServer() {
+  const server = getServerManager();
+  return await server.stop();
+}
 
 // src/commands/dev/actions/dev-server.ts
+import { logger } from "@elizaos/core";
 async function startDevMode(options) {
   const cwd = process.cwd();
   const context = createDevContext(cwd);
@@ -348,9 +345,28 @@ async function startDevMode(options) {
     );
   }
   const cliArgs = [];
-  if (options.port) {
-    cliArgs.push("--port", options.port.toString());
+  let desiredPort;
+  if (options.port !== void 0) {
+    desiredPort = options.port;
+  } else {
+    const serverPort = process.env.SERVER_PORT;
+    const parsedPort = serverPort ? Number.parseInt(serverPort, 10) : NaN;
+    desiredPort = Number.isNaN(parsedPort) ? 3e3 : parsedPort;
+  }
+  let availablePort;
+  try {
+    availablePort = await findNextAvailablePort(desiredPort);
+    if (availablePort !== desiredPort) {
+      logger.warn(`Port ${desiredPort} is in use, using port ${availablePort} instead`);
+    }
+  } catch (error) {
+    logger.error(
+      `Failed to find available port starting from ${desiredPort}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    logger.error("Please specify a different port using --port option");
+    throw new Error(`No available ports found starting from ${desiredPort}`);
   }
+  cliArgs.push("--port", availablePort.toString());
   if (options.configure) {
     cliArgs.push("--configure");
   }
@@ -397,7 +413,13 @@ async function startDevMode(options) {
 var dev = new Command().name("dev").description(
   "Start the project or plugin in development mode with auto-rebuild, detailed logging, and file change detection"
 ).option("-c, --configure", "Reconfigure services and AI models (skips using saved configuration)").option("--character [paths...]", "Character file(s) to use - accepts paths or URLs").option("-b, --build", "Build the project before starting").addOption(
-  new Option("-p, --port <port>", "Port to listen on (default: 3000)").argParser(validatePort)
+  new Option("-p, --port <port>", "Port to listen on (default: 3000)").argParser((value) => {
+    const port = Number.parseInt(value, 10);
+    if (Number.isNaN(port) || port < 0 || port > 65535) {
+      throw new Error("Port must be a number between 0 and 65535");
+    }
+    return port;
+  })
 ).action(async (options) => {
   try {
     await startDevMode(options);
@@ -940,7 +962,7 @@ env.action(() => {
 import { Command as Command3 } from "commander";
 
 // src/commands/plugins/actions/install.ts
-import { logger as logger3 } from "@elizaos/core";
+import { logger as logger4 } from "@elizaos/core";
 
 // src/commands/plugins/utils/naming.ts
 var findPluginPackageName = (pluginInput, allDependencies) => {
@@ -982,7 +1004,7 @@ var extractPackageName = (pluginInput) => {
 };
 
 // src/commands/plugins/utils/env-vars.ts
-import { logger } from "@elizaos/core";
+import { logger as logger2 } from "@elizaos/core";
 import { existsSync as existsSync8, readFileSync, readdirSync as readdirSync2 } from "fs";
 import path7 from "path";
 import * as clack4 from "@clack/prompts";
@@ -1017,7 +1039,7 @@ var extractPluginEnvRequirements = async (packageName, cwd) => {
     for (const possiblePath of possiblePaths) {
       if (existsSync8(possiblePath)) {
         packageJsonPath = possiblePath;
-        logger.debug(`Found plugin package.json at: ${packageJsonPath}`);
+        logger2.debug(`Found plugin package.json at: ${packageJsonPath}`);
         break;
       }
     }
@@ -1030,7 +1052,7 @@ var extractPluginEnvRequirements = async (packageName, cwd) => {
             const pkgJsonPath = path7.join(nodeModulesPath, pkg, "package.json");
             if (existsSync8(pkgJsonPath)) {
               packageJsonPath = pkgJsonPath;
-              logger.debug(`Found matching plugin package.json at: ${packageJsonPath}`);
+              logger2.debug(`Found matching plugin package.json at: ${packageJsonPath}`);
               break;
             }
           }
@@ -1038,23 +1060,23 @@ var extractPluginEnvRequirements = async (packageName, cwd) => {
       }
     }
     if (!packageJsonPath) {
-      logger.debug(`Plugin package.json not found for: ${packageName}`);
-      logger.debug(`Searched paths: ${possiblePaths.join(", ")}`);
+      logger2.debug(`Plugin package.json not found for: ${packageName}`);
+      logger2.debug(`Searched paths: ${possiblePaths.join(", ")}`);
       return {};
     }
     const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     const agentConfig = packageJson.agentConfig;
     if (!agentConfig || !agentConfig.pluginParameters) {
-      logger.debug(`No agentConfig.pluginParameters found in ${packageName} at ${packageJsonPath}`);
+      logger2.debug(`No agentConfig.pluginParameters found in ${packageName} at ${packageJsonPath}`);
       return {};
     }
-    logger.debug(
+    logger2.debug(
       `Found environment variables for ${packageName}: ${Object.keys(agentConfig.pluginParameters).join(", ")}`
     );
     return agentConfig.pluginParameters;
   } catch (error) {
-    logger.debug(
+    logger2.debug(
       `Error reading plugin package.json for ${packageName}: ${error instanceof Error ? error.message : String(error)}`
     );
     return {};
@@ -1281,10 +1303,10 @@ var promptForPluginEnvVars = async (packageName, cwd) => {
       }
     }
     if (packageFound) {
-      logger.debug(`Package ${packageName} found but has no environment variables defined`);
+      logger2.debug(`Package ${packageName} found but has no environment variables defined`);
       clack4.log.success(`No environment variables required for ${packageName}`);
     } else {
-      logger.debug(`Package ${packageName} not found in node_modules`);
+      logger2.debug(`Package ${packageName} not found in node_modules`);
       clack4.log.warn(
         `Could not find ${packageName} in node_modules. Environment variables may need to be configured manually.`
       );
@@ -1425,7 +1447,7 @@ Restart your application after adding the variables.`
 };
 
 // src/commands/plugins/utils/directory.ts
-import { logger as logger2 } from "@elizaos/core";
+import { logger as logger3 } from "@elizaos/core";
 import { readFileSync as readFileSync2 } from "fs";
 import path8 from "path";
 var getDependenciesFromDirectory = (cwd) => {
@@ -1442,9 +1464,9 @@ var getDependenciesFromDirectory = (cwd) => {
     return { ...dependencies, ...devDependencies };
   } catch (error) {
     if (error instanceof SyntaxError) {
-      logger2.warn(`Could not parse package.json: ${error.message}`);
+      logger3.warn(`Could not parse package.json: ${error.message}`);
     } else {
-      logger2.warn(
+      logger3.warn(
         `Error reading package.json: ${error instanceof Error ? error.message : String(error)}`
       );
     }
@@ -1479,7 +1501,7 @@ async function installPluginFromGitHub(plugin, cwd, opts) {
   const pluginNameForPostInstall = repo;
   const success = await installPlugin(githubSpecifier, cwd, void 0, opts.skipVerification);
   if (success) {
-    logger3.info(`Successfully installed ${pluginNameForPostInstall} from ${githubSpecifier}.`);
+    logger4.info(`Successfully installed ${pluginNameForPostInstall} from ${githubSpecifier}.`);
     const packageName = extractPackageName(plugin);
     if (!opts.skipEnvPrompt) {
       await new Promise((resolve2) => setTimeout(resolve2, 500));
@@ -1488,7 +1510,7 @@ async function installPluginFromGitHub(plugin, cwd, opts) {
       try {
         await promptForPluginEnvVars(packageName, cwd);
       } catch (error) {
-        logger3.warn(
+        logger4.warn(
           `Warning: Could not prompt for environment variables: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -1499,14 +1521,14 @@ async function installPluginFromGitHub(plugin, cwd, opts) {
     showInstallationSuccess(packageName);
     process.exit(0);
   } else {
-    logger3.error(`Failed to install plugin from ${githubSpecifier}.`);
+    logger4.error(`Failed to install plugin from ${githubSpecifier}.`);
     process.exit(1);
   }
 }
 async function installPluginFromRegistry(plugin, cwd, opts) {
   const cachedRegistry = await fetchPluginRegistry();
   if (!cachedRegistry || !cachedRegistry.registry) {
-    logger3.error('Plugin registry cache not found. Please run "elizaos plugins update" first.');
+    logger4.error('Plugin registry cache not found. Please run "elizaos plugins update" first.');
     process.exit(1);
   }
   const possibleNames = normalizePluginName(plugin);
@@ -1529,7 +1551,7 @@ async function installPluginFromRegistry(plugin, cwd, opts) {
       try {
         await promptForPluginEnvVars(actualPackageName, cwd);
       } catch (error) {
-        logger3.warn(
+        logger4.warn(
           `Warning: Could not prompt for environment variables: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -1545,8 +1567,8 @@ async function installPluginFromRegistry(plugin, cwd, opts) {
 }
 async function addPlugin(pluginArg, opts) {
   if (!pluginArg || !pluginArg.trim()) {
-    logger3.error("Plugin name cannot be empty or whitespace-only.");
-    logger3.info(
+    logger4.error("Plugin name cannot be empty or whitespace-only.");
+    logger4.info(
       'Please provide a valid plugin name (e.g., "openai", "plugin-anthropic", "@elizaos/plugin-sql")'
     );
     process.exit(1);
@@ -1554,14 +1576,14 @@ async function addPlugin(pluginArg, opts) {
   const cwd = process.cwd();
   const directoryInfo = detectDirectoryType(cwd);
   if (!directoryInfo || !directoryInfo.hasPackageJson) {
-    logger3.error(
+    logger4.error(
       `Command must be run inside an ElizaOS project directory. This directory is: ${directoryInfo?.type || "invalid or inaccessible"}`
     );
     process.exit(1);
   }
   const allDependencies = getDependenciesFromDirectory(cwd);
   if (!allDependencies) {
-    logger3.error("Could not read dependencies from package.json");
+    logger4.error("Could not read dependencies from package.json");
     process.exit(1);
   }
   let plugin = pluginArg;
@@ -1576,7 +1598,7 @@ async function addPlugin(pluginArg, opts) {
   }
   const installedPluginName = findPluginPackageName(plugin, allDependencies);
   if (installedPluginName) {
-    logger3.info(`Plugin "${installedPluginName}" is already added to this project.`);
+    logger4.info(`Plugin "${installedPluginName}" is already added to this project.`);
     process.exit(0);
   }
   const githubRegex = /^(?:github:)?([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)(?:#([a-zA-Z0-9_.-]+))?$/;
@@ -1588,7 +1610,7 @@ async function addPlugin(pluginArg, opts) {
 }
 
 // src/commands/plugins/actions/remove.ts
-import { logger as logger4 } from "@elizaos/core";
+import { logger as logger5 } from "@elizaos/core";
 import { existsSync as existsSync9, rmSync } from "fs";
 import path9 from "path";
 async function removePlugin(plugin) {
@@ -1609,7 +1631,7 @@ async function removePlugin(plugin) {
   }
   const packageNameToRemove = findPluginPackageName(plugin, allDependencies);
   if (!packageNameToRemove) {
-    logger4.warn(`Plugin matching "${plugin}" not found in project dependencies.`);
+    logger5.warn(`Plugin matching "${plugin}" not found in project dependencies.`);
     console.info("\nCheck installed plugins using: elizaos plugins installed-plugins");
     process.exit(0);
   }
@@ -1619,11 +1641,11 @@ async function removePlugin(plugin) {
       cwd
     });
   } catch (execError) {
-    logger4.error(
+    logger5.error(
       `Failed to run 'bun remove ${packageNameToRemove}': ${execError instanceof Error ? execError.message : String(execError)}`
     );
     if (execError && typeof execError === "object" && "stderr" in execError && typeof execError.stderr === "string" && execError.stderr.includes("not found")) {
-      logger4.info(
+      logger5.info(
         `'bun remove' indicated package was not found. Continuing with directory removal attempt.`
       );
     } else {
@@ -1643,7 +1665,7 @@ async function removePlugin(plugin) {
     try {
       rmSync(pluginDir, { recursive: true, force: true });
     } catch (rmError) {
-      logger4.error(
+      logger5.error(
         `Failed to remove directory ${pluginDir}: ${rmError instanceof Error ? rmError.message : String(rmError)}`
       );
     }
@@ -1653,7 +1675,7 @@ async function removePlugin(plugin) {
       try {
         rmSync(nonPrefixedDir, { recursive: true, force: true });
       } catch (rmError) {
-        logger4.error(
+        logger5.error(
           `Failed to remove directory ${nonPrefixedDir}: ${rmError instanceof Error ? rmError.message : String(rmError)}`
         );
       }
@@ -1663,11 +1685,11 @@ async function removePlugin(plugin) {
 }
 
 // src/commands/plugins/actions/list.ts
-import { logger as logger5 } from "@elizaos/core";
+import { logger as logger6 } from "@elizaos/core";
 async function listAvailablePlugins(opts) {
   const cachedRegistry = await fetchPluginRegistry();
   if (!cachedRegistry || !cachedRegistry.registry || Object.keys(cachedRegistry.registry).length === 0) {
-    logger5.info("Plugin cache is empty or not found.");
+    logger6.info("Plugin cache is empty or not found.");
     console.log('\nPlease run "elizaos plugins update" to fetch the latest plugin registry.');
     return;
   }
@@ -1745,7 +1767,7 @@ async function listInstalledPlugins() {
 }
 
 // src/commands/plugins/actions/upgrade.ts
-import { logger as logger8 } from "@elizaos/core";
+import { logger as logger9 } from "@elizaos/core";
 import path11 from "path";
 import { existsSync as existsSync11 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -1759,7 +1781,7 @@ import { EventEmitter } from "events";
 import { existsSync as existsSync10, readFileSync as readFileSync3 } from "fs";
 import path10 from "path";
 import { fileURLToPath } from "url";
-import { logger as logger6 } from "@elizaos/core";
+import { logger as logger7 } from "@elizaos/core";
 var MigrationGuideLoader = class {
   guides = [];
   guidesDir;
@@ -1909,7 +1931,7 @@ var MigrationGuideLoader = class {
       }
     ];
     if (!this.guidesDir || !existsSync10(this.guidesDir)) {
-      logger6.info("Using embedded migration guidance (external CLI mode)");
+      logger7.info("Using embedded migration guidance (external CLI mode)");
       this.createEmbeddedGuides(guideConfigs);
       return;
     }
@@ -1926,13 +1948,13 @@ var MigrationGuideLoader = class {
             keywords: config2.keywords
           });
         } catch (error) {
-          logger6.warn(`Failed to load migration guide: ${config2.name}`, error);
+          logger7.warn(`Failed to load migration guide: ${config2.name}`, error);
         }
       } else {
-        logger6.warn(`Migration guide not found: ${guidePath}`);
+        logger7.warn(`Migration guide not found: ${guidePath}`);
       }
     }
-    logger6.info(`Loaded ${this.guides.length} migration guides from ${this.guidesDir}`);
+    logger7.info(`Loaded ${this.guides.length} migration guides from ${this.guidesDir}`);
   }
   createEmbeddedGuides(guideConfigs) {
     const embeddedGuides = {
@@ -2180,7 +2202,7 @@ function createMigrationGuideLoader(projectRoot) {
 }
 
 // src/utils/upgrade/simple-migration-agent.ts
-import { logger as logger7 } from "@elizaos/core";
+import { logger as logger8 } from "@elizaos/core";
 var SimpleMigrationAgent = class extends EventEmitter {
   repoPath;
   abortController;
@@ -2203,10 +2225,10 @@ var SimpleMigrationAgent = class extends EventEmitter {
     try {
       this.guideLoader = createMigrationGuideLoader();
       if (this.verbose) {
-        logger7.info("Migration guide loader initialized successfully");
+        logger8.info("Migration guide loader initialized successfully");
       }
     } catch (error) {
-      logger7.warn("Failed to initialize migration guide loader", error);
+      logger8.warn("Failed to initialize migration guide loader", error);
       throw new Error("Cannot initialize migration system without guide access");
     }
   }
@@ -2751,13 +2773,13 @@ async function upgradePlugin(pluginPath, opts) {
       process.env.ANTHROPIC_API_KEY = opts.apiKey;
     }
     if (!process.env.ANTHROPIC_API_KEY) {
-      logger8.error("ANTHROPIC_API_KEY is required for plugin upgrade.");
+      logger9.error("ANTHROPIC_API_KEY is required for plugin upgrade.");
       console.log("\nPlease set ANTHROPIC_API_KEY environment variable or use --api-key option.");
       console.log("Get your API key from: https://console.anthropic.com/");
       process.exit(1);
     }
     if (!process.env.ANTHROPIC_API_KEY.startsWith("sk-ant-")) {
-      logger8.error("Invalid ANTHROPIC_API_KEY format.");
+      logger9.error("Invalid ANTHROPIC_API_KEY format.");
       console.log('\nThe API key should start with "sk-ant-"');
       console.log("Get your API key from: https://console.anthropic.com/");
       process.exit(1);
@@ -2928,17 +2950,17 @@ Error: ${error instanceof Error ? error.message : String(error)}`));
 }
 
 // src/commands/plugins/actions/generate.ts
-import { logger as logger9 } from "@elizaos/core";
+import { logger as logger10 } from "@elizaos/core";
 import { readFileSync as readFileSync4 } from "fs";
 import path12 from "path";
 async function generatePlugin(opts) {
   try {
-    const { PluginCreator } = await import("./plugin-creator-5CER524N.js");
+    const { PluginCreator } = await import("./plugin-creator-Y2NWASXI.js");
     if (opts.apiKey) {
       process.env.ANTHROPIC_API_KEY = opts.apiKey;
     }
     if (!process.env.ANTHROPIC_API_KEY) {
-      logger9.error("ANTHROPIC_API_KEY is required for plugin generation.");
+      logger10.error("ANTHROPIC_API_KEY is required for plugin generation.");
       console.log("\nPlease set ANTHROPIC_API_KEY environment variable or use --api-key option.");
       process.exit(1);
     }
@@ -2948,13 +2970,13 @@ async function generatePlugin(opts) {
         const specContent = readFileSync4(opts.specFile, "utf-8");
         spec = JSON.parse(specContent);
       } catch (error) {
-        logger9.error(
+        logger10.error(
           `Failed to read or parse spec file: ${error instanceof Error ? error.message : String(error)}`
         );
         process.exit(1);
       }
     } else if (opts.skipPrompts) {
-      logger9.error("--skip-prompts requires --spec-file to be provided");
+      logger10.error("--skip-prompts requires --spec-file to be provided");
       process.exit(1);
     }
     const creator = new PluginCreator({
@@ -2981,7 +3003,7 @@ Next steps:`);
       console.log(`3. Test the plugin: bun test`);
       console.log(`4. Add to your ElizaOS project`);
     } else {
-      logger9.error(`Plugin generation failed: ${result.error?.message}`);
+      logger10.error(`Plugin generation failed: ${result.error?.message}`);
       process.exit(1);
     }
   } catch (error) {
@@ -3344,16 +3366,14 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 import * as clack9 from "@clack/prompts";
 
 // src/commands/update/index.ts
-import { logger as logger13 } from "@elizaos/core";
+import { logger as logger14 } from "@elizaos/core";
 import { Command as Command4 } from "commander";
 
 // src/commands/update/actions/cli-update.ts
-var import_execa2 = __toESM(require_execa(), 1);
-import { logger as logger11 } from "@elizaos/core";
+import { logger as logger12 } from "@elizaos/core";
 
 // src/commands/update/utils/version-utils.ts
-var import_execa = __toESM(require_execa(), 1);
-import { logger as logger10 } from "@elizaos/core";
+import { logger as logger11 } from "@elizaos/core";
 import * as semver from "semver";
 var SPECIAL_VERSION_TAGS = ["latest", "next", "canary", "rc", "dev", "nightly", "alpha"];
 var ELIZAOS_ORG = "@elizaos";
@@ -3363,7 +3383,7 @@ async function getVersion2() {
     const envInfo = await UserEnvironment.getInstance().getInfo();
     return envInfo.cli.version;
   } catch (error) {
-    logger10.error("Error getting CLI version:", error);
+    logger11.error("Error getting CLI version:", error);
     return FALLBACK_VERSION;
   }
 }
@@ -3399,14 +3419,14 @@ function isMajorUpdate(currentVersion, targetVersion) {
 }
 async function fetchLatestVersion(packageName) {
   try {
-    const { stdout } = await (0, import_execa.execa)("npm", ["view", packageName, "version"], {
+    const { stdout } = await bunExecSimple("npm", ["view", packageName, "version"], {
       env: { NODE_ENV: "production" }
     });
     const version = stdout.trim();
-    logger10.debug(`Latest version of ${packageName} from npm: ${version}`);
+    logger11.debug(`Latest version of ${packageName} from npm: ${version}`);
     return version;
   } catch (error) {
-    logger10.error(
+    logger11.error(
       `Failed to fetch version for ${packageName}: ${error instanceof Error ? error.message : String(error)}`
     );
     return null;
@@ -3437,21 +3457,19 @@ async function performCliUpdate(options = {}) {
     if (!options.skipBunMigration) {
       const npmInstallation = await isCliInstalledViaNpm();
       if (npmInstallation) {
-        logger11.info("Detected npm installation, migrating to bun...");
+        logger12.info("Detected npm installation, migrating to bun...");
         try {
           await migrateCliToBun(latestVersion);
           console.log(`CLI updated successfully to version ${latestVersion} [\u2713]`);
           return true;
         } catch (migrationError) {
-          logger11.warn("Migration to bun failed, falling back to npm update...");
-          logger11.debug(
+          logger12.warn("Migration to bun failed, falling back to npm update...");
+          logger12.debug(
             "Migration error:",
             migrationError instanceof Error ? migrationError.message : String(migrationError)
           );
           try {
-            await (0, import_execa2.execa)("npm", ["install", "-g", `@elizaos/cli@${latestVersion}`], {
-              stdio: "inherit"
-            });
+            await bunExecInherit("npm", ["install", "-g", `@elizaos/cli@${latestVersion}`]);
             console.log(`CLI updated successfully to version ${latestVersion} [\u2713]`);
             return true;
           } catch (npmError) {
@@ -3463,7 +3481,7 @@ async function performCliUpdate(options = {}) {
       }
     }
     try {
-      await (0, import_execa2.execa)("bun", ["add", "-g", `@elizaos/cli@${latestVersion}`], { stdio: "inherit" });
+      await bunExecInherit("bun", ["add", "-g", `@elizaos/cli@${latestVersion}`]);
       console.log(`CLI updated successfully to version ${latestVersion} [\u2713]`);
       return true;
     } catch (bunError) {
@@ -3471,7 +3489,7 @@ async function performCliUpdate(options = {}) {
       console.error("  curl -fsSL https://bun.sh/install | bash");
       console.error("  # or");
       console.error("  npm install -g bun");
-      logger11.debug("Bun error:", bunError instanceof Error ? bunError.message : String(bunError));
+      logger12.debug("Bun error:", bunError instanceof Error ? bunError.message : String(bunError));
       return false;
     }
   } catch (error) {
@@ -3486,9 +3504,8 @@ import { promises as fs6 } from "fs";
 import * as path16 from "path";
 
 // src/commands/update/utils/package-utils.ts
-var import_execa3 = __toESM(require_execa(), 1);
 import fs5 from "fs/promises";
-import { logger as logger12 } from "@elizaos/core";
+import { logger as logger13 } from "@elizaos/core";
 async function checkForUpdates(dependencies) {
   const updates = {};
   const elizaPackages = Object.entries(dependencies).filter(([pkg]) => pkg.startsWith(ELIZAOS_ORG)).filter(([, version]) => !isWorkspaceVersion(version));
@@ -3499,7 +3516,7 @@ async function checkForUpdates(dependencies) {
     if (needsUpdate) {
       updates[pkg] = { current: currentVersion, latest: latestVersion };
     } else if (error) {
-      logger12.debug(`${pkg}: ${error}`);
+      logger13.debug(`${pkg}: ${error}`);
     }
   }
   return { hasUpdates: Object.keys(updates).length > 0, updates };
@@ -3535,7 +3552,7 @@ async function installDependencies(cwd) {
   console.log("\nInstalling updated packages...");
   try {
     const packageManager = await getPackageManager();
-    await (0, import_execa3.execa)(packageManager, ["install"], { cwd, stdio: "inherit" });
+    await bunExecInherit(packageManager, ["install"], { cwd });
     console.log("Dependencies installed successfully [\u2713]");
   } catch (error) {
     throw new Error(
@@ -3616,9 +3633,9 @@ function handleInvalidDirectory(directoryInfo) {
 // src/commands/update/index.ts
 var update = new Command4().name("update").description("Update ElizaOS CLI and project dependencies").option("-c, --check", "Check for available updates without applying them").option("--skip-build", "Skip building after updating").option("--cli", "Update only the CLI").option("--packages", "Update only packages").hook("preAction", async () => {
   try {
-    await displayBanner();
+    await displayBanner(true);
   } catch {
-    logger13.debug("Banner display failed, continuing with update");
+    logger14.debug("Banner display failed, continuing with update");
   }
 }).action(async (options) => {
   try {
@@ -3633,9 +3650,7 @@ var update = new Command4().name("update").description("Update ElizaOS CLI and p
       if (isNpx || isBunx) {
         console.warn("CLI update is not available when running via npx or bunx.");
         console.info("Please install the CLI globally:");
-        console.info("  bun install -g @elizaos/cli");
-        console.info("  # or");
-        console.info("  npm install -g @elizaos/cli");
+        console.info(" bun install -g @elizaos/cli");
         if (!updatePackages) return;
       } else {
         const success = await performCliUpdate();
@@ -3652,7 +3667,7 @@ var update = new Command4().name("update").description("Update ElizaOS CLI and p
         console.info("To create a new ElizaOS project, use: elizaos create <project-name>");
         return;
       }
-      logger13.debug(`Detected ${directoryInfo.type}`);
+      logger14.debug(`Detected ${directoryInfo.type}`);
       if (!isInProject) {
         handleInvalidDirectory(directoryInfo);
         return;
@@ -4043,15 +4058,12 @@ var publish = new Command5().name("publish").description("Publish a plugin to np
 import { Command as Command6 } from "commander";
 
 // src/commands/monorepo/actions/clone.ts
-var import_execa4 = __toESM(require_execa(), 1);
 import { existsSync as existsSync12, readdirSync as readdirSync3, mkdirSync } from "fs";
 import path19 from "path";
 async function cloneRepository(repo, branch, destination) {
   try {
     const repoUrl = `https://github.com/${repo}`;
-    await (0, import_execa4.execa)("git", ["clone", "-b", branch, repoUrl, destination], {
-      stdio: "inherit"
-    });
+    await bunExecInherit("git", ["clone", "-b", branch, repoUrl, destination]);
   } catch (error) {
     if (error instanceof Error && error.message.includes("exit code 128")) {
       console.error(`
@@ -4170,12 +4182,9 @@ var monorepo = new Command6().name("monorepo").description("Clone ElizaOS monore
   }
 });
 
-// src/commands/start/index.ts
-import { loadCharacterTryPath as loadCharacterTryPath2 } from "@elizaos/server";
-
 // src/project.ts
 import {
-  logger as logger14
+  logger as logger15
 } from "@elizaos/core";
 import { stringToUuid } from "@elizaos/core";
 import * as fs9 from "fs";
@@ -4217,7 +4226,7 @@ async function loadProject(dir) {
     const packageJson = JSON.parse(fs9.readFileSync(path21.join(dir, "package.json"), "utf8"));
     const main2 = packageJson.main;
     if (!main2) {
-      logger14.warn("No main field found in package.json, using default character");
+      logger15.warn("No main field found in package.json, using default character");
       const defaultCharacterName = "Eliza (Default)";
       const elizaCharacter = getElizaCharacter();
       const defaultAgent = {
@@ -4227,7 +4236,7 @@ async function loadProject(dir) {
           name: defaultCharacterName
         },
         init: async () => {
-          logger14.info("Initializing default Eliza character");
+          logger15.info("Initializing default Eliza character");
         }
       };
       return {
@@ -4250,18 +4259,18 @@ async function loadProject(dir) {
           const importPath = path21.resolve(entryPoint);
           const importUrl = process.platform === "win32" ? "file:///" + importPath.replace(/\\/g, "/") : "file://" + importPath;
           projectModule = await import(importUrl);
-          logger14.info(`Loaded project from ${entryPoint}`);
+          logger15.info(`Loaded project from ${entryPoint}`);
           const exportKeys = Object.keys(projectModule);
-          logger14.debug(`Module exports: ${exportKeys.join(", ")}`);
+          logger15.debug(`Module exports: ${exportKeys.join(", ")}`);
           if (exportKeys.includes("default")) {
-            logger14.debug(`Default export type: ${typeof projectModule.default}`);
+            logger15.debug(`Default export type: ${typeof projectModule.default}`);
             if (typeof projectModule.default === "object" && projectModule.default !== null) {
-              logger14.debug(`Default export keys: ${Object.keys(projectModule.default).join(", ")}`);
+              logger15.debug(`Default export keys: ${Object.keys(projectModule.default).join(", ")}`);
             }
           }
           break;
         } catch (error) {
-          logger14.warn(`Failed to import project from ${entryPoint}:`, error);
+          logger15.warn(`Failed to import project from ${entryPoint}:`, error);
         }
       }
     }
@@ -4269,13 +4278,13 @@ async function loadProject(dir) {
       throw new Error("Could not find project entry point");
     }
     const moduleIsPlugin = isPlugin(projectModule);
-    logger14.debug(`Is this a plugin? ${moduleIsPlugin}`);
+    logger15.debug(`Is this a plugin? ${moduleIsPlugin}`);
     if (moduleIsPlugin) {
-      logger14.info("Detected plugin module instead of project");
+      logger15.info("Detected plugin module instead of project");
       try {
         const plugin = extractPlugin(projectModule);
-        logger14.debug(`Found plugin: ${plugin.name} - ${plugin.description}`);
-        logger14.debug(`Plugin has the following properties: ${Object.keys(plugin).join(", ")}`);
+        logger15.debug(`Found plugin: ${plugin.name} - ${plugin.description}`);
+        logger15.debug(`Plugin has the following properties: ${Object.keys(plugin).join(", ")}`);
         const completePlugin = {
           // Copy all other properties from the original plugin first
           ...plugin,
@@ -4283,7 +4292,7 @@ async function loadProject(dir) {
           name: plugin.name || "unknown-plugin",
           description: plugin.description || "No description",
           init: plugin.init || (async () => {
-            logger14.info(`Dummy init for plugin: ${plugin.name}`);
+            logger15.info(`Dummy init for plugin: ${plugin.name}`);
           })
         };
         const characterName = "Eliza (Test Mode)";
@@ -4294,13 +4303,13 @@ async function loadProject(dir) {
           name: characterName,
           system: `${elizaCharacter.system} Testing the plugin: ${completePlugin.name}.`
         };
-        logger14.info(`Using Eliza character as test agent for plugin: ${completePlugin.name}`);
+        logger15.info(`Using Eliza character as test agent for plugin: ${completePlugin.name}`);
         const testAgent = {
           character: testCharacter,
           plugins: [completePlugin],
           // Only include the plugin being tested
           init: async () => {
-            logger14.info(`Initializing Eliza test agent for plugin: ${completePlugin.name}`);
+            logger15.info(`Initializing Eliza test agent for plugin: ${completePlugin.name}`);
           }
         };
         return {
@@ -4310,24 +4319,24 @@ async function loadProject(dir) {
           pluginModule: completePlugin
         };
       } catch (error) {
-        logger14.error("Error extracting plugin from module:", error);
+        logger15.error("Error extracting plugin from module:", error);
         throw error;
       }
     }
     const agents = [];
     if (projectModule.default && typeof projectModule.default === "object" && Array.isArray(projectModule.default.agents)) {
       agents.push(...projectModule.default.agents);
-      logger14.debug(`Found ${agents.length} agents in default export's agents array`);
+      logger15.debug(`Found ${agents.length} agents in default export's agents array`);
     } else {
       for (const [key, value] of Object.entries(projectModule)) {
         if (key === "default" && value && typeof value === "object") {
           if (value.character && value.init) {
             agents.push(value);
-            logger14.debug(`Found agent in default export (single agent)`);
+            logger15.debug(`Found agent in default export (single agent)`);
           }
         } else if (value && typeof value === "object" && value.character && value.init) {
           agents.push(value);
-          logger14.debug(`Found agent in named export: ${key}`);
+          logger15.debug(`Found agent in named export: ${key}`);
         }
       }
     }
@@ -4340,24 +4349,36 @@ async function loadProject(dir) {
     };
     return project;
   } catch (error) {
-    logger14.error("Error loading project:", error);
+    logger15.error("Error loading project:", error);
     throw error;
   }
 }
 
+// src/utils/port-validation.ts
+function validatePort(value) {
+  const port = Number.parseInt(value, 10);
+  if (Number.isNaN(port) || port <= 0 || port > 65535) {
+    throw new Error("Port must be a number between 1 and 65535");
+  }
+  return port;
+}
+
 // src/commands/start/index.ts
-import { logger as logger19 } from "@elizaos/core";
+import { logger as logger20 } from "@elizaos/core";
+import { loadCharacterTryPath as loadCharacterTryPath2 } from "@elizaos/server";
 import { Command as Command7 } from "commander";
+import * as fs10 from "fs";
+import * as path23 from "path";
 
 // src/commands/start/actions/server-start.ts
 import { AgentServer, jsonToCharacter, loadCharacterTryPath } from "@elizaos/server";
-import { logger as logger18 } from "@elizaos/core";
+import { logger as logger19 } from "@elizaos/core";
 
 // src/commands/start/actions/agent-start.ts
 import {
   AgentRuntime as AgentRuntime2,
   encryptedCharacter,
-  logger as logger17,
+  logger as logger18,
   stringToUuid as stringToUuid2
 } from "@elizaos/core";
 import { plugin as sqlPlugin } from "@elizaos/plugin-sql";
@@ -4400,19 +4421,19 @@ async function setDefaultSecretsFromEnv(character) {
 }
 
 // src/commands/start/utils/dependency-resolver.ts
-import { logger as logger15 } from "@elizaos/core";
+import { logger as logger16 } from "@elizaos/core";
 function resolvePluginDependencies(availablePlugins, isTestMode = false) {
   const resolutionOrder = [];
   const visited = /* @__PURE__ */ new Set();
   const visiting = /* @__PURE__ */ new Set();
   function visit(pluginName) {
     if (!availablePlugins.has(pluginName)) {
-      logger15.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
+      logger16.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
       return;
     }
     if (visited.has(pluginName)) return;
     if (visiting.has(pluginName)) {
-      logger15.error(`Circular dependency detected involving plugin: ${pluginName}`);
+      logger16.error(`Circular dependency detected involving plugin: ${pluginName}`);
       return;
     }
     visiting.add(pluginName);
@@ -4436,12 +4457,12 @@ function resolvePluginDependencies(availablePlugins, isTestMode = false) {
     }
   }
   const finalPlugins = resolutionOrder.map((name) => availablePlugins.get(name)).filter((p) => p);
-  logger15.info(`Final plugins being loaded: ${finalPlugins.map((p) => p.name).join(", ")}`);
+  logger16.info(`Final plugins being loaded: ${finalPlugins.map((p) => p.name).join(", ")}`);
   return finalPlugins;
 }
 
 // src/commands/start/utils/plugin-utils.ts
-import { logger as logger16 } from "@elizaos/core";
+import { logger as logger17 } from "@elizaos/core";
 function isValidPluginShape(obj) {
   if (!obj || typeof obj !== "object" || !obj.name) {
     return false;
@@ -4456,12 +4477,12 @@ async function loadAndPreparePlugin(pluginName) {
     try {
       pluginModule = await loadPluginModule(pluginName);
       if (!pluginModule) {
-        logger16.error(`Failed to load local plugin ${pluginName}.`);
+        logger17.error(`Failed to load local plugin ${pluginName}.`);
         provideLocalPluginGuidance(pluginName, context);
         return null;
       }
     } catch (error) {
-      logger16.error(`Error loading local plugin ${pluginName}: ${error}`);
+      logger17.error(`Error loading local plugin ${pluginName}: ${error}`);
       provideLocalPluginGuidance(pluginName, context);
       return null;
     }
@@ -4469,17 +4490,17 @@ async function loadAndPreparePlugin(pluginName) {
     try {
       pluginModule = await loadPluginModule(pluginName);
       if (!pluginModule) {
-        logger16.info(`Plugin ${pluginName} not available, installing...`);
+        logger17.info(`Plugin ${pluginName} not available, installing...`);
         await installPlugin(pluginName, process.cwd(), version);
         pluginModule = await loadPluginModule(pluginName);
       }
     } catch (error) {
-      logger16.error(`Failed to process plugin ${pluginName}: ${error}`);
+      logger17.error(`Failed to process plugin ${pluginName}: ${error}`);
       return null;
     }
   }
   if (!pluginModule) {
-    logger16.error(`Failed to load module for plugin ${pluginName}.`);
+    logger17.error(`Failed to load module for plugin ${pluginName}.`);
     return null;
   }
   const expectedFunctionName = `${pluginName.replace(/^@elizaos\/plugin-/, "").replace(/^@elizaos\//, "").replace(/-./g, (match) => match[1].toUpperCase())}Plugin`;
@@ -4493,7 +4514,7 @@ async function loadAndPreparePlugin(pluginName) {
       return potentialPlugin;
     }
   }
-  logger16.warn(`Could not find a valid plugin export in ${pluginName}.`);
+  logger17.warn(`Could not find a valid plugin export in ${pluginName}.`);
   return null;
 }
 
@@ -4545,26 +4566,26 @@ async function startAgent(character, server, init, plugins2 = [], options = {})
   try {
     const migrationService = runtime.getService("database_migration");
     if (migrationService) {
-      logger17.info("Discovering plugin schemas for dynamic migration...");
+      logger18.info("Discovering plugin schemas for dynamic migration...");
       migrationService.discoverAndRegisterPluginSchemas(finalPlugins);
-      logger17.info("Running all plugin migrations...");
+      logger18.info("Running all plugin migrations...");
       await migrationService.runAllPluginMigrations();
-      logger17.info("All plugin migrations completed successfully");
+      logger18.info("All plugin migrations completed successfully");
     } else {
-      logger17.warn("DatabaseMigrationService not found - plugin schema migrations skipped");
+      logger18.warn("DatabaseMigrationService not found - plugin schema migrations skipped");
     }
   } catch (error) {
-    logger17.error("Failed to run plugin migrations:", error);
+    logger18.error("Failed to run plugin migrations:", error);
     throw error;
   }
   server.registerAgent(runtime);
-  logger17.log(`Started ${runtime.character.name} as ${runtime.agentId}`);
+  logger18.log(`Started ${runtime.character.name} as ${runtime.agentId}`);
   return runtime;
 }
 async function stopAgent(runtime, server) {
   await runtime.close();
   server.unregisterAgent(runtime.agentId);
-  logger17.success(`Agent ${runtime.character.name} stopped successfully!`);
+  logger18.success(`Agent ${runtime.character.name} stopped successfully!`);
 }
 
 // src/commands/start/actions/server-start.ts
@@ -4611,13 +4632,13 @@ async function startAgents(options) {
   const desiredPort = options.port || Number.parseInt(process.env.SERVER_PORT || "3000");
   const serverPort = await findNextAvailablePort(desiredPort);
   if (serverPort !== desiredPort) {
-    logger18.warn(`Port ${desiredPort} is in use, using port ${serverPort} instead`);
+    logger19.warn(`Port ${desiredPort} is in use, using port ${serverPort} instead`);
   }
   process.env.SERVER_PORT = serverPort.toString();
   try {
     await server.start(serverPort);
   } catch (error) {
-    logger18.error(`Failed to start server on port ${serverPort}:`, error);
+    logger19.error(`Failed to start server on port ${serverPort}:`, error);
     throw error;
   }
   if (options.projectAgents && options.projectAgents.length > 0) {
@@ -4640,57 +4661,68 @@ async function startAgents(options) {
 }
 
 // src/commands/start/index.ts
-import * as fs10 from "fs";
-import * as path23 from "path";
-var start = new Command7().name("start").description("Start the Eliza agent server").option("-c, --configure", "Reconfigure services and AI models").option("-p, --port <port>", "Port to listen on", validatePort).option("--character <paths...>", "Character file(s) to use").hook("preAction", async () => {
+var start = new Command7().name("start").description("Build and start the Eliza agent server").option("-c, --configure", "Reconfigure services and AI models").option("-p, --port <port>", "Port to listen on", validatePort).option("--character <paths...>", "Character file(s) to use").hook("preAction", async () => {
   await displayBanner();
 }).action(async (options) => {
   try {
     await loadEnvConfig();
+    const cwd = process.cwd();
+    const dirInfo = detectDirectoryType(cwd);
+    const isMonorepo = dirInfo.type === "elizaos-monorepo";
+    if (!isMonorepo && !process.env.ELIZA_TEST_MODE) {
+      try {
+        await buildProject(cwd, false);
+      } catch (error) {
+        logger20.error(`Build error: ${error instanceof Error ? error.message : String(error)}`);
+        logger20.warn(
+          "Build failed, but continuing with start. Some features may not work correctly."
+        );
+      }
+    }
     let characters = [];
     let projectAgents = [];
     if (options.character && options.character.length > 0) {
       for (const charPath of options.character) {
         const resolvedPath = path23.resolve(charPath);
         if (!fs10.existsSync(resolvedPath)) {
-          logger19.error(`Character file not found: ${resolvedPath}`);
+          logger20.error(`Character file not found: ${resolvedPath}`);
           throw new Error(`Character file not found: ${resolvedPath}`);
         }
         try {
           const character = await loadCharacterTryPath2(resolvedPath);
           if (character) {
             characters.push(character);
-            logger19.info(`Successfully loaded character: ${character.name}`);
+            logger20.info(`Successfully loaded character: ${character.name}`);
           } else {
-            logger19.error(
+            logger20.error(
               `Failed to load character from ${resolvedPath}: Invalid or empty character file`
             );
             throw new Error(`Invalid character file: ${resolvedPath}`);
           }
         } catch (e) {
-          logger19.error(`Failed to load character from ${resolvedPath}:`, e);
+          logger20.error(`Failed to load character from ${resolvedPath}:`, e);
           throw new Error(`Invalid character file: ${resolvedPath}`);
         }
       }
     } else {
       try {
-        const cwd = process.cwd();
-        const dirInfo = detectDirectoryType(cwd);
-        if (dirInfo.hasPackageJson && dirInfo.type !== "non-elizaos-dir") {
-          logger19.info("No character files specified, attempting to load project agents...");
-          const project = await loadProject(cwd);
+        const cwd2 = process.cwd();
+        const dirInfo2 = detectDirectoryType(cwd2);
+        if (dirInfo2.hasPackageJson && dirInfo2.type !== "non-elizaos-dir") {
+          logger20.info("No character files specified, attempting to load project agents...");
+          const project = await loadProject(cwd2);
           if (project.agents && project.agents.length > 0) {
-            logger19.info(`Found ${project.agents.length} agent(s) in project configuration`);
+            logger20.info(`Found ${project.agents.length} agent(s) in project configuration`);
             projectAgents = project.agents;
             for (const agent2 of project.agents) {
               if (agent2.character) {
-                logger19.info(`Loaded character: ${agent2.character.name}`);
+                logger20.info(`Loaded character: ${agent2.character.name}`);
               }
             }
           }
         }
       } catch (e) {
-        logger19.debug("Failed to load project agents, will use default character:", e);
+        logger20.debug("Failed to load project agents, will use default character:", e);
       }
     }
     await startAgents({ ...options, characters, projectAgents });
@@ -4769,14 +4801,14 @@ ${emoji.error("Error: Failed to run Phala CLI")}`);
 var teeCommand = new Command9("tee").description("Manage TEE deployments").addCommand(phalaCliCommand);
 
 // src/commands/test/index.ts
-import { logger as logger26 } from "@elizaos/core";
+import { logger as logger27 } from "@elizaos/core";
 import { Command as Command10, Option as Option2 } from "commander";
 
 // src/commands/test/actions/run-all-tests.ts
-import { logger as logger24 } from "@elizaos/core";
+import { logger as logger25 } from "@elizaos/core";
 
 // src/commands/test/utils/project-utils.ts
-import { logger as logger20 } from "@elizaos/core";
+import { logger as logger21 } from "@elizaos/core";
 import * as fs11 from "fs";
 import path24 from "path";
 function getProjectType(testPath) {
@@ -4813,7 +4845,7 @@ async function installPluginDependencies(projectInfo) {
       };
       await fs11.promises.writeFile(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
     }
-    const { installPlugin: installPlugin2 } = await import("./utils-DTW3XU6O.js");
+    const { installPlugin: installPlugin2 } = await import("./utils-QSRUVLAT.js");
     for (const dependency of project.pluginModule.dependencies) {
       await installPlugin2(dependency, pluginsDir);
       const dependencyPath = path24.join(pluginsDir, "node_modules", dependency);
@@ -4821,7 +4853,7 @@ async function installPluginDependencies(projectInfo) {
         try {
           await runBunCommand(["install"], dependencyPath);
         } catch (error) {
-          logger20.warn(
+          logger21.warn(
             `[Test Command] Failed to install devDependencies for ${dependency}: ${error}`
           );
         }
@@ -4831,12 +4863,12 @@ async function installPluginDependencies(projectInfo) {
 }
 
 // src/commands/test/actions/component-tests.ts
-import { logger as logger22 } from "@elizaos/core";
+import { logger as logger23 } from "@elizaos/core";
 import { spawn as spawn3 } from "child_process";
 import path26 from "path";
 
 // src/utils/testing/tsc-validator.ts
-import { logger as logger21 } from "@elizaos/core";
+import { logger as logger22 } from "@elizaos/core";
 import path25 from "path";
 import { existsSync as existsSync17 } from "fs";
 async function runTypeCheck(projectPath, strict = true) {
@@ -4864,7 +4896,7 @@ async function runTypeCheck(projectPath, strict = true) {
       warnings: stderr.includes("warning") ? [stderr] : []
     };
   } catch (error) {
-    logger21.error("TypeScript validation failed:", error);
+    logger22.error("TypeScript validation failed:", error);
     return {
       success: false,
       errors: [`TypeScript validation error: ${error.message}`],
@@ -4878,39 +4910,39 @@ async function runComponentTests(testPath, options, projectInfo) {
   const cwd = process.cwd();
   const isPlugin2 = projectInfo.type === "elizaos-plugin";
   if (!options.skipTypeCheck) {
-    logger22.info("Running TypeScript validation...");
+    logger23.info("Running TypeScript validation...");
     const typeCheckResult = await runTypeCheck(cwd, true);
     if (!typeCheckResult.success) {
-      logger22.error("TypeScript validation failed:");
-      typeCheckResult.errors.forEach((error) => logger22.error(error));
+      logger23.error("TypeScript validation failed:");
+      typeCheckResult.errors.forEach((error) => logger23.error(error));
       return { failed: true };
     }
-    logger22.success("TypeScript validation passed");
+    logger23.success("TypeScript validation passed");
   }
   if (!options.skipBuild) {
     try {
-      logger22.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
+      logger23.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
       await buildProject(cwd, isPlugin2);
-      logger22.success(`Build completed successfully`);
+      logger23.success(`Build completed successfully`);
     } catch (buildError) {
-      logger22.error(`Build failed: ${buildError}`);
+      logger23.error(`Build failed: ${buildError}`);
       return { failed: true };
     }
   }
-  logger22.info("Running component tests...");
+  logger23.info("Running component tests...");
   return new Promise((resolve2) => {
     const args = ["test", "--passWithNoTests"];
     if (options.name) {
       const baseName = processFilterName(options.name);
       if (baseName) {
-        logger22.info(`Using test filter: ${baseName}`);
+        logger23.info(`Using test filter: ${baseName}`);
         args.push("-t", baseName);
       }
     }
     const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
     const baseDir = monorepoRoot ?? process.cwd();
     const targetPath = testPath ? path26.resolve(baseDir, testPath) : process.cwd();
-    logger22.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
+    logger23.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
     const child = spawn3("bun", args, {
       stdio: "inherit",
       shell: false,
@@ -4924,11 +4956,11 @@ async function runComponentTests(testPath, options, projectInfo) {
       }
     });
     child.on("close", (code) => {
-      logger22.info("Component tests completed");
+      logger23.info("Component tests completed");
       resolve2({ failed: code !== 0 });
     });
     child.on("error", (error) => {
-      logger22.error("Error running component tests:", error);
+      logger23.error("Error running component tests:", error);
       resolve2({ failed: true });
     });
   });
@@ -4936,7 +4968,7 @@ async function runComponentTests(testPath, options, projectInfo) {
 
 // src/commands/test/actions/e2e-tests.ts
 import { AgentServer as AgentServer2, jsonToCharacter as jsonToCharacter2, loadCharacterTryPath as loadCharacterTryPath3 } from "@elizaos/server";
-import { logger as logger23 } from "@elizaos/core";
+import { logger as logger24 } from "@elizaos/core";
 import * as dotenv2 from "dotenv";
 import * as fs12 from "fs";
 import path27 from "path";
@@ -4945,12 +4977,12 @@ async function runE2eTests(testPath, options, projectInfo) {
     try {
       const cwd = process.cwd();
       const isPlugin2 = projectInfo.type === "elizaos-plugin";
-      logger23.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
+      logger24.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
       await buildProject(cwd, isPlugin2);
-      logger23.info(`Build completed successfully`);
+      logger24.info(`Build completed successfully`);
     } catch (buildError) {
-      logger23.error(`Build error: ${buildError}`);
-      logger23.warn(`Attempting to continue with tests despite build error`);
+      logger24.error(`Build error: ${buildError}`);
+      logger24.warn(`Attempting to continue with tests despite build error`);
     }
   }
   let server;
@@ -4984,33 +5016,33 @@ async function runE2eTests(testPath, options, projectInfo) {
     process.env.PGLITE_DATA_DIR = elizaDbDir;
     console.info(`Set PGLITE_DATA_DIR to: ${elizaDbDir}`);
     if (fs12.existsSync(envFilePath)) {
-      logger23.info(`Loading environment variables from: ${envFilePath}`);
+      logger24.info(`Loading environment variables from: ${envFilePath}`);
       dotenv2.config({ path: envFilePath });
-      logger23.info("Environment variables loaded");
+      logger24.info("Environment variables loaded");
     } else {
-      logger23.warn(`Environment file not found: ${envFilePath}`);
+      logger24.warn(`Environment file not found: ${envFilePath}`);
     }
     const postgresUrl = process.env.POSTGRES_URL;
-    logger23.info(
+    logger24.info(
       `PostgreSQL URL for e2e tests: ${postgresUrl ? "found" : "not found (will use PGlite)"}`
     );
-    logger23.info("Creating server instance...");
+    logger24.info("Creating server instance...");
     server = new AgentServer2();
-    logger23.info("Server instance created");
-    logger23.info("Initializing server...");
+    logger24.info("Server instance created");
+    logger24.info("Initializing server...");
     try {
       await server.initialize({
         dataDir: elizaDbDir,
         postgresUrl
       });
-      logger23.info("Server initialized successfully");
+      logger24.info("Server initialized successfully");
     } catch (initError) {
-      logger23.error("Server initialization failed:", initError);
+      logger24.error("Server initialization failed:", initError);
       throw initError;
     }
     let project;
     try {
-      logger23.info("Attempting to load project or plugin...");
+      logger24.info("Attempting to load project or plugin...");
       const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
       const baseDir = monorepoRoot ?? process.cwd();
       const targetPath = testPath ? path27.resolve(baseDir, testPath) : process.cwd();
@@ -5018,39 +5050,39 @@ async function runE2eTests(testPath, options, projectInfo) {
       if (!project || !project.agents || project.agents.length === 0) {
         throw new Error("No agents found in project configuration");
       }
-      logger23.info(`Found ${project.agents.length} agents`);
-      logger23.info("Setting up server properties...");
+      logger24.info(`Found ${project.agents.length} agents`);
+      logger24.info("Setting up server properties...");
       server.startAgent = async (character) => {
-        logger23.info(`Starting agent for character ${character.name}`);
+        logger24.info(`Starting agent for character ${character.name}`);
         return startAgent(character, server, void 0, [], { isTestMode: true });
       };
       server.loadCharacterTryPath = loadCharacterTryPath3;
       server.jsonToCharacter = jsonToCharacter2;
-      logger23.info("Server properties set up");
+      logger24.info("Server properties set up");
       const desiredPort = options.port || Number.parseInt(process.env.SERVER_PORT || "3000");
       const serverPort = await findNextAvailablePort(desiredPort);
       if (serverPort !== desiredPort) {
-        logger23.warn(`Port ${desiredPort} is in use for testing, using port ${serverPort} instead.`);
+        logger24.warn(`Port ${desiredPort} is in use for testing, using port ${serverPort} instead.`);
       }
-      logger23.info("Starting server...");
+      logger24.info("Starting server...");
       try {
         await server.start(serverPort);
-        logger23.info("Server started successfully on port", serverPort);
+        logger24.info("Server started successfully on port", serverPort);
       } catch (error) {
-        logger23.error("Error starting server:", error);
+        logger24.error("Error starting server:", error);
         if (error instanceof Error) {
-          logger23.error("Error details:", error.message);
-          logger23.error("Stack trace:", error.stack);
+          logger24.error("Error details:", error.message);
+          logger24.error("Stack trace:", error.stack);
         }
         throw error;
       }
       try {
-        logger23.info(
+        logger24.info(
           `Found ${project.agents.length} agents in ${project.isPlugin ? "plugin" : "project"}`
         );
         if (project.isPlugin || project.agents.length === 0) {
           process.env.ELIZA_TESTING_PLUGIN = "true";
-          logger23.info("Using default Eliza character as test agent");
+          logger24.info("Using default Eliza character as test agent");
           try {
             const pluginUnderTest = project.pluginModule;
             if (!pluginUnderTest) {
@@ -5073,16 +5105,16 @@ async function runE2eTests(testPath, options, projectInfo) {
               plugins: runtime.plugins
               // Pass all plugins, not just the one under test
             });
-            logger23.info("Default test agent started successfully");
+            logger24.info("Default test agent started successfully");
           } catch (pluginError) {
-            logger23.error(`Error starting plugin test agent: ${pluginError}`);
+            logger24.error(`Error starting plugin test agent: ${pluginError}`);
             throw pluginError;
           }
         } else {
           for (const agent2 of project.agents) {
             try {
               const originalCharacter = { ...agent2.character };
-              logger23.debug(`Starting agent: ${originalCharacter.name}`);
+              logger24.debug(`Starting agent: ${originalCharacter.name}`);
               const runtime = await startAgent(
                 originalCharacter,
                 server,
@@ -5095,28 +5127,28 @@ async function runE2eTests(testPath, options, projectInfo) {
               projectAgents.push(agent2);
               await new Promise((resolve2) => setTimeout(resolve2, 1e3));
             } catch (agentError) {
-              logger23.error(`Error starting agent ${agent2.character.name}:`, agentError);
+              logger24.error(`Error starting agent ${agent2.character.name}:`, agentError);
               if (agentError instanceof Error) {
-                logger23.error("Error details:", agentError.message);
-                logger23.error("Stack trace:", agentError.stack);
+                logger24.error("Error details:", agentError.message);
+                logger24.error("Stack trace:", agentError.stack);
               }
-              logger23.warn(`Skipping agent ${agent2.character.name} due to startup error`);
+              logger24.warn(`Skipping agent ${agent2.character.name} due to startup error`);
             }
           }
         }
         if (runtimes.length === 0) {
           throw new Error("Failed to start any agents from project");
         }
-        logger23.debug(`Successfully started ${runtimes.length} agents for testing`);
+        logger24.debug(`Successfully started ${runtimes.length} agents for testing`);
         let totalFailed = 0;
         let anyTestsFound = false;
         for (let i = 0; i < runtimes.length; i++) {
           const runtime = runtimes[i];
           const projectAgent = projectAgents[i];
           if (project.isPlugin) {
-            logger23.debug(`Running tests for plugin: ${project.pluginModule?.name}`);
+            logger24.debug(`Running tests for plugin: ${project.pluginModule?.name}`);
           } else {
-            logger23.debug(`Running tests for agent: ${runtime.character.name}`);
+            logger24.debug(`Running tests for agent: ${runtime.character.name}`);
           }
           const testRunner = new TestRunner(runtime, projectAgent);
           const currentDirInfo = projectInfo;
@@ -5137,17 +5169,17 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
         return { failed: anyTestsFound ? totalFailed > 0 : false };
       } catch (error) {
-        logger23.error("Error in runE2eTests:", error);
+        logger24.error("Error in runE2eTests:", error);
         if (error instanceof Error) {
-          logger23.error("Error details:", error.message);
-          logger23.error("Stack trace:", error.stack);
+          logger24.error("Error details:", error.message);
+          logger24.error("Stack trace:", error.stack);
         } else {
-          logger23.error("Unknown error type:", typeof error);
-          logger23.error("Error value:", error);
+          logger24.error("Unknown error type:", typeof error);
+          logger24.error("Error value:", error);
           try {
-            logger23.error("Stringified error:", JSON.stringify(error, null, 2));
+            logger24.error("Stringified error:", JSON.stringify(error, null, 2));
           } catch (e) {
-            logger23.error("Could not stringify error:", e);
+            logger24.error("Could not stringify error:", e);
           }
         }
         return { failed: true };
@@ -5170,33 +5202,33 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
       }
     } catch (error) {
-      logger23.error("Error in runE2eTests:", error);
+      logger24.error("Error in runE2eTests:", error);
       if (error instanceof Error) {
-        logger23.error("Error details:", error.message);
-        logger23.error("Stack trace:", error.stack);
+        logger24.error("Error details:", error.message);
+        logger24.error("Stack trace:", error.stack);
       } else {
-        logger23.error("Unknown error type:", typeof error);
-        logger23.error("Error value:", error);
+        logger24.error("Unknown error type:", typeof error);
+        logger24.error("Error value:", error);
         try {
-          logger23.error("Stringified error:", JSON.stringify(error, null, 2));
+          logger24.error("Stringified error:", JSON.stringify(error, null, 2));
         } catch (e) {
-          logger23.error("Could not stringify error:", e);
+          logger24.error("Could not stringify error:", e);
         }
       }
       return { failed: true };
     }
   } catch (error) {
-    logger23.error("Error in runE2eTests:", error);
+    logger24.error("Error in runE2eTests:", error);
     if (error instanceof Error) {
-      logger23.error("Error details:", error.message);
-      logger23.error("Stack trace:", error.stack);
+      logger24.error("Error details:", error.message);
+      logger24.error("Stack trace:", error.stack);
     } else {
-      logger23.error("Unknown error type:", typeof error);
-      logger23.error("Error value:", error);
+      logger24.error("Unknown error type:", typeof error);
+      logger24.error("Error value:", error);
       try {
-        logger23.error("Stringified error:", JSON.stringify(error, null, 2));
+        logger24.error("Stringified error:", JSON.stringify(error, null, 2));
       } catch (e) {
-        logger23.error("Could not stringify error:", e);
+        logger24.error("Could not stringify error:", e);
       }
     }
     return { failed: true };
@@ -5209,15 +5241,15 @@ async function runAllTests(testPath, options) {
   if (!options.skipBuild) {
     const componentResult = await runComponentTests(testPath, options, projectInfo);
     if (componentResult.failed) {
-      logger24.error("Component tests failed. Continuing to e2e tests...");
+      logger25.error("Component tests failed. Continuing to e2e tests...");
     }
   }
   const e2eResult = await runE2eTests(testPath, options, projectInfo);
   if (e2eResult.failed) {
-    logger24.error("E2E tests failed.");
+    logger25.error("E2E tests failed.");
     process.exit(1);
   }
-  logger24.success("All tests passed successfully!");
+  logger25.success("All tests passed successfully!");
   process.exit(0);
 }
 
@@ -5225,7 +5257,7 @@ async function runAllTests(testPath, options) {
 import * as net from "net";
 
 // src/commands/test/utils/plugin-utils.ts
-import { logger as logger25 } from "@elizaos/core";
+import { logger as logger26 } from "@elizaos/core";
 import * as fs13 from "fs";
 import path28 from "path";
 
@@ -5237,31 +5269,31 @@ var test = new Command10().name("test").description("Run tests for the current p
   const projectInfo = getProjectType(testPath);
   await installPluginDependencies(projectInfo);
 }).action(async (testPath, options) => {
-  logger26.info("Starting tests...");
+  logger27.info("Starting tests...");
   try {
     const projectInfo = getProjectType(testPath);
     switch (options.type) {
       case "component":
-        logger26.info("Running component tests only...");
+        logger27.info("Running component tests only...");
         const componentResult = await runComponentTests(testPath, options, projectInfo);
         if (componentResult.failed) {
-          logger26.error("Component tests failed.");
+          logger27.error("Component tests failed.");
           process.exit(1);
         }
-        logger26.success("Component tests passed successfully!");
+        logger27.success("Component tests passed successfully!");
         break;
       case "e2e":
-        logger26.info("Running e2e tests only...");
+        logger27.info("Running e2e tests only...");
         const e2eResult = await runE2eTests(testPath, options, projectInfo);
         if (e2eResult.failed) {
-          logger26.error("E2E tests failed.");
+          logger27.error("E2E tests failed.");
           process.exit(1);
         }
-        logger26.success("E2E tests passed successfully!");
+        logger27.success("E2E tests passed successfully!");
         break;
       case "all":
       default:
-        logger26.info("Running all tests...");
+        logger27.info("Running all tests...");
         await runAllTests(testPath, options);
         break;
     }
@@ -5272,13 +5304,46 @@ var test = new Command10().name("test").description("Run tests for the current p
 });
 
 // src/index.ts
-import { logger as logger27 } from "@elizaos/core";
+import { logger as logger28 } from "@elizaos/core";
 import { Command as Command11 } from "commander";
 process.env.NODE_OPTIONS = "--no-deprecation";
 process.env.NODE_NO_WARNINGS = "1";
 process.env.QUIET_MODE = process.env.QUIET_MODE || "true";
-process.on("SIGINT", () => process.exit(0));
-process.on("SIGTERM", () => process.exit(0));
+var shutdownState = {
+  isShuttingDown: false,
+  /**
+   * Atomically check and set the shutdown flag
+   * @returns true if shutdown was initiated, false if already in progress
+   */
+  tryInitiateShutdown() {
+    if (this.isShuttingDown) {
+      return false;
+    }
+    this.isShuttingDown = true;
+    return true;
+  }
+};
+async function gracefulShutdown(signal) {
+  if (!shutdownState.tryInitiateShutdown()) {
+    logger28.debug(`Ignoring ${signal} - shutdown already in progress`);
+    return;
+  }
+  logger28.info(`Received ${signal}, shutting down gracefully...`);
+  try {
+    const serverWasStopped = await stopServer();
+    if (serverWasStopped) {
+      logger28.info("Server stopped successfully");
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger28.error(`Error stopping server: ${errorMessage}`);
+    logger28.debug("Full error details:", error);
+  }
+  const exitCode = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 0;
+  process.exit(exitCode);
+}
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
 async function main() {
   if (process.argv.includes("--no-emoji")) {
     configureEmojis({ forceDisable: true });
@@ -5302,6 +5367,6 @@ async function main() {
   await program.parseAsync();
 }
 main().catch((error) => {
-  logger27.error("An error occurred:", error);
+  logger28.error("An error occurred:", error);
   process.exit(1);
 });