@elizaos/cli 1.3.1 → 1.4.2

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env bun
 import {
   create
-} from "./chunk-RM6LUTKD.js";
+} from "./chunk-FSSUAWXQ.js";
 import {
   getElizaCharacter
-} from "./chunk-KDNV7EA5.js";
+} from "./chunk-SMZBJQJR.js";
 import {
   TestRunner,
   UserEnvironment,
@@ -38,23 +38,24 @@ import {
   provideLocalPluginGuidance,
   publishToGitHub,
   resolvePgliteDir,
+  runBunWithSpinner,
   saveRegistrySettings,
   testPublishToGitHub,
   testPublishToNpm,
   tryDelegateToLocalCli,
   validateDataDir
-} from "./chunk-2ALAPQLV.js";
+} from "./chunk-D3QSET5H.js";
 import {
   configureEmojis,
   emoji,
   runBunCommand
-} from "./chunk-FDEDLANP.js";
-import "./chunk-4O6EZU37.js";
+} from "./chunk-FQYWRHLX.js";
+import "./chunk-GXWWPFBO.js";
 import {
   bunExec,
   bunExecInherit,
   bunExecSimple
-} from "./chunk-D3Q2UZLZ.js";
+} from "./chunk-I4L4T7QX.js";
 import "./chunk-3RG5ZIWI.js";
 
 // src/commands/dev/index.ts
@@ -263,8 +264,8 @@ async function getLocalCliPath() {
     "index.js"
   );
   try {
-    const fs14 = await import("fs");
-    return fs14.existsSync(localCliPath) ? localCliPath : null;
+    const fs15 = await import("fs");
+    return fs15.existsSync(localCliPath) ? localCliPath : null;
   } catch {
     return null;
   }
@@ -410,10 +411,95 @@ async function stopServer() {
   return stopServerProcess();
 }
 
-// src/commands/dev/actions/dev-server.ts
+// src/utils/dependency-manager.ts
+import * as fs from "fs";
+import * as path4 from "path";
 import { logger } from "@elizaos/core";
+function hasElizaOSCli(packageJsonPath) {
+  try {
+    if (!fs.existsSync(packageJsonPath)) {
+      return false;
+    }
+    let packageJson;
+    try {
+      packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    } catch (parseError) {
+      logger.debug({ error: parseError, packageJsonPath }, `Error parsing JSON in package.json`);
+      return false;
+    }
+    const dependencies = packageJson.dependencies || {};
+    const devDependencies = packageJson.devDependencies || {};
+    return "@elizaos/cli" in dependencies || "@elizaos/cli" in devDependencies;
+  } catch (error) {
+    logger.debug({ error, packageJsonPath }, `Error reading package.json`);
+    return false;
+  }
+}
+function shouldAutoInstallCli(cwd = process.cwd()) {
+  if (process.env.ELIZA_NO_AUTO_INSTALL === "true") {
+    logger.debug("Auto-install disabled via ELIZA_NO_AUTO_INSTALL");
+    return false;
+  }
+  if (process.env.CI === "true" || process.env.ELIZA_TEST_MODE === "true") {
+    logger.debug("Skipping auto-install in CI/test environment");
+    return false;
+  }
+  const dirInfo = detectDirectoryType(cwd);
+  if (dirInfo.type === "elizaos-monorepo" || dirInfo.monorepoRoot) {
+    logger.debug("Skipping auto-install in monorepo");
+    return false;
+  }
+  if (!dirInfo.hasPackageJson) {
+    logger.debug("No package.json found, skipping auto-install");
+    return false;
+  }
+  const packageJsonPath = path4.join(cwd, "package.json");
+  if (hasElizaOSCli(packageJsonPath)) {
+    logger.debug("@elizaos/cli already present, skipping auto-install");
+    return false;
+  }
+  return true;
+}
+async function installElizaOSCli(cwd = process.cwd()) {
+  try {
+    logger.info("Adding @elizaos/cli as dev dependency for enhanced development experience...");
+    const result = await runBunWithSpinner(["add", "--dev", "@elizaos/cli"], cwd, {
+      spinnerText: "Installing @elizaos/cli with bun...",
+      successText: "\u2713 @elizaos/cli installed successfully",
+      errorText: "Failed to install @elizaos/cli",
+      showOutputOnError: false
+      // Don't show verbose output for this
+    });
+    if (result.success) {
+      logger.info("\u2713 @elizaos/cli added as dev dependency");
+      return true;
+    } else {
+      logger.warn("\u26A0 Failed to install @elizaos/cli as dev dependency (optional)");
+      logger.debug({ error: result.error }, "Installation error:");
+      return false;
+    }
+  } catch (error) {
+    logger.warn("\u26A0 Failed to install @elizaos/cli as dev dependency (optional)");
+    logger.debug({ error }, "Installation error:");
+    return false;
+  }
+}
+async function ensureElizaOSCli(cwd = process.cwd()) {
+  if (!shouldAutoInstallCli(cwd)) {
+    return;
+  }
+  logger.debug("Auto-installing @elizaos/cli for enhanced development experience");
+  const success = await installElizaOSCli(cwd);
+  if (success) {
+    logger.info("Next time you can use the local CLI for better performance and consistency");
+  }
+}
+
+// src/commands/dev/actions/dev-server.ts
+import { logger as logger2 } from "@elizaos/core";
 async function startDevMode(options) {
   const cwd = process.cwd();
+  await ensureElizaOSCli(cwd);
   const context = createDevContext(cwd);
   const serverManager2 = getServerManager();
   const { directoryType } = context;
@@ -444,13 +530,13 @@ async function startDevMode(options) {
   try {
     availablePort = await findNextAvailablePort(desiredPort);
     if (availablePort !== desiredPort) {
-      logger.warn(`Port ${desiredPort} is in use, using port ${availablePort} instead`);
+      logger2.warn(`Port ${desiredPort} is in use, using port ${availablePort} instead`);
     }
   } catch (error) {
-    logger.error(
+    logger2.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");
+    logger2.error("Please specify a different port using --port option");
     throw new Error(`No available ports found starting from ${desiredPort}`);
   }
   cliArgs.push("--port", availablePort.toString());
@@ -524,15 +610,15 @@ import colors3 from "yoctocolors";
 
 // src/commands/env/actions/edit.ts
 import * as clack from "@clack/prompts";
-import { existsSync as existsSync4 } from "fs";
-import path5 from "path";
+import { existsSync as existsSync5 } from "fs";
+import path6 from "path";
 
 // src/commands/env/utils/file-operations.ts
-import { existsSync as existsSync3 } from "fs";
-import path4 from "path";
+import { existsSync as existsSync4 } from "fs";
+import path5 from "path";
 async function getLocalEnvPath() {
-  const localEnvPath = path4.join(process.cwd(), ".env");
-  return existsSync3(localEnvPath) ? localEnvPath : null;
+  const localEnvPath = path5.join(process.cwd(), ".env");
+  return existsSync4(localEnvPath) ? localEnvPath : null;
 }
 async function parseEnvFile(filePath) {
   const service = createEnvFileService(filePath);
@@ -547,7 +633,7 @@ async function writeEnvFile(filePath, envVars) {
 }
 async function resetEnvFile(filePath) {
   try {
-    if (!existsSync3(filePath)) {
+    if (!existsSync4(filePath)) {
       return false;
     }
     const service = createEnvFileService(filePath);
@@ -586,9 +672,9 @@ function maskedValue(value) {
 async function editEnvVars(options, fromMainMenu = false) {
   const { yes } = options;
   const localEnvPath = await getLocalEnvPath();
-  if (!localEnvPath || !existsSync4(localEnvPath)) {
-    const exampleEnvPath = path5.join(process.cwd(), ".env.example");
-    const hasExample = existsSync4(exampleEnvPath);
+  if (!localEnvPath || !existsSync5(localEnvPath)) {
+    const exampleEnvPath = path6.join(process.cwd(), ".env.example");
+    const hasExample = existsSync5(exampleEnvPath);
     if (hasExample) {
       console.log("No local .env file found. Create one with:");
       console.log("  cp .env.example .env");
@@ -739,8 +825,8 @@ async function addNewVariable(envPath, envVars, yes = false) {
 import * as clack3 from "@clack/prompts";
 
 // src/commands/env/actions/list.ts
-import { existsSync as existsSync5 } from "fs";
-import path6 from "path";
+import { existsSync as existsSync6 } from "fs";
+import path7 from "path";
 import colors from "yoctocolors";
 async function listEnvVars() {
   const envInfo = await UserEnvironment.getInstanceInfo();
@@ -753,11 +839,11 @@ async function listEnvVars() {
   );
   console.info(colors.bold("\nLocal Environment Variables:"));
   const localEnvFilePath = await getLocalEnvPath();
-  console.info(`Path: ${localEnvFilePath ?? path6.join(process.cwd(), ".env")}`);
-  if (!localEnvFilePath || !existsSync5(localEnvFilePath)) {
+  console.info(`Path: ${localEnvFilePath ?? path7.join(process.cwd(), ".env")}`);
+  if (!localEnvFilePath || !existsSync6(localEnvFilePath)) {
     console.info(colors.yellow("  No local .env file found"));
-    const exampleEnvPath = path6.join(process.cwd(), ".env.example");
-    if (existsSync5(exampleEnvPath)) {
+    const exampleEnvPath = path7.join(process.cwd(), ".env.example");
+    if (existsSync6(exampleEnvPath)) {
       console.info(colors.red("  [X] Missing .env file. Create one with:"));
       console.info(`     ${colors.bold(colors.green("cp .env.example .env"))}`);
     } else {
@@ -797,7 +883,7 @@ async function handleListCommand(options) {
   } else if (options.local) {
     console.info(colors.bold("\nLocal Environment Variables:"));
     const localEnvPath = await getLocalEnvPath();
-    if (!localEnvPath || !existsSync5(localEnvPath)) {
+    if (!localEnvPath || !existsSync6(localEnvPath)) {
       console.info("  No local .env file found in the current directory");
       return;
     }
@@ -816,21 +902,21 @@ async function handleListCommand(options) {
 
 // src/commands/env/actions/reset.ts
 import * as clack2 from "@clack/prompts";
-import { existsSync as existsSync7 } from "fs";
-import path7 from "path";
+import { existsSync as existsSync8 } from "fs";
+import path8 from "path";
 import colors2 from "yoctocolors";
 
 // src/commands/env/utils/directory-operations.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { rimraf } from "rimraf";
 async function safeDeleteDirectory(dir, actions, label) {
-  if (!existsSync6(dir)) {
+  if (!existsSync7(dir)) {
     actions.skipped.push(`${label} (not found)`);
     return false;
   }
   try {
     await rimraf(dir);
-    if (!existsSync6(dir)) {
+    if (!existsSync7(dir)) {
       actions.deleted.push(label);
       return true;
     } else {
@@ -845,36 +931,36 @@ async function safeDeleteDirectory(dir, actions, label) {
 
 // src/commands/env/actions/reset.ts
 async function resolvePgliteDir2() {
-  return path7.join(process.cwd(), ".eliza", "db");
+  return path8.join(process.cwd(), ".eliza", "db");
 }
 async function resetEnv(options) {
   const { yes } = options;
-  const elizaDir = path7.join(process.cwd(), ".eliza");
-  const cacheDir = path7.join(elizaDir, "cache");
-  const localEnvPath = await getLocalEnvPath() ?? path7.join(process.cwd(), ".env");
+  const elizaDir = path8.join(process.cwd(), ".eliza");
+  const cacheDir = path8.join(elizaDir, "cache");
+  const localEnvPath = await getLocalEnvPath() ?? path8.join(process.cwd(), ".env");
   const localDbDir = await resolvePgliteDir2();
   const resetItems = [
     {
       title: "Local environment variables",
       value: "localEnv",
-      description: existsSync7(localEnvPath) ? "Reset values in local .env file" : "Local .env file not found, nothing to reset",
-      selected: existsSync7(localEnvPath)
+      description: existsSync8(localEnvPath) ? "Reset values in local .env file" : "Local .env file not found, nothing to reset",
+      selected: existsSync8(localEnvPath)
     },
     {
       title: "Cache folder",
       value: "cache",
-      description: existsSync7(cacheDir) ? "Delete the cache folder" : "Cache folder not found, nothing to delete",
-      selected: existsSync7(cacheDir)
+      description: existsSync8(cacheDir) ? "Delete the cache folder" : "Cache folder not found, nothing to delete",
+      selected: existsSync8(cacheDir)
     },
     {
       title: "Local database files",
       value: "localDb",
-      description: existsSync7(localDbDir) ? "Delete local database files" : "Local database folder not found, nothing to delete",
-      selected: existsSync7(localDbDir)
+      description: existsSync8(localDbDir) ? "Delete local database files" : "Local database folder not found, nothing to delete",
+      selected: existsSync8(localDbDir)
     }
   ];
   const validResetItems = resetItems.filter(
-    (item) => item.value === "localEnv" && existsSync7(localEnvPath) || item.value === "cache" && existsSync7(cacheDir) || item.value === "localDb" && existsSync7(localDbDir)
+    (item) => item.value === "localEnv" && existsSync8(localEnvPath) || item.value === "cache" && existsSync8(cacheDir) || item.value === "localDb" && existsSync8(localDbDir)
   );
   let selectedValues = [];
   if (yes) {
@@ -1052,7 +1138,7 @@ env.action(() => {
 import { Command as Command3 } from "commander";
 
 // src/commands/plugins/actions/install.ts
-import { logger as logger4 } from "@elizaos/core";
+import { logger as logger5 } from "@elizaos/core";
 
 // src/commands/plugins/utils/naming.ts
 var findPluginPackageName = (pluginInput, allDependencies) => {
@@ -1094,55 +1180,55 @@ var extractPackageName = (pluginInput) => {
 };
 
 // src/commands/plugins/utils/env-vars.ts
-import { logger as logger2 } from "@elizaos/core";
-import { existsSync as existsSync8, readFileSync, readdirSync as readdirSync2 } from "fs";
-import path8 from "path";
+import { logger as logger3 } from "@elizaos/core";
+import { existsSync as existsSync9, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
+import path9 from "path";
 import * as clack4 from "@clack/prompts";
 var extractPluginEnvRequirements = async (packageName, cwd) => {
   try {
     const possiblePaths = [
       // Direct path
-      path8.join(cwd, "node_modules", packageName, "package.json"),
+      path9.join(cwd, "node_modules", packageName, "package.json"),
       // Scoped package path (e.g., @elizaos/plugin-discord)
-      path8.join(cwd, "node_modules", packageName.replace("/", path8.sep), "package.json")
+      path9.join(cwd, "node_modules", packageName.replace("/", path9.sep), "package.json")
     ];
     if (!packageName.startsWith("@elizaos/")) {
       possiblePaths.push(
-        path8.join(cwd, "node_modules", "@elizaos", packageName, "package.json"),
-        path8.join(cwd, "node_modules", "@elizaos", `plugin-${packageName}`, "package.json")
+        path9.join(cwd, "node_modules", "@elizaos", packageName, "package.json"),
+        path9.join(cwd, "node_modules", "@elizaos", `plugin-${packageName}`, "package.json")
       );
     }
     let currentDir = cwd;
     for (let i = 0; i < 5; i++) {
-      const parentNodeModules = path8.join(currentDir, "node_modules");
-      if (existsSync8(parentNodeModules)) {
+      const parentNodeModules = path9.join(currentDir, "node_modules");
+      if (existsSync9(parentNodeModules)) {
         possiblePaths.push(
-          path8.join(parentNodeModules, packageName, "package.json"),
-          path8.join(parentNodeModules, packageName.replace("/", path8.sep), "package.json")
+          path9.join(parentNodeModules, packageName, "package.json"),
+          path9.join(parentNodeModules, packageName.replace("/", path9.sep), "package.json")
         );
       }
-      const parentDir = path8.dirname(currentDir);
+      const parentDir = path9.dirname(currentDir);
       if (parentDir === currentDir) break;
       currentDir = parentDir;
     }
     let packageJsonPath = null;
     for (const possiblePath of possiblePaths) {
-      if (existsSync8(possiblePath)) {
+      if (existsSync9(possiblePath)) {
         packageJsonPath = possiblePath;
-        logger2.debug(`Found plugin package.json at: ${packageJsonPath}`);
+        logger3.debug({ packageJsonPath }, `Found plugin package.json at:`);
         break;
       }
     }
     if (!packageJsonPath) {
-      const nodeModulesPath = path8.join(cwd, "node_modules");
-      if (existsSync8(nodeModulesPath)) {
+      const nodeModulesPath = path9.join(cwd, "node_modules");
+      if (existsSync9(nodeModulesPath)) {
         const packages = readdirSync2(nodeModulesPath);
         for (const pkg of packages) {
           if (pkg.includes(packageName.replace("@elizaos/", "").replace("plugin-", ""))) {
-            const pkgJsonPath = path8.join(nodeModulesPath, pkg, "package.json");
-            if (existsSync8(pkgJsonPath)) {
+            const pkgJsonPath = path9.join(nodeModulesPath, pkg, "package.json");
+            if (existsSync9(pkgJsonPath)) {
               packageJsonPath = pkgJsonPath;
-              logger2.debug(`Found matching plugin package.json at: ${packageJsonPath}`);
+              logger3.debug({ packageJsonPath }, `Found matching plugin package.json at:`);
               break;
             }
           }
@@ -1150,30 +1236,29 @@ var extractPluginEnvRequirements = async (packageName, cwd) => {
       }
     }
     if (!packageJsonPath) {
-      logger2.debug(`Plugin package.json not found for: ${packageName}`);
-      logger2.debug(`Searched paths: ${possiblePaths.join(", ")}`);
+      logger3.debug({ packageName }, `Plugin package.json not found`);
+      logger3.debug({ paths: possiblePaths }, `Searched paths:`);
       return {};
     }
-    const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
+    const packageJsonContent = readFileSync2(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     const agentConfig = packageJson.agentConfig;
     if (!agentConfig || !agentConfig.pluginParameters) {
-      logger2.debug(`No agentConfig.pluginParameters found in ${packageName} at ${packageJsonPath}`);
+      logger3.debug(`No agentConfig.pluginParameters found in ${packageName} at ${packageJsonPath}`);
       return {};
     }
-    logger2.debug(
-      `Found environment variables for ${packageName}: ${Object.keys(agentConfig.pluginParameters).join(", ")}`
+    logger3.debug(
+      { packageName, vars: Object.keys(agentConfig.pluginParameters) },
+      "Found environment variables"
     );
     return agentConfig.pluginParameters;
   } catch (error) {
-    logger2.debug(
-      `Error reading plugin package.json for ${packageName}: ${error instanceof Error ? error.message : String(error)}`
-    );
+    logger3.debug({ error, packageName }, "Error reading plugin package.json");
     return {};
   }
 };
 var readEnvFile = async (cwd) => {
-  const envPath = path8.join(cwd, ".env");
+  const envPath = path9.join(cwd, ".env");
   const envService = createEnvFileService(envPath);
   return envService.read();
 };
@@ -1360,7 +1445,7 @@ var promptForEnvVar = async (varName, config2) => {
   return finalValue.trim();
 };
 var updateEnvFile = async (cwd, varName, value) => {
-  const envPath = path8.join(cwd, ".env");
+  const envPath = path9.join(cwd, ".env");
   const envService = createEnvFileService(envPath);
   await envService.update(varName, value, {
     preserveComments: true,
@@ -1378,7 +1463,7 @@ var promptForPluginEnvVars = async (packageName, cwd) => {
     }
   }
   if (Object.keys(envRequirements).length === 0) {
-    const nodeModulesPath = path8.join(cwd, "node_modules");
+    const nodeModulesPath = path9.join(cwd, "node_modules");
     const possiblePackages = [
       packageName,
       `@elizaos/${packageName.replace("plugin-", "")}`,
@@ -1386,17 +1471,17 @@ var promptForPluginEnvVars = async (packageName, cwd) => {
     ];
     let packageFound = false;
     for (const pkg of possiblePackages) {
-      const pkgPath = path8.join(nodeModulesPath, ...pkg.split("/"));
-      if (existsSync8(path8.join(pkgPath, "package.json"))) {
+      const pkgPath = path9.join(nodeModulesPath, ...pkg.split("/"));
+      if (existsSync9(path9.join(pkgPath, "package.json"))) {
         packageFound = true;
         break;
       }
     }
     if (packageFound) {
-      logger2.debug(`Package ${packageName} found but has no environment variables defined`);
+      logger3.debug(`Package ${packageName} found but has no environment variables defined`);
       clack4.log.success(`No environment variables required for ${packageName}`);
     } else {
-      logger2.debug(`Package ${packageName} not found in node_modules`);
+      logger3.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.`
       );
@@ -1537,26 +1622,26 @@ Restart your application after adding the variables.`
 };
 
 // src/commands/plugins/utils/directory.ts
-import { logger as logger3 } from "@elizaos/core";
-import { readFileSync as readFileSync2 } from "fs";
-import path9 from "path";
+import { logger as logger4 } from "@elizaos/core";
+import { readFileSync as readFileSync3 } from "fs";
+import path10 from "path";
 var getDependenciesFromDirectory = (cwd) => {
   const directoryInfo = detectDirectoryType(cwd);
   if (!directoryInfo.hasPackageJson) {
     return null;
   }
   try {
-    const packageJsonPath = path9.join(cwd, "package.json");
-    const packageJsonContent = readFileSync2(packageJsonPath, "utf-8");
+    const packageJsonPath = path10.join(cwd, "package.json");
+    const packageJsonContent = readFileSync3(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     const dependencies = packageJson.dependencies || {};
     const devDependencies = packageJson.devDependencies || {};
     return { ...dependencies, ...devDependencies };
   } catch (error) {
     if (error instanceof SyntaxError) {
-      logger3.warn(`Could not parse package.json: ${error.message}`);
+      logger4.warn(`Could not parse package.json: ${error.message}`);
     } else {
-      logger3.warn(
+      logger4.warn(
         `Error reading package.json: ${error instanceof Error ? error.message : String(error)}`
       );
     }
@@ -1591,7 +1676,7 @@ async function installPluginFromGitHub(plugin, cwd, opts) {
   const pluginNameForPostInstall = repo;
   const success = await installPlugin(githubSpecifier, cwd, void 0, opts.skipVerification);
   if (success) {
-    logger4.info(`Successfully installed ${pluginNameForPostInstall} from ${githubSpecifier}.`);
+    logger5.info(`Successfully installed ${pluginNameForPostInstall} from ${githubSpecifier}.`);
     const packageName = extractPackageName(plugin);
     if (!opts.skipEnvPrompt) {
       await new Promise((resolve2) => setTimeout(resolve2, 500));
@@ -1600,7 +1685,7 @@ async function installPluginFromGitHub(plugin, cwd, opts) {
       try {
         await promptForPluginEnvVars(packageName, cwd);
       } catch (error) {
-        logger4.warn(
+        logger5.warn(
           `Warning: Could not prompt for environment variables: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -1611,14 +1696,14 @@ async function installPluginFromGitHub(plugin, cwd, opts) {
     showInstallationSuccess(packageName);
     process.exit(0);
   } else {
-    logger4.error(`Failed to install plugin from ${githubSpecifier}.`);
+    logger5.error(`Failed to install plugin from ${githubSpecifier}.`);
     process.exit(1);
   }
 }
 async function installPluginFromRegistry(plugin, cwd, opts) {
   const cachedRegistry = await fetchPluginRegistry();
   if (!cachedRegistry || !cachedRegistry.registry) {
-    logger4.error('Plugin registry cache not found. Please run "elizaos plugins update" first.');
+    logger5.error('Plugin registry cache not found. Please run "elizaos plugins update" first.');
     process.exit(1);
   }
   const possibleNames = normalizePluginName(plugin);
@@ -1641,7 +1726,7 @@ async function installPluginFromRegistry(plugin, cwd, opts) {
       try {
         await promptForPluginEnvVars(actualPackageName, cwd);
       } catch (error) {
-        logger4.warn(
+        logger5.warn(
           `Warning: Could not prompt for environment variables: ${error instanceof Error ? error.message : String(error)}`
         );
       }
@@ -1657,8 +1742,8 @@ async function installPluginFromRegistry(plugin, cwd, opts) {
 }
 async function addPlugin(pluginArg, opts) {
   if (!pluginArg || !pluginArg.trim()) {
-    logger4.error("Plugin name cannot be empty or whitespace-only.");
-    logger4.info(
+    logger5.error("Plugin name cannot be empty or whitespace-only.");
+    logger5.info(
       'Please provide a valid plugin name (e.g., "openai", "plugin-anthropic", "@elizaos/plugin-sql")'
     );
     process.exit(1);
@@ -1666,14 +1751,14 @@ async function addPlugin(pluginArg, opts) {
   const cwd = process.cwd();
   const directoryInfo = detectDirectoryType(cwd);
   if (!directoryInfo || !directoryInfo.hasPackageJson) {
-    logger4.error(
+    logger5.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) {
-    logger4.error("Could not read dependencies from package.json");
+    logger5.error("Could not read dependencies from package.json");
     process.exit(1);
   }
   let plugin = pluginArg;
@@ -1688,7 +1773,7 @@ async function addPlugin(pluginArg, opts) {
   }
   const installedPluginName = findPluginPackageName(plugin, allDependencies);
   if (installedPluginName) {
-    logger4.info(`Plugin "${installedPluginName}" is already added to this project.`);
+    logger5.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_.-]+))?$/;
@@ -1700,9 +1785,9 @@ async function addPlugin(pluginArg, opts) {
 }
 
 // src/commands/plugins/actions/remove.ts
-import { logger as logger5 } from "@elizaos/core";
-import { existsSync as existsSync9, rmSync } from "fs";
-import path10 from "path";
+import { logger as logger6 } from "@elizaos/core";
+import { existsSync as existsSync10, rmSync } from "fs";
+import path11 from "path";
 async function removePlugin(plugin) {
   const cwd = process.cwd();
   const directoryInfo = detectDirectoryType(cwd);
@@ -1721,7 +1806,7 @@ async function removePlugin(plugin) {
   }
   const packageNameToRemove = findPluginPackageName(plugin, allDependencies);
   if (!packageNameToRemove) {
-    logger5.warn(`Plugin matching "${plugin}" not found in project dependencies.`);
+    logger6.warn(`Plugin matching "${plugin}" not found in project dependencies.`);
     console.info("\nCheck installed plugins using: elizaos plugins installed-plugins");
     process.exit(0);
   }
@@ -1731,11 +1816,11 @@ async function removePlugin(plugin) {
       cwd
     });
   } catch (execError) {
-    logger5.error(
+    logger6.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")) {
-      logger5.info(
+      logger6.info(
         `'bun remove' indicated package was not found. Continuing with directory removal attempt.`
       );
     } else {
@@ -1750,22 +1835,22 @@ async function removePlugin(plugin) {
   }
   baseName = baseName.replace(/^plugin-/, "");
   const dirNameToRemove = `plugin-${baseName}`;
-  const pluginDir = path10.join(cwd, dirNameToRemove);
-  if (existsSync9(pluginDir)) {
+  const pluginDir = path11.join(cwd, dirNameToRemove);
+  if (existsSync10(pluginDir)) {
     try {
       rmSync(pluginDir, { recursive: true, force: true });
     } catch (rmError) {
-      logger5.error(
+      logger6.error(
         `Failed to remove directory ${pluginDir}: ${rmError instanceof Error ? rmError.message : String(rmError)}`
       );
     }
   } else {
-    const nonPrefixedDir = path10.join(cwd, baseName);
-    if (existsSync9(nonPrefixedDir)) {
+    const nonPrefixedDir = path11.join(cwd, baseName);
+    if (existsSync10(nonPrefixedDir)) {
       try {
         rmSync(nonPrefixedDir, { recursive: true, force: true });
       } catch (rmError) {
-        logger5.error(
+        logger6.error(
           `Failed to remove directory ${nonPrefixedDir}: ${rmError instanceof Error ? rmError.message : String(rmError)}`
         );
       }
@@ -1775,11 +1860,11 @@ async function removePlugin(plugin) {
 }
 
 // src/commands/plugins/actions/list.ts
-import { logger as logger6 } from "@elizaos/core";
+import { logger as logger7 } from "@elizaos/core";
 async function listAvailablePlugins(opts) {
   const cachedRegistry = await fetchPluginRegistry();
   if (!cachedRegistry || !cachedRegistry.registry || Object.keys(cachedRegistry.registry).length === 0) {
-    logger6.info("Plugin cache is empty or not found.");
+    logger7.info("Plugin cache is empty or not found.");
     console.log('\nPlease run "elizaos plugins update" to fetch the latest plugin registry.');
     return;
   }
@@ -1857,20 +1942,20 @@ async function listInstalledPlugins() {
 }
 
 // src/commands/plugins/actions/upgrade.ts
-import { logger as logger9 } from "@elizaos/core";
-import path12 from "path";
-import { existsSync as existsSync11 } from "fs";
+import { logger as logger10 } from "@elizaos/core";
+import path13 from "path";
+import { existsSync as existsSync12 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import fs from "fs-extra";
+import fs2 from "fs-extra";
 
 // src/utils/upgrade/simple-migration-agent.ts
 import { query } from "@anthropic-ai/claude-code";
 
 // src/utils/upgrade/migration-guide-loader.ts
-import { existsSync as existsSync10, readFileSync as readFileSync3 } from "fs";
-import path11 from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync4 } from "fs";
+import path12 from "path";
 import { fileURLToPath } from "url";
-import { logger as logger7 } from "@elizaos/core";
+import { logger as logger8 } from "@elizaos/core";
 var MigrationGuideLoader = class {
   guides = [];
   guidesDir;
@@ -1880,33 +1965,33 @@ var MigrationGuideLoader = class {
   }
   findGuidesDirectory(projectRoot) {
     if (projectRoot) {
-      const guidesPath = path11.join(projectRoot, "packages/docs/docs/plugins/migration/claude-code");
-      if (existsSync10(guidesPath)) {
+      const guidesPath = path12.join(projectRoot, "packages/docs/docs/plugins/migration/claude-code");
+      if (existsSync11(guidesPath)) {
         return guidesPath;
       }
     }
     let currentRoot = process.cwd();
     let previousRoot = "";
-    while (currentRoot !== previousRoot && !existsSync10(path11.join(currentRoot, "packages/docs"))) {
+    while (currentRoot !== previousRoot && !existsSync11(path12.join(currentRoot, "packages/docs"))) {
       previousRoot = currentRoot;
-      currentRoot = path11.dirname(currentRoot);
+      currentRoot = path12.dirname(currentRoot);
     }
-    const monorepoGuidesPath = path11.join(
+    const monorepoGuidesPath = path12.join(
       currentRoot,
       "packages/docs/docs/plugins/migration/claude-code"
     );
-    if (existsSync10(monorepoGuidesPath)) {
+    if (existsSync11(monorepoGuidesPath)) {
       return monorepoGuidesPath;
     }
-    const workingDirGuides = path11.join(process.cwd(), "migration-guides");
-    if (existsSync10(workingDirGuides)) {
+    const workingDirGuides = path12.join(process.cwd(), "migration-guides");
+    if (existsSync11(workingDirGuides)) {
       return workingDirGuides;
     }
     const currentFileUrl = import.meta.url;
     const currentFilePath = fileURLToPath(currentFileUrl);
-    const cliPackageRoot = path11.dirname(path11.dirname(path11.dirname(path11.dirname(currentFilePath))));
-    const bundledGuidesPath = path11.join(cliPackageRoot, "migration-guides");
-    if (existsSync10(bundledGuidesPath)) {
+    const cliPackageRoot = path12.dirname(path12.dirname(path12.dirname(path12.dirname(currentFilePath))));
+    const bundledGuidesPath = path12.join(cliPackageRoot, "migration-guides");
+    if (existsSync11(bundledGuidesPath)) {
       return bundledGuidesPath;
     }
     return "";
@@ -2019,16 +2104,16 @@ var MigrationGuideLoader = class {
         ]
       }
     ];
-    if (!this.guidesDir || !existsSync10(this.guidesDir)) {
-      logger7.info("Using embedded migration guidance (external CLI mode)");
+    if (!this.guidesDir || !existsSync11(this.guidesDir)) {
+      logger8.info("Using embedded migration guidance (external CLI mode)");
       this.createEmbeddedGuides(guideConfigs);
       return;
     }
     for (const config2 of guideConfigs) {
-      const guidePath = path11.join(this.guidesDir, config2.name);
-      if (existsSync10(guidePath)) {
+      const guidePath = path12.join(this.guidesDir, config2.name);
+      if (existsSync11(guidePath)) {
         try {
-          const content = readFileSync3(guidePath, "utf-8");
+          const content = readFileSync4(guidePath, "utf-8");
           this.guides.push({
             name: config2.name,
             path: guidePath,
@@ -2037,13 +2122,16 @@ var MigrationGuideLoader = class {
             keywords: config2.keywords
           });
         } catch (error) {
-          logger7.warn(`Failed to load migration guide: ${config2.name}`, error);
+          logger8.warn({ error, guideName: config2.name }, `Failed to load migration guide`);
         }
       } else {
-        logger7.warn(`Migration guide not found: ${guidePath}`);
+        logger8.warn({ guidePath }, `Migration guide not found`);
       }
     }
-    logger7.info(`Loaded ${this.guides.length} migration guides from ${this.guidesDir}`);
+    logger8.info(
+      { count: this.guides.length, guidesDir: this.guidesDir },
+      `Loaded migration guides`
+    );
   }
   createEmbeddedGuides(guideConfigs) {
     const embeddedGuides = {
@@ -2291,7 +2379,7 @@ function createMigrationGuideLoader(projectRoot) {
 }
 
 // src/utils/upgrade/simple-migration-agent.ts
-import { logger as logger8 } from "@elizaos/core";
+import { logger as logger9 } from "@elizaos/core";
 var SimpleMigrationAgent = class extends EventTarget {
   handlers = /* @__PURE__ */ new Map();
   repoPath;
@@ -2315,10 +2403,10 @@ var SimpleMigrationAgent = class extends EventTarget {
     try {
       this.guideLoader = createMigrationGuideLoader();
       if (this.verbose) {
-        logger8.info("Migration guide loader initialized successfully");
+        logger9.info("Migration guide loader initialized successfully");
       }
     } catch (error) {
-      logger8.warn("Failed to initialize migration guide loader", error);
+      logger9.warn({ error }, "Failed to initialize migration guide loader");
       throw new Error("Cannot initialize migration system without guide access");
     }
   }
@@ -2926,13 +3014,13 @@ async function upgradePlugin(pluginPath, opts) {
       process.env.ANTHROPIC_API_KEY = opts.apiKey;
     }
     if (!process.env.ANTHROPIC_API_KEY) {
-      logger9.error("ANTHROPIC_API_KEY is required for plugin upgrade.");
+      logger10.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-")) {
-      logger9.error("Invalid ANTHROPIC_API_KEY format.");
+      logger10.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);
@@ -2952,41 +3040,41 @@ async function upgradePlugin(pluginPath, opts) {
       console.log("\nInstall the SDK: bun add @anthropic-ai/claude-code");
       process.exit(1);
     }
-    const workingDir = path12.resolve(pluginPath);
-    if (!existsSync11(workingDir)) {
+    const workingDir = path13.resolve(pluginPath);
+    if (!existsSync12(workingDir)) {
       throw new Error(`Plugin directory not found: ${workingDir}`);
     }
     console.log(chalk.cyan("\u{1F527} Setting up migration environment..."));
     let projectRoot = process.cwd();
     let guidesSource;
     let previousRoot = "";
-    while (projectRoot !== previousRoot && !existsSync11(path12.join(projectRoot, "packages/docs"))) {
+    while (projectRoot !== previousRoot && !existsSync12(path13.join(projectRoot, "packages/docs"))) {
       previousRoot = projectRoot;
-      projectRoot = path12.dirname(projectRoot);
+      projectRoot = path13.dirname(projectRoot);
     }
-    const monorepoGuidesPath = path12.join(
+    const monorepoGuidesPath = path13.join(
       projectRoot,
       "packages/docs/docs/plugins/migration/claude-code"
     );
-    if (existsSync11(monorepoGuidesPath)) {
+    if (existsSync12(monorepoGuidesPath)) {
       guidesSource = monorepoGuidesPath;
     } else {
       const currentFileUrl = import.meta.url;
       const currentFilePath = fileURLToPath2(currentFileUrl);
-      const cliPackageRoot = path12.dirname(
-        path12.dirname(path12.dirname(path12.dirname(currentFilePath)))
+      const cliPackageRoot = path13.dirname(
+        path13.dirname(path13.dirname(path13.dirname(currentFilePath)))
       );
-      const bundledGuidesPath = path12.join(cliPackageRoot, "migration-guides");
-      if (existsSync11(bundledGuidesPath)) {
+      const bundledGuidesPath = path13.join(cliPackageRoot, "migration-guides");
+      if (existsSync12(bundledGuidesPath)) {
         guidesSource = bundledGuidesPath;
       } else {
         guidesSource = "";
       }
     }
-    const guidesTarget = path12.join(workingDir, "migration-guides");
-    await fs.ensureDir(guidesTarget);
-    if (guidesSource && existsSync11(guidesSource)) {
-      await fs.copy(guidesSource, guidesTarget, { overwrite: true });
+    const guidesTarget = path13.join(workingDir, "migration-guides");
+    await fs2.ensureDir(guidesTarget);
+    if (guidesSource && existsSync12(guidesSource)) {
+      await fs2.copy(guidesSource, guidesTarget, { overwrite: true });
       if (opts.debug) {
         console.log(chalk.gray(`Copied guides from: ${guidesSource}`));
       }
@@ -3022,8 +3110,8 @@ Plugin: ${pluginPath}`));
     });
     const result = await agent2.migrate();
     try {
-      if (existsSync11(guidesTarget)) {
-        await fs.remove(guidesTarget);
+      if (existsSync12(guidesTarget)) {
+        await fs2.remove(guidesTarget);
         if (opts.debug) {
           console.log(chalk.gray("Cleaned up migration guides"));
         }
@@ -3036,7 +3124,7 @@ Plugin: ${pluginPath}`));
     if (result.success) {
       console.log(chalk.green("\nMigration completed successfully!"));
       console.log(chalk.gray("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-      console.log(`Location: ${chalk.cyan(path12.basename(result.repoPath))}`);
+      console.log(`Location: ${chalk.cyan(path13.basename(result.repoPath))}`);
       console.log(`Duration: ${chalk.yellow(Math.round(result.duration / 1e3) + "s")}`);
       console.log(`AI Operations: ${chalk.blue(result.messageCount)}`);
       if (result.guidesUsed && result.guidesUsed.length > 0) {
@@ -3046,7 +3134,7 @@ Plugin: ${pluginPath}`));
         }
       }
       console.log(chalk.bold("\nNext Steps:"));
-      console.log(`${chalk.gray("1.")} cd ${chalk.cyan(path12.basename(result.repoPath))}`);
+      console.log(`${chalk.gray("1.")} cd ${chalk.cyan(path13.basename(result.repoPath))}`);
       console.log(
         `${chalk.gray("2.")} git checkout 1.x ${chalk.gray("# Review the migrated code")}`
       );
@@ -3075,9 +3163,9 @@ Plugin: ${pluginPath}`));
     }
   } catch (error) {
     try {
-      const guidesTarget = path12.join(path12.resolve(pluginPath), "migration-guides");
-      if (existsSync11(guidesTarget)) {
-        await fs.remove(guidesTarget);
+      const guidesTarget = path13.join(path13.resolve(pluginPath), "migration-guides");
+      if (existsSync12(guidesTarget)) {
+        await fs2.remove(guidesTarget);
         if (opts.debug) {
           console.log(chalk.gray("Cleaned up migration guides after error"));
         }
@@ -3103,33 +3191,33 @@ Error: ${error instanceof Error ? error.message : String(error)}`));
 }
 
 // src/commands/plugins/actions/generate.ts
-import { logger as logger10 } from "@elizaos/core";
-import { readFileSync as readFileSync4 } from "fs";
-import path13 from "path";
+import { logger as logger11 } from "@elizaos/core";
+import { readFileSync as readFileSync5 } from "fs";
+import path14 from "path";
 async function generatePlugin(opts) {
   try {
-    const { PluginCreator } = await import("./plugin-creator-H26ZLR6H.js");
+    const { PluginCreator } = await import("./plugin-creator-TCUFII32.js");
     if (opts.apiKey) {
       process.env.ANTHROPIC_API_KEY = opts.apiKey;
     }
     if (!process.env.ANTHROPIC_API_KEY) {
-      logger10.error("ANTHROPIC_API_KEY is required for plugin generation.");
+      logger11.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);
     }
     let spec = void 0;
     if (opts.specFile) {
       try {
-        const specContent = readFileSync4(opts.specFile, "utf-8");
+        const specContent = readFileSync5(opts.specFile, "utf-8");
         spec = JSON.parse(specContent);
       } catch (error) {
-        logger10.error(
+        logger11.error(
           `Failed to read or parse spec file: ${error instanceof Error ? error.message : String(error)}`
         );
         process.exit(1);
       }
     } else if (opts.skipPrompts) {
-      logger10.error("--skip-prompts requires --spec-file to be provided");
+      logger11.error("--skip-prompts requires --spec-file to be provided");
       process.exit(1);
     }
     const creator = new PluginCreator({
@@ -3151,12 +3239,12 @@ ${emoji.success("Plugin successfully generated!")}`);
 The plugin has been created in your current directory.`);
       console.log(`
 Next steps:`);
-      console.log(`1. cd ${path13.basename(result.pluginPath ?? "")}`);
+      console.log(`1. cd ${path14.basename(result.pluginPath ?? "")}`);
       console.log(`2. Review the generated code`);
       console.log(`3. Test the plugin: bun test`);
       console.log(`4. Add to your ElizaOS project`);
     } else {
-      logger10.error(`Plugin generation failed: ${result.error?.message}`);
+      logger11.error(`Plugin generation failed: ${result.error?.message}`);
       process.exit(1);
     }
   } catch (error) {
@@ -3214,20 +3302,20 @@ plugins.command("generate").description("Generate a new plugin using AI-powered
 
 // src/commands/publish/index.ts
 import { Command as Command5 } from "commander";
-import { promises as fs8 } from "fs";
-import path19 from "path";
+import { promises as fs9 } from "fs";
+import path20 from "path";
 import * as clack10 from "@clack/prompts";
 
 // src/commands/publish/actions/npm-publish.ts
-import { promises as fs2 } from "fs";
-import path14 from "path";
+import { promises as fs3 } from "fs";
+import path15 from "path";
 async function publishToNpm(cwd, packageJson, npmUsername) {
   console.info(`Publishing as npm user: ${npmUsername}`);
   if (!packageJson.npmPackage || packageJson.npmPackage === "${NPM_PACKAGE}") {
     packageJson.npmPackage = packageJson.name;
     console.info(`Set npmPackage to: ${packageJson.npmPackage}`);
-    const packageJsonPath = path14.join(cwd, "package.json");
-    await fs2.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
+    const packageJsonPath = path15.join(cwd, "package.json");
+    await fs3.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
   }
   console.info("Building package...");
   await bunExecInherit("npm", ["run", "build"], { cwd });
@@ -3256,21 +3344,21 @@ async function publishToGitHubAction(cwd, packageJson, credentials, skipRegistry
 }
 
 // src/commands/publish/actions/registry-publish.ts
-import { promises as fs3 } from "fs";
-import path15 from "path";
+import { promises as fs4 } from "fs";
+import path16 from "path";
 var REGISTRY_PACKAGES_PATH = "packages";
 var LOCAL_REGISTRY_PATH = "packages/registry";
 async function updateRegistryIndex(packageMetadata, dryRun = false) {
   try {
-    const indexPath = dryRun ? path15.join(process.cwd(), LOCAL_REGISTRY_PATH, "index.json") : path15.join(process.cwd(), "temp-registry", "index.json");
+    const indexPath = dryRun ? path16.join(process.cwd(), LOCAL_REGISTRY_PATH, "index.json") : path16.join(process.cwd(), "temp-registry", "index.json");
     try {
-      await fs3.access(path15.dirname(indexPath));
+      await fs4.access(path16.dirname(indexPath));
     } catch {
-      await fs3.mkdir(path15.dirname(indexPath), { recursive: true });
+      await fs4.mkdir(path16.dirname(indexPath), { recursive: true });
       try {
-        await fs3.access(indexPath);
+        await fs4.access(indexPath);
       } catch {
-        await fs3.writeFile(
+        await fs4.writeFile(
           indexPath,
           JSON.stringify(
             {
@@ -3285,7 +3373,7 @@ async function updateRegistryIndex(packageMetadata, dryRun = false) {
     }
     let indexContent;
     try {
-      indexContent = await fs3.readFile(indexPath, "utf-8");
+      indexContent = await fs4.readFile(indexPath, "utf-8");
     } catch (error) {
       indexContent = JSON.stringify({
         v1: { packages: {} },
@@ -3317,7 +3405,7 @@ async function updateRegistryIndex(packageMetadata, dryRun = false) {
       publishedAt: packageMetadata.publishedAt,
       published: !dryRun
     };
-    await fs3.writeFile(indexPath, JSON.stringify(index, null, 2));
+    await fs4.writeFile(indexPath, JSON.stringify(index, null, 2));
     console.info(
       `Registry index ${dryRun ? "(dry run) " : ""}updated with ${packageMetadata.name}@${packageMetadata.version}`
     );
@@ -3331,10 +3419,10 @@ async function updateRegistryIndex(packageMetadata, dryRun = false) {
 }
 async function savePackageToRegistry(packageMetadata, dryRun = false) {
   try {
-    const packageDir = dryRun ? path15.join(process.cwd(), LOCAL_REGISTRY_PATH, REGISTRY_PACKAGES_PATH, packageMetadata.name) : path15.join(process.cwd(), "temp-registry", REGISTRY_PACKAGES_PATH, packageMetadata.name);
-    const metadataPath = path15.join(packageDir, `${packageMetadata.version}.json`);
-    await fs3.mkdir(packageDir, { recursive: true });
-    await fs3.writeFile(metadataPath, JSON.stringify(packageMetadata, null, 2));
+    const packageDir = dryRun ? path16.join(process.cwd(), LOCAL_REGISTRY_PATH, REGISTRY_PACKAGES_PATH, packageMetadata.name) : path16.join(process.cwd(), "temp-registry", REGISTRY_PACKAGES_PATH, packageMetadata.name);
+    const metadataPath = path16.join(packageDir, `${packageMetadata.version}.json`);
+    await fs4.mkdir(packageDir, { recursive: true });
+    await fs4.writeFile(metadataPath, JSON.stringify(packageMetadata, null, 2));
     console.info(`Package metadata ${dryRun ? "(dry run) " : ""}saved to ${metadataPath}`);
     await updateRegistryIndex(packageMetadata, dryRun);
     return true;
@@ -3347,8 +3435,8 @@ async function savePackageToRegistry(packageMetadata, dryRun = false) {
 }
 
 // src/commands/publish/utils/validation.ts
-import { promises as fs4 } from "fs";
-import path16 from "path";
+import { promises as fs5 } from "fs";
+import path17 from "path";
 import * as clack6 from "@clack/prompts";
 async function validatePluginRequirements(cwd, packageJson) {
   const errors = [];
@@ -3359,23 +3447,23 @@ async function validatePluginRequirements(cwd, packageJson) {
       'Plugin name must start with "plugin-". Please update your package name and try again.'
     );
   }
-  const pluginDirName = path16.basename(cwd);
+  const pluginDirName = path17.basename(cwd);
   const expectedDefaultDesc = `ElizaOS plugin for ${pluginDirName.replace("plugin-", "")}`;
   if (packageJson.description === expectedDefaultDesc || packageJson.description === "${PLUGINDESCRIPTION}") {
     warnings.push(
       "Description appears to be the default generated description. Consider writing a custom description."
     );
   }
-  const imagesDir = path16.join(cwd, "images");
-  const logoPath = path16.join(imagesDir, "logo.jpg");
-  const bannerPath = path16.join(imagesDir, "banner.jpg");
+  const imagesDir = path17.join(cwd, "images");
+  const logoPath = path17.join(imagesDir, "logo.jpg");
+  const bannerPath = path17.join(imagesDir, "banner.jpg");
   try {
-    await fs4.access(logoPath);
+    await fs5.access(logoPath);
   } catch {
     warnings.push("Missing required logo.jpg in images/ directory (400x400px, max 500KB).");
   }
   try {
-    await fs4.access(bannerPath);
+    await fs5.access(bannerPath);
   } catch {
     warnings.push("Missing required banner.jpg in images/ directory (1280x640px, max 1MB).");
   }
@@ -3513,30 +3601,39 @@ async function getNpmUsername() {
 }
 
 // src/commands/publish/utils/version-check.ts
-import { promises as fs7 } from "fs";
-import path18 from "path";
+import { promises as fs8 } from "fs";
+import path19 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import * as clack9 from "@clack/prompts";
 
 // src/commands/update/index.ts
-import { logger as logger14 } from "@elizaos/core";
+import { logger as logger15 } from "@elizaos/core";
 import { Command as Command4 } from "commander";
 
 // src/commands/update/actions/cli-update.ts
-import { logger as logger12 } from "@elizaos/core";
+import { logger as logger13 } from "@elizaos/core";
 
 // src/commands/update/utils/version-utils.ts
-import { logger as logger11 } from "@elizaos/core";
+import { logger as logger12 } from "@elizaos/core";
 import * as semver from "semver";
 var SPECIAL_VERSION_TAGS = ["latest", "next", "canary", "rc", "dev", "nightly", "alpha"];
 var ELIZAOS_ORG = "@elizaos";
 var FALLBACK_VERSION = "0.0.0";
 async function getVersion2() {
   try {
+    const directoryInfo = detectDirectoryType(process.cwd());
+    const isMonorepo = directoryInfo.type === "elizaos-monorepo";
+    if (isMonorepo) {
+      return "monorepo";
+    }
     const envInfo = await UserEnvironment.getInstance().getInfo();
-    return envInfo.cli.version;
+    const version = envInfo.cli.version;
+    if (isWorkspaceVersion(version)) {
+      return "monorepo";
+    }
+    return version;
   } catch (error) {
-    logger11.error("Error getting CLI version:", error);
+    logger12.error({ error }, "Error getting CLI version:");
     return FALLBACK_VERSION;
   }
 }
@@ -3576,10 +3673,10 @@ async function fetchLatestVersion(packageName) {
       env: { NODE_ENV: "production" }
     });
     const version = stdout.trim();
-    logger11.debug(`Latest version of ${packageName} from npm: ${version}`);
+    logger12.debug(`Latest version of ${packageName} from npm: ${version}`);
     return version;
   } catch (error) {
-    logger11.error(
+    logger12.error(
       `Failed to fetch version for ${packageName}: ${error instanceof Error ? error.message : String(error)}`
     );
     return null;
@@ -3610,14 +3707,14 @@ async function performCliUpdate(options = {}) {
     if (!options.skipBunMigration) {
       const npmInstallation = await isCliInstalledViaNpm();
       if (npmInstallation) {
-        logger12.info("Detected npm installation, migrating to bun...");
+        logger13.info("Detected npm installation, migrating to bun...");
         try {
           await migrateCliToBun(latestVersion);
           console.log(`CLI updated successfully to version ${latestVersion} [\u2713]`);
           return true;
         } catch (migrationError) {
-          logger12.warn("Migration to bun failed, falling back to npm update...");
-          logger12.debug(
+          logger13.warn("Migration to bun failed, falling back to npm update...");
+          logger13.debug(
             "Migration error:",
             migrationError instanceof Error ? migrationError.message : String(migrationError)
           );
@@ -3642,7 +3739,10 @@ async function performCliUpdate(options = {}) {
       console.error("  curl -fsSL https://bun.sh/install | bash");
       console.error("  # or");
       console.error("  npm install -g bun");
-      logger12.debug("Bun error:", bunError instanceof Error ? bunError.message : String(bunError));
+      logger13.debug(
+        { error: bunError instanceof Error ? bunError.message : String(bunError) },
+        "Bun error:"
+      );
       return false;
     }
   } catch (error) {
@@ -3653,12 +3753,12 @@ async function performCliUpdate(options = {}) {
 
 // src/commands/update/actions/dependency-update.ts
 import * as clack8 from "@clack/prompts";
-import { promises as fs6 } from "fs";
-import * as path17 from "path";
+import { promises as fs7 } from "fs";
+import * as path18 from "path";
 
 // src/commands/update/utils/package-utils.ts
-import fs5 from "fs/promises";
-import { logger as logger13 } from "@elizaos/core";
+import fs6 from "fs/promises";
+import { logger as logger14 } from "@elizaos/core";
 async function checkForUpdates(dependencies) {
   const updates = {};
   const elizaPackages = Object.entries(dependencies).filter(([pkg]) => pkg.startsWith(ELIZAOS_ORG)).filter(([, version]) => !isWorkspaceVersion(version));
@@ -3669,7 +3769,7 @@ async function checkForUpdates(dependencies) {
     if (needsUpdate) {
       updates[pkg] = { current: currentVersion, latest: latestVersion };
     } else if (error) {
-      logger13.debug(`${pkg}: ${error}`);
+      logger14.debug(`${pkg}: ${error}`);
     }
   }
   return { hasUpdates: Object.keys(updates).length > 0, updates };
@@ -3683,7 +3783,7 @@ function displayUpdateSummary(updates) {
   });
 }
 async function updatePackageJson(packageJsonPath, updates) {
-  const content = await fs5.readFile(packageJsonPath, "utf8");
+  const content = await fs6.readFile(packageJsonPath, "utf8");
   const packageJson = JSON.parse(content);
   let modified = false;
   for (const [pkg, { latest }] of Object.entries(updates)) {
@@ -3697,7 +3797,7 @@ async function updatePackageJson(packageJsonPath, updates) {
     }
   }
   if (modified) {
-    await fs5.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+    await fs6.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
     console.log("Updated package.json with new versions");
   }
 }
@@ -3717,8 +3817,8 @@ async function installDependencies(cwd) {
 // src/commands/update/actions/dependency-update.ts
 async function updateDependencies(cwd, isPlugin2, options = {}) {
   const { dryRun = false, skipBuild = false } = options;
-  const packageJsonPath = path17.join(cwd, "package.json");
-  const content = await fs6.readFile(packageJsonPath, "utf8");
+  const packageJsonPath = path18.join(cwd, "package.json");
+  const content = await fs7.readFile(packageJsonPath, "utf8");
   const packageJson = JSON.parse(content);
   const allDependencies = {
     ...packageJson.dependencies,
@@ -3788,7 +3888,7 @@ var update = new Command4().name("update").description("Update ElizaOS CLI and p
   try {
     await displayBanner(true);
   } catch {
-    logger14.debug("Banner display failed, continuing with update");
+    logger15.debug("Banner display failed, continuing with update");
   }
 }).action(async (options) => {
   try {
@@ -3820,7 +3920,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;
       }
-      logger14.debug(`Detected ${directoryInfo.type}`);
+      logger15.debug(`Detected ${directoryInfo.type}`);
       if (!isInProject) {
         handleInvalidDirectory(directoryInfo);
         return;
@@ -3857,11 +3957,11 @@ var update = new Command4().name("update").description("Update ElizaOS CLI and p
 // src/commands/publish/utils/version-check.ts
 async function checkCliVersion() {
   try {
-    const cliPackageJsonPath = path18.resolve(
-      path18.dirname(fileURLToPath3(import.meta.url)),
+    const cliPackageJsonPath = path19.resolve(
+      path19.dirname(fileURLToPath3(import.meta.url)),
       "../package.json"
     );
-    const cliPackageJsonContent = await fs7.readFile(cliPackageJsonPath, "utf-8");
+    const cliPackageJsonContent = await fs8.readFile(cliPackageJsonPath, "utf-8");
     const cliPackageJson = JSON.parse(cliPackageJsonContent);
     const currentVersion = cliPackageJson.version || "0.0.0";
     const { stdout } = await bunExecSimple("npm", ["view", "@elizaos/cli", "time", "--json"]);
@@ -3919,7 +4019,7 @@ var publish = new Command5().name("publish").description("Publish a plugin to np
       process.exit(1);
     }
     const cliVersion = await checkCliVersion();
-    const pluginDirName = path19.basename(process.cwd());
+    const pluginDirName = path20.basename(process.cwd());
     if (!pluginDirName.startsWith("plugin-")) {
       console.error("This command must be run from a plugin directory (plugin-*)");
       process.exit(1);
@@ -3945,8 +4045,8 @@ var publish = new Command5().name("publish").description("Publish a plugin to np
         }
       }
     }
-    const packageJsonPath = path19.join(cwd, "package.json");
-    const packageJsonContent = await fs8.readFile(packageJsonPath, "utf-8");
+    const packageJsonPath = path20.join(cwd, "package.json");
+    const packageJsonContent = await fs9.readFile(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     if (!packageJson.name || !packageJson.version) {
       console.error("Invalid package.json: missing name or version.");
@@ -4087,7 +4187,7 @@ var publish = new Command5().name("publish").description("Publish a plugin to np
       }
     });
     const finalPluginName = packageJson.name.startsWith("@") ? packageJson.name.split("/")[1] : packageJson.name;
-    await fs8.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
+    await fs9.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
     await validatePluginRequirements(cwd, packageJson);
     const settings = await getRegistrySettings();
     const publishUsername = credentials ? credentials.username : npmUsername;
@@ -4211,8 +4311,8 @@ var publish = new Command5().name("publish").description("Publish a plugin to np
 import { Command as Command6 } from "commander";
 
 // src/commands/monorepo/actions/clone.ts
-import { existsSync as existsSync12, readdirSync as readdirSync3, mkdirSync } from "fs";
-import path20 from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync3, mkdirSync } from "fs";
+import path21 from "path";
 async function cloneRepository(repo, branch, destination) {
   try {
     const repoUrl = `https://github.com/${repo}`;
@@ -4236,8 +4336,8 @@ For a complete list of branches, visit: https://github.com/elizaOS/eliza/branche
   }
 }
 function prepareDestination(dir) {
-  const destinationDir = path20.resolve(process.cwd(), dir);
-  if (existsSync12(destinationDir)) {
+  const destinationDir = path21.resolve(process.cwd(), dir);
+  if (existsSync13(destinationDir)) {
     const files = readdirSync3(destinationDir);
     if (files.length > 0) {
       throw new Error(`Destination directory ${destinationDir} already exists and is not empty`);
@@ -4255,7 +4355,7 @@ async function cloneMonorepo(cloneInfo) {
 }
 
 // src/commands/monorepo/utils/setup-instructions.ts
-import path21 from "path";
+import path22 from "path";
 function getBunInstallInstructions() {
   const platform = process.platform;
   if (platform === "win32") {
@@ -4310,7 +4410,7 @@ ${emoji.rocket("If you don't have Bun installed:")}`);
   console.log("   After installation, restart your terminal");
 }
 function displayNextSteps(targetDir) {
-  const cdPath = path21.relative(process.cwd(), targetDir);
+  const cdPath = path22.relative(process.cwd(), targetDir);
   displayBasicSteps(cdPath);
   displayPrerequisites();
   displayBunInstructions();
@@ -4337,11 +4437,11 @@ var monorepo = new Command6().name("monorepo").description("Clone ElizaOS monore
 
 // src/project.ts
 import {
-  logger as logger15
+  logger as logger16
 } from "@elizaos/core";
 import { stringToUuid } from "@elizaos/core";
-import * as fs9 from "fs";
-import path22 from "path";
+import * as fs10 from "fs";
+import path23 from "path";
 function isPlugin(module) {
   if (module && typeof module === "object" && typeof module.name === "string" && typeof module.description === "string") {
     return true;
@@ -4376,10 +4476,10 @@ async function loadProject(dir) {
     if (!dirInfo.hasPackageJson) {
       throw new Error(`No package.json found in ${dir}`);
     }
-    const packageJson = JSON.parse(fs9.readFileSync(path22.join(dir, "package.json"), "utf8"));
+    const packageJson = JSON.parse(fs10.readFileSync(path23.join(dir, "package.json"), "utf8"));
     const main2 = packageJson.main;
     if (!main2) {
-      logger15.warn("No main field found in package.json, using default character");
+      logger16.warn("No main field found in package.json, using default character");
       const defaultCharacterName = "Eliza (Default)";
       const elizaCharacter = getElizaCharacter();
       const defaultAgent = {
@@ -4389,7 +4489,7 @@ async function loadProject(dir) {
           name: defaultCharacterName
         },
         init: async () => {
-          logger15.info("Initializing default Eliza character");
+          logger16.info("Initializing default Eliza character");
         }
       };
       return {
@@ -4398,32 +4498,32 @@ async function loadProject(dir) {
       };
     }
     const entryPoints = [
-      path22.join(dir, main2),
-      path22.join(dir, "dist/index.js"),
-      path22.join(dir, "src/index.ts"),
-      path22.join(dir, "src/index.js"),
-      path22.join(dir, "index.ts"),
-      path22.join(dir, "index.js")
+      path23.join(dir, main2),
+      path23.join(dir, "dist/index.js"),
+      path23.join(dir, "src/index.ts"),
+      path23.join(dir, "src/index.js"),
+      path23.join(dir, "index.ts"),
+      path23.join(dir, "index.js")
     ];
     let projectModule = null;
     for (const entryPoint of entryPoints) {
-      if (fs9.existsSync(entryPoint)) {
+      if (fs10.existsSync(entryPoint)) {
         try {
-          const importPath = path22.resolve(entryPoint);
+          const importPath = path23.resolve(entryPoint);
           const importUrl = process.platform === "win32" ? "file:///" + importPath.replace(/\\/g, "/") : "file://" + importPath;
           projectModule = await import(importUrl);
-          logger15.info(`Loaded project from ${entryPoint}`);
+          logger16.info(`Loaded project from ${entryPoint}`);
           const exportKeys = Object.keys(projectModule);
-          logger15.debug(`Module exports: ${exportKeys.join(", ")}`);
+          logger16.debug({ exportKeys }, `Module exports:`);
           if (exportKeys.includes("default")) {
-            logger15.debug(`Default export type: ${typeof projectModule.default}`);
+            logger16.debug({ type: typeof projectModule.default }, `Default export type:`);
             if (typeof projectModule.default === "object" && projectModule.default !== null) {
-              logger15.debug(`Default export keys: ${Object.keys(projectModule.default).join(", ")}`);
+              logger16.debug({ keys: Object.keys(projectModule.default) }, `Default export keys:`);
             }
           }
           break;
         } catch (error) {
-          logger15.warn(`Failed to import project from ${entryPoint}:`, error);
+          logger16.warn({ error, entryPoint }, `Failed to import project`);
         }
       }
     }
@@ -4431,13 +4531,13 @@ async function loadProject(dir) {
       throw new Error("Could not find project entry point");
     }
     const moduleIsPlugin = isPlugin(projectModule);
-    logger15.debug(`Is this a plugin? ${moduleIsPlugin}`);
+    logger16.debug({ moduleIsPlugin }, `Is this a plugin?`);
     if (moduleIsPlugin) {
-      logger15.info("Detected plugin module instead of project");
+      logger16.info("Detected plugin module instead of project");
       try {
         const plugin = extractPlugin(projectModule);
-        logger15.debug(`Found plugin: ${plugin.name} - ${plugin.description}`);
-        logger15.debug(`Plugin has the following properties: ${Object.keys(plugin).join(", ")}`);
+        logger16.debug({ name: plugin.name, description: plugin.description }, `Found plugin:`);
+        logger16.debug({ keys: Object.keys(plugin) }, `Plugin has the following properties:`);
         const completePlugin = {
           // Copy all other properties from the original plugin first
           ...plugin,
@@ -4445,7 +4545,7 @@ async function loadProject(dir) {
           name: plugin.name || "unknown-plugin",
           description: plugin.description || "No description",
           init: plugin.init || (async () => {
-            logger15.info(`Dummy init for plugin: ${plugin.name}`);
+            logger16.info(`Dummy init for plugin: ${plugin.name}`);
           })
         };
         const characterName = "Eliza (Test Mode)";
@@ -4456,13 +4556,13 @@ async function loadProject(dir) {
           name: characterName,
           system: `${elizaCharacter.system} Testing the plugin: ${completePlugin.name}.`
         };
-        logger15.info(`Using Eliza character as test agent for plugin: ${completePlugin.name}`);
+        logger16.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 () => {
-            logger15.info(`Initializing Eliza test agent for plugin: ${completePlugin.name}`);
+            logger16.info(`Initializing Eliza test agent for plugin: ${completePlugin.name}`);
           }
         };
         return {
@@ -4472,24 +4572,24 @@ async function loadProject(dir) {
           pluginModule: completePlugin
         };
       } catch (error) {
-        logger15.error("Error extracting plugin from module:", error);
+        logger16.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);
-      logger15.debug(`Found ${agents.length} agents in default export's agents array`);
+      logger16.debug({ count: agents.length }, `Found 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);
-            logger15.debug(`Found agent in default export (single agent)`);
+            logger16.debug(`Found agent in default export (single agent)`);
           }
         } else if (value && typeof value === "object" && value.character && value.init) {
           agents.push(value);
-          logger15.debug(`Found agent in named export: ${key}`);
+          logger16.debug({ key }, `Found agent in named export`);
         }
       }
     }
@@ -4502,7 +4602,7 @@ async function loadProject(dir) {
     };
     return project;
   } catch (error) {
-    logger15.error("Error loading project:", error);
+    logger16.error({ error }, "Error loading project:");
     throw error;
   }
 }
@@ -4517,19 +4617,19 @@ function validatePort(value) {
 }
 
 // src/commands/start/index.ts
-import { logger as logger20 } from "@elizaos/core";
+import { logger as logger21 } from "@elizaos/core";
 import { Command as Command7 } from "commander";
-import * as fs10 from "fs";
-import * as path24 from "path";
+import * as fs11 from "fs";
+import * as path25 from "path";
 
 // src/commands/start/actions/server-start.ts
-import { logger as logger19 } from "@elizaos/core";
+import { logger as logger20 } from "@elizaos/core";
 
 // src/commands/start/actions/agent-start.ts
 import {
   AgentRuntime as AgentRuntime2,
   encryptedCharacter,
-  logger as logger18,
+  logger as logger19,
   stringToUuid as stringToUuid2
 } from "@elizaos/core";
 import { plugin as sqlPlugin } from "@elizaos/plugin-sql";
@@ -4572,19 +4672,19 @@ async function setDefaultSecretsFromEnv(character) {
 }
 
 // src/commands/start/utils/dependency-resolver.ts
-import { logger as logger16 } from "@elizaos/core";
+import { logger as logger17 } 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)) {
-      logger16.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
+      logger17.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
       return;
     }
     if (visited.has(pluginName)) return;
     if (visiting.has(pluginName)) {
-      logger16.error(`Circular dependency detected involving plugin: ${pluginName}`);
+      logger17.error(`Circular dependency detected involving plugin: ${pluginName}`);
       return;
     }
     visiting.add(pluginName);
@@ -4608,12 +4708,12 @@ function resolvePluginDependencies(availablePlugins, isTestMode = false) {
     }
   }
   const finalPlugins = resolutionOrder.map((name) => availablePlugins.get(name)).filter((p) => p);
-  logger16.info(`Final plugins being loaded: ${finalPlugins.map((p) => p.name).join(", ")}`);
+  logger17.info({ plugins: finalPlugins.map((p) => p.name) }, `Final plugins being loaded:`);
   return finalPlugins;
 }
 
 // src/commands/start/utils/plugin-utils.ts
-import { logger as logger17 } from "@elizaos/core";
+import { logger as logger18 } from "@elizaos/core";
 function isValidPluginShape(obj) {
   if (!obj || typeof obj !== "object" || !obj.name) {
     return false;
@@ -4628,12 +4728,12 @@ async function loadAndPreparePlugin(pluginName) {
     try {
       pluginModule = await loadPluginModule(pluginName);
       if (!pluginModule) {
-        logger17.error(`Failed to load local plugin ${pluginName}.`);
+        logger18.error(`Failed to load local plugin ${pluginName}.`);
         provideLocalPluginGuidance(pluginName, context);
         return null;
       }
     } catch (error) {
-      logger17.error(`Error loading local plugin ${pluginName}: ${error}`);
+      logger18.error(`Error loading local plugin ${pluginName}: ${error}`);
       provideLocalPluginGuidance(pluginName, context);
       return null;
     }
@@ -4641,17 +4741,17 @@ async function loadAndPreparePlugin(pluginName) {
     try {
       pluginModule = await loadPluginModule(pluginName);
       if (!pluginModule) {
-        logger17.info(`Plugin ${pluginName} not available, installing...`);
+        logger18.info(`Plugin ${pluginName} not available, installing...`);
         await installPlugin(pluginName, process.cwd(), version);
         pluginModule = await loadPluginModule(pluginName);
       }
     } catch (error) {
-      logger17.error(`Failed to process plugin ${pluginName}: ${error}`);
+      logger18.error(`Failed to process plugin ${pluginName}: ${error}`);
       return null;
     }
   }
   if (!pluginModule) {
-    logger17.error(`Failed to load module for plugin ${pluginName}.`);
+    logger18.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`;
@@ -4665,7 +4765,7 @@ async function loadAndPreparePlugin(pluginName) {
       return potentialPlugin;
     }
   }
-  logger17.warn(`Could not find a valid plugin export in ${pluginName}.`);
+  logger18.warn(`Could not find a valid plugin export in ${pluginName}.`);
   return null;
 }
 
@@ -4676,7 +4776,6 @@ async function startAgent(character, server, init, plugins2 = [], options = {})
     await setDefaultSecretsFromEnv(character);
   }
   const loadedPlugins = /* @__PURE__ */ new Map();
-  loadedPlugins.set(sqlPlugin.name, sqlPlugin);
   const pluginsToLoad = new Set(character.plugins || []);
   for (const p of plugins2) {
     if (typeof p === "string") {
@@ -4701,6 +4800,16 @@ async function startAgent(character, server, init, plugins2 = [], options = {})
       }
     }
   }
+  let haveSql = false;
+  for (const n of allAvailablePlugins.keys()) {
+    if (n === sqlPlugin.name || n === "mysql") {
+      haveSql = true;
+      break;
+    }
+  }
+  if (!haveSql) {
+    allAvailablePlugins.set(sqlPlugin.name, sqlPlugin);
+  }
   const finalPlugins = resolvePluginDependencies(allAvailablePlugins, options.isTestMode);
   const runtime = new AgentRuntime2({
     character: encryptedCharacter(character),
@@ -4717,32 +4826,32 @@ async function startAgent(character, server, init, plugins2 = [], options = {})
   try {
     const migrationService = runtime.getService("database_migration");
     if (migrationService) {
-      logger18.info("Discovering plugin schemas for dynamic migration...");
+      logger19.info("Discovering plugin schemas for dynamic migration...");
       migrationService.discoverAndRegisterPluginSchemas(finalPlugins);
-      logger18.info("Running all plugin migrations...");
+      logger19.info("Running all plugin migrations...");
       await migrationService.runAllPluginMigrations();
-      logger18.info("All plugin migrations completed successfully");
+      logger19.info("All plugin migrations completed successfully");
     } else {
-      logger18.warn("DatabaseMigrationService not found - plugin schema migrations skipped");
+      logger19.warn("DatabaseMigrationService not found - plugin schema migrations skipped");
     }
   } catch (error) {
-    logger18.error("Failed to run plugin migrations:", error);
+    logger19.error({ error }, "Failed to run plugin migrations:");
     throw error;
   }
   server.registerAgent(runtime);
-  logger18.log(`Started ${runtime.character.name} as ${runtime.agentId}`);
+  logger19.log(`Started ${runtime.character.name} as ${runtime.agentId}`);
   return runtime;
 }
 async function stopAgent(runtime, server) {
   await runtime.close();
   server.unregisterAgent(runtime.agentId);
-  logger18.success(`Agent ${runtime.character.name} stopped successfully!`);
+  logger19.success(`Agent ${runtime.character.name} stopped successfully!`);
 }
 
 // src/commands/start/actions/server-start.ts
-import path23 from "path";
+import path24 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { existsSync as existsSync14, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync7 } from "fs";
 async function startAgents(options) {
   const postgresUrl = await configureDatabaseSettings(options.configure);
   if (postgresUrl) process.env.POSTGRES_URL = postgresUrl;
@@ -4751,19 +4860,19 @@ async function startAgents(options) {
   const serverModule = await moduleLoader.load("@elizaos/server");
   const { AgentServer, jsonToCharacter, loadCharacterTryPath } = serverModule;
   const __filename = fileURLToPath4(import.meta.url);
-  const __dirname = path23.dirname(__filename);
-  let cliDistPath = path23.resolve(__dirname, "../../../");
-  const indexPath = path23.join(cliDistPath, "index.html");
-  if (!existsSync14(indexPath)) {
+  const __dirname = path24.dirname(__filename);
+  let cliDistPath = path24.resolve(__dirname, "../../../");
+  const indexPath = path24.join(cliDistPath, "index.html");
+  if (!existsSync15(indexPath)) {
     let currentDir = __dirname;
-    while (currentDir !== path23.dirname(currentDir)) {
-      const packageJsonPath = path23.join(currentDir, "package.json");
-      if (existsSync14(packageJsonPath)) {
+    while (currentDir !== path24.dirname(currentDir)) {
+      const packageJsonPath = path24.join(currentDir, "package.json");
+      if (existsSync15(packageJsonPath)) {
         try {
-          const packageJson = JSON.parse(readFileSync6(packageJsonPath, "utf-8"));
+          const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
           if (packageJson.name === "@elizaos/cli") {
-            const distPath = path23.join(currentDir, "dist");
-            if (existsSync14(path23.join(distPath, "index.html"))) {
+            const distPath = path24.join(currentDir, "dist");
+            if (existsSync15(path24.join(distPath, "index.html"))) {
               cliDistPath = distPath;
               break;
             }
@@ -4771,7 +4880,7 @@ async function startAgents(options) {
         } catch {
         }
       }
-      currentDir = path23.dirname(currentDir);
+      currentDir = path24.dirname(currentDir);
     }
   }
   const server = new AgentServer();
@@ -4786,13 +4895,13 @@ async function startAgents(options) {
   const desiredPort = options.port || Number.parseInt(process.env.SERVER_PORT || "3000");
   const serverPort = await findNextAvailablePort(desiredPort);
   if (serverPort !== desiredPort) {
-    logger19.warn(`Port ${desiredPort} is in use, using port ${serverPort} instead`);
+    logger20.warn({ desiredPort, serverPort }, "Port is in use, using alternate port");
   }
   process.env.SERVER_PORT = serverPort.toString();
   try {
     await server.start(serverPort);
   } catch (error) {
-    logger19.error(`Failed to start server on port ${serverPort}:`, error);
+    logger20.error({ error, serverPort }, `Failed to start server on port:`);
     throw error;
   }
   if (options.projectAgents && options.projectAgents.length > 0) {
@@ -4820,15 +4929,16 @@ var start = new Command7().name("start").description("Build and start the Eliza
 }).action(async (options) => {
   try {
     await loadEnvConfig();
-    const localModulesPath = path24.join(process.cwd(), "node_modules");
+    await ensureElizaOSCli();
+    const localModulesPath = path25.join(process.cwd(), "node_modules");
     if (process.env.NODE_PATH) {
-      process.env.NODE_PATH = `${localModulesPath}${path24.delimiter}${process.env.NODE_PATH}`;
+      process.env.NODE_PATH = `${localModulesPath}${path25.delimiter}${process.env.NODE_PATH}`;
     } else {
       process.env.NODE_PATH = localModulesPath;
     }
-    const localBinPath = path24.join(process.cwd(), "node_modules", ".bin");
+    const localBinPath = path25.join(process.cwd(), "node_modules", ".bin");
     if (process.env.PATH) {
-      process.env.PATH = `${localBinPath}${path24.delimiter}${process.env.PATH}`;
+      process.env.PATH = `${localBinPath}${path25.delimiter}${process.env.PATH}`;
     } else {
       process.env.PATH = localBinPath;
     }
@@ -4839,8 +4949,8 @@ var start = new Command7().name("start").description("Build and start the Eliza
       try {
         await buildProject(cwd, false);
       } catch (error) {
-        logger20.error(`Build error: ${error instanceof Error ? error.message : String(error)}`);
-        logger20.warn(
+        logger21.error(`Build error: ${error instanceof Error ? error.message : String(error)}`);
+        logger21.warn(
           "Build failed, but continuing with start. Some features may not work correctly."
         );
       }
@@ -4852,24 +4962,24 @@ var start = new Command7().name("start").description("Build and start the Eliza
       const serverModule = await moduleLoader.load("@elizaos/server");
       const { loadCharacterTryPath } = serverModule;
       for (const charPath of options.character) {
-        const resolvedPath = path24.resolve(charPath);
-        if (!fs10.existsSync(resolvedPath)) {
-          logger20.error(`Character file not found: ${resolvedPath}`);
+        const resolvedPath = path25.resolve(charPath);
+        if (!fs11.existsSync(resolvedPath)) {
+          logger21.error(`Character file not found: ${resolvedPath}`);
           throw new Error(`Character file not found: ${resolvedPath}`);
         }
         try {
           const character = await loadCharacterTryPath(resolvedPath);
           if (character) {
             characters.push(character);
-            logger20.info(`Successfully loaded character: ${character.name}`);
+            logger21.info(`Successfully loaded character: ${character.name}`);
           } else {
-            logger20.error(
+            logger21.error(
               `Failed to load character from ${resolvedPath}: Invalid or empty character file`
             );
             throw new Error(`Invalid character file: ${resolvedPath}`);
           }
         } catch (e) {
-          logger20.error(`Failed to load character from ${resolvedPath}:`, e);
+          logger21.error({ error: e, resolvedPath }, `Failed to load character from path:`);
           throw new Error(`Invalid character file: ${resolvedPath}`);
         }
       }
@@ -4878,20 +4988,20 @@ var start = new Command7().name("start").description("Build and start the Eliza
         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...");
+          logger21.info("No character files specified, attempting to load project agents...");
           const project = await loadProject(cwd2);
           if (project.agents && project.agents.length > 0) {
-            logger20.info(`Found ${project.agents.length} agent(s) in project configuration`);
+            logger21.info(`Found ${project.agents.length} agent(s) in project configuration`);
             projectAgents = project.agents;
             for (const agent2 of project.agents) {
               if (agent2.character) {
-                logger20.info(`Loaded character: ${agent2.character.name}`);
+                logger21.info(`Loaded character: ${agent2.character.name}`);
               }
             }
           }
         }
       } catch (e) {
-        logger20.debug("Failed to load project agents, will use default character:", e);
+        logger21.debug({ error: e }, "Failed to load project agents, will use default character:");
       }
     }
     await startAgents({ ...options, characters, projectAgents });
@@ -4970,18 +5080,18 @@ ${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 logger27 } from "@elizaos/core";
+import { logger as logger28 } from "@elizaos/core";
 import { Command as Command10, Option as Option2 } from "commander";
 
 // src/commands/test/actions/run-all-tests.ts
-import { logger as logger25 } from "@elizaos/core";
+import { logger as logger26 } from "@elizaos/core";
 
 // src/commands/test/utils/project-utils.ts
-import { logger as logger21 } from "@elizaos/core";
-import * as fs11 from "fs";
-import path25 from "path";
+import { logger as logger22 } from "@elizaos/core";
+import * as fs12 from "fs";
+import path26 from "path";
 function getProjectType(testPath) {
-  const targetPath = testPath ? path25.resolve(process.cwd(), testPath) : process.cwd();
+  const targetPath = testPath ? path26.resolve(process.cwd(), testPath) : process.cwd();
   return detectDirectoryType(targetPath);
 }
 function processFilterName(name) {
@@ -5000,29 +5110,29 @@ async function installPluginDependencies(projectInfo) {
   }
   const project = await loadProject(process.cwd());
   if (project.isPlugin && project.pluginModule?.dependencies && project.pluginModule.dependencies.length > 0) {
-    const pluginsDir = path25.join(process.cwd(), ".eliza", "plugins");
-    if (!fs11.existsSync(pluginsDir)) {
-      await fs11.promises.mkdir(pluginsDir, { recursive: true });
+    const pluginsDir = path26.join(process.cwd(), ".eliza", "plugins");
+    if (!fs12.existsSync(pluginsDir)) {
+      await fs12.promises.mkdir(pluginsDir, { recursive: true });
     }
-    const packageJsonPath = path25.join(pluginsDir, "package.json");
-    if (!fs11.existsSync(packageJsonPath)) {
+    const packageJsonPath = path26.join(pluginsDir, "package.json");
+    if (!fs12.existsSync(packageJsonPath)) {
       const packageJsonContent = {
         name: "test-plugin-dependencies",
         version: "1.0.0",
         description: "A temporary package for installing test plugin dependencies",
         dependencies: {}
       };
-      await fs11.promises.writeFile(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
+      await fs12.promises.writeFile(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
     }
-    const { installPlugin: installPlugin2 } = await import("./utils-H66532NB.js");
+    const { installPlugin: installPlugin2 } = await import("./utils-5HPZSIF6.js");
     for (const dependency of project.pluginModule.dependencies) {
       await installPlugin2(dependency, pluginsDir);
-      const dependencyPath = path25.join(pluginsDir, "node_modules", dependency);
-      if (fs11.existsSync(dependencyPath)) {
+      const dependencyPath = path26.join(pluginsDir, "node_modules", dependency);
+      if (fs12.existsSync(dependencyPath)) {
         try {
           await runBunCommand(["install"], dependencyPath);
         } catch (error) {
-          logger21.warn(
+          logger22.warn(
             `[Test Command] Failed to install devDependencies for ${dependency}: ${error}`
           );
         }
@@ -5032,17 +5142,16 @@ async function installPluginDependencies(projectInfo) {
 }
 
 // src/commands/test/actions/component-tests.ts
-import { logger as logger23 } from "@elizaos/core";
-import { spawn as spawn2 } from "child_process";
-import path27 from "path";
+import { logger as logger24 } from "@elizaos/core";
+import path28 from "path";
 
 // src/utils/testing/tsc-validator.ts
-import { logger as logger22 } from "@elizaos/core";
-import path26 from "path";
-import { existsSync as existsSync17 } from "fs";
+import { logger as logger23 } from "@elizaos/core";
+import path27 from "path";
+import { existsSync as existsSync18 } from "fs";
 async function runTypeCheck(projectPath, strict = true) {
-  const tsconfigPath = path26.join(projectPath, "tsconfig.json");
-  if (!existsSync17(tsconfigPath)) {
+  const tsconfigPath = path27.join(projectPath, "tsconfig.json");
+  if (!existsSync18(tsconfigPath)) {
     return {
       success: false,
       errors: [`No tsconfig.json found at ${tsconfigPath}`],
@@ -5054,7 +5163,7 @@ async function runTypeCheck(projectPath, strict = true) {
     if (strict) {
       args.push("--strict");
     }
-    const result = await bunExec("tsc", args, {
+    const result = await bunExec("bun", ["x", "tsc", ...args], {
       cwd: projectPath
     });
     const { stdout, stderr } = result;
@@ -5065,7 +5174,7 @@ async function runTypeCheck(projectPath, strict = true) {
       warnings: stderr.includes("warning") ? [stderr] : []
     };
   } catch (error) {
-    logger22.error("TypeScript validation failed:", error);
+    logger23.error({ error }, "TypeScript validation failed:");
     return {
       success: false,
       errors: [`TypeScript validation error: ${error.message}`],
@@ -5079,78 +5188,72 @@ async function runComponentTests(testPath, options, projectInfo) {
   const cwd = process.cwd();
   const isPlugin2 = projectInfo.type === "elizaos-plugin";
   if (!options.skipTypeCheck) {
-    logger23.info("Running TypeScript validation...");
+    logger24.info("Running TypeScript validation...");
     const typeCheckResult = await runTypeCheck(cwd, true);
     if (!typeCheckResult.success) {
-      logger23.error("TypeScript validation failed:");
-      typeCheckResult.errors.forEach((error) => logger23.error(error));
+      logger24.error("TypeScript validation failed:");
+      typeCheckResult.errors.forEach((error) => logger24.error(error));
       return { failed: true };
     }
-    logger23.success("TypeScript validation passed");
+    logger24.success("TypeScript validation passed");
   }
   if (!options.skipBuild) {
     try {
-      logger23.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
+      logger24.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
       await buildProject(cwd, isPlugin2);
-      logger23.success(`Build completed successfully`);
+      logger24.success(`Build completed successfully`);
     } catch (buildError) {
-      logger23.error(`Build failed: ${buildError}`);
+      logger24.error(`Build failed: ${buildError}`);
       return { failed: true };
     }
   }
-  logger23.info("Running component tests...");
-  return new Promise((resolve2) => {
-    const args = ["test", "--passWithNoTests"];
-    if (options.name) {
-      const baseName = processFilterName(options.name);
-      if (baseName) {
-        logger23.info(`Using test filter: ${baseName}`);
-        args.push("-t", baseName);
-      }
+  logger24.info("Running component tests...");
+  const args = ["test", "--passWithNoTests"];
+  if (options.name) {
+    const baseName = processFilterName(options.name);
+    if (baseName) {
+      logger24.info(`Using test filter: ${baseName}`);
+      args.push("-t", baseName);
     }
-    const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
-    const baseDir = monorepoRoot ?? process.cwd();
-    const targetPath = testPath ? path27.resolve(baseDir, testPath) : process.cwd();
-    logger23.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
-    const child = spawn2("bun", args, {
-      stdio: "inherit",
-      shell: false,
+  }
+  const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
+  const baseDir = monorepoRoot ?? process.cwd();
+  const targetPath = testPath ? path28.resolve(baseDir, testPath) : process.cwd();
+  logger24.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
+  try {
+    const result = await bunExecInherit("bun", args, {
       cwd: targetPath,
       env: {
-        ...process.env,
         FORCE_COLOR: "1",
         // Force color output
-        CI: "false"
-        // Ensure we're not in CI mode which might buffer
+        CI: ""
+        // Override CI to empty string (some tools check existence, but most check truthiness)
       }
     });
-    child.on("close", (code) => {
-      logger23.info("Component tests completed");
-      resolve2({ failed: code !== 0 });
-    });
-    child.on("error", (error) => {
-      logger23.error("Error running component tests:", error);
-      resolve2({ failed: true });
-    });
-  });
+    logger24.info("Component tests completed");
+    return { failed: !result.success };
+  } catch (error) {
+    logger24.error({ error }, "Error running component tests:");
+    return { failed: true };
+  }
 }
 
 // src/commands/test/actions/e2e-tests.ts
-import { logger as logger24 } from "@elizaos/core";
+import { logger as logger25 } from "@elizaos/core";
 import * as dotenv2 from "dotenv";
-import * as fs12 from "fs";
-import path28 from "path";
+import * as fs13 from "fs";
+import path29 from "path";
 async function runE2eTests(testPath, options, projectInfo) {
   if (!options.skipBuild) {
     try {
       const cwd = process.cwd();
       const isPlugin2 = projectInfo.type === "elizaos-plugin";
-      logger24.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
+      logger25.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
       await buildProject(cwd, isPlugin2);
-      logger24.info(`Build completed successfully`);
+      logger25.info(`Build completed successfully`);
     } catch (buildError) {
-      logger24.error(`Build error: ${buildError}`);
-      logger24.warn(`Attempting to continue with tests despite build error`);
+      logger25.error(`Build error: ${buildError}`);
+      logger25.warn(`Attempting to continue with tests despite build error`);
     }
   }
   let server;
@@ -5160,10 +5263,10 @@ async function runE2eTests(testPath, options, projectInfo) {
     const moduleLoader = getModuleLoader();
     const serverModule = await moduleLoader.load("@elizaos/server");
     const { AgentServer, jsonToCharacter, loadCharacterTryPath } = serverModule;
-    const elizaDir = path28.join(process.cwd(), ".eliza");
-    const packageName = path28.basename(process.cwd());
+    const elizaDir = path29.join(process.cwd(), ".eliza");
+    const packageName = path29.basename(process.cwd());
     const timestamp = Date.now();
-    const uniqueDbDir = path28.join(process.cwd(), ".elizadb-test", `${packageName}-${timestamp}`);
+    const uniqueDbDir = path29.join(process.cwd(), ".elizadb-test", `${packageName}-${timestamp}`);
     const elizaDbDir = uniqueDbDir;
     const envInfo = await UserEnvironment.getInstanceInfo();
     const envFilePath = envInfo.paths.envFilePath;
@@ -5172,88 +5275,88 @@ async function runE2eTests(testPath, options, projectInfo) {
     console.info(`Database directory: ${elizaDbDir}`);
     console.info(`Environment file: ${envFilePath}`);
     console.info(`Package name: ${packageName}, Timestamp: ${timestamp}`);
-    if (fs12.existsSync(elizaDbDir)) {
+    if (fs13.existsSync(elizaDbDir)) {
       console.info(`Cleaning up existing database directory: ${elizaDbDir}`);
       try {
-        fs12.rmSync(elizaDbDir, { recursive: true, force: true });
+        fs13.rmSync(elizaDbDir, { recursive: true, force: true });
         console.info(`Successfully cleaned up existing database directory`);
       } catch (error) {
         console.warn(`Failed to clean up existing database directory: ${error}`);
       }
     }
     console.info(`Creating fresh database directory: ${elizaDbDir}`);
-    fs12.mkdirSync(elizaDbDir, { recursive: true });
+    fs13.mkdirSync(elizaDbDir, { recursive: true });
     console.info(`Created database directory: ${elizaDbDir}`);
     process.env.PGLITE_DATA_DIR = elizaDbDir;
     console.info(`Set PGLITE_DATA_DIR to: ${elizaDbDir}`);
-    if (fs12.existsSync(envFilePath)) {
-      logger24.info(`Loading environment variables from: ${envFilePath}`);
+    if (fs13.existsSync(envFilePath)) {
+      logger25.info(`Loading environment variables from: ${envFilePath}`);
       dotenv2.config({ path: envFilePath });
-      logger24.info("Environment variables loaded");
+      logger25.info("Environment variables loaded");
     } else {
-      logger24.warn(`Environment file not found: ${envFilePath}`);
+      logger25.warn(`Environment file not found: ${envFilePath}`);
     }
     const postgresUrl = process.env.POSTGRES_URL;
-    logger24.info(
+    logger25.info(
       `PostgreSQL URL for e2e tests: ${postgresUrl ? "found" : "not found (will use PGlite)"}`
     );
-    logger24.info("Creating server instance...");
+    logger25.info("Creating server instance...");
     server = new AgentServer();
-    logger24.info("Server instance created");
-    logger24.info("Initializing server...");
+    logger25.info("Server instance created");
+    logger25.info("Initializing server...");
     try {
       await server.initialize({
         dataDir: elizaDbDir,
         postgresUrl
       });
-      logger24.info("Server initialized successfully");
+      logger25.info("Server initialized successfully");
     } catch (initError) {
-      logger24.error("Server initialization failed:", initError);
+      logger25.error({ error: initError }, "Server initialization failed:");
       throw initError;
     }
     let project;
     try {
-      logger24.info("Attempting to load project or plugin...");
+      logger25.info("Attempting to load project or plugin...");
       const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
       const baseDir = monorepoRoot ?? process.cwd();
-      const targetPath = testPath ? path28.resolve(baseDir, testPath) : process.cwd();
+      const targetPath = testPath ? path29.resolve(baseDir, testPath) : process.cwd();
       project = await loadProject(targetPath);
       if (!project || !project.agents || project.agents.length === 0) {
         throw new Error("No agents found in project configuration");
       }
-      logger24.info(`Found ${project.agents.length} agents`);
-      logger24.info("Setting up server properties...");
+      logger25.info(`Found ${project.agents.length} agents`);
+      logger25.info("Setting up server properties...");
       server.startAgent = async (character) => {
-        logger24.info(`Starting agent for character ${character.name}`);
+        logger25.info(`Starting agent for character ${character.name}`);
         return startAgent(character, server, void 0, [], { isTestMode: true });
       };
       server.loadCharacterTryPath = loadCharacterTryPath;
       server.jsonToCharacter = jsonToCharacter;
-      logger24.info("Server properties set up");
+      logger25.info("Server properties set up");
       const desiredPort = options.port || Number.parseInt(process.env.SERVER_PORT || "3000");
       const serverPort = await findNextAvailablePort(desiredPort);
       if (serverPort !== desiredPort) {
-        logger24.warn(`Port ${desiredPort} is in use for testing, using port ${serverPort} instead.`);
+        logger25.warn(`Port ${desiredPort} is in use for testing, using port ${serverPort} instead.`);
       }
-      logger24.info("Starting server...");
+      logger25.info("Starting server...");
       try {
         await server.start(serverPort);
-        logger24.info("Server started successfully on port", serverPort);
+        logger25.info({ serverPort }, "Server started successfully on port");
       } catch (error) {
-        logger24.error("Error starting server:", error);
+        logger25.error({ error }, "Error starting server:");
         if (error instanceof Error) {
-          logger24.error("Error details:", error.message);
-          logger24.error("Stack trace:", error.stack);
+          logger25.error({ message: error.message }, "Error details:");
+          logger25.error({ stack: error.stack }, "Stack trace:");
         }
         throw error;
       }
       try {
-        logger24.info(
+        logger25.info(
           `Found ${project.agents.length} agents in ${project.isPlugin ? "plugin" : "project"}`
         );
         if (project.isPlugin || project.agents.length === 0) {
           process.env.ELIZA_TESTING_PLUGIN = "true";
-          logger24.info("Using default Eliza character as test agent");
+          logger25.info("Using default Eliza character as test agent");
           try {
             const pluginUnderTest = project.pluginModule;
             if (!pluginUnderTest) {
@@ -5276,16 +5379,16 @@ async function runE2eTests(testPath, options, projectInfo) {
               plugins: runtime.plugins
               // Pass all plugins, not just the one under test
             });
-            logger24.info("Default test agent started successfully");
+            logger25.info("Default test agent started successfully");
           } catch (pluginError) {
-            logger24.error(`Error starting plugin test agent: ${pluginError}`);
+            logger25.error({ error: pluginError }, `Error starting plugin test agent:`);
             throw pluginError;
           }
         } else {
           for (const agent2 of project.agents) {
             try {
               const originalCharacter = { ...agent2.character };
-              logger24.debug(`Starting agent: ${originalCharacter.name}`);
+              logger25.debug(`Starting agent: ${originalCharacter.name}`);
               const runtime = await startAgent(
                 originalCharacter,
                 server,
@@ -5298,28 +5401,31 @@ async function runE2eTests(testPath, options, projectInfo) {
               projectAgents.push(agent2);
               await new Promise((resolve2) => setTimeout(resolve2, 1e3));
             } catch (agentError) {
-              logger24.error(`Error starting agent ${agent2.character.name}:`, agentError);
+              logger25.error(
+                { error: agentError, agentName: agent2.character.name },
+                "Error starting agent"
+              );
               if (agentError instanceof Error) {
-                logger24.error("Error details:", agentError.message);
-                logger24.error("Stack trace:", agentError.stack);
+                logger25.error({ message: agentError.message }, "Error details:");
+                logger25.error({ stack: agentError.stack }, "Stack trace:");
               }
-              logger24.warn(`Skipping agent ${agent2.character.name} due to startup error`);
+              logger25.warn(`Skipping agent ${agent2.character.name} due to startup error`);
             }
           }
         }
         if (runtimes.length === 0) {
           throw new Error("Failed to start any agents from project");
         }
-        logger24.debug(`Successfully started ${runtimes.length} agents for testing`);
+        logger25.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) {
-            logger24.debug(`Running tests for plugin: ${project.pluginModule?.name}`);
+            logger25.debug(`Running tests for plugin: ${project.pluginModule?.name}`);
           } else {
-            logger24.debug(`Running tests for agent: ${runtime.character.name}`);
+            logger25.debug(`Running tests for agent: ${runtime.character.name}`);
           }
           const testRunner = new TestRunner(runtime, projectAgent);
           const currentDirInfo = projectInfo;
@@ -5340,17 +5446,17 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
         return { failed: anyTestsFound ? totalFailed > 0 : false };
       } catch (error) {
-        logger24.error("Error in runE2eTests:", error);
+        logger25.error({ error }, "Error in runE2eTests:");
         if (error instanceof Error) {
-          logger24.error("Error details:", error.message);
-          logger24.error("Stack trace:", error.stack);
+          logger25.error({ message: error.message }, "Error details:");
+          logger25.error({ stack: error.stack }, "Stack trace:");
         } else {
-          logger24.error("Unknown error type:", typeof error);
-          logger24.error("Error value:", error);
+          logger25.error({ type: typeof error }, "Unknown error type:");
+          logger25.error({ error }, "Error value:");
           try {
-            logger24.error("Stringified error:", JSON.stringify(error, null, 2));
+            logger25.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
           } catch (e) {
-            logger24.error("Could not stringify error:", e);
+            logger25.error({ error: e }, "Could not stringify error:");
           }
         }
         return { failed: true };
@@ -5359,47 +5465,47 @@ async function runE2eTests(testPath, options, projectInfo) {
           delete process.env.ELIZA_TESTING_PLUGIN;
         }
         try {
-          if (fs12.existsSync(elizaDbDir)) {
+          if (fs13.existsSync(elizaDbDir)) {
             console.info(`Cleaning up test database directory: ${elizaDbDir}`);
-            fs12.rmSync(elizaDbDir, { recursive: true, force: true });
+            fs13.rmSync(elizaDbDir, { recursive: true, force: true });
             console.info(`Successfully cleaned up test database directory`);
           }
-          const testDir = path28.dirname(elizaDbDir);
-          if (fs12.existsSync(testDir) && fs12.readdirSync(testDir).length === 0) {
-            fs12.rmSync(testDir, { recursive: true, force: true });
+          const testDir = path29.dirname(elizaDbDir);
+          if (fs13.existsSync(testDir) && fs13.readdirSync(testDir).length === 0) {
+            fs13.rmSync(testDir, { recursive: true, force: true });
           }
         } catch (cleanupError) {
           console.warn(`Failed to clean up test database directory: ${cleanupError}`);
         }
       }
     } catch (error) {
-      logger24.error("Error in runE2eTests:", error);
+      logger25.error({ error }, "Error in runE2eTests:");
       if (error instanceof Error) {
-        logger24.error("Error details:", error.message);
-        logger24.error("Stack trace:", error.stack);
+        logger25.error({ message: error.message }, "Error details:");
+        logger25.error({ stack: error.stack }, "Stack trace:");
       } else {
-        logger24.error("Unknown error type:", typeof error);
-        logger24.error("Error value:", error);
+        logger25.error({ type: typeof error }, "Unknown error type:");
+        logger25.error({ error }, "Error value:");
         try {
-          logger24.error("Stringified error:", JSON.stringify(error, null, 2));
+          logger25.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
         } catch (e) {
-          logger24.error("Could not stringify error:", e);
+          logger25.error({ error: e }, "Could not stringify error:");
         }
       }
       return { failed: true };
     }
   } catch (error) {
-    logger24.error("Error in runE2eTests:", error);
+    logger25.error({ error }, "Error in runE2eTests:");
     if (error instanceof Error) {
-      logger24.error("Error details:", error.message);
-      logger24.error("Stack trace:", error.stack);
+      logger25.error({ message: error.message }, "Error details:");
+      logger25.error({ stack: error.stack }, "Stack trace:");
     } else {
-      logger24.error("Unknown error type:", typeof error);
-      logger24.error("Error value:", error);
+      logger25.error({ type: typeof error }, "Unknown error type:");
+      logger25.error({ error }, "Error value:");
       try {
-        logger24.error("Stringified error:", JSON.stringify(error, null, 2));
+        logger25.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
       } catch (e) {
-        logger24.error("Could not stringify error:", e);
+        logger25.error({ error: e }, "Could not stringify error:");
       }
     }
     return { failed: true };
@@ -5409,18 +5515,24 @@ async function runE2eTests(testPath, options, projectInfo) {
 // src/commands/test/actions/run-all-tests.ts
 async function runAllTests(testPath, options) {
   const projectInfo = getProjectType(testPath);
+  let componentResult = { failed: false };
   if (!options.skipBuild) {
-    const componentResult = await runComponentTests(testPath, options, projectInfo);
-    if (componentResult.failed) {
-      logger25.error("Component tests failed. Continuing to e2e tests...");
-    }
+    componentResult = await runComponentTests(testPath, options, projectInfo);
+  } else {
+    logger26.info("Skipping component tests due to --skip-build option");
   }
   const e2eResult = await runE2eTests(testPath, options, projectInfo);
-  if (e2eResult.failed) {
-    logger25.error("E2E tests failed.");
+  if (componentResult.failed || e2eResult.failed) {
+    if (componentResult.failed) {
+      logger26.error("Component tests failed.");
+    }
+    if (e2eResult.failed) {
+      logger26.error("E2E tests failed.");
+    }
+    logger26.error("Test suite failed.");
     process.exit(1);
   }
-  logger25.success("All tests passed successfully!");
+  logger26.success("All tests passed successfully!");
   process.exit(0);
 }
 
@@ -5428,43 +5540,47 @@ async function runAllTests(testPath, options) {
 import * as net from "net";
 
 // src/commands/test/utils/plugin-utils.ts
-import { logger as logger26 } from "@elizaos/core";
-import * as fs13 from "fs";
-import path29 from "path";
+import { logger as logger27 } from "@elizaos/core";
+import * as fs14 from "fs";
+import path30 from "path";
 
 // src/commands/test/index.ts
 var test = new Command10().name("test").description("Run tests for the current project or a specified plugin").argument("[path]", "Optional path to the project or plugin to test").addOption(
   new Option2("-t, --type <type>", "the type of test to run").choices(["component", "e2e", "all"]).default("all")
 ).option("--port <port>", "The port to run e2e tests on", validatePort).option("--name <name>", "Filter tests by name").option("--skip-build", "Skip building before running tests").option("--skip-type-check", "Skip TypeScript validation before running tests").hook("preAction", async (thisCommand) => {
   const testPath = thisCommand.args[0];
+  const options = thisCommand.opts();
+  if (options.type === "component") {
+    return;
+  }
   const projectInfo = getProjectType(testPath);
   await installPluginDependencies(projectInfo);
 }).action(async (testPath, options) => {
-  logger27.info("Starting tests...");
+  logger28.info("Starting tests...");
   try {
     const projectInfo = getProjectType(testPath);
     switch (options.type) {
       case "component":
-        logger27.info("Running component tests only...");
+        logger28.info("Running component tests only...");
         const componentResult = await runComponentTests(testPath, options, projectInfo);
         if (componentResult.failed) {
-          logger27.error("Component tests failed.");
+          logger28.error("Component tests failed.");
           process.exit(1);
         }
-        logger27.success("Component tests passed successfully!");
+        logger28.success("Component tests passed successfully!");
         break;
       case "e2e":
-        logger27.info("Running e2e tests only...");
+        logger28.info("Running e2e tests only...");
         const e2eResult = await runE2eTests(testPath, options, projectInfo);
         if (e2eResult.failed) {
-          logger27.error("E2E tests failed.");
+          logger28.error("E2E tests failed.");
           process.exit(1);
         }
-        logger27.success("E2E tests passed successfully!");
+        logger28.success("E2E tests passed successfully!");
         break;
       case "all":
       default:
-        logger27.info("Running all tests...");
+        logger28.info("Running all tests...");
         await runAllTests(testPath, options);
         break;
     }
@@ -5475,7 +5591,7 @@ var test = new Command10().name("test").description("Run tests for the current p
 });
 
 // src/index.ts
-import { logger as logger28 } from "@elizaos/core";
+import { logger as logger29 } from "@elizaos/core";
 import { Command as Command11 } from "commander";
 process.env.NODE_OPTIONS = "--no-deprecation";
 process.env.NODE_NO_WARNINGS = "1";
@@ -5496,19 +5612,19 @@ var shutdownState = {
 };
 async function gracefulShutdown(signal) {
   if (!shutdownState.tryInitiateShutdown()) {
-    logger28.debug(`Ignoring ${signal} - shutdown already in progress`);
+    logger29.debug(`Ignoring ${signal} - shutdown already in progress`);
     return;
   }
-  logger28.info(`Received ${signal}, shutting down gracefully...`);
+  logger29.info(`Received ${signal}, shutting down gracefully...`);
   try {
     const serverWasStopped = await stopServer();
     if (serverWasStopped) {
-      logger28.info("Server stopped successfully");
+      logger29.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);
+    logger29.error(`Error stopping server: ${errorMessage}`);
+    logger29.debug({ error }, "Full error details:");
   }
   const exitCode = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 0;
   process.exit(exitCode);
@@ -5542,6 +5658,6 @@ async function main() {
   await program.parseAsync();
 }
 main().catch((error) => {
-  logger28.error("An error occurred:", error);
+  logger29.error({ error }, "An error occurred:");
   process.exit(1);
 });