@elizaos/cli 1.0.15 → 1.0.16

package/dist/index.js

@@ -5,10 +5,10 @@ const require = createRequire(import.meta.url);
 
 import {
   create
-} from "./chunk-BRDZOULQ.js";
+} from "./chunk-UVBNT4WP.js";
 import {
   getElizaCharacter
-} from "./chunk-OXZUNMVC.js";
+} from "./chunk-PRO6QOLZ.js";
 import {
   TestRunner,
   UserEnvironment,
@@ -16,6 +16,7 @@ import {
   buildProject,
   checkAndShowUpdateNotification,
   configureDatabaseSettings,
+  createEnvFileService,
   detectDirectoryType,
   detectPluginContext,
   displayBanner,
@@ -38,7 +39,6 @@ import {
   logHeader,
   migrateCliToBun,
   normalizePluginName,
-  promptForEnvVars,
   provideLocalPluginGuidance,
   publishToGitHub,
   resolvePgliteDir,
@@ -46,14 +46,12 @@ import {
   testPublishToGitHub,
   testPublishToNpm,
   validateDataDir
-} from "./chunk-AZUBN22B.js";
-import {
-  runBunCommand
-} from "./chunk-RIAWNDYI.js";
+} from "./chunk-OK5O2MHJ.js";
 import {
   configureEmojis,
-  emoji
-} from "./chunk-KB3JDWUI.js";
+  emoji,
+  runBunCommand
+} from "./chunk-W4NJVJQV.js";
 import "./chunk-F24MS2YR.js";
 import "./chunk-AQ6OMR2A.js";
 
@@ -412,51 +410,30 @@ import { existsSync as existsSync4 } from "fs";
 import path4 from "path";
 
 // src/commands/env/utils/file-operations.ts
-import dotenv from "dotenv";
 import { existsSync as existsSync3 } from "fs";
-import fs from "fs/promises";
 import path3 from "path";
 async function getLocalEnvPath() {
   const localEnvPath = path3.join(process.cwd(), ".env");
   return existsSync3(localEnvPath) ? localEnvPath : null;
 }
 async function parseEnvFile(filePath) {
-  try {
-    if (!existsSync3(filePath)) {
-      return {};
-    }
-    const content = await fs.readFile(filePath, "utf-8");
-    if (content.trim() === "") {
-      return {};
-    }
-    return dotenv.parse(content);
-  } catch (error) {
-    console.error(
-      `Error parsing .env file: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return {};
-  }
+  const service = createEnvFileService(filePath);
+  return service.read();
 }
 async function writeEnvFile(filePath, envVars) {
-  try {
-    const dir = path3.dirname(filePath);
-    if (!existsSync3(dir)) {
-      await fs.mkdir(dir, { recursive: true });
-    }
-    const content = Object.entries(envVars).map(([key, value]) => `${key}=${value}`).join("\n");
-    await fs.writeFile(filePath, content);
-  } catch (error) {
-    console.error(
-      `Error writing .env file: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
+  const service = createEnvFileService(filePath);
+  await service.write(envVars, {
+    preserveComments: true,
+    updateProcessEnv: true
+  });
 }
 async function resetEnvFile(filePath) {
   try {
     if (!existsSync3(filePath)) {
       return false;
     }
-    const envVars = await parseEnvFile(filePath);
+    const service = createEnvFileService(filePath);
+    const envVars = await service.read();
     if (Object.keys(envVars).length === 0) {
       return false;
     }
@@ -464,7 +441,11 @@ async function resetEnvFile(filePath) {
       acc[key] = "";
       return acc;
     }, {});
-    await writeEnvFile(filePath, resetVars);
+    await service.write(resetVars, {
+      preserveComments: true,
+      updateProcessEnv: false
+      // Don't update process.env with empty values
+    });
     return true;
   } catch (error) {
     console.error(
@@ -584,7 +565,7 @@ async function editEnvVars(options, fromMainMenu = false) {
         console.log(`\u2713 Updated ${selection}`);
       }
     } else if (action === "delete") {
-      let confirm8 = true;
+      let confirm9 = true;
       if (!yes) {
         const resp = await clack.confirm({
           message: `Are you sure you want to delete ${selection}?`,
@@ -594,9 +575,9 @@ async function editEnvVars(options, fromMainMenu = false) {
           clack.cancel("Operation cancelled.");
           process.exit(0);
         }
-        confirm8 = resp;
+        confirm9 = resp;
       }
-      if (confirm8) {
+      if (confirm9) {
         delete envVars[selection];
         await writeEnvFile(localEnvPath, envVars);
         console.log(`\u2713 Removed ${selection}`);
@@ -810,15 +791,15 @@ async function resetEnv(options) {
       const item = resetItems.find((item2) => item2.value === value);
       console.log(`  \u2022 ${item?.title || value}`);
     }
-    const confirm8 = await clack2.confirm({
+    const confirm9 = await clack2.confirm({
       message: "Are you sure you want to reset the selected items?",
       initialValue: false
     });
-    if (clack2.isCancel(confirm8)) {
+    if (clack2.isCancel(confirm9)) {
       clack2.cancel("Operation cancelled.");
       process.exit(0);
     }
-    if (!confirm8) {
+    if (!confirm9) {
       console.log("Reset cancelled.");
       return;
     }
@@ -996,21 +977,70 @@ var extractPackageName = (pluginInput) => {
 
 // src/commands/plugins/utils/env-vars.ts
 import { logger } from "@elizaos/core";
-import { existsSync as existsSync8, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync8, readFileSync, readdirSync as readdirSync2 } from "fs";
 import path7 from "path";
 import * as clack4 from "@clack/prompts";
 var extractPluginEnvRequirements = async (packageName, cwd) => {
   try {
-    const nodeModulesPath = path7.join(cwd, "node_modules", packageName, "package.json");
-    if (!existsSync8(nodeModulesPath)) {
-      logger.debug(`Plugin package.json not found at: ${nodeModulesPath}`);
+    const possiblePaths = [
+      // Direct path
+      path7.join(cwd, "node_modules", packageName, "package.json"),
+      // Scoped package path (e.g., @elizaos/plugin-discord)
+      path7.join(cwd, "node_modules", packageName.replace("/", path7.sep), "package.json")
+    ];
+    if (!packageName.startsWith("@elizaos/")) {
+      possiblePaths.push(
+        path7.join(cwd, "node_modules", "@elizaos", packageName, "package.json"),
+        path7.join(cwd, "node_modules", "@elizaos", `plugin-${packageName}`, "package.json")
+      );
+    }
+    let currentDir = cwd;
+    for (let i = 0; i < 5; i++) {
+      const parentNodeModules = path7.join(currentDir, "node_modules");
+      if (existsSync8(parentNodeModules)) {
+        possiblePaths.push(
+          path7.join(parentNodeModules, packageName, "package.json"),
+          path7.join(parentNodeModules, packageName.replace("/", path7.sep), "package.json")
+        );
+      }
+      const parentDir = path7.dirname(currentDir);
+      if (parentDir === currentDir) break;
+      currentDir = parentDir;
+    }
+    let packageJsonPath = null;
+    for (const possiblePath of possiblePaths) {
+      if (existsSync8(possiblePath)) {
+        packageJsonPath = possiblePath;
+        logger.debug(`Found plugin package.json at: ${packageJsonPath}`);
+        break;
+      }
+    }
+    if (!packageJsonPath) {
+      const nodeModulesPath = path7.join(cwd, "node_modules");
+      if (existsSync8(nodeModulesPath)) {
+        const packages = readdirSync2(nodeModulesPath);
+        for (const pkg of packages) {
+          if (pkg.includes(packageName.replace("@elizaos/", "").replace("plugin-", ""))) {
+            const pkgJsonPath = path7.join(nodeModulesPath, pkg, "package.json");
+            if (existsSync8(pkgJsonPath)) {
+              packageJsonPath = pkgJsonPath;
+              logger.debug(`Found matching plugin package.json at: ${packageJsonPath}`);
+              break;
+            }
+          }
+        }
+      }
+    }
+    if (!packageJsonPath) {
+      logger.debug(`Plugin package.json not found for: ${packageName}`);
+      logger.debug(`Searched paths: ${possiblePaths.join(", ")}`);
       return {};
     }
-    const packageJsonContent = readFileSync(nodeModulesPath, "utf-8");
+    const packageJsonContent = readFileSync(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     const agentConfig = packageJson.agentConfig;
     if (!agentConfig || !agentConfig.pluginParameters) {
-      logger.debug(`No agentConfig.pluginParameters found in ${packageName}`);
+      logger.debug(`No agentConfig.pluginParameters found in ${packageName} at ${packageJsonPath}`);
       return {};
     }
     logger.debug(
@@ -1024,17 +1054,10 @@ var extractPluginEnvRequirements = async (packageName, cwd) => {
     return {};
   }
 };
-var readEnvFile = (cwd) => {
-  const envPath = path7.join(cwd, ".env");
-  try {
-    return readFileSync(envPath, "utf-8");
-  } catch (error) {
-    return "";
-  }
-};
-var writeEnvFile2 = (cwd, content) => {
+var readEnvFile = async (cwd) => {
   const envPath = path7.join(cwd, ".env");
-  writeFileSync(envPath, content, "utf-8");
+  const envService = createEnvFileService(envPath);
+  return envService.read();
 };
 var extractDefaultFromDescription = (description) => {
   const patterns = [
@@ -1057,40 +1080,158 @@ var extractDefaultFromDescription = (description) => {
 };
 var promptForEnvVar = async (varName, config2) => {
   const {
+    type = "string",
     description = "No description available",
     default: explicitDefault,
-    sensitive = false
+    sensitive = false,
+    required = true
+    // Default to true for backwards compatibility
   } = config2;
   const defaultValue = explicitDefault || extractDefaultFromDescription(description);
   const isSecret = sensitive !== void 0 ? sensitive : varName.toLowerCase().includes("key") || varName.toLowerCase().includes("token") || varName.toLowerCase().includes("secret") || varName.toLowerCase().includes("password");
-  const message = defaultValue ? `Enter ${varName} (default: ${defaultValue})` : `Enter ${varName}`;
-  const placeholder = isSecret ? "Your secret key/token..." : defaultValue || "Enter value...";
   if (description && description !== "No description available") {
     clack4.note(`${description}`, `${varName} Info`);
   }
+  if (type === "boolean") {
+    const defaultBool = defaultValue === "true" || String(explicitDefault).toLowerCase() === "true";
+    const response2 = await clack4.confirm({
+      message: required ? `Enable ${varName}?` : `Enable ${varName}? (optional)`,
+      initialValue: defaultBool
+    });
+    if (clack4.isCancel(response2)) {
+      clack4.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    if (!required && response2 === void 0) {
+      return "";
+    }
+    return String(response2);
+  }
+  if (type === "number") {
+    const message2 = defaultValue ? `Enter ${varName} (default: ${String(defaultValue)})` : required ? `Enter ${varName}` : `Enter ${varName} (press Enter to skip)`;
+    const promptConfig2 = {
+      message: message2,
+      placeholder: required ? String(defaultValue || "Enter a number") : String(defaultValue || "Press Enter to skip"),
+      initialValue: defaultValue ? String(defaultValue) : void 0,
+      validate: (input) => {
+        if ((!input || input.trim() === "") && !required) {
+          return void 0;
+        }
+        if ((!input || input.trim() === "") && required && !defaultValue) {
+          return "This field cannot be empty. Press Ctrl+C to cancel.";
+        }
+        const trimmed = input.trim();
+        if (trimmed && isNaN(Number(trimmed))) {
+          return "Please enter a valid number";
+        }
+        return void 0;
+      }
+    };
+    const response2 = await clack4.text(promptConfig2);
+    if (clack4.isCancel(response2)) {
+      clack4.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    const finalValue2 = response2 && response2.trim() || defaultValue || "";
+    return finalValue2.trim();
+  }
+  if (type === "array") {
+    const message2 = defaultValue ? `Enter ${varName} (comma-separated, default: ${String(defaultValue)})` : required ? `Enter ${varName} (comma-separated values)` : `Enter ${varName} (comma-separated values, press Enter to skip)`;
+    const promptConfig2 = {
+      message: message2,
+      placeholder: required ? String(defaultValue || "value1,value2,value3") : String(defaultValue || "Press Enter to skip"),
+      initialValue: defaultValue ? String(defaultValue) : void 0,
+      validate: (input) => {
+        if ((!input || input.trim() === "") && !required) {
+          return void 0;
+        }
+        if ((!input || input.trim() === "") && required && !defaultValue) {
+          return "This field cannot be empty. Press Ctrl+C to cancel.";
+        }
+        return void 0;
+      }
+    };
+    const response2 = await clack4.text(promptConfig2);
+    if (clack4.isCancel(response2)) {
+      clack4.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    const finalValue2 = response2 && response2.trim() || defaultValue || "";
+    if (finalValue2) {
+      return finalValue2.split(",").map((v) => v.trim()).filter((v) => v).join(",");
+    }
+    return finalValue2;
+  }
+  if (type === "json") {
+    clack4.log.info("Enter a JSON object. For multi-line input, use the editor.");
+    const message2 = defaultValue ? `Enter ${varName} JSON (default: ${String(defaultValue)})` : required ? `Enter ${varName} JSON` : `Enter ${varName} JSON (press Enter to skip)`;
+    const promptConfig2 = {
+      message: message2,
+      placeholder: required ? String(defaultValue || '{"key": "value"}') : String(defaultValue || "Press Enter to skip"),
+      initialValue: defaultValue ? String(defaultValue) : void 0,
+      validate: (input) => {
+        if ((!input || input.trim() === "") && !required) {
+          return void 0;
+        }
+        if ((!input || input.trim() === "") && required && !defaultValue) {
+          return "This field cannot be empty. Press Ctrl+C to cancel.";
+        }
+        if (input && input.trim()) {
+          try {
+            JSON.parse(input.trim());
+          } catch (error) {
+            return "Please enter valid JSON format";
+          }
+        }
+        return void 0;
+      }
+    };
+    const response2 = await clack4.text(promptConfig2);
+    if (clack4.isCancel(response2)) {
+      clack4.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    const finalValue2 = response2 && response2.trim() || defaultValue || "";
+    if (finalValue2) {
+      try {
+        const parsed = JSON.parse(finalValue2);
+        return JSON.stringify(parsed);
+      } catch {
+        return finalValue2;
+      }
+    }
+    return finalValue2;
+  }
+  const message = defaultValue ? `Enter ${varName} (default: ${String(defaultValue)})` : required ? `Enter ${varName}` : `Enter ${varName} (press Enter to skip)`;
+  const placeholder = isSecret ? "Your secret key/token..." : required ? String(defaultValue || "Required value") : String(defaultValue || "Press Enter to skip");
   const promptFn = isSecret ? clack4.password : clack4.text;
   const promptConfig = {
     message,
     placeholder,
     validate: (input) => {
-      if ((!input || input.trim() === "") && !defaultValue) {
+      if ((!input || input.trim() === "") && required && !defaultValue) {
         return "This field cannot be empty. Press Ctrl+C to cancel.";
       }
+      if ((!input || input.trim() === "") && !required) {
+        return void 0;
+      }
       if (varName.includes("URL") || varName.includes("ENDPOINT")) {
-        try {
-          new URL(input.trim());
-        } catch {
-          return "Please enter a valid URL (e.g., https://api.example.com)";
+        if (input && input.trim()) {
+          try {
+            new URL(input.trim());
+          } catch {
+            return "Please enter a valid URL (e.g., https://api.example.com)";
+          }
         }
       }
-      if (varName.includes("API_KEY") && input.trim().length < 5) {
+      if (varName.includes("API_KEY") && input.trim().length > 0 && input.trim().length < 5) {
         return "API key seems too short. Please verify you entered the complete key.";
       }
       return void 0;
     }
   };
   if (defaultValue && !isSecret) {
-    promptConfig.initialValue = defaultValue;
+    promptConfig.initialValue = String(defaultValue);
   }
   const response = await promptFn(promptConfig);
   if (clack4.isCancel(response)) {
@@ -1100,37 +1241,54 @@ var promptForEnvVar = async (varName, config2) => {
   const finalValue = response && response.trim() || defaultValue || "";
   return finalValue.trim();
 };
-var updateEnvFile = (cwd, varName, value) => {
-  const envContent = readEnvFile(cwd);
-  const lines = envContent.split("\n");
-  const existingLineIndex = lines.findIndex((line) => line.startsWith(`${varName}=`));
-  if (existingLineIndex >= 0) {
-    lines[existingLineIndex] = `${varName}=${value}`;
-  } else {
-    if (envContent && !envContent.endsWith("\n")) {
-      lines.push("");
-    }
-    lines.push(`${varName}=${value}`);
-  }
-  writeEnvFile2(cwd, lines.join("\n"));
+var updateEnvFile = async (cwd, varName, value) => {
+  const envPath = path7.join(cwd, ".env");
+  const envService = createEnvFileService(envPath);
+  await envService.update(varName, value, {
+    preserveComments: true,
+    updateProcessEnv: true
+  });
 };
 var promptForPluginEnvVars = async (packageName, cwd) => {
-  const envRequirements = await extractPluginEnvRequirements(packageName, cwd);
+  let envRequirements = await extractPluginEnvRequirements(packageName, cwd);
+  if (Object.keys(envRequirements).length === 0 && !packageName.startsWith("@elizaos/")) {
+    const elizaosPackageName = `@elizaos/${packageName.replace("plugin-", "")}`;
+    envRequirements = await extractPluginEnvRequirements(elizaosPackageName, cwd);
+    if (Object.keys(envRequirements).length === 0) {
+      const elizaosPluginPackageName = `@elizaos/plugin-${packageName.replace("plugin-", "")}`;
+      envRequirements = await extractPluginEnvRequirements(elizaosPluginPackageName, cwd);
+    }
+  }
   if (Object.keys(envRequirements).length === 0) {
-    logger.debug(`No environment variables required for ${packageName}`);
-    clack4.log.success(`No environment variables required for ${packageName}`);
+    const nodeModulesPath = path7.join(cwd, "node_modules");
+    const possiblePackages = [
+      packageName,
+      `@elizaos/${packageName.replace("plugin-", "")}`,
+      `@elizaos/plugin-${packageName.replace("plugin-", "")}`
+    ];
+    let packageFound = false;
+    for (const pkg of possiblePackages) {
+      const pkgPath = path7.join(nodeModulesPath, ...pkg.split("/"));
+      if (existsSync8(path7.join(pkgPath, "package.json"))) {
+        packageFound = true;
+        break;
+      }
+    }
+    if (packageFound) {
+      logger.debug(`Package ${packageName} found but has no environment variables defined`);
+      clack4.log.success(`No environment variables required for ${packageName}`);
+    } else {
+      logger.debug(`Package ${packageName} not found in node_modules`);
+      clack4.log.warn(
+        `Could not find ${packageName} in node_modules. Environment variables may need to be configured manually.`
+      );
+    }
     return;
   }
   await new Promise((resolve2) => setTimeout(resolve2, 100));
   clack4.intro(`Setting up ${packageName} Plugin`);
-  const envContent = readEnvFile(cwd);
-  const existingVars = {};
-  envContent.split("\n").forEach((line) => {
-    const match = line.match(/^([^=]+)=(.*)$/);
-    if (match) {
-      existingVars[match[1]] = match[2];
-    }
-  });
+  const envVars = await readEnvFile(cwd);
+  const existingVars = envVars;
   const missingVars = [];
   const existingConfigured = [];
   Object.entries(envRequirements).forEach(([varName, config2]) => {
@@ -1183,7 +1341,7 @@ ${optionalVars.map(([name]) => `  - ${name}`).join("\n")}
       const value = await promptForEnvVar(varName, config2);
       if (value) {
         spinner2.start(`Saving ${varName} to .env file...`);
-        updateEnvFile(cwd, varName, value);
+        await updateEnvFile(cwd, varName, value);
         spinner2.stop(`${varName} configured successfully`);
         newlyConfigured++;
         configuredCount++;
@@ -1302,7 +1460,7 @@ async function installPluginFromGitHub(plugin, cwd, opts) {
   if (success) {
     logger3.info(`Successfully installed ${pluginNameForPostInstall} from ${githubSpecifier}.`);
     if (!opts.skipEnvPrompt) {
-      await new Promise((resolve2) => setTimeout(resolve2, 50));
+      await new Promise((resolve2) => setTimeout(resolve2, 500));
       const packageName = extractPackageName(plugin);
       console.log(`
 \u{1F527} Checking environment variables for ${packageName}...`);
@@ -1341,7 +1499,7 @@ async function installPluginFromRegistry(plugin, cwd, opts) {
   if (registryInstallResult) {
     console.log(`Successfully installed ${targetName}`);
     if (!opts.skipEnvPrompt) {
-      await new Promise((resolve2) => setTimeout(resolve2, 50));
+      await new Promise((resolve2) => setTimeout(resolve2, 500));
       const updatedDependencies = getDependenciesFromDirectory(cwd);
       const actualPackageName = findPluginPackageName(targetName, updatedDependencies || {}) || targetName;
       console.log(`
@@ -1566,78 +1724,996 @@ async function listInstalledPlugins() {
 }
 
 // src/commands/plugins/actions/upgrade.ts
-import { logger as logger6 } from "@elizaos/core";
+import { logger as logger8 } from "@elizaos/core";
+import path11 from "path";
+import { existsSync as existsSync11 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import fs from "fs-extra";
+
+// src/utils/upgrade/simple-migration-agent.ts
+import { query } from "@anthropic-ai/claude-code";
+import { EventEmitter } from "events";
+
+// src/utils/upgrade/migration-guide-loader.ts
+import { existsSync as existsSync10, readFileSync as readFileSync3 } from "fs";
 import path10 from "path";
+import { fileURLToPath } from "url";
+import { logger as logger6 } from "@elizaos/core";
+var MigrationGuideLoader = class {
+  guides = [];
+  guidesDir;
+  constructor(projectRoot) {
+    this.guidesDir = this.findGuidesDirectory(projectRoot);
+    this.loadGuides();
+  }
+  findGuidesDirectory(projectRoot) {
+    if (projectRoot) {
+      const guidesPath = path10.join(projectRoot, "packages/docs/docs/plugins/migration/claude-code");
+      if (existsSync10(guidesPath)) {
+        return guidesPath;
+      }
+    }
+    let currentRoot = process.cwd();
+    let previousRoot = "";
+    while (currentRoot !== previousRoot && !existsSync10(path10.join(currentRoot, "packages/docs"))) {
+      previousRoot = currentRoot;
+      currentRoot = path10.dirname(currentRoot);
+    }
+    const monorepoGuidesPath = path10.join(
+      currentRoot,
+      "packages/docs/docs/plugins/migration/claude-code"
+    );
+    if (existsSync10(monorepoGuidesPath)) {
+      return monorepoGuidesPath;
+    }
+    const workingDirGuides = path10.join(process.cwd(), "migration-guides");
+    if (existsSync10(workingDirGuides)) {
+      return workingDirGuides;
+    }
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = fileURLToPath(currentFileUrl);
+    const cliPackageRoot = path10.dirname(path10.dirname(path10.dirname(path10.dirname(currentFilePath))));
+    const bundledGuidesPath = path10.join(cliPackageRoot, "migration-guides");
+    if (existsSync10(bundledGuidesPath)) {
+      return bundledGuidesPath;
+    }
+    return "";
+  }
+  loadGuides() {
+    const guideConfigs = [
+      {
+        name: "migration-guide.md",
+        category: "basic",
+        keywords: [
+          "import",
+          "path",
+          "action",
+          "provider",
+          "basic",
+          "core",
+          "elizaLogger",
+          "logger",
+          "IAgentRuntime",
+          "AgentRuntime",
+          "Account",
+          "Entity",
+          "composeContext",
+          "generateObject",
+          "package.json",
+          "dependencies",
+          "scripts",
+          "build"
+        ]
+      },
+      {
+        name: "state-and-providers-guide.md",
+        category: "basic",
+        keywords: [
+          "state",
+          "provider",
+          "ProviderResult",
+          "context",
+          "memory",
+          "runtime",
+          "world",
+          "room",
+          "entityId",
+          "userId",
+          "optional"
+        ]
+      },
+      {
+        name: "prompt-and-generation-guide.md",
+        category: "basic",
+        keywords: [
+          "template",
+          "prompt",
+          "generation",
+          "XML",
+          "JSON",
+          "useModel",
+          "generateText",
+          "messages",
+          "format"
+        ]
+      },
+      {
+        name: "advanced-migration-guide.md",
+        category: "advanced",
+        keywords: [
+          "service",
+          "evaluator",
+          "settings",
+          "singleton",
+          "lifecycle",
+          "initialize",
+          "start",
+          "stop",
+          "client",
+          "complex"
+        ]
+      },
+      {
+        name: "testing-guide.md",
+        category: "testing",
+        keywords: [
+          "test",
+          "coverage",
+          "vitest",
+          "bun",
+          "mock",
+          "unit",
+          "integration",
+          "error",
+          "edge",
+          "performance",
+          "test-utils"
+        ]
+      },
+      {
+        name: "completion-requirements.md",
+        category: "completion",
+        keywords: [
+          "release",
+          "workflow",
+          "npm",
+          "deploy",
+          "gitignore",
+          "npmignore",
+          "license",
+          "prettier",
+          "final",
+          "validation"
+        ]
+      }
+    ];
+    if (!this.guidesDir || !existsSync10(this.guidesDir)) {
+      logger6.info("Using embedded migration guidance (external CLI mode)");
+      this.createEmbeddedGuides(guideConfigs);
+      return;
+    }
+    for (const config2 of guideConfigs) {
+      const guidePath = path10.join(this.guidesDir, config2.name);
+      if (existsSync10(guidePath)) {
+        try {
+          const content = readFileSync3(guidePath, "utf-8");
+          this.guides.push({
+            name: config2.name,
+            path: guidePath,
+            content,
+            category: config2.category,
+            keywords: config2.keywords
+          });
+        } catch (error) {
+          logger6.warn(`Failed to load migration guide: ${config2.name}`, error);
+        }
+      } else {
+        logger6.warn(`Migration guide not found: ${guidePath}`);
+      }
+    }
+    logger6.info(`Loaded ${this.guides.length} migration guides from ${this.guidesDir}`);
+  }
+  createEmbeddedGuides(guideConfigs) {
+    const embeddedGuides = {
+      "migration-guide.md": this.getEmbeddedMigrationGuide(),
+      "testing-guide.md": this.getEmbeddedTestingGuide(),
+      "completion-requirements.md": this.getEmbeddedCompletionGuide()
+    };
+    for (const config2 of guideConfigs) {
+      const embeddedContent = embeddedGuides[config2.name];
+      if (embeddedContent) {
+        this.guides.push({
+          name: config2.name,
+          path: `embedded:${config2.name}`,
+          content: embeddedContent,
+          category: config2.category,
+          keywords: config2.keywords
+        });
+      }
+    }
+  }
+  getEmbeddedMigrationGuide() {
+    return `# ElizaOS Plugin Migration Guide - Essential Steps
+
+## Core Migration Requirements
+
+### 1. Import Path Updates
+- elizaLogger \u2192 logger
+- IAgentRuntime \u2192 AgentRuntime  
+- Account \u2192 Entity
+- userId \u2192 entityId
+
+### 2. Package.json Updates
+- Update to @elizaos/core ^1.0.0
+- Update scripts to use bun
+- Add proper exports and types
+
+### 3. Action Migration
+- Replace composeContext with new patterns
+- Convert JSON templates to XML
+- Update generateObject to runtime.useModel
+- Fix handler patterns
+
+### 4. Provider Migration  
+- Add name property
+- Return ProviderResult
+- Make state parameter required
+
+### 5. Testing Requirements
+- Use bun test framework
+- Achieve 95%+ coverage
+- Test all components thoroughly
+
+For complete details, refer to the comprehensive guides in the ElizaOS documentation.`;
+  }
+  getEmbeddedTestingGuide() {
+    return `# ElizaOS Testing Guide - Essential Requirements
+
+## Test Framework
+- Use bun test (not vitest)
+- Achieve 95%+ code coverage
+- Test all actions, providers, evaluators
+
+## Test Structure
+\`\`\`
+src/__tests__/
+\u251C\u2500\u2500 test-utils.ts
+\u251C\u2500\u2500 actions/
+\u251C\u2500\u2500 providers/
+\u2514\u2500\u2500 evaluators/
+\`\`\`
+
+## Coverage Requirements
+- All components must be tested
+- Error cases must be covered
+- Edge cases must be handled
+- Integration tests required
+
+## Common Issues
+- Mock all async dependencies
+- Clean up after each test
+- Use proper test isolation
+
+Run: bun test --coverage`;
+  }
+  getEmbeddedCompletionGuide() {
+    return `# ElizaOS Completion Requirements
+
+## Required Files
+- .gitignore
+- .npmignore  
+- LICENSE
+- .prettierrc
+- .github/workflows/npm-deploy.yml
+
+## Final Validation
+\`\`\`bash
+bun run build     # Must pass
+bun test          # Must pass  
+bunx tsc --noEmit # Must pass
+\`\`\`
+
+## Package.json Requirements
+- Correct name format
+- Version 1.0.0
+- Proper exports
+- Build scripts
+- Test scripts
+
+## Release Workflow
+- GitHub workflow for npm publish
+- Automated testing
+- Version management`;
+  }
+  /**
+   * Search for relevant guides based on keywords or content
+   */
+  searchGuides(query2, limit = 3) {
+    const queryLower = query2.toLowerCase();
+    const queryWords = queryLower.split(/\s+/).filter((word) => word.length > 2);
+    const results = [];
+    for (const guide of this.guides) {
+      let relevanceScore = 0;
+      const matchedKeywords = [];
+      for (const keyword of guide.keywords) {
+        if (queryWords.some((word) => keyword.toLowerCase().includes(word))) {
+          relevanceScore += 2;
+          matchedKeywords.push(keyword);
+        }
+      }
+      const contentLower = guide.content.toLowerCase();
+      for (const word of queryWords) {
+        const matches = (contentLower.match(new RegExp(word, "g")) || []).length;
+        relevanceScore += matches * 0.5;
+      }
+      if (queryLower.includes("import") && guide.name === "migration-guide.md") {
+        relevanceScore += 3;
+      }
+      if (queryLower.includes("test") && guide.name === "testing-guide.md") {
+        relevanceScore += 3;
+      }
+      if (queryLower.includes("state") && guide.name === "state-and-providers-guide.md") {
+        relevanceScore += 3;
+      }
+      if (relevanceScore > 0) {
+        results.push({
+          guide,
+          relevanceScore,
+          matchedKeywords
+        });
+      }
+    }
+    return results.sort((a, b) => b.relevanceScore - a.relevanceScore).slice(0, limit);
+  }
+  /**
+   * Get a specific guide by name
+   */
+  getGuide(name) {
+    return this.guides.find((guide) => guide.name === name) || null;
+  }
+  /**
+   * Get all guides of a specific category
+   */
+  getGuidesByCategory(category) {
+    return this.guides.filter((guide) => guide.category === category);
+  }
+  /**
+   * Get guides that are most relevant for common migration issues
+   */
+  getRelevantGuidesForIssue(issue) {
+    const issueMap = {
+      import_error: ["import", "path", "elizaLogger", "logger"],
+      build_error: ["build", "typescript", "package.json", "dependencies"],
+      type_error: ["typescript", "type", "IAgentRuntime", "AgentRuntime"],
+      action_migration: ["action", "composeContext", "generateObject", "handler"],
+      provider_migration: ["provider", "ProviderResult", "state", "context"],
+      test_failure: ["test", "coverage", "mock", "unit"],
+      service_migration: ["service", "lifecycle", "initialize", "singleton"],
+      template_migration: ["template", "XML", "JSON", "prompt"],
+      release_setup: ["release", "workflow", "npm", "deploy"]
+    };
+    const keywords = issueMap[issue];
+    if (!keywords) {
+      return this.searchGuides(issue);
+    }
+    return this.searchGuides(keywords.join(" "));
+  }
+  /**
+   * Generate a comprehensive migration context for Claude
+   */
+  generateMigrationContext() {
+    const context = [
+      "# ELIZAOS PLUGIN MIGRATION GUIDE REFERENCES",
+      "",
+      "You have access to the following comprehensive migration guides:",
+      ""
+    ];
+    for (const guide of this.guides) {
+      context.push(`## ${guide.name.replace(".md", "").toUpperCase()}`);
+      context.push(`Category: ${guide.category}`);
+      context.push(`Keywords: ${guide.keywords.join(", ")}`);
+      context.push("");
+      const preview = guide.content.substring(0, 500).replace(/\n/g, " ");
+      context.push(`Preview: ${preview}...`);
+      context.push("");
+      context.push("---");
+      context.push("");
+    }
+    context.push("## GUIDE USAGE INSTRUCTIONS");
+    context.push("");
+    context.push("- Reference specific guides for detailed migration steps");
+    context.push("- Use migration-guide.md for basic actions and providers");
+    context.push("- Use advanced-migration-guide.md for services and evaluators");
+    context.push("- Use testing-guide.md for comprehensive test coverage");
+    context.push("- Use completion-requirements.md for final release preparation");
+    context.push("");
+    return context.join("\n");
+  }
+  /**
+   * Get full content of all guides for RAG embedding
+   */
+  getAllGuidesContent() {
+    const content = [
+      "# COMPLETE ELIZAOS MIGRATION KNOWLEDGE BASE",
+      "",
+      "This contains all migration guides and their complete content for reference.",
+      ""
+    ];
+    for (const guide of this.guides) {
+      content.push(`# GUIDE: ${guide.name}`);
+      content.push(`Category: ${guide.category}`);
+      content.push(`Keywords: ${guide.keywords.join(", ")}`);
+      content.push("");
+      content.push("## CONTENT:");
+      content.push("");
+      content.push(guide.content);
+      content.push("");
+      content.push("---");
+      content.push("");
+    }
+    return content.join("\n");
+  }
+};
+function createMigrationGuideLoader(projectRoot) {
+  return new MigrationGuideLoader(projectRoot);
+}
+
+// src/utils/upgrade/simple-migration-agent.ts
+import { logger as logger7 } from "@elizaos/core";
+var SimpleMigrationAgent = class extends EventEmitter {
+  repoPath;
+  abortController;
+  verbose;
+  guideLoader;
+  constructor(repoPath, options = {}) {
+    super();
+    this.repoPath = repoPath;
+    this.abortController = new AbortController();
+    this.verbose = options.verbose || false;
+    try {
+      this.guideLoader = createMigrationGuideLoader();
+      if (this.verbose) {
+        logger7.info("Migration guide loader initialized successfully");
+      }
+    } catch (error) {
+      logger7.warn("Failed to initialize migration guide loader", error);
+      throw new Error("Cannot initialize migration system without guide access");
+    }
+  }
+  isImportantUpdate(text3) {
+    const importantPatterns = [
+      /GATE \d+/i,
+      /analysis/i,
+      /migration/i,
+      /complete/i,
+      /success/i,
+      /error/i,
+      /building/i,
+      /testing/i,
+      /✓|✗|🎉|🚀|📊/
+    ];
+    return importantPatterns.some((pattern) => pattern.test(text3)) && text3.length < 200;
+  }
+  formatProgressUpdate(text3) {
+    text3 = text3.trim();
+    if (text3.includes("GATE")) {
+      return `
+\u{1F3AF} ${text3}`;
+    } else if (text3.includes("complete") || text3.includes("\u2713")) {
+      return `\u2705 ${text3}`;
+    } else if (text3.includes("error") || text3.includes("\u2717")) {
+      return `\u274C ${text3}`;
+    } else if (text3.includes("analyzing") || text3.includes("migration")) {
+      return `\u{1F50D} ${text3}`;
+    } else if (text3.includes("building")) {
+      return `\u{1F528} ${text3}`;
+    } else if (text3.includes("testing")) {
+      return `\u{1F9EA} ${text3}`;
+    }
+    return text3;
+  }
+  getSimplifiedToolName(toolName) {
+    const toolMap = {
+      TodoWrite: "\u{1F4DD} Planning",
+      Bash: "\u26A1 Running",
+      Read: "\u{1F4D6} Reading",
+      Edit: "\u270F\uFE0F  Editing",
+      Write: "\u{1F4C4} Writing",
+      LS: "\u{1F50D} Exploring",
+      Grep: "\u{1F50E} Searching",
+      Task: "\u{1F527} Processing"
+    };
+    return toolMap[toolName] || null;
+  }
+  async migrate() {
+    const startTime = Date.now();
+    let messageCount = 0;
+    try {
+      process.env.CLAUDE_CODE_ENABLE_TELEMETRY = "0";
+      process.env.OTEL_LOGS_EXPORTER = "";
+      process.env.OTEL_LOG_USER_PROMPTS = "0";
+      process.env.OTEL_METRICS_EXPORTER = "";
+      console.log("Claude is analyzing and migrating your plugin...\n");
+      this.emit("start");
+      console.log(`Starting migration in directory: ${this.repoPath}`);
+      const migrationContext = this.guideLoader.getAllGuidesContent();
+      const guideReferences = this.guideLoader.generateMigrationContext();
+      const migrationPrompt = `You are about to help migrate an ElizaOS plugin from 0.x to 1.x format.
+
+CRITICAL: You must follow the INTEGRATED EXECUTION PROTOCOL exactly as specified in the CLAUDE.md file.
+
+This is a GATED PROCESS with 9 gates (0-8). You CANNOT skip steps.
+
+COMPREHENSIVE MIGRATION KNOWLEDGE BASE:
+${migrationContext}
+
+GUIDE REFERENCE SYSTEM:
+${guideReferences}
+
+REFERENCE GUIDES are in migration-guides/ directory:
+- migration-guide.md (basic migration steps)
+- state-and-providers-guide.md (state & providers migration)
+- prompt-and-generation-guide.md (templates & generation)
+- advanced-migration-guide.md (services, settings, evaluators)
+- testing-guide.md (comprehensive testing requirements)
+- completion-requirements.md (final validation and release preparation)
+
+ENHANCED RAG CAPABILITIES:
+You have access to the complete content of all migration guides above. Use this knowledge to:
+1. Provide specific, detailed migration steps
+2. Reference exact sections from the appropriate guides
+3. Troubleshoot specific issues with targeted solutions
+4. Ensure comprehensive coverage of all migration requirements
+
+CRITICAL TEST VALIDATION REQUIREMENTS - ABSOLUTE REQUIREMENTS
+
+MIGRATION CANNOT BE COMPLETED UNTIL ALL TESTS PASS
+
+Throughout the migration process, you MUST validate these requirements and loop until they pass:
+
+1. MANDATORY TEST VALIDATION LOOP: After every significant code change, run:
+   - bun run test - ALL tests must pass (100% success rate, ZERO failures)
+   - bunx tsc --noEmit - ZERO TypeScript errors in src/ directory
+   - Only test files can have type errors, src/ must be error-free
+
+2. CONTINUOUS VALIDATION LOOP: If ANY of these fail:
+   - Analyze the errors thoroughly
+   - Fix all issues identified
+   - Re-run the validation commands
+   - Repeat until BOTH commands succeed with zero errors
+   - DO NOT PROCEED until validation passes
+
+3. COVERAGE VS TEST CONFLICTS: If tests conflict with 95% coverage requirements:
+   - Prioritize making tests pass over coverage percentage
+   - Use workarounds like test mocks, stubs, or simplified implementations
+   - Lower coverage if necessary - tests passing is more important
+   - Add // @ts-ignore comments if needed for test compatibility
+
+4. RELEASE WORKFLOW REQUIREMENT: The .github/workflows/release.yml requires bun run test to pass before npm publish. Migration is NOT complete until all tests pass.
+
+5. ABSOLUTE REQUIREMENTS - NO EXCEPTIONS:
+   - bun run test MUST show 0 failing tests
+   - If ANY test fails, the migration is INCOMPLETE
+   - Do not declare success until bun run test passes completely
+   - Work around any test issues rather than leaving them failing
+
+START WITH GATE 0: Create 1.x branch
+Execute: git checkout -b 1.x
+Gate Check: git branch --show-current must output "1.x"
+
+THEN GATE 1: Complete analysis following the exact format in the integrated-migration-loop.md
+
+DO NOT PROCEED until each gate check passes AND all validation requirements are met.
+
+Remember: You must grind on test failures and TypeScript errors until they are 100% resolved. The release workflow will fail if tests don't pass.
+
+FINAL VALIDATION REQUIREMENTS (GATE 8+) - ABSOLUTELY MANDATORY
+
+THE MIGRATION IS NOT COMPLETE UNTIL EVERY SINGLE TEST PASSES
+
+After completing all 9 gates, you MUST perform final validation and loop until both pass:
+
+FINAL VALIDATION LOOP - REPEAT UNTIL SUCCESS:
+1. Run: bun run test
+   - MUST pass 100% - this is required for npm release workflow
+   - If ANY tests fail, analyze and fix them, then retry
+   - Use workarounds, mocks, simplified implementations if needed
+   - Lower coverage requirements if tests conflict with coverage
+   - Do NOT declare migration complete until this shows ZERO failures
+
+2. Run: bunx tsc --noEmit  
+   - MUST have ZERO errors in src/ directory
+   - Test files can have type errors as exception, but fix if possible
+   - If any src/ errors exist, fix them and retry
+
+3. REPEAT FINAL VALIDATION LOOP until both commands succeed with zero errors
+   - Keep trying different approaches
+   - Simplify tests if needed
+   - Use test mocks and stubs
+   - Do whatever it takes to make tests pass
+
+4. Only AFTER both final validations pass with ZERO failures, declare migration complete
+
+ABSOLUTE REQUIREMENT: The migration is NOT complete until bun run test shows zero failures. The release workflow will fail otherwise. NO EXCEPTIONS.`;
+      let queryGenerator;
+      try {
+        queryGenerator = query({
+          prompt: migrationPrompt,
+          abortController: this.abortController,
+          options: {
+            cwd: this.repoPath,
+            model: "opus",
+            permissionMode: "bypassPermissions"
+          }
+        });
+      } catch (queryError) {
+        const errorMessage = queryError instanceof Error ? queryError.message : String(queryError);
+        throw new Error(`Failed to initialize Claude Code SDK query: ${errorMessage}`);
+      }
+      for await (const message of queryGenerator) {
+        messageCount++;
+        try {
+          if (message.type === "assistant") {
+            if (message.message && message.message.content) {
+              const content = message.message.content;
+              if (Array.isArray(content)) {
+                for (const block of content) {
+                  if (block.type === "text") {
+                    const text3 = block.text;
+                    if (this.isImportantUpdate(text3)) {
+                      console.log(this.formatProgressUpdate(text3));
+                    }
+                  } else if (block.type === "tool_use") {
+                    const toolName = this.getSimplifiedToolName(block.name);
+                    if (toolName) {
+                      process.stdout.write(`${toolName}...`);
+                    }
+                  }
+                }
+              } else if (typeof content === "string") {
+                if (this.isImportantUpdate(content)) {
+                  console.log(this.formatProgressUpdate(content));
+                }
+              }
+            }
+          }
+          if ("type" in message && message.type === "tool_result") {
+            process.stdout.write(" \u2713\n");
+          }
+          if (message.type === "result") {
+            console.log(`
+
+\u{1F4CA} Migration Summary:`);
+            console.log(`Status: ${message.subtype === "success" ? "\u2705 Completed" : "\u274C Failed"}`);
+            if (message.total_cost_usd) console.log(`Cost: $${message.total_cost_usd}`);
+            if (message.duration_ms)
+              console.log(`Duration: ${Math.round(message.duration_ms / 1e3)}s`);
+            if (message.num_turns) console.log(`AI Operations: ${message.num_turns}`);
+            console.log("");
+          }
+          if (message.type === "system" && message.subtype === "init") {
+            console.log(`Starting migration session...
+`);
+          }
+        } catch (messageError) {
+          if (this.verbose) {
+            const errorMessage = messageError instanceof Error ? messageError.message : String(messageError);
+            console.log(`
+\u274C Message processing error: ${errorMessage}`);
+          }
+        }
+        if (messageCount % 20 === 0) {
+          console.log(`
+\u23F3 Processing... (${messageCount} operations)
+`);
+          this.emit("progress", messageCount);
+        }
+      }
+      console.log("\nMigration completed successfully!");
+      const guidesUsed = this.guideLoader.getGuidesByCategory("basic").concat(this.guideLoader.getGuidesByCategory("advanced")).concat(this.guideLoader.getGuidesByCategory("testing")).concat(this.guideLoader.getGuidesByCategory("completion")).map((guide) => guide.name);
+      return {
+        success: true,
+        repoPath: this.repoPath,
+        duration: Date.now() - startTime,
+        messageCount,
+        guidesUsed
+      };
+    } catch (error) {
+      console.log("\n\u2717 Migration failed");
+      console.log(`
+Error details:`, error);
+      return {
+        success: false,
+        repoPath: this.repoPath,
+        duration: Date.now() - startTime,
+        messageCount,
+        error
+      };
+    }
+  }
+  abort() {
+    this.abortController.abort();
+    console.log("\nMigration aborted by user");
+  }
+  /**
+   * Get migration help for specific issues
+   */
+  getMigrationHelp(issue) {
+    try {
+      const results = this.guideLoader.getRelevantGuidesForIssue(issue);
+      if (results.length === 0) {
+        return `No specific guidance found for: ${issue}
+Check the basic migration-guide.md for general steps.`;
+      }
+      const help = [
+        `MIGRATION GUIDANCE FOR: ${issue.toUpperCase()}`,
+        "",
+        "Relevant guides found:",
+        ""
+      ];
+      for (const result of results) {
+        help.push(`## ${result.guide.name}`);
+        help.push(`Relevance Score: ${result.relevanceScore.toFixed(1)}`);
+        help.push(`Matched Keywords: ${result.matchedKeywords.join(", ")}`);
+        help.push(`Category: ${result.guide.category}`);
+        help.push("");
+      }
+      return help.join("\n");
+    } catch (error) {
+      return `Error getting migration help: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+  /**
+   * Search guides for specific content
+   */
+  searchGuides(query2, limit = 3) {
+    try {
+      const results = this.guideLoader.searchGuides(query2, limit);
+      if (results.length === 0) {
+        return `No guides found matching: ${query2}`;
+      }
+      const searchResults = [
+        `SEARCH RESULTS FOR: ${query2}`,
+        "",
+        `Found ${results.length} relevant guide(s):`,
+        ""
+      ];
+      for (const result of results) {
+        searchResults.push(`## ${result.guide.name}`);
+        searchResults.push(`Score: ${result.relevanceScore.toFixed(1)}`);
+        searchResults.push(`Keywords: ${result.matchedKeywords.join(", ")}`);
+        searchResults.push(`Path: ${result.guide.path}`);
+        searchResults.push("");
+      }
+      return searchResults.join("\n");
+    } catch (error) {
+      return `Error searching guides: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+  /**
+   * Get complete migration context for debugging
+   */
+  getFullMigrationContext() {
+    try {
+      return this.guideLoader.getAllGuidesContent();
+    } catch (error) {
+      return `Error getting migration context: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+};
+
+// src/commands/plugins/actions/upgrade.ts
+import chalk from "chalk";
 async function upgradePlugin(pluginPath, opts) {
   try {
-    const { PluginMigrator } = await import("./migrator-UQ4XFYE5.js");
     if (opts.apiKey) {
       process.env.ANTHROPIC_API_KEY = opts.apiKey;
     }
     if (!process.env.ANTHROPIC_API_KEY) {
-      logger6.error("ANTHROPIC_API_KEY is required for plugin upgrade.");
+      logger8.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);
     }
-    const migrator = new PluginMigrator({
-      skipTests: opts.skipTests,
-      skipValidation: opts.skipValidation
+    if (!process.env.ANTHROPIC_API_KEY.startsWith("sk-ant-")) {
+      logger8.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);
+    }
+    try {
+      await import("@anthropic-ai/claude-code");
+      if (opts.debug) {
+        console.log("\u2713 Claude Code SDK ready");
+      }
+    } catch (importError) {
+      console.log(chalk.red("\u2717 Claude Code SDK not available"));
+      console.log(
+        chalk.red(
+          `Error: ${importError instanceof Error ? importError.message : String(importError)}`
+        )
+      );
+      console.log("\nInstall the SDK: bun add @anthropic-ai/claude-code");
+      process.exit(1);
+    }
+    const workingDir = path11.resolve(pluginPath);
+    if (!existsSync11(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(path11.join(projectRoot, "packages/docs"))) {
+      previousRoot = projectRoot;
+      projectRoot = path11.dirname(projectRoot);
+    }
+    const monorepoGuidesPath = path11.join(
+      projectRoot,
+      "packages/docs/docs/plugins/migration/claude-code"
+    );
+    if (existsSync11(monorepoGuidesPath)) {
+      guidesSource = monorepoGuidesPath;
+    } else {
+      const currentFileUrl = import.meta.url;
+      const currentFilePath = fileURLToPath2(currentFileUrl);
+      const cliPackageRoot = path11.dirname(
+        path11.dirname(path11.dirname(path11.dirname(currentFilePath)))
+      );
+      const bundledGuidesPath = path11.join(cliPackageRoot, "migration-guides");
+      if (existsSync11(bundledGuidesPath)) {
+        guidesSource = bundledGuidesPath;
+      } else {
+        guidesSource = "";
+      }
+    }
+    const guidesTarget = path11.join(workingDir, "migration-guides");
+    await fs.ensureDir(guidesTarget);
+    if (guidesSource && existsSync11(guidesSource)) {
+      await fs.copy(guidesSource, guidesTarget, { overwrite: true });
+      if (opts.debug) {
+        console.log(chalk.gray(`Copied guides from: ${guidesSource}`));
+      }
+    } else {
+      if (opts.debug) {
+        console.log(chalk.yellow("Migration guides not found, using embedded guidance"));
+      }
+    }
+    console.log(chalk.green("\u2705 Environment ready"));
+    console.log(chalk.bold("\nElizaOS Plugin Migration (0.x \u2192 1.x)"));
+    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\u2500\u2500\u2500\u2500"));
+    console.log("\u2022 Enhanced AI-powered migration with comprehensive guide integration");
+    console.log("\u2022 9-gate progressive validation system with RAG search");
+    console.log("\u2022 Automated analysis and migration with 95%+ test coverage");
+    console.log("\u2022 Zero-failure release preparation with full validation");
+    if (opts.debug) {
+      console.log(chalk.gray(`
+Plugin: ${pluginPath}`));
+      console.log(chalk.gray(`Working directory: ${workingDir}`));
+    }
+    if (!opts.skipConfirmation) {
+      console.log(chalk.yellow("\n\u26A0\uFE0F  This will modify files in the plugin directory."));
+      console.log(chalk.yellow("Ensure your changes are committed first.\n"));
+      console.log("Starting in 3 seconds... (Press Ctrl+C to cancel)");
+      await new Promise((resolve2) => setTimeout(resolve2, 3e3));
+    }
+    const agent2 = new SimpleMigrationAgent(workingDir, {
+      verbose: opts.verbose || opts.debug
     });
-    console.log(`
-${emoji.rocket(`Starting plugin upgrade for: ${pluginPath}`)}
-`);
-    const result = await migrator.migrate(pluginPath);
+    let messageCount = 0;
+    agent2.on("progress", (count) => {
+      messageCount = count;
+    });
+    const result = await agent2.migrate();
+    try {
+      if (existsSync11(guidesTarget)) {
+        await fs.remove(guidesTarget);
+        if (opts.debug) {
+          console.log(chalk.gray("Cleaned up migration guides"));
+        }
+      }
+    } catch (cleanupError) {
+      if (opts.debug) {
+        console.log(chalk.yellow(`Warning: Could not clean up guides: ${cleanupError}`));
+      }
+    }
     if (result.success) {
-      console.log(`
-${emoji.success("Plugin successfully upgraded!")}`);
-      console.log(`   Branch: ${result.branchName}`);
-      console.log(`   Location: ${result.repoPath}`);
-      console.log(`
-The upgraded plugin has been copied to your current directory.`);
-      console.log(`
-Next steps:`);
-      console.log(`1. cd ${path10.basename(result.repoPath ?? "")}`);
-      console.log(`2. Review the changes`);
-      console.log(`3. Test the upgraded plugin thoroughly`);
-      console.log(`4. Push to GitHub and create a pull request when ready`);
+      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(path11.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) {
+        console.log(`Migration Guides Used: ${chalk.magenta(result.guidesUsed.length)}`);
+        if (opts.debug) {
+          console.log(`  ${chalk.gray(result.guidesUsed.join(", "))}`);
+        }
+      }
+      console.log(chalk.bold("\nNext Steps:"));
+      console.log(`${chalk.gray("1.")} cd ${chalk.cyan(path11.basename(result.repoPath))}`);
+      console.log(
+        `${chalk.gray("2.")} git checkout 1.x ${chalk.gray("# Review the migrated code")}`
+      );
+      console.log(`${chalk.gray("3.")} bun test ${chalk.gray("# Verify all tests pass")}`);
+      console.log(`${chalk.gray("4.")} bun run build ${chalk.gray("# Verify the build")}`);
+      console.log(`${chalk.gray("5.")} Test in a real project`);
+      console.log(`${chalk.gray("6.")} Merge to main and publish
+`);
     } else {
-      logger6.error(`Plugin upgrade failed: ${result.error?.message}`);
+      console.log(chalk.red("\n\u274C Migration failed"));
+      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"));
+      if (result.error) {
+        const errorMsg = result.error.message || String(result.error);
+        console.log(chalk.red(`\u{1F4A5} ${errorMsg}`));
+        if (opts.debug || opts.verbose) {
+          console.log(chalk.gray("\nDetailed error:"));
+          console.log(chalk.gray(result.error.stack || result.error.message));
+        }
+      }
+      console.log(chalk.yellow("\n\u{1F527} Quick fixes:"));
+      console.log("\u2022 Check plugin structure follows ElizaOS standards");
+      console.log("\u2022 Verify ANTHROPIC_API_KEY is valid");
+      console.log("\u2022 Try with --debug for detailed output");
+      console.log("\u2022 Ensure all dependencies are installed\n");
       process.exit(1);
     }
   } catch (error) {
+    try {
+      const guidesTarget = path11.join(path11.resolve(pluginPath), "migration-guides");
+      if (existsSync11(guidesTarget)) {
+        await fs.remove(guidesTarget);
+        if (opts.debug) {
+          console.log(chalk.gray("Cleaned up migration guides after error"));
+        }
+      }
+    } catch (cleanupError) {
+    }
+    console.log("\n" + chalk.red("\u2717 Plugin upgrade failed!"));
+    if (opts.debug || opts.verbose) {
+      console.log("\n" + chalk.bold("Detailed Error Information:"));
+      console.log(chalk.red(error instanceof Error ? error.stack : String(error)));
+    } else {
+      console.log(chalk.red(`
+Error: ${error instanceof Error ? error.message : String(error)}`));
+    }
+    console.log("\n" + chalk.yellow("Troubleshooting Tips:"));
+    console.log("1. Check that your plugin follows standard ElizaOS structure");
+    console.log("2. Ensure all dependencies are installed");
+    console.log("3. Try running with --verbose or --debug for more details");
+    console.log("4. Verify your ANTHROPIC_API_KEY is valid");
     handleError(error);
     process.exit(1);
   }
 }
 
 // src/commands/plugins/actions/generate.ts
-import { logger as logger7 } from "@elizaos/core";
-import { readFileSync as readFileSync3 } from "fs";
-import path11 from "path";
+import { logger as logger9 } from "@elizaos/core";
+import { readFileSync as readFileSync4 } from "fs";
+import path12 from "path";
 async function generatePlugin(opts) {
   try {
-    const { PluginCreator } = await import("./plugin-creator-TLQLTQIB.js");
+    const { PluginCreator } = await import("./plugin-creator-ZCOZ3UCT.js");
     if (opts.apiKey) {
       process.env.ANTHROPIC_API_KEY = opts.apiKey;
     }
     if (!process.env.ANTHROPIC_API_KEY) {
-      logger7.error("ANTHROPIC_API_KEY is required for plugin generation.");
+      logger9.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 = readFileSync3(opts.specFile, "utf-8");
+        const specContent = readFileSync4(opts.specFile, "utf-8");
         spec = JSON.parse(specContent);
       } catch (error) {
-        logger7.error(
+        logger9.error(
           `Failed to read or parse spec file: ${error instanceof Error ? error.message : String(error)}`
         );
         process.exit(1);
       }
     } else if (opts.skipPrompts) {
-      logger7.error("--skip-prompts requires --spec-file to be provided");
+      logger9.error("--skip-prompts requires --spec-file to be provided");
       process.exit(1);
     }
     const creator = new PluginCreator({
@@ -1659,12 +2735,12 @@ ${emoji.success("Plugin successfully generated!")}`);
 The plugin has been created in your current directory.`);
       console.log(`
 Next steps:`);
-      console.log(`1. cd ${path11.basename(result.pluginPath ?? "")}`);
+      console.log(`1. cd ${path12.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 {
-      logger7.error(`Plugin generation failed: ${result.error?.message}`);
+      logger9.error(`Plugin generation failed: ${result.error?.message}`);
       process.exit(1);
     }
   } catch (error) {
@@ -1711,7 +2787,9 @@ plugins.command("remove").aliases(["delete", "del", "rm"]).description("Remove a
     process.exit(1);
   }
 });
-plugins.command("upgrade").description("Upgrade a plugin from version 0.x to 1.x using AI-powered migration").argument("<path>", "GitHub repository URL or local folder path").option("--api-key <key>", "Anthropic API key (or use ANTHROPIC_API_KEY env var)").option("--skip-tests", "Skip test validation loop").option("--skip-validation", "Skip production readiness validation").action(async (pluginPath, opts) => {
+plugins.command("upgrade").description(
+  "Upgrade a plugin from version 0.x to 1.x using AI-powered migration (requires Claude Code CLI)"
+).argument("<path>", "GitHub repository URL or local folder path").option("--api-key <key>", "Anthropic API key (or use ANTHROPIC_API_KEY env var)").option("--skip-tests", "Skip test validation loop").option("--skip-validation", "Skip production readiness validation").option("--quiet", "Suppress progress display").option("--verbose", "Show detailed information").option("--debug", "Show debug information").option("--skip-confirmation", "Skip user confirmation").action(async (pluginPath, opts) => {
   await upgradePlugin(pluginPath, opts);
 });
 plugins.command("generate").description("Generate a new plugin using AI-powered code generation").option("--api-key <key>", "Anthropic API key (or use ANTHROPIC_API_KEY env var)").option("--skip-tests", "Skip test validation loop").option("--skip-validation", "Skip production readiness validation").option("--skip-prompts", "Skip interactive prompts (requires --spec-file)").option("--spec-file <path>", "Path to JSON file containing plugin specification").action(async (opts) => {
@@ -1721,19 +2799,19 @@ 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 path17 from "path";
+import path18 from "path";
 import * as clack9 from "@clack/prompts";
 
 // src/commands/publish/actions/npm-publish.ts
 import { execa as execa2 } from "execa";
 import { promises as fs2 } from "fs";
-import path12 from "path";
+import path13 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 = path12.join(cwd, "package.json");
+    const packageJsonPath = path13.join(cwd, "package.json");
     await fs2.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
   }
   console.info("Building package...");
@@ -1764,16 +2842,16 @@ async function publishToGitHubAction(cwd, packageJson, credentials, skipRegistry
 
 // src/commands/publish/actions/registry-publish.ts
 import { promises as fs3 } from "fs";
-import path13 from "path";
+import path14 from "path";
 var REGISTRY_PACKAGES_PATH = "packages";
 var LOCAL_REGISTRY_PATH = "packages/registry";
 async function updateRegistryIndex(packageMetadata, dryRun = false) {
   try {
-    const indexPath = dryRun ? path13.join(process.cwd(), LOCAL_REGISTRY_PATH, "index.json") : path13.join(process.cwd(), "temp-registry", "index.json");
+    const indexPath = dryRun ? path14.join(process.cwd(), LOCAL_REGISTRY_PATH, "index.json") : path14.join(process.cwd(), "temp-registry", "index.json");
     try {
-      await fs3.access(path13.dirname(indexPath));
+      await fs3.access(path14.dirname(indexPath));
     } catch {
-      await fs3.mkdir(path13.dirname(indexPath), { recursive: true });
+      await fs3.mkdir(path14.dirname(indexPath), { recursive: true });
       try {
         await fs3.access(indexPath);
       } catch {
@@ -1838,8 +2916,8 @@ async function updateRegistryIndex(packageMetadata, dryRun = false) {
 }
 async function savePackageToRegistry(packageMetadata, dryRun = false) {
   try {
-    const packageDir = dryRun ? path13.join(process.cwd(), LOCAL_REGISTRY_PATH, REGISTRY_PACKAGES_PATH, packageMetadata.name) : path13.join(process.cwd(), "temp-registry", REGISTRY_PACKAGES_PATH, packageMetadata.name);
-    const metadataPath = path13.join(packageDir, `${packageMetadata.version}.json`);
+    const packageDir = dryRun ? path14.join(process.cwd(), LOCAL_REGISTRY_PATH, REGISTRY_PACKAGES_PATH, packageMetadata.name) : path14.join(process.cwd(), "temp-registry", REGISTRY_PACKAGES_PATH, packageMetadata.name);
+    const metadataPath = path14.join(packageDir, `${packageMetadata.version}.json`);
     await fs3.mkdir(packageDir, { recursive: true });
     await fs3.writeFile(metadataPath, JSON.stringify(packageMetadata, null, 2));
     console.info(`Package metadata ${dryRun ? "(dry run) " : ""}saved to ${metadataPath}`);
@@ -1855,7 +2933,7 @@ async function savePackageToRegistry(packageMetadata, dryRun = false) {
 
 // src/commands/publish/utils/validation.ts
 import { promises as fs4 } from "fs";
-import path14 from "path";
+import path15 from "path";
 import * as clack5 from "@clack/prompts";
 async function validatePluginRequirements(cwd, packageJson) {
   const errors = [];
@@ -1866,16 +2944,16 @@ async function validatePluginRequirements(cwd, packageJson) {
       'Plugin name must start with "plugin-". Please update your package name and try again.'
     );
   }
-  const pluginDirName = path14.basename(cwd);
+  const pluginDirName = path15.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 = path14.join(cwd, "images");
-  const logoPath = path14.join(imagesDir, "logo.jpg");
-  const bannerPath = path14.join(imagesDir, "banner.jpg");
+  const imagesDir = path15.join(cwd, "images");
+  const logoPath = path15.join(imagesDir, "logo.jpg");
+  const bannerPath = path15.join(imagesDir, "banner.jpg");
   try {
     await fs4.access(logoPath);
   } catch {
@@ -2023,20 +3101,20 @@ async function getNpmUsername() {
 // src/commands/publish/utils/version-check.ts
 import { execa as execa7 } from "execa";
 import { promises as fs7 } from "fs";
-import path16 from "path";
-import { fileURLToPath } from "url";
+import path17 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import * as clack8 from "@clack/prompts";
 
 // src/commands/update/index.ts
-import { logger as logger11 } from "@elizaos/core";
+import { logger as logger13 } from "@elizaos/core";
 import { Command as Command4 } from "commander";
 
 // src/commands/update/actions/cli-update.ts
-import { logger as logger9 } from "@elizaos/core";
+import { logger as logger11 } from "@elizaos/core";
 import { execa as execa5 } from "execa";
 
 // src/commands/update/utils/version-utils.ts
-import { logger as logger8 } from "@elizaos/core";
+import { logger as logger10 } from "@elizaos/core";
 import { execa as execa4 } from "execa";
 import * as semver from "semver";
 var SPECIAL_VERSION_TAGS = ["latest", "next", "canary", "rc", "dev", "nightly", "alpha"];
@@ -2047,7 +3125,7 @@ async function getVersion2() {
     const envInfo = await UserEnvironment.getInstance().getInfo();
     return envInfo.cli.version;
   } catch (error) {
-    logger8.error("Error getting CLI version:", error);
+    logger10.error("Error getting CLI version:", error);
     return FALLBACK_VERSION;
   }
 }
@@ -2087,10 +3165,10 @@ async function fetchLatestVersion(packageName) {
       env: { NODE_ENV: "production" }
     });
     const version = stdout.trim();
-    logger8.debug(`Latest version of ${packageName} from npm: ${version}`);
+    logger10.debug(`Latest version of ${packageName} from npm: ${version}`);
     return version;
   } catch (error) {
-    logger8.error(
+    logger10.error(
       `Failed to fetch version for ${packageName}: ${error instanceof Error ? error.message : String(error)}`
     );
     return null;
@@ -2121,14 +3199,14 @@ async function performCliUpdate(options = {}) {
     if (!options.skipBunMigration) {
       const npmInstallation = await isCliInstalledViaNpm();
       if (npmInstallation) {
-        logger9.info("Detected npm installation, migrating to bun...");
+        logger11.info("Detected npm installation, migrating to bun...");
         try {
           await migrateCliToBun(latestVersion);
           console.log(`CLI updated successfully to version ${latestVersion} [\u2713]`);
           return true;
         } catch (migrationError) {
-          logger9.warn("Migration to bun failed, falling back to npm update...");
-          logger9.debug(
+          logger11.warn("Migration to bun failed, falling back to npm update...");
+          logger11.debug(
             "Migration error:",
             migrationError instanceof Error ? migrationError.message : String(migrationError)
           );
@@ -2158,12 +3236,12 @@ async function performCliUpdate(options = {}) {
 // src/commands/update/actions/dependency-update.ts
 import * as clack7 from "@clack/prompts";
 import { promises as fs6 } from "fs";
-import * as path15 from "path";
+import * as path16 from "path";
 
 // src/commands/update/utils/package-utils.ts
 import fs5 from "fs/promises";
 import { execa as execa6 } from "execa";
-import { logger as logger10 } from "@elizaos/core";
+import { logger as logger12 } from "@elizaos/core";
 async function checkForUpdates(dependencies) {
   const updates = {};
   const elizaPackages = Object.entries(dependencies).filter(([pkg]) => pkg.startsWith(ELIZAOS_ORG)).filter(([, version]) => !isWorkspaceVersion(version));
@@ -2174,7 +3252,7 @@ async function checkForUpdates(dependencies) {
     if (needsUpdate) {
       updates[pkg] = { current: currentVersion, latest: latestVersion };
     } else if (error) {
-      logger10.debug(`${pkg}: ${error}`);
+      logger12.debug(`${pkg}: ${error}`);
     }
   }
   return { hasUpdates: Object.keys(updates).length > 0, updates };
@@ -2222,7 +3300,7 @@ 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 = path15.join(cwd, "package.json");
+  const packageJsonPath = path16.join(cwd, "package.json");
   const content = await fs6.readFile(packageJsonPath, "utf8");
   const packageJson = JSON.parse(content);
   const allDependencies = {
@@ -2293,7 +3371,7 @@ var update = new Command4().name("update").description("Update ElizaOS CLI and p
   try {
     await displayBanner();
   } catch {
-    logger11.debug("Banner display failed, continuing with update");
+    logger13.debug("Banner display failed, continuing with update");
   }
 }).action(async (options) => {
   try {
@@ -2326,7 +3404,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;
       }
-      logger11.debug(`Detected ${directoryInfo.type}`);
+      logger13.debug(`Detected ${directoryInfo.type}`);
       if (!isValidForUpdates(directoryInfo)) {
         handleInvalidDirectory(directoryInfo);
         return;
@@ -2363,8 +3441,8 @@ 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 = path16.resolve(
-      path16.dirname(fileURLToPath(import.meta.url)),
+    const cliPackageJsonPath = path17.resolve(
+      path17.dirname(fileURLToPath3(import.meta.url)),
       "../package.json"
     );
     const cliPackageJsonContent = await fs7.readFile(cliPackageJsonPath, "utf-8");
@@ -2425,7 +3503,7 @@ var publish = new Command5().name("publish").description("Publish a plugin to np
       process.exit(1);
     }
     const cliVersion = await checkCliVersion();
-    const pluginDirName = path17.basename(process.cwd());
+    const pluginDirName = path18.basename(process.cwd());
     if (!pluginDirName.startsWith("plugin-")) {
       console.error("This command must be run from a plugin directory (plugin-*)");
       process.exit(1);
@@ -2451,7 +3529,7 @@ var publish = new Command5().name("publish").description("Publish a plugin to np
         }
       }
     }
-    const packageJsonPath = path17.join(cwd, "package.json");
+    const packageJsonPath = path18.join(cwd, "package.json");
     const packageJsonContent = await fs8.readFile(packageJsonPath, "utf-8");
     const packageJson = JSON.parse(packageJsonContent);
     if (!packageJson.name || !packageJson.version) {
@@ -2718,8 +3796,8 @@ import { Command as Command6 } from "commander";
 
 // src/commands/monorepo/actions/clone.ts
 import { execa as execa8 } from "execa";
-import { existsSync as existsSync10, readdirSync as readdirSync2, mkdirSync } from "fs";
-import path18 from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync3, mkdirSync } from "fs";
+import path19 from "path";
 async function cloneRepository(repo, branch, destination) {
   try {
     const repoUrl = `https://github.com/${repo}`;
@@ -2745,9 +3823,9 @@ For a complete list of branches, visit: https://github.com/elizaOS/eliza/branche
   }
 }
 function prepareDestination(dir) {
-  const destinationDir = path18.resolve(process.cwd(), dir);
-  if (existsSync10(destinationDir)) {
-    const files = readdirSync2(destinationDir);
+  const destinationDir = path19.resolve(process.cwd(), dir);
+  if (existsSync12(destinationDir)) {
+    const files = readdirSync3(destinationDir);
     if (files.length > 0) {
       throw new Error(`Destination directory ${destinationDir} already exists and is not empty`);
     }
@@ -2764,7 +3842,7 @@ async function cloneMonorepo(cloneInfo) {
 }
 
 // src/commands/monorepo/utils/setup-instructions.ts
-import path19 from "path";
+import path20 from "path";
 function getBunInstallInstructions() {
   const platform = process.platform;
   if (platform === "win32") {
@@ -2819,7 +3897,7 @@ ${emoji.rocket("If you don't have Bun installed:")}`);
   console.log("   After installation, restart your terminal");
 }
 function displayNextSteps(targetDir) {
-  const cdPath = path19.relative(process.cwd(), targetDir);
+  const cdPath = path20.relative(process.cwd(), targetDir);
   displayBasicSteps(cdPath);
   displayPrerequisites();
   displayBunInstructions();
@@ -2849,11 +3927,11 @@ import { loadCharacterTryPath as loadCharacterTryPath2 } from "@elizaos/server";
 
 // src/project.ts
 import {
-  logger as logger12
+  logger as logger14
 } from "@elizaos/core";
 import { stringToUuid } from "@elizaos/core";
 import * as fs9 from "fs";
-import path20 from "path";
+import path21 from "path";
 function isPlugin(module) {
   if (module && typeof module === "object" && typeof module.name === "string" && typeof module.description === "string") {
     return true;
@@ -2888,10 +3966,10 @@ async function loadProject(dir) {
     if (!dirInfo.hasPackageJson) {
       throw new Error(`No package.json found in ${dir}`);
     }
-    const packageJson = JSON.parse(fs9.readFileSync(path20.join(dir, "package.json"), "utf8"));
+    const packageJson = JSON.parse(fs9.readFileSync(path21.join(dir, "package.json"), "utf8"));
     const main2 = packageJson.main;
     if (!main2) {
-      logger12.warn("No main field found in package.json, using default character");
+      logger14.warn("No main field found in package.json, using default character");
       const defaultCharacterName = "Eliza (Default)";
       const elizaCharacter = getElizaCharacter();
       const defaultAgent = {
@@ -2901,7 +3979,7 @@ async function loadProject(dir) {
           name: defaultCharacterName
         },
         init: async () => {
-          logger12.info("Initializing default Eliza character");
+          logger14.info("Initializing default Eliza character");
         }
       };
       return {
@@ -2910,32 +3988,32 @@ async function loadProject(dir) {
       };
     }
     const entryPoints = [
-      path20.join(dir, main2),
-      path20.join(dir, "dist/index.js"),
-      path20.join(dir, "src/index.ts"),
-      path20.join(dir, "src/index.js"),
-      path20.join(dir, "index.ts"),
-      path20.join(dir, "index.js")
+      path21.join(dir, main2),
+      path21.join(dir, "dist/index.js"),
+      path21.join(dir, "src/index.ts"),
+      path21.join(dir, "src/index.js"),
+      path21.join(dir, "index.ts"),
+      path21.join(dir, "index.js")
     ];
     let projectModule = null;
     for (const entryPoint of entryPoints) {
       if (fs9.existsSync(entryPoint)) {
         try {
-          const importPath = path20.resolve(entryPoint);
+          const importPath = path21.resolve(entryPoint);
           const importUrl = process.platform === "win32" ? "file:///" + importPath.replace(/\\/g, "/") : "file://" + importPath;
           projectModule = await import(importUrl);
-          logger12.info(`Loaded project from ${entryPoint}`);
+          logger14.info(`Loaded project from ${entryPoint}`);
           const exportKeys = Object.keys(projectModule);
-          logger12.debug(`Module exports: ${exportKeys.join(", ")}`);
+          logger14.debug(`Module exports: ${exportKeys.join(", ")}`);
           if (exportKeys.includes("default")) {
-            logger12.debug(`Default export type: ${typeof projectModule.default}`);
+            logger14.debug(`Default export type: ${typeof projectModule.default}`);
             if (typeof projectModule.default === "object" && projectModule.default !== null) {
-              logger12.debug(`Default export keys: ${Object.keys(projectModule.default).join(", ")}`);
+              logger14.debug(`Default export keys: ${Object.keys(projectModule.default).join(", ")}`);
             }
           }
           break;
         } catch (error) {
-          logger12.warn(`Failed to import project from ${entryPoint}:`, error);
+          logger14.warn(`Failed to import project from ${entryPoint}:`, error);
         }
       }
     }
@@ -2943,13 +4021,13 @@ async function loadProject(dir) {
       throw new Error("Could not find project entry point");
     }
     const moduleIsPlugin = isPlugin(projectModule);
-    logger12.debug(`Is this a plugin? ${moduleIsPlugin}`);
+    logger14.debug(`Is this a plugin? ${moduleIsPlugin}`);
     if (moduleIsPlugin) {
-      logger12.info("Detected plugin module instead of project");
+      logger14.info("Detected plugin module instead of project");
       try {
         const plugin = extractPlugin(projectModule);
-        logger12.debug(`Found plugin: ${plugin.name} - ${plugin.description}`);
-        logger12.debug(`Plugin has the following properties: ${Object.keys(plugin).join(", ")}`);
+        logger14.debug(`Found plugin: ${plugin.name} - ${plugin.description}`);
+        logger14.debug(`Plugin has the following properties: ${Object.keys(plugin).join(", ")}`);
         const completePlugin = {
           // Copy all other properties from the original plugin first
           ...plugin,
@@ -2957,7 +4035,7 @@ async function loadProject(dir) {
           name: plugin.name || "unknown-plugin",
           description: plugin.description || "No description",
           init: plugin.init || (async () => {
-            logger12.info(`Dummy init for plugin: ${plugin.name}`);
+            logger14.info(`Dummy init for plugin: ${plugin.name}`);
           })
         };
         const characterName = "Eliza (Test Mode)";
@@ -2968,13 +4046,13 @@ async function loadProject(dir) {
           name: characterName,
           system: `${elizaCharacter.system} Testing the plugin: ${completePlugin.name}.`
         };
-        logger12.info(`Using Eliza character as test agent for plugin: ${completePlugin.name}`);
+        logger14.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 () => {
-            logger12.info(`Initializing Eliza test agent for plugin: ${completePlugin.name}`);
+            logger14.info(`Initializing Eliza test agent for plugin: ${completePlugin.name}`);
           }
         };
         return {
@@ -2984,24 +4062,24 @@ async function loadProject(dir) {
           pluginModule: completePlugin
         };
       } catch (error) {
-        logger12.error("Error extracting plugin from module:", error);
+        logger14.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);
-      logger12.debug(`Found ${agents.length} agents in default export's agents array`);
+      logger14.debug(`Found ${agents.length} agents in default export's agents array`);
     } else {
       for (const [key, value] of Object.entries(projectModule)) {
         if (key === "default" && value && typeof value === "object") {
           if (value.character && value.init) {
             agents.push(value);
-            logger12.debug(`Found agent in default export (single agent)`);
+            logger14.debug(`Found agent in default export (single agent)`);
           }
         } else if (value && typeof value === "object" && value.character && value.init) {
           agents.push(value);
-          logger12.debug(`Found agent in named export: ${key}`);
+          logger14.debug(`Found agent in named export: ${key}`);
         }
       }
     }
@@ -3014,52 +4092,79 @@ async function loadProject(dir) {
     };
     return project;
   } catch (error) {
-    logger12.error("Error loading project:", error);
+    logger14.error("Error loading project:", error);
     throw error;
   }
 }
 
 // src/commands/start/index.ts
-import { logger as logger17 } from "@elizaos/core";
+import { logger as logger19 } from "@elizaos/core";
 import { Command as Command7 } from "commander";
 
 // src/commands/start/actions/server-start.ts
 import { AgentServer, jsonToCharacter, loadCharacterTryPath } from "@elizaos/server";
-import { logger as logger16 } from "@elizaos/core";
+import { logger as logger18 } from "@elizaos/core";
 
 // src/commands/start/actions/agent-start.ts
 import {
   AgentRuntime as AgentRuntime2,
   encryptedCharacter,
-  logger as logger15,
+  logger as logger17,
   stringToUuid as stringToUuid2
 } from "@elizaos/core";
 import { plugin as sqlPlugin } from "@elizaos/plugin-sql";
 
 // src/commands/start/utils/config-utils.ts
-import dotenv2 from "dotenv";
+import dotenv from "dotenv";
 async function loadEnvConfig() {
   const envInfo = await UserEnvironment.getInstanceInfo();
   if (envInfo.paths.envFilePath) {
-    dotenv2.config({ path: envInfo.paths.envFilePath });
+    dotenv.config({ path: envInfo.paths.envFilePath });
   }
   return process.env;
 }
+function hasCharacterSecrets(character) {
+  return character?.settings?.secrets && Object.keys(character.settings.secrets).length > 0;
+}
+function ensureCharacterSettings(character) {
+  if (!character.settings) {
+    character.settings = {};
+  }
+}
+async function loadLocalEnvSecrets() {
+  const envPath = await getLocalEnvPath();
+  if (!envPath) {
+    return null;
+  }
+  return await parseEnvFile(envPath);
+}
+async function setDefaultSecretsFromEnv(character) {
+  ensureCharacterSettings(character);
+  if (hasCharacterSecrets(character)) {
+    return false;
+  }
+  const envSecrets = await loadLocalEnvSecrets();
+  if (!envSecrets) {
+    return false;
+  }
+  character.settings.secrets = envSecrets;
+  return true;
+}
 
 // src/commands/start/utils/dependency-resolver.ts
-import { logger as logger13 } from "@elizaos/core";
+import { logger as logger15 } 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)) {
-      logger13.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
+      logger15.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
       return;
     }
     if (visited.has(pluginName)) return;
     if (visiting.has(pluginName)) {
-      logger13.error(`Circular dependency detected involving plugin: ${pluginName}`);
+      logger15.error(`Circular dependency detected involving plugin: ${pluginName}`);
       return;
     }
     visiting.add(pluginName);
@@ -3083,12 +4188,12 @@ function resolvePluginDependencies(availablePlugins, isTestMode = false) {
     }
   }
   const finalPlugins = resolutionOrder.map((name) => availablePlugins.get(name)).filter((p) => p);
-  logger13.info(`Final plugins being loaded: ${finalPlugins.map((p) => p.name).join(", ")}`);
+  logger15.info(`Final plugins being loaded: ${finalPlugins.map((p) => p.name).join(", ")}`);
   return finalPlugins;
 }
 
 // src/commands/start/utils/plugin-utils.ts
-import { logger as logger14 } from "@elizaos/core";
+import { logger as logger16 } from "@elizaos/core";
 function isValidPluginShape(obj) {
   if (!obj || typeof obj !== "object" || !obj.name) {
     return false;
@@ -3103,12 +4208,12 @@ async function loadAndPreparePlugin(pluginName) {
     try {
       pluginModule = await loadPluginModule(pluginName);
       if (!pluginModule) {
-        logger14.error(`Failed to load local plugin ${pluginName}.`);
+        logger16.error(`Failed to load local plugin ${pluginName}.`);
         provideLocalPluginGuidance(pluginName, context);
         return null;
       }
     } catch (error) {
-      logger14.error(`Error loading local plugin ${pluginName}: ${error}`);
+      logger16.error(`Error loading local plugin ${pluginName}: ${error}`);
       provideLocalPluginGuidance(pluginName, context);
       return null;
     }
@@ -3116,17 +4221,17 @@ async function loadAndPreparePlugin(pluginName) {
     try {
       pluginModule = await loadPluginModule(pluginName);
       if (!pluginModule) {
-        logger14.info(`Plugin ${pluginName} not available, installing...`);
+        logger16.info(`Plugin ${pluginName} not available, installing...`);
         await installPlugin(pluginName, process.cwd(), version);
         pluginModule = await loadPluginModule(pluginName);
       }
     } catch (error) {
-      logger14.error(`Failed to process plugin ${pluginName}: ${error}`);
+      logger16.error(`Failed to process plugin ${pluginName}: ${error}`);
       return null;
     }
   }
   if (!pluginModule) {
-    logger14.error(`Failed to load module for plugin ${pluginName}.`);
+    logger16.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`;
@@ -3140,13 +4245,16 @@ async function loadAndPreparePlugin(pluginName) {
       return potentialPlugin;
     }
   }
-  logger14.warn(`Could not find a valid plugin export in ${pluginName}.`);
+  logger16.warn(`Could not find a valid plugin export in ${pluginName}.`);
   return null;
 }
 
 // src/commands/start/actions/agent-start.ts
 async function startAgent(character, server, init, plugins2 = [], options = {}) {
   character.id ??= stringToUuid2(character.name);
+  if (!hasCharacterSecrets(character)) {
+    await setDefaultSecretsFromEnv(character);
+  }
   const loadedPlugins = /* @__PURE__ */ new Map();
   loadedPlugins.set(sqlPlugin.name, sqlPlugin);
   const pluginsToLoad = new Set(character.plugins || []);
@@ -3189,26 +4297,26 @@ async function startAgent(character, server, init, plugins2 = [], options = {})
   try {
     const migrationService = runtime.getService("database_migration");
     if (migrationService) {
-      logger15.info("Discovering plugin schemas for dynamic migration...");
+      logger17.info("Discovering plugin schemas for dynamic migration...");
       migrationService.discoverAndRegisterPluginSchemas(finalPlugins);
-      logger15.info("Running all plugin migrations...");
+      logger17.info("Running all plugin migrations...");
       await migrationService.runAllPluginMigrations();
-      logger15.info("All plugin migrations completed successfully");
+      logger17.info("All plugin migrations completed successfully");
     } else {
-      logger15.warn("DatabaseMigrationService not found - plugin schema migrations skipped");
+      logger17.warn("DatabaseMigrationService not found - plugin schema migrations skipped");
     }
   } catch (error) {
-    logger15.error("Failed to run plugin migrations:", error);
+    logger17.error("Failed to run plugin migrations:", error);
     throw error;
   }
   server.registerAgent(runtime);
-  logger15.log(`Started ${runtime.character.name} as ${runtime.agentId}`);
+  logger17.log(`Started ${runtime.character.name} as ${runtime.agentId}`);
   return runtime;
 }
 async function stopAgent(runtime, server) {
   await runtime.close();
   server.unregisterAgent(runtime.agentId);
-  logger15.success(`Agent ${runtime.character.name} stopped successfully!`);
+  logger17.success(`Agent ${runtime.character.name} stopped successfully!`);
 }
 
 // src/commands/start/actions/server-start.ts
@@ -3225,7 +4333,7 @@ async function startAgents(options) {
   const desiredPort = options.port || Number.parseInt(process.env.SERVER_PORT || "3000");
   const serverPort = await findNextAvailablePort(desiredPort);
   if (serverPort !== desiredPort) {
-    logger16.warn(`Port ${desiredPort} is in use, using port ${serverPort} instead`);
+    logger18.warn(`Port ${desiredPort} is in use, using port ${serverPort} instead`);
   }
   process.env.SERVER_PORT = serverPort.toString();
   server.start(serverPort);
@@ -3250,7 +4358,7 @@ async function startAgents(options) {
 
 // src/commands/start/index.ts
 import * as fs10 from "fs";
-import * as path21 from "path";
+import * as path22 from "path";
 var start = new Command7().name("start").description("Start the Eliza agent server").option("-c, --configure", "Reconfigure services and AI models").option("-p, --port <port>", "Port to listen on", validatePort).option("--character <paths...>", "Character file(s) to use").hook("preAction", async () => {
   await displayBanner();
 }).action(async (options) => {
@@ -3260,24 +4368,24 @@ var start = new Command7().name("start").description("Start the Eliza agent serv
     let projectAgents = [];
     if (options.character && options.character.length > 0) {
       for (const charPath of options.character) {
-        const resolvedPath = path21.resolve(charPath);
+        const resolvedPath = path22.resolve(charPath);
         if (!fs10.existsSync(resolvedPath)) {
-          logger17.error(`Character file not found: ${resolvedPath}`);
+          logger19.error(`Character file not found: ${resolvedPath}`);
           throw new Error(`Character file not found: ${resolvedPath}`);
         }
         try {
           const character = await loadCharacterTryPath2(resolvedPath);
           if (character) {
             characters.push(character);
-            logger17.info(`Successfully loaded character: ${character.name}`);
+            logger19.info(`Successfully loaded character: ${character.name}`);
           } else {
-            logger17.error(
+            logger19.error(
               `Failed to load character from ${resolvedPath}: Invalid or empty character file`
             );
             throw new Error(`Invalid character file: ${resolvedPath}`);
           }
         } catch (e) {
-          logger17.error(`Failed to load character from ${resolvedPath}:`, e);
+          logger19.error(`Failed to load character from ${resolvedPath}:`, e);
           throw new Error(`Invalid character file: ${resolvedPath}`);
         }
       }
@@ -3286,20 +4394,20 @@ var start = new Command7().name("start").description("Start the Eliza agent serv
         const cwd = process.cwd();
         const dirInfo = detectDirectoryType(cwd);
         if (dirInfo.hasPackageJson && dirInfo.type !== "non-elizaos-dir") {
-          logger17.info("No character files specified, attempting to load project agents...");
+          logger19.info("No character files specified, attempting to load project agents...");
           const project = await loadProject(cwd);
           if (project.agents && project.agents.length > 0) {
-            logger17.info(`Found ${project.agents.length} agent(s) in project configuration`);
+            logger19.info(`Found ${project.agents.length} agent(s) in project configuration`);
             projectAgents = project.agents;
             for (const agent2 of project.agents) {
               if (agent2.character) {
-                logger17.info(`Loaded character: ${agent2.character.name}`);
+                logger19.info(`Loaded character: ${agent2.character.name}`);
               }
             }
           }
         }
       } catch (e) {
-        logger17.debug("Failed to load project agents, will use default character:", e);
+        logger19.debug("Failed to load project agents, will use default character:", e);
       }
     }
     await startAgents({ ...options, characters, projectAgents });
@@ -3378,18 +4486,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 logger24 } from "@elizaos/core";
+import { logger as logger26 } from "@elizaos/core";
 import { Command as Command10, Option as Option2 } from "commander";
 
 // src/commands/test/actions/run-all-tests.ts
-import { logger as logger22 } from "@elizaos/core";
+import { logger as logger24 } from "@elizaos/core";
 
 // src/commands/test/utils/project-utils.ts
-import { logger as logger18 } from "@elizaos/core";
+import { logger as logger20 } from "@elizaos/core";
 import * as fs11 from "fs";
-import path22 from "path";
+import path23 from "path";
 function getProjectType(testPath) {
-  const targetPath = testPath ? path22.resolve(process.cwd(), testPath) : process.cwd();
+  const targetPath = testPath ? path23.resolve(process.cwd(), testPath) : process.cwd();
   return detectDirectoryType(targetPath);
 }
 function processFilterName(name) {
@@ -3408,11 +4516,11 @@ async function installPluginDependencies(projectInfo) {
   }
   const project = await loadProject(process.cwd());
   if (project.isPlugin && project.pluginModule?.dependencies && project.pluginModule.dependencies.length > 0) {
-    const pluginsDir = path22.join(process.cwd(), ".eliza", "plugins");
+    const pluginsDir = path23.join(process.cwd(), ".eliza", "plugins");
     if (!fs11.existsSync(pluginsDir)) {
       await fs11.promises.mkdir(pluginsDir, { recursive: true });
     }
-    const packageJsonPath = path22.join(pluginsDir, "package.json");
+    const packageJsonPath = path23.join(pluginsDir, "package.json");
     if (!fs11.existsSync(packageJsonPath)) {
       const packageJsonContent = {
         name: "test-plugin-dependencies",
@@ -3422,15 +4530,15 @@ async function installPluginDependencies(projectInfo) {
       };
       await fs11.promises.writeFile(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
     }
-    const { installPlugin: installPlugin2 } = await import("./utils-BROS5JZQ.js");
+    const { installPlugin: installPlugin2 } = await import("./utils-I3EA43DE.js");
     for (const dependency of project.pluginModule.dependencies) {
       await installPlugin2(dependency, pluginsDir);
-      const dependencyPath = path22.join(pluginsDir, "node_modules", dependency);
+      const dependencyPath = path23.join(pluginsDir, "node_modules", dependency);
       if (fs11.existsSync(dependencyPath)) {
         try {
           await runBunCommand(["install"], dependencyPath);
         } catch (error) {
-          logger18.warn(
+          logger20.warn(
             `[Test Command] Failed to install devDependencies for ${dependency}: ${error}`
           );
         }
@@ -3440,18 +4548,18 @@ async function installPluginDependencies(projectInfo) {
 }
 
 // src/commands/test/actions/component-tests.ts
-import { logger as logger20 } from "@elizaos/core";
+import { logger as logger22 } from "@elizaos/core";
 import { spawn as spawn3 } from "child_process";
-import path24 from "path";
+import path25 from "path";
 
 // src/utils/testing/tsc-validator.ts
-import { logger as logger19 } from "@elizaos/core";
+import { logger as logger21 } from "@elizaos/core";
 import { execa as execa9 } from "execa";
-import path23 from "path";
-import { existsSync as existsSync14 } from "fs";
+import path24 from "path";
+import { existsSync as existsSync16 } from "fs";
 async function runTypeCheck(projectPath, strict = true) {
-  const tsconfigPath = path23.join(projectPath, "tsconfig.json");
-  if (!existsSync14(tsconfigPath)) {
+  const tsconfigPath = path24.join(projectPath, "tsconfig.json");
+  if (!existsSync16(tsconfigPath)) {
     return {
       success: false,
       errors: [`No tsconfig.json found at ${tsconfigPath}`],
@@ -3474,7 +4582,7 @@ async function runTypeCheck(projectPath, strict = true) {
       warnings: stderr.includes("warning") ? [stderr] : []
     };
   } catch (error) {
-    logger19.error("TypeScript validation failed:", error);
+    logger21.error("TypeScript validation failed:", error);
     return {
       success: false,
       errors: [`TypeScript validation error: ${error.message}`],
@@ -3488,37 +4596,39 @@ async function runComponentTests(testPath, options, projectInfo) {
   const cwd = process.cwd();
   const isPlugin2 = projectInfo.type === "elizaos-plugin";
   if (!options.skipTypeCheck) {
-    logger20.info("Running TypeScript validation...");
+    logger22.info("Running TypeScript validation...");
     const typeCheckResult = await runTypeCheck(cwd, true);
     if (!typeCheckResult.success) {
-      logger20.error("TypeScript validation failed:");
-      typeCheckResult.errors.forEach((error) => logger20.error(error));
+      logger22.error("TypeScript validation failed:");
+      typeCheckResult.errors.forEach((error) => logger22.error(error));
       return { failed: true };
     }
-    logger20.success("TypeScript validation passed");
+    logger22.success("TypeScript validation passed");
   }
   if (!options.skipBuild) {
     try {
-      logger20.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
+      logger22.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
       await buildProject(cwd, isPlugin2);
-      logger20.success(`Build completed successfully`);
+      logger22.success(`Build completed successfully`);
     } catch (buildError) {
-      logger20.error(`Build failed: ${buildError}`);
+      logger22.error(`Build failed: ${buildError}`);
       return { failed: true };
     }
   }
-  logger20.info("Running component tests...");
+  logger22.info("Running component tests...");
   return new Promise((resolve2) => {
     const args = ["test", "--passWithNoTests"];
     if (options.name) {
       const baseName = processFilterName(options.name);
       if (baseName) {
-        logger20.info(`Using test filter: ${baseName}`);
+        logger22.info(`Using test filter: ${baseName}`);
         args.push("-t", baseName);
       }
     }
-    const targetPath = testPath ? path24.resolve(process.cwd(), "..", testPath) : process.cwd();
-    logger20.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
+    const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
+    const baseDir = monorepoRoot ?? process.cwd();
+    const targetPath = testPath ? path25.resolve(baseDir, testPath) : process.cwd();
+    logger22.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
     const child = spawn3("bun", args, {
       stdio: "inherit",
       shell: false,
@@ -3532,11 +4642,11 @@ async function runComponentTests(testPath, options, projectInfo) {
       }
     });
     child.on("close", (code) => {
-      logger20.info("Component tests completed");
+      logger22.info("Component tests completed");
       resolve2({ failed: code !== 0 });
     });
     child.on("error", (error) => {
-      logger20.error("Error running component tests:", error);
+      logger22.error("Error running component tests:", error);
       resolve2({ failed: true });
     });
   });
@@ -3544,31 +4654,31 @@ async function runComponentTests(testPath, options, projectInfo) {
 
 // src/commands/test/actions/e2e-tests.ts
 import { AgentServer as AgentServer2, jsonToCharacter as jsonToCharacter2, loadCharacterTryPath as loadCharacterTryPath3 } from "@elizaos/server";
-import { logger as logger21 } from "@elizaos/core";
-import * as dotenv3 from "dotenv";
+import { logger as logger23 } from "@elizaos/core";
+import * as dotenv2 from "dotenv";
 import * as fs12 from "fs";
-import path25 from "path";
+import path26 from "path";
 async function runE2eTests(testPath, options, projectInfo) {
   if (!options.skipBuild) {
     try {
       const cwd = process.cwd();
       const isPlugin2 = projectInfo.type === "elizaos-plugin";
-      logger21.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
+      logger23.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
       await buildProject(cwd, isPlugin2);
-      logger21.info(`Build completed successfully`);
+      logger23.info(`Build completed successfully`);
     } catch (buildError) {
-      logger21.error(`Build error: ${buildError}`);
-      logger21.warn(`Attempting to continue with tests despite build error`);
+      logger23.error(`Build error: ${buildError}`);
+      logger23.warn(`Attempting to continue with tests despite build error`);
     }
   }
   let server;
   try {
     const runtimes = [];
     const projectAgents = [];
-    const elizaDir = path25.join(process.cwd(), ".eliza");
-    const packageName = path25.basename(process.cwd());
+    const elizaDir = path26.join(process.cwd(), ".eliza");
+    const packageName = path26.basename(process.cwd());
     const timestamp = Date.now();
-    const uniqueDbDir = path25.join(process.cwd(), ".elizadb-test", `${packageName}-${timestamp}`);
+    const uniqueDbDir = path26.join(process.cwd(), ".elizadb-test", `${packageName}-${timestamp}`);
     const elizaDbDir = uniqueDbDir;
     const envInfo = await UserEnvironment.getInstanceInfo();
     const envFilePath = envInfo.paths.envFilePath;
@@ -3592,91 +4702,73 @@ async function runE2eTests(testPath, options, projectInfo) {
     process.env.PGLITE_DATA_DIR = elizaDbDir;
     console.info(`Set PGLITE_DATA_DIR to: ${elizaDbDir}`);
     if (fs12.existsSync(envFilePath)) {
-      logger21.info(`Loading environment variables from: ${envFilePath}`);
-      dotenv3.config({ path: envFilePath });
-      logger21.info("Environment variables loaded");
+      logger23.info(`Loading environment variables from: ${envFilePath}`);
+      dotenv2.config({ path: envFilePath });
+      logger23.info("Environment variables loaded");
     } else {
-      logger21.warn(`Environment file not found: ${envFilePath}`);
-    }
-    try {
-      logger21.info("Configuring database...");
-      await promptForEnvVars("pglite");
-      logger21.info("Database configuration completed");
-    } catch (error) {
-      logger21.error("Error configuring database:", error);
-      if (error instanceof Error) {
-        logger21.error("Error details:", error.message);
-        logger21.error("Stack trace:", error.stack);
-      }
-      throw error;
+      logger23.warn(`Environment file not found: ${envFilePath}`);
     }
     const postgresUrl = process.env.POSTGRES_URL;
-    logger21.info(
+    logger23.info(
       `PostgreSQL URL for e2e tests: ${postgresUrl ? "found" : "not found (will use PGlite)"}`
     );
-    logger21.info("Creating server instance...");
+    logger23.info("Creating server instance...");
     server = new AgentServer2();
-    logger21.info("Server instance created");
-    logger21.info("Initializing server...");
+    logger23.info("Server instance created");
+    logger23.info("Initializing server...");
     try {
       await server.initialize({
         dataDir: elizaDbDir,
         postgresUrl
       });
-      logger21.info("Server initialized successfully");
+      logger23.info("Server initialized successfully");
     } catch (initError) {
-      logger21.error("Server initialization failed:", initError);
+      logger23.error("Server initialization failed:", initError);
       throw initError;
     }
     let project;
     try {
-      logger21.info("Attempting to load project or plugin...");
+      logger23.info("Attempting to load project or plugin...");
       const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
-      if (!monorepoRoot) {
-        throw new Error(
-          "Could not find monorepo root. Make sure to run tests from within the Eliza project."
-        );
-      }
-      const targetPath = testPath ? path25.resolve(monorepoRoot, testPath) : process.cwd();
+      const baseDir = monorepoRoot ?? process.cwd();
+      const targetPath = testPath ? path26.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");
       }
-      logger21.info(
-        `Found ${project.agents.length} agents in ${project.isPlugin ? "plugin" : "project"} configuration`
-      );
-      logger21.info("Setting up server properties...");
+      logger23.info(`Found ${project.agents.length} agents`);
+      logger23.info("Setting up server properties...");
       server.startAgent = async (character) => {
-        logger21.info(`Starting agent for character ${character.name}`);
+        logger23.info(`Starting agent for character ${character.name}`);
         return startAgent(character, server, void 0, [], { isTestMode: true });
       };
       server.loadCharacterTryPath = loadCharacterTryPath3;
       server.jsonToCharacter = jsonToCharacter2;
-      logger21.info("Server properties set up");
+      logger23.info("Server properties set up");
       const desiredPort = options.port || Number.parseInt(process.env.SERVER_PORT || "3000");
       const serverPort = await findNextAvailablePort(desiredPort);
       if (serverPort !== desiredPort) {
-        logger21.warn(`Port ${desiredPort} is in use for testing, using port ${serverPort} instead.`);
+        logger23.warn(`Port ${desiredPort} is in use for testing, using port ${serverPort} instead.`);
       }
-      logger21.info("Starting server...");
+      logger23.info("Starting server...");
       try {
         await server.start(serverPort);
-        logger21.info("Server started successfully on port", serverPort);
+        logger23.info("Server started successfully on port", serverPort);
       } catch (error) {
-        logger21.error("Error starting server:", error);
+        logger23.error("Error starting server:", error);
         if (error instanceof Error) {
-          logger21.error("Error details:", error.message);
-          logger21.error("Stack trace:", error.stack);
+          logger23.error("Error details:", error.message);
+          logger23.error("Stack trace:", error.stack);
         }
         throw error;
       }
       try {
-        logger21.info(
+        logger23.info(
           `Found ${project.agents.length} agents in ${project.isPlugin ? "plugin" : "project"}`
         );
         if (project.isPlugin || project.agents.length === 0) {
           process.env.ELIZA_TESTING_PLUGIN = "true";
-          logger21.info("Using default Eliza character as test agent");
+          logger23.info("Using default Eliza character as test agent");
           try {
             const pluginUnderTest = project.pluginModule;
             if (!pluginUnderTest) {
@@ -3699,16 +4791,16 @@ async function runE2eTests(testPath, options, projectInfo) {
               plugins: runtime.plugins
               // Pass all plugins, not just the one under test
             });
-            logger21.info("Default test agent started successfully");
+            logger23.info("Default test agent started successfully");
           } catch (pluginError) {
-            logger21.error(`Error starting plugin test agent: ${pluginError}`);
+            logger23.error(`Error starting plugin test agent: ${pluginError}`);
             throw pluginError;
           }
         } else {
           for (const agent2 of project.agents) {
             try {
               const originalCharacter = { ...agent2.character };
-              logger21.debug(`Starting agent: ${originalCharacter.name}`);
+              logger23.debug(`Starting agent: ${originalCharacter.name}`);
               const runtime = await startAgent(
                 originalCharacter,
                 server,
@@ -3721,28 +4813,28 @@ async function runE2eTests(testPath, options, projectInfo) {
               projectAgents.push(agent2);
               await new Promise((resolve2) => setTimeout(resolve2, 1e3));
             } catch (agentError) {
-              logger21.error(`Error starting agent ${agent2.character.name}:`, agentError);
+              logger23.error(`Error starting agent ${agent2.character.name}:`, agentError);
               if (agentError instanceof Error) {
-                logger21.error("Error details:", agentError.message);
-                logger21.error("Stack trace:", agentError.stack);
+                logger23.error("Error details:", agentError.message);
+                logger23.error("Stack trace:", agentError.stack);
               }
-              logger21.warn(`Skipping agent ${agent2.character.name} due to startup error`);
+              logger23.warn(`Skipping agent ${agent2.character.name} due to startup error`);
             }
           }
         }
         if (runtimes.length === 0) {
           throw new Error("Failed to start any agents from project");
         }
-        logger21.debug(`Successfully started ${runtimes.length} agents for testing`);
+        logger23.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) {
-            logger21.debug(`Running tests for plugin: ${project.pluginModule?.name}`);
+            logger23.debug(`Running tests for plugin: ${project.pluginModule?.name}`);
           } else {
-            logger21.debug(`Running tests for agent: ${runtime.character.name}`);
+            logger23.debug(`Running tests for agent: ${runtime.character.name}`);
           }
           const testRunner = new TestRunner(runtime, projectAgent);
           const currentDirInfo = projectInfo;
@@ -3763,17 +4855,17 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
         return { failed: anyTestsFound ? totalFailed > 0 : false };
       } catch (error) {
-        logger21.error("Error in runE2eTests:", error);
+        logger23.error("Error in runE2eTests:", error);
         if (error instanceof Error) {
-          logger21.error("Error details:", error.message);
-          logger21.error("Stack trace:", error.stack);
+          logger23.error("Error details:", error.message);
+          logger23.error("Stack trace:", error.stack);
         } else {
-          logger21.error("Unknown error type:", typeof error);
-          logger21.error("Error value:", error);
+          logger23.error("Unknown error type:", typeof error);
+          logger23.error("Error value:", error);
           try {
-            logger21.error("Stringified error:", JSON.stringify(error, null, 2));
+            logger23.error("Stringified error:", JSON.stringify(error, null, 2));
           } catch (e) {
-            logger21.error("Could not stringify error:", e);
+            logger23.error("Could not stringify error:", e);
           }
         }
         return { failed: true };
@@ -3787,7 +4879,7 @@ async function runE2eTests(testPath, options, projectInfo) {
             fs12.rmSync(elizaDbDir, { recursive: true, force: true });
             console.info(`Successfully cleaned up test database directory`);
           }
-          const testDir = path25.dirname(elizaDbDir);
+          const testDir = path26.dirname(elizaDbDir);
           if (fs12.existsSync(testDir) && fs12.readdirSync(testDir).length === 0) {
             fs12.rmSync(testDir, { recursive: true, force: true });
           }
@@ -3796,33 +4888,33 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
       }
     } catch (error) {
-      logger21.error("Error in runE2eTests:", error);
+      logger23.error("Error in runE2eTests:", error);
       if (error instanceof Error) {
-        logger21.error("Error details:", error.message);
-        logger21.error("Stack trace:", error.stack);
+        logger23.error("Error details:", error.message);
+        logger23.error("Stack trace:", error.stack);
       } else {
-        logger21.error("Unknown error type:", typeof error);
-        logger21.error("Error value:", error);
+        logger23.error("Unknown error type:", typeof error);
+        logger23.error("Error value:", error);
         try {
-          logger21.error("Stringified error:", JSON.stringify(error, null, 2));
+          logger23.error("Stringified error:", JSON.stringify(error, null, 2));
         } catch (e) {
-          logger21.error("Could not stringify error:", e);
+          logger23.error("Could not stringify error:", e);
         }
       }
       return { failed: true };
     }
   } catch (error) {
-    logger21.error("Error in runE2eTests:", error);
+    logger23.error("Error in runE2eTests:", error);
     if (error instanceof Error) {
-      logger21.error("Error details:", error.message);
-      logger21.error("Stack trace:", error.stack);
+      logger23.error("Error details:", error.message);
+      logger23.error("Stack trace:", error.stack);
     } else {
-      logger21.error("Unknown error type:", typeof error);
-      logger21.error("Error value:", error);
+      logger23.error("Unknown error type:", typeof error);
+      logger23.error("Error value:", error);
       try {
-        logger21.error("Stringified error:", JSON.stringify(error, null, 2));
+        logger23.error("Stringified error:", JSON.stringify(error, null, 2));
       } catch (e) {
-        logger21.error("Could not stringify error:", e);
+        logger23.error("Could not stringify error:", e);
       }
     }
     return { failed: true };
@@ -3835,15 +4927,15 @@ async function runAllTests(testPath, options) {
   if (!options.skipBuild) {
     const componentResult = await runComponentTests(testPath, options, projectInfo);
     if (componentResult.failed) {
-      logger22.error("Component tests failed. Continuing to e2e tests...");
+      logger24.error("Component tests failed. Continuing to e2e tests...");
     }
   }
   const e2eResult = await runE2eTests(testPath, options, projectInfo);
   if (e2eResult.failed) {
-    logger22.error("E2E tests failed.");
+    logger24.error("E2E tests failed.");
     process.exit(1);
   }
-  logger22.success("All tests passed successfully!");
+  logger24.success("All tests passed successfully!");
   process.exit(0);
 }
 
@@ -3851,9 +4943,9 @@ async function runAllTests(testPath, options) {
 import * as net from "net";
 
 // src/commands/test/utils/plugin-utils.ts
-import { logger as logger23 } from "@elizaos/core";
+import { logger as logger25 } from "@elizaos/core";
 import * as fs13 from "fs";
-import path26 from "path";
+import path27 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(
@@ -3863,31 +4955,31 @@ var test = new Command10().name("test").description("Run tests for the current p
   const projectInfo = getProjectType(testPath);
   await installPluginDependencies(projectInfo);
 }).action(async (testPath, options) => {
-  logger24.info("Starting tests...");
+  logger26.info("Starting tests...");
   try {
     const projectInfo = getProjectType(testPath);
     switch (options.type) {
       case "component":
-        logger24.info("Running component tests only...");
+        logger26.info("Running component tests only...");
         const componentResult = await runComponentTests(testPath, options, projectInfo);
         if (componentResult.failed) {
-          logger24.error("Component tests failed.");
+          logger26.error("Component tests failed.");
           process.exit(1);
         }
-        logger24.success("Component tests passed successfully!");
+        logger26.success("Component tests passed successfully!");
         break;
       case "e2e":
-        logger24.info("Running e2e tests only...");
+        logger26.info("Running e2e tests only...");
         const e2eResult = await runE2eTests(testPath, options, projectInfo);
         if (e2eResult.failed) {
-          logger24.error("E2E tests failed.");
+          logger26.error("E2E tests failed.");
           process.exit(1);
         }
-        logger24.success("E2E tests passed successfully!");
+        logger26.success("E2E tests passed successfully!");
         break;
       case "all":
       default:
-        logger24.info("Running all tests...");
+        logger26.info("Running all tests...");
         await runAllTests(testPath, options);
         break;
     }
@@ -3898,11 +4990,8 @@ var test = new Command10().name("test").description("Run tests for the current p
 });
 
 // src/index.ts
-import { logger as logger25 } from "@elizaos/core";
+import { logger as logger27 } from "@elizaos/core";
 import { Command as Command11 } from "commander";
-import { existsSync as existsSync17, readFileSync as readFileSync5 } from "fs";
-import path27, { dirname } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
 process.env.NODE_OPTIONS = "--no-deprecation";
 process.env.NODE_NO_WARNINGS = "1";
 process.on("SIGINT", () => process.exit(0));
@@ -3914,15 +5003,7 @@ async function main() {
   if (process.argv.includes("--no-auto-install")) {
     process.env.ELIZA_NO_AUTO_INSTALL = "true";
   }
-  const __filename = fileURLToPath2(import.meta.url);
-  const __dirname = dirname(__filename);
-  const packageJsonPath = path27.resolve(__dirname, "../package.json");
-  let version = "0.0.0";
-  if (!existsSync17(packageJsonPath)) {
-  } else {
-    const packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
-    version = packageJson.version;
-  }
+  const version = getVersion();
   const args = process.argv.slice(2);
   const isUpdateCommand = args.includes("update");
   const willShowBanner = args.length === 0;
@@ -3938,6 +5019,6 @@ async function main() {
   await program.parseAsync();
 }
 main().catch((error) => {
-  logger25.error("An error occurred:", error);
+  logger27.error("An error occurred:", error);
   process.exit(1);
 });