@elizaos/cli 1.0.15 → 1.0.16

package/dist/{chunk-AZUBN22B.js → chunk-OK5O2MHJ.js}

@@ -4,11 +4,9 @@ const require = createRequire(import.meta.url);
 
 import {
   displayBunInstallationTipCompact,
+  emoji,
   runBunCommand
-} from "./chunk-RIAWNDYI.js";
-import {
-  emoji
-} from "./chunk-KB3JDWUI.js";
+} from "./chunk-W4NJVJQV.js";
 import {
   getAgentRuntimeUrl,
   getAgentsBaseUrl
@@ -816,405 +814,16 @@ async function confirmAction(message) {
 }
 
 // src/utils/config-manager.ts
-import path6 from "path";
-import { promises as fs5 } from "fs";
-import { logger as logger7 } from "@elizaos/core";
-
-// src/utils/env-prompt.ts
-import * as clack2 from "@clack/prompts";
-import colors from "yoctocolors";
-import { promises as fs4 } from "fs";
 import path5 from "path";
+import { promises as fs4 } from "fs";
 import { logger as logger6 } from "@elizaos/core";
-var ENV_VAR_CONFIGS = {
-  openai: [
-    {
-      name: "OpenAI API Key",
-      key: "OPENAI_API_KEY",
-      required: true,
-      description: "Required for the OpenAI plugin to generate text and embeddings.",
-      url: "https://platform.openai.com/api-keys",
-      secret: true
-    }
-  ],
-  anthropic: [
-    {
-      name: "Anthropic API Key",
-      key: "ANTHROPIC_API_KEY",
-      required: true,
-      description: "Required for the Anthropic plugin to use Claude models.",
-      url: "https://console.anthropic.com/settings/keys",
-      secret: true
-    }
-  ],
-  discord: [
-    {
-      name: "Discord API Token",
-      key: "DISCORD_API_TOKEN",
-      required: false,
-      description: "The bot token for your Discord application. This enables your agent to connect to Discord and interact with users there.",
-      url: "https://discord.com/developers/applications",
-      secret: true
-    },
-    {
-      name: "Discord Application ID",
-      key: "DISCORD_APPLICATION_ID",
-      required: false,
-      description: "The application ID for your Discord bot. Required together with the API token to enable Discord integration.",
-      url: "https://discord.com/developers/applications",
-      secret: false
-    }
-  ],
-  twitter: [
-    {
-      name: "Twitter API Key",
-      key: "TWITTER_API_KEY",
-      required: false,
-      description: "API Key for Twitter integration. Needed to connect your agent to Twitter.",
-      url: "https://developer.twitter.com/en/portal/dashboard",
-      secret: true
-    },
-    {
-      name: "Twitter API Secret",
-      key: "TWITTER_API_SECRET",
-      required: false,
-      description: "API Secret for Twitter integration.",
-      url: "https://developer.twitter.com/en/portal/dashboard",
-      secret: true
-    },
-    {
-      name: "Twitter Access Token",
-      key: "TWITTER_ACCESS_TOKEN",
-      required: false,
-      description: "Access Token for Twitter integration.",
-      url: "https://developer.twitter.com/en/portal/dashboard",
-      secret: true
-    },
-    {
-      name: "Twitter Access Token Secret",
-      key: "TWITTER_ACCESS_TOKEN_SECRET",
-      required: false,
-      description: "Access Token Secret for Twitter integration.",
-      url: "https://developer.twitter.com/en/portal/dashboard",
-      secret: true
-    }
-  ],
-  telegram: [
-    {
-      name: "Telegram Bot Token",
-      key: "TELEGRAM_BOT_TOKEN",
-      required: false,
-      description: "Bot Token for Telegram integration. Needed to connect your agent to Telegram.",
-      url: "https://core.telegram.org/bots#how-do-i-create-a-bot",
-      secret: true
-    }
-  ],
-  pglite: [
-    {
-      name: "Database Directory",
-      key: "PGLITE_DATA_DIR",
-      required: false,
-      description: "Directory where PGLite will store database files.",
-      url: "",
-      secret: false
-    }
-  ],
-  postgresql: [
-    {
-      name: "PostgreSQL URL",
-      key: "POSTGRES_URL",
-      required: false,
-      description: "URL for connecting to your PostgreSQL database.",
-      url: "https://neon.tech/docs/connect/connect-from-any-app",
-      secret: false
-    }
-  ]
-};
-async function getEnvFilePath() {
-  const envInfo = await UserEnvironment.getInstanceInfo();
-  return envInfo.paths.envFilePath;
-}
-async function readEnvFile() {
-  const envPath = await getEnvFilePath();
-  const result = {};
-  try {
-    if (await fs4.access(envPath).then(() => true).catch(() => false)) {
-      const content = await fs4.readFile(envPath, "utf8");
-      const lines = content.split("\n");
-      for (const line of lines) {
-        const trimmedLine = line.trim();
-        if (trimmedLine && !trimmedLine.startsWith("#")) {
-          const separatorIndex = trimmedLine.indexOf("=");
-          if (separatorIndex > 0) {
-            const key = trimmedLine.substring(0, separatorIndex).trim();
-            const value = trimmedLine.substring(separatorIndex + 1).trim();
-            result[key] = value;
-          }
-        }
-      }
-    }
-  } catch (error) {
-    logger6.error(`Error reading environment file: ${error}`);
-  }
-  return result;
-}
-async function writeEnvFile(envVars) {
-  try {
-    const envPath = await getEnvFilePath();
-    const elizaDir = path5.dirname(envPath);
-    if (!await fs4.access(elizaDir).then(() => true).catch(() => false)) {
-      await fs4.mkdir(elizaDir, { recursive: true });
-    }
-    let content = "";
-    for (const [key, value] of Object.entries(envVars)) {
-      content += `${key}=${value}
-`;
-    }
-    await fs4.writeFile(envPath, content, "utf8");
-    logger6.info(`Environment variables saved to ${envPath}`);
-  } catch (error) {
-    logger6.error(`Error writing environment file: ${error}`);
-  }
-}
-async function promptForEnvVar(config) {
-  const existingValue = process.env[config.key];
-  if (existingValue && existingValue.trim() !== "") {
-    return existingValue;
-  }
-  console.log(
-    colors.magenta(
-      `
-${config.name} ${config.required ? "(Required)" : "(Optional - press Enter to skip)"}`
-    )
-  );
-  console.log(colors.white(config.description));
-  if (config.url) {
-    console.log(colors.blue(`Get it here: ${config.url}`));
-  }
-  const value = await (config.secret ? clack2.password({
-    message: `Enter your ${config.name}:`,
-    validate: (input) => {
-      if (config.required && (!input || input.trim() === "")) {
-        return "This field is required";
-      }
-      return void 0;
-    }
-  }) : clack2.text({
-    message: `Enter your ${config.name}:`,
-    validate: (input) => {
-      if (config.required && (!input || input.trim() === "")) {
-        return "This field is required";
-      }
-      return void 0;
-    }
-  }));
-  if (clack2.isCancel(value)) {
-    clack2.cancel("Operation cancelled.");
-    process.exit(0);
-  }
-  if (!config.required && (!value || value.trim() === "")) {
-    return "";
-  }
-  if (config.key === "PGLITE_DATA_DIR" && value && value.startsWith("~")) {
-    return value.replace(/^~/, process.cwd());
-  }
-  return value;
-}
-async function promptForEnvVars(pluginName) {
-  const envVarConfigs = ENV_VAR_CONFIGS[pluginName.toLowerCase()];
-  if (!envVarConfigs) {
-    return {};
-  }
-  if (pluginName.toLowerCase() === "discord") {
-    console.log(colors.blue("\n=== Discord Integration (Optional) ==="));
-    console.log(
-      colors.white(
-        "Setting up Discord integration will allow your agent to interact with Discord users."
-      )
-    );
-    console.log(
-      colors.white("You can press Enter to skip these if you don't want to use Discord.")
-    );
-  } else if (pluginName.toLowerCase() === "twitter") {
-    console.log(colors.blue("\n=== Twitter Integration (Optional) ==="));
-    console.log(
-      colors.white(
-        "Setting up Twitter integration will allow your agent to post and interact on Twitter."
-      )
-    );
-    console.log(
-      colors.white("You can press Enter to skip these if you don't want to use Twitter.")
-    );
-  } else if (pluginName.toLowerCase() === "telegram") {
-    console.log(colors.blue("\n=== Telegram Integration (Optional) ==="));
-    console.log(
-      colors.white(
-        "Setting up Telegram integration will allow your agent to interact in Telegram chats."
-      )
-    );
-    console.log(
-      colors.white("You can press Enter to skip these if you don't want to use Telegram.")
-    );
-  }
-  const envVars = await readEnvFile();
-  const result = {};
-  let changes = false;
-  for (const config of envVarConfigs) {
-    if (envVars[config.key] && envVars[config.key] !== "dummy_key" && envVars[config.key] !== "invalid_token_for_testing") {
-      continue;
-    }
-    await new Promise((resolve2) => setTimeout(resolve2, 100));
-    const value = await promptForEnvVar(config);
-    if (value !== null) {
-      result[config.key] = value;
-      envVars[config.key] = value;
-      process.env[config.key] = value;
-    }
-    changes = true;
-  }
-  if (changes) {
-    writeEnvFile(envVars);
-  }
-  return result;
-}
-async function validateEnvVars(pluginName) {
-  const envVarConfigs = ENV_VAR_CONFIGS[pluginName.toLowerCase()];
-  if (!envVarConfigs) {
-    return true;
-  }
-  const envVars = await readEnvFile();
-  for (const config of envVarConfigs) {
-    if (config.required && (!envVars[config.key] || envVars[config.key] === "dummy_key")) {
-      return false;
-    }
-  }
-  return true;
-}
-async function getMissingEnvVars(pluginName) {
-  const envVarConfigs = ENV_VAR_CONFIGS[pluginName.toLowerCase()];
-  if (!envVarConfigs) {
-    return [];
-  }
-  const envVars = await readEnvFile();
-  const missing = [];
-  for (const config of envVarConfigs) {
-    if (config.required && (!envVars[config.key] || envVars[config.key] === "dummy_key")) {
-      missing.push(config.key);
-    }
-  }
-  return missing;
-}
-async function validatePluginEnvVars(pluginName) {
-  const envVars = await readEnvFile();
-  switch (pluginName.toLowerCase()) {
-    case "discord":
-      if (envVars.DISCORD_API_TOKEN && envVars.DISCORD_API_TOKEN.trim() !== "" && (!envVars.DISCORD_APPLICATION_ID || envVars.DISCORD_APPLICATION_ID.trim() === "")) {
-        return {
-          valid: false,
-          message: "Discord Application ID is required when using a Discord API Token"
-        };
-      }
-      if (envVars.DISCORD_API_TOKEN && envVars.DISCORD_API_TOKEN.trim() !== "" && envVars.DISCORD_APPLICATION_ID && envVars.DISCORD_APPLICATION_ID.trim() !== "") {
-        return {
-          valid: true,
-          message: "Discord integration is properly configured."
-        };
-      }
-      if ((!envVars.DISCORD_API_TOKEN || envVars.DISCORD_API_TOKEN.trim() === "") && (!envVars.DISCORD_APPLICATION_ID || envVars.DISCORD_APPLICATION_ID.trim() === "")) {
-        return {
-          valid: true,
-          message: "Discord integration is not configured (optional)."
-        };
-      }
-      return {
-        valid: false,
-        message: "Discord configuration is incomplete. Please provide both API Token and Application ID."
-      };
-    case "twitter": {
-      const twitterKeys = [
-        "TWITTER_API_KEY",
-        "TWITTER_API_SECRET",
-        "TWITTER_ACCESS_TOKEN",
-        "TWITTER_ACCESS_TOKEN_SECRET"
-      ];
-      const providedKeys = twitterKeys.filter((key) => envVars[key] && envVars[key].trim() !== "");
-      if (providedKeys.length > 0 && providedKeys.length < twitterKeys.length) {
-        return {
-          valid: false,
-          message: `Twitter configuration is incomplete. Missing: ${twitterKeys.filter((key) => !providedKeys.includes(key)).join(", ")}`
-        };
-      }
-      if (providedKeys.length === twitterKeys.length) {
-        return {
-          valid: true,
-          message: "Twitter configuration is valid"
-        };
-      }
-      return {
-        valid: true,
-        message: "Twitter integration is not configured (optional)."
-      };
-    }
-    case "telegram":
-      if (envVars.TELEGRAM_BOT_TOKEN && envVars.TELEGRAM_BOT_TOKEN.trim() !== "") {
-        return {
-          valid: true,
-          message: "Telegram configuration is valid"
-        };
-      }
-      return {
-        valid: false,
-        message: "Telegram Bot Token is required for Telegram integration"
-      };
-    case "openai":
-      if (envVars.OPENAI_API_KEY && envVars.OPENAI_API_KEY.trim() !== "") {
-        return {
-          valid: true,
-          message: "OpenAI configuration is valid"
-        };
-      }
-      return {
-        valid: false,
-        message: "OpenAI API Key is required for OpenAI integration"
-      };
-    case "anthropic":
-      if (envVars.ANTHROPIC_API_KEY && envVars.ANTHROPIC_API_KEY.trim() !== "") {
-        return {
-          valid: true,
-          message: "Anthropic configuration is valid"
-        };
-      }
-      return {
-        valid: false,
-        message: "Anthropic API Key is required for Anthropic integration"
-      };
-    case "postgres":
-      if (envVars.POSTGRES_URL && envVars.POSTGRES_URL.trim() !== "") {
-        return {
-          valid: true,
-          message: "PostgreSQL configuration is valid"
-        };
-      }
-      return {
-        valid: false,
-        message: "PostgreSQL URL is required for PostgreSQL integration"
-      };
-    default:
-      return {
-        valid: true,
-        message: `No specific validation rules for ${pluginName}`
-      };
-  }
-}
-
-// src/utils/config-manager.ts
 async function getConfigFilePath() {
   const envInfo = await UserEnvironment.getInstanceInfo();
   return envInfo.paths.configPath;
 }
 async function fileExists(p) {
   try {
-    await fs5.access(p);
+    await fs4.access(p);
     return true;
   } catch {
     return false;
@@ -1230,10 +839,10 @@ async function loadConfig() {
         // Mark as default config
       };
     }
-    const content = await fs5.readFile(configPath, "utf8");
+    const content = await fs4.readFile(configPath, "utf8");
     return JSON.parse(content);
   } catch (error) {
-    logger7.warn(`Error loading configuration: ${error}`);
+    logger6.warn(`Error loading configuration: ${error}`);
     return {
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
       isDefault: true
@@ -1244,53 +853,31 @@ async function loadConfig() {
 async function saveConfig(config) {
   try {
     const configPath = await getConfigFilePath();
-    const elizaDir = path6.dirname(configPath);
+    const elizaDir = path5.dirname(configPath);
     if (!await fileExists(elizaDir)) {
-      await fs5.mkdir(elizaDir, { recursive: true });
+      await fs4.mkdir(elizaDir, { recursive: true });
     }
     config.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    await fs5.writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
-    logger7.info(`Configuration saved to ${configPath}`);
+    await fs4.writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
+    logger6.info(`Configuration saved to ${configPath}`);
   } catch (error) {
-    logger7.error(`Error saving configuration: ${error}`);
-  }
-}
-async function checkPluginRequirements(pluginName) {
-  return validatePluginEnvVars(pluginName);
-}
-async function getPluginStatus() {
-  const configPath = await getConfigFilePath();
-  if (!await fileExists(configPath)) {
-    return {};
-  }
-  try {
-    const configContent = await fs5.readFile(configPath, "utf-8");
-    const config = JSON.parse(configContent);
-    const status = {};
-    for (const plugin of Object.keys(config.plugins ?? {})) {
-      const check = await validatePluginEnvVars(plugin);
-      status[plugin] = check.valid;
-    }
-    return status;
-  } catch (error) {
-    logger7.error(`Error reading config file: ${error}`);
-    return {};
+    logger6.error(`Error saving configuration: ${error}`);
   }
 }
 
 // src/utils/copy-template.ts
 import { existsSync as existsSync5 } from "fs";
-import { promises as fs6 } from "fs";
-import path7 from "path";
+import { promises as fs5 } from "fs";
+import path6 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { logger as logger8 } from "@elizaos/core";
+import { logger as logger7 } from "@elizaos/core";
 var __filename = fileURLToPath2(import.meta.url);
-var __dirname = path7.dirname(__filename);
+var __dirname = path6.dirname(__filename);
 async function copyDir(src, dest, exclude = []) {
-  const resolvedSrc = path7.resolve(src);
-  const resolvedDest = path7.resolve(dest);
-  await fs6.mkdir(resolvedDest, { recursive: true });
-  const entries = await fs6.readdir(resolvedSrc, { withFileTypes: true });
+  const resolvedSrc = path6.resolve(src);
+  const resolvedDest = path6.resolve(dest);
+  await fs5.mkdir(resolvedDest, { recursive: true });
+  const entries = await fs5.readdir(resolvedSrc, { withFileTypes: true });
   const files = [];
   const directories = [];
   for (const entry of entries) {
@@ -1311,16 +898,16 @@ async function copyDir(src, dest, exclude = []) {
   for (let i = 0; i < files.length; i += MAX_CONCURRENT_FILES) {
     const batch = files.slice(i, i + MAX_CONCURRENT_FILES);
     const batchPromises = batch.map(async (entry) => {
-      const srcPath = path7.join(resolvedSrc, entry.name);
-      const destPath = path7.join(resolvedDest, entry.name);
-      await fs6.copyFile(srcPath, destPath);
+      const srcPath = path6.join(resolvedSrc, entry.name);
+      const destPath = path6.join(resolvedDest, entry.name);
+      await fs5.copyFile(srcPath, destPath);
     });
     filePromises.push(...batchPromises);
   }
   await Promise.all(filePromises);
   for (const entry of directories) {
-    const srcPath = path7.join(resolvedSrc, entry.name);
-    const destPath = path7.join(resolvedDest, entry.name);
+    const srcPath = path6.join(resolvedSrc, entry.name);
+    const destPath = path6.join(resolvedDest, entry.name);
     await copyDir(srcPath, destPath, exclude);
   }
 }
@@ -1340,24 +927,24 @@ async function copyTemplate(templateType, targetDir) {
   const packageName = getPackageName(templateType);
   const possibleTemplatePaths = [
     // 1. Direct path from source directory (for tests and development)
-    path7.resolve(__dirname, "../../templates", packageName),
+    path6.resolve(__dirname, "../../templates", packageName),
     // 2. Production: templates bundled with the CLI dist
-    path7.resolve(
-      path7.dirname(__require.resolve("@elizaos/cli/package.json")),
+    path6.resolve(
+      path6.dirname(__require.resolve("@elizaos/cli/package.json")),
       "dist",
       "templates",
       packageName
     ),
     // 3. Development/Test: templates in the CLI package root
-    path7.resolve(
-      path7.dirname(__require.resolve("@elizaos/cli/package.json")),
+    path6.resolve(
+      path6.dirname(__require.resolve("@elizaos/cli/package.json")),
       "templates",
       packageName
     ),
     // 4. Fallback: relative to current module (for built dist)
-    path7.resolve(__dirname, "..", "templates", packageName),
+    path6.resolve(__dirname, "..", "templates", packageName),
     // 5. Additional fallback: relative to dist directory
-    path7.resolve(__dirname, "..", "..", "templates", packageName)
+    path6.resolve(__dirname, "..", "..", "templates", packageName)
   ];
   let templateDir = null;
   for (const possiblePath of possibleTemplatePaths) {
@@ -1372,29 +959,29 @@ async function copyTemplate(templateType, targetDir) {
 ${possibleTemplatePaths.join("\n")}`
     );
   }
-  logger8.debug(`Copying ${templateType} template from ${templateDir} to ${targetDir}`);
+  logger7.debug(`Copying ${templateType} template from ${templateDir} to ${targetDir}`);
   await copyDir(templateDir, targetDir);
   if (templateType === "plugin") {
-    const pluginNameFromPath = path7.basename(targetDir);
+    const pluginNameFromPath = path6.basename(targetDir);
     await replacePluginNameInFiles(targetDir, pluginNameFromPath);
   }
-  const packageJsonPath = path7.join(targetDir, "package.json");
+  const packageJsonPath = path6.join(targetDir, "package.json");
   try {
-    const cliPackageJsonPath = path7.resolve(
-      path7.dirname(__require.resolve("@elizaos/cli/package.json")),
+    const cliPackageJsonPath = path6.resolve(
+      path6.dirname(__require.resolve("@elizaos/cli/package.json")),
       "package.json"
     );
-    const cliPackageJson = JSON.parse(await fs6.readFile(cliPackageJsonPath, "utf8"));
+    const cliPackageJson = JSON.parse(await fs5.readFile(cliPackageJsonPath, "utf8"));
     const cliPackageVersion = cliPackageJson.version;
-    const packageJson = JSON.parse(await fs6.readFile(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(await fs5.readFile(packageJsonPath, "utf8"));
     if (packageJson.private) {
       delete packageJson.private;
-      logger8.debug("Removed private field from template package.json");
+      logger7.debug("Removed private field from template package.json");
     }
     if (packageJson.dependencies) {
       for (const depName of Object.keys(packageJson.dependencies)) {
         if (depName.startsWith("@elizaos/")) {
-          logger8.info(`Setting ${depName} to use version ${cliPackageVersion}`);
+          logger7.info(`Setting ${depName} to use version ${cliPackageVersion}`);
           packageJson.dependencies[depName] = "latest";
         }
       }
@@ -1402,22 +989,22 @@ ${possibleTemplatePaths.join("\n")}`
     if (packageJson.devDependencies) {
       for (const depName of Object.keys(packageJson.devDependencies)) {
         if (depName.startsWith("@elizaos/")) {
-          logger8.info(`Setting dev dependency ${depName} to use version ${cliPackageVersion}`);
+          logger7.info(`Setting dev dependency ${depName} to use version ${cliPackageVersion}`);
           packageJson.devDependencies[depName] = "latest";
         }
       }
     }
-    const projectNameFromPath = path7.basename(targetDir);
+    const projectNameFromPath = path6.basename(targetDir);
     if (packageJson.name !== projectNameFromPath) {
       packageJson.name = projectNameFromPath;
-      logger8.info(`Setting package name to ${projectNameFromPath}`);
+      logger7.info(`Setting package name to ${projectNameFromPath}`);
     }
-    await fs6.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-    logger8.debug("Updated package.json with latest dependency versions");
+    await fs5.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    logger7.debug("Updated package.json with latest dependency versions");
   } catch (error) {
-    logger8.error(`Error updating package.json: ${error}`);
+    logger7.error(`Error updating package.json: ${error}`);
   }
-  logger8.debug(`${templateType} template copied successfully`);
+  logger7.debug(`${templateType} template copied successfully`);
 }
 async function replacePluginNameInFiles(targetDir, pluginName) {
   const filesToProcess = [
@@ -1428,16 +1015,16 @@ async function replacePluginNameInFiles(targetDir, pluginName) {
     // package.json name is handled by the publish command
   ];
   const promises2 = filesToProcess.map(async (filePath) => {
-    const fullPath = path7.join(targetDir, filePath);
+    const fullPath = path6.join(targetDir, filePath);
     try {
-      if (await fs6.access(fullPath).then(() => true).catch(() => false)) {
-        let content = await fs6.readFile(fullPath, "utf8");
+      if (await fs5.access(fullPath).then(() => true).catch(() => false)) {
+        let content = await fs5.readFile(fullPath, "utf8");
         content = content.replace(/plugin-starter/g, pluginName);
-        await fs6.writeFile(fullPath, content, "utf8");
-        logger8.debug(`Updated plugin name in ${filePath}`);
+        await fs5.writeFile(fullPath, content, "utf8");
+        logger7.debug(`Updated plugin name in ${filePath}`);
       }
     } catch (error) {
-      logger8.warn(
+      logger7.warn(
         `Could not update ${filePath}: ${error instanceof Error ? error.message : String(error)}`
       );
     }
@@ -1445,12 +1032,12 @@ async function replacePluginNameInFiles(targetDir, pluginName) {
   await Promise.all(promises2);
 }
 async function copyClientDist() {
-  logger8.debug("Copying client dist files to CLI package");
-  const srcClientDist = path7.resolve(process.cwd(), "../client/dist");
-  const destClientDist = path7.resolve(process.cwd(), "./dist");
-  const indexSrc = path7.join(srcClientDist, "index.html");
-  const indexDest = path7.join(destClientDist, "index.html");
-  await fs6.mkdir(destClientDist, { recursive: true });
+  logger7.debug("Copying client dist files to CLI package");
+  const srcClientDist = path6.resolve(process.cwd(), "../client/dist");
+  const destClientDist = path6.resolve(process.cwd(), "./dist");
+  const indexSrc = path6.join(srcClientDist, "index.html");
+  const indexDest = path6.join(destClientDist, "index.html");
+  await fs5.mkdir(destClientDist, { recursive: true });
   let retries = 0;
   const maxRetries = 10;
   const retryDelay = 1e3;
@@ -1458,33 +1045,45 @@ async function copyClientDist() {
     if (existsSync5(indexSrc)) {
       break;
     }
-    logger8.info(`Waiting for client index.html (attempt ${retries + 1}/${maxRetries})\u2026`);
+    logger7.info(`Waiting for client index.html (attempt ${retries + 1}/${maxRetries})\u2026`);
     await new Promise((r) => setTimeout(r, retryDelay));
     retries++;
   }
   if (!existsSync5(indexSrc)) {
-    logger8.error(`index.html not found at ${indexSrc} after ${maxRetries} attempts`);
-    logger8.error("Client package must be built before CLI package. Run: bun run build:client");
+    logger7.error(`index.html not found at ${indexSrc} after ${maxRetries} attempts`);
+    logger7.error("Client package must be built before CLI package. Run: bun run build:client");
     throw new Error("Client dist files not found - build the client package first");
   }
   await copyDir(srcClientDist, destClientDist);
   if (!existsSync5(indexDest)) {
-    logger8.error(`index.html missing in CLI dist at ${indexDest}`);
+    logger7.error(`index.html missing in CLI dist at ${indexDest}`);
     throw new Error("Failed to copy client files to CLI dist directory");
   }
-  logger8.info("\u2705 Client files successfully copied to CLI package");
-  logger8.success("Client dist files copied successfully");
+  logger7.info("\u2705 Client files successfully copied to CLI package");
+  logger7.success("Client dist files copied successfully");
 }
 
 // src/utils/display-banner.ts
 import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
-import path8, { dirname } from "path";
+import path7, { dirname } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { execa as execa4 } from "execa";
+function isRunningFromNodeModules() {
+  const __filename2 = fileURLToPath3(import.meta.url);
+  return __filename2.includes("node_modules");
+}
 function getVersion() {
+  const userEnv = UserEnvironment.getInstance();
+  const monorepoRoot = userEnv.findMonorepoRoot(process.cwd());
+  if (monorepoRoot) {
+    return "monorepo";
+  }
+  if (!isRunningFromNodeModules()) {
+    return "monorepo";
+  }
   const __filename2 = fileURLToPath3(import.meta.url);
   const __dirname2 = dirname(__filename2);
-  const packageJsonPath = path8.resolve(__dirname2, "../package.json");
+  const packageJsonPath = path7.resolve(__dirname2, "../package.json");
   let version = "0.0.0";
   if (!existsSync6(packageJsonPath)) {
     console.error(`Warning: package.json not found at ${packageJsonPath}`);
@@ -1519,6 +1118,9 @@ function isUtf8Locale() {
 var versionCheckCache = null;
 var CACHE_DURATION = 10 * 60 * 1e3;
 async function getLatestCliVersion(currentVersion) {
+  if (currentVersion === "monorepo") {
+    return null;
+  }
   try {
     if (versionCheckCache && Date.now() - versionCheckCache.timestamp < CACHE_DURATION) {
       return versionCheckCache.latestVersion;
@@ -1566,6 +1168,9 @@ function showUpdateNotification(currentVersion, latestVersion) {
   console.log("");
 }
 async function checkAndShowUpdateNotification(currentVersion) {
+  if (currentVersion === "monorepo") {
+    return false;
+  }
   try {
     const latestVersion = await getLatestCliVersion(currentVersion);
     if (latestVersion) {
@@ -1648,12 +1253,275 @@ ${b}\u2800\u2800\u2800\u2800\u28B8\u28FF\u2866\u2800\u2800\u2809\u281B\u283F\u28
   }
 }
 
+// src/services/env-file.service.ts
+import { promises as fs6 } from "fs";
+import path8 from "path";
+import { existsSync as existsSync7 } from "fs";
+import { logger as logger8 } from "@elizaos/core";
+var EnvFileService = class {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath || "";
+  }
+  /**
+   * Initialize the service with the appropriate file path
+   */
+  async initialize() {
+    if (!this.filePath) {
+      const envInfo = await UserEnvironment.getInstanceInfo();
+      this.filePath = envInfo.paths.envFilePath;
+    }
+  }
+  /**
+   * Get the current environment file path
+   */
+  getFilePath() {
+    return this.filePath;
+  }
+  /**
+   * Read and parse the environment file
+   */
+  async read() {
+    const result = {};
+    try {
+      if (!existsSync7(this.filePath)) {
+        return result;
+      }
+      const content = await fs6.readFile(this.filePath, "utf-8");
+      const lines = content.split("\n");
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine && !trimmedLine.startsWith("#")) {
+          const separatorIndex = trimmedLine.indexOf("=");
+          if (separatorIndex > 0) {
+            const key = trimmedLine.substring(0, separatorIndex).trim();
+            const value = trimmedLine.substring(separatorIndex + 1).trim();
+            result[key] = value;
+          }
+        }
+      }
+    } catch (error) {
+      logger8.error(`Error reading environment file: ${error}`);
+    }
+    return result;
+  }
+  /**
+   * Read environment file with comments preserved
+   */
+  async readWithComments() {
+    const entries = [];
+    try {
+      if (!existsSync7(this.filePath)) {
+        return entries;
+      }
+      const content = await fs6.readFile(this.filePath, "utf-8");
+      const lines = content.split("\n");
+      let currentComment;
+      for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith("#")) {
+          const comment = trimmedLine.substring(1).trim();
+          currentComment = currentComment ? `${currentComment}
+${comment}` : comment;
+        } else if (trimmedLine && !trimmedLine.startsWith("#")) {
+          const separatorIndex = trimmedLine.indexOf("=");
+          if (separatorIndex > 0) {
+            const key = trimmedLine.substring(0, separatorIndex).trim();
+            const value = trimmedLine.substring(separatorIndex + 1).trim();
+            entries.push({
+              key,
+              value,
+              comment: currentComment
+            });
+            currentComment = void 0;
+          }
+        } else if (!trimmedLine) {
+          currentComment = void 0;
+        }
+      }
+    } catch (error) {
+      logger8.error(`Error reading environment file with comments: ${error}`);
+    }
+    return entries;
+  }
+  /**
+   * Write environment variables to file
+   */
+  async write(vars, options = {}) {
+    const { preserveComments = false, createBackup = false, updateProcessEnv = true } = options;
+    try {
+      const dir = path8.dirname(this.filePath);
+      if (!existsSync7(dir)) {
+        await fs6.mkdir(dir, { recursive: true });
+      }
+      if (createBackup && existsSync7(this.filePath)) {
+        const backupPath = `${this.filePath}.${Date.now()}.bak`;
+        await fs6.copyFile(this.filePath, backupPath);
+        logger8.info(`Created backup at ${backupPath}`);
+      }
+      let content = "";
+      const varsCopy = { ...vars };
+      if (preserveComments) {
+        const existingEntries = await this.readWithComments();
+        const existingKeys = new Set(existingEntries.map((e) => e.key));
+        for (const entry of existingEntries) {
+          if (Object.prototype.hasOwnProperty.call(varsCopy, entry.key)) {
+            if (entry.comment) {
+              content += `# ${entry.comment.replace(/\n/g, "\n# ")}
+`;
+            }
+            content += `${entry.key}=${varsCopy[entry.key]}
+`;
+            delete varsCopy[entry.key];
+          }
+        }
+        if (Object.keys(varsCopy).length > 0 && content) {
+          content += "\n";
+        }
+      }
+      for (const [key, value] of Object.entries(varsCopy)) {
+        if (typeof value === "string") {
+          content += `${key}=${value}
+`;
+          if (updateProcessEnv) {
+            process.env[key] = value;
+          }
+        }
+      }
+      await fs6.writeFile(this.filePath, content, "utf-8");
+      logger8.info(`Environment variables saved to ${this.filePath}`);
+    } catch (error) {
+      logger8.error(`Error writing environment file: ${error}`);
+      throw error;
+    }
+  }
+  /**
+   * Update a single environment variable
+   */
+  async update(key, value, options = {}) {
+    const vars = await this.read();
+    vars[key] = value;
+    if (options.updateProcessEnv !== false) {
+      process.env[key] = value;
+    }
+    await this.write(vars, { preserveComments: true, ...options });
+  }
+  /**
+   * Update multiple environment variables
+   */
+  async updateMany(updates, options = {}) {
+    const vars = await this.read();
+    Object.assign(vars, updates);
+    if (options.updateProcessEnv !== false) {
+      for (const [key, value] of Object.entries(updates)) {
+        process.env[key] = value;
+      }
+    }
+    await this.write(vars, { preserveComments: true, ...options });
+  }
+  /**
+   * Delete an environment variable
+   */
+  async delete(key) {
+    const vars = await this.read();
+    delete vars[key];
+    delete process.env[key];
+    await this.write(vars, { preserveComments: true });
+  }
+  /**
+   * Check if a key exists
+   */
+  async exists(key) {
+    const vars = await this.read();
+    return Object.prototype.hasOwnProperty.call(vars, key);
+  }
+  /**
+   * Get a single environment variable value
+   */
+  async get(key) {
+    const vars = await this.read();
+    return vars[key];
+  }
+  /**
+   * Create a backup of the current environment file
+   */
+  async backup() {
+    if (!existsSync7(this.filePath)) {
+      throw new Error("No environment file to backup");
+    }
+    const backupPath = `${this.filePath}.${Date.now()}.bak`;
+    await fs6.copyFile(this.filePath, backupPath);
+    return backupPath;
+  }
+  /**
+   * Validate the environment file
+   */
+  async validate() {
+    const errors = [];
+    try {
+      if (!existsSync7(this.filePath)) {
+        return { valid: true, errors: [] };
+      }
+      const content = await fs6.readFile(this.filePath, "utf-8");
+      const lines = content.split("\n");
+      lines.forEach((line, index) => {
+        const trimmedLine = line.trim();
+        if (trimmedLine && !trimmedLine.startsWith("#")) {
+          const separatorIndex = trimmedLine.indexOf("=");
+          if (separatorIndex < 1) {
+            errors.push(`Line ${index + 1}: Invalid format (missing '=' separator)`);
+          } else {
+            const key = trimmedLine.substring(0, separatorIndex).trim();
+            if (!/^[A-Z_][A-Z0-9_]*$/i.test(key)) {
+              errors.push(`Line ${index + 1}: Invalid key format '${key}'`);
+            }
+          }
+        }
+      });
+    } catch (error) {
+      errors.push(`Error reading file: ${error}`);
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+var globalInstance = null;
+async function getEnvFileService() {
+  if (!globalInstance) {
+    globalInstance = new EnvFileService();
+    await globalInstance.initialize();
+  }
+  return globalInstance;
+}
+function createEnvFileService(filePath) {
+  return new EnvFileService(filePath);
+}
+
+// src/utils/env-prompt.ts
+async function getEnvFilePath() {
+  const service = await getEnvFileService();
+  return service.getFilePath();
+}
+async function readEnvFile() {
+  const service = await getEnvFileService();
+  return service.read();
+}
+async function writeEnvFile(envVars) {
+  const service = await getEnvFileService();
+  await service.write(envVars, {
+    preserveComments: false,
+    updateProcessEnv: true
+  });
+}
+
 // src/utils/get-config.ts
 import { logger as logger9 } from "@elizaos/core";
 import dotenv2 from "dotenv";
 import path9 from "path";
-import { existsSync as existsSync7, promises as fs7 } from "fs";
-import * as clack3 from "@clack/prompts";
+import { existsSync as existsSync8, promises as fs7 } from "fs";
+import * as clack2 from "@clack/prompts";
 import { z } from "zod";
 var postgresConfigSchema = z.object({
   type: z.literal("postgres"),
@@ -1671,19 +1539,19 @@ var SAMPLE_ENV_TEMPLATE = `### elizaOS Environment Variables ###
 # To get started, copy this file to .env, or make a .env and add the settings you'd like to override
 # Please read the comments for each of the configurations
 
-## The only thing you ABSOLUTELY NEED to get up and running is one of the model provider keys, 
+## The only thing you ABSOLUTELY NEED to get up and running is one of the model provider keys,
 ## i.e. OPENAI_API_KEY or ANTHROPIC_API_KEY, or setup the local-ai or ollama plugin
 ## Everything else is optional, and most settings and secrets can be configured in your agent or through the GUI
 ## For multi-agent, each agent will need keys for the various services it is connected to
 -------------------------------
-## You can use the .env or environment variables generally for shared keys, such as to model providers, 
+## You can use the .env or environment variables generally for shared keys, such as to model providers,
 ## database, etc, with scoped keys for services such as Telegram, Discord, etc
 
 ## MODEL PROVIDER KEYS ##
-## Eliza is compatible with a wide array of model providers. Many have OpenAI compatible APIs, 
+## Eliza is compatible with a wide array of model providers. Many have OpenAI compatible APIs,
 ## and you can use them by overriding the base URL
 
-## NOTE: You will need a provider that provides embeddings. So even if you use Claude, you will 
+## NOTE: You will need a provider that provides embeddings. So even if you use Claude, you will
 ## need to get embeddings using another provider, for example openai or our local-ai plugin
 
 # OpenAI Configuration
@@ -1730,7 +1598,7 @@ ANTHROPIC_API_KEY=
 
 
 # Highly recommended to use nomic-embed-text for embeddings
-# OLLAMA_EMBEDDING_MODEL=nomic-embed-text 
+# OLLAMA_EMBEDDING_MODEL=nomic-embed-text
 
 ### DATABASE ###
 # By default, Eliza will use a local pglite instance
@@ -1792,36 +1660,24 @@ async function getElizaDirectories(targetProjectDir) {
   return { elizaDir, elizaDbDir, envFilePath };
 }
 async function ensureDir(dirPath) {
-  if (!existsSync7(dirPath)) {
+  if (!existsSync8(dirPath)) {
     await fs7.mkdir(dirPath, { recursive: true });
     logger9.debug(`Created directory: ${dirPath}`);
   }
 }
 async function setupEnvFile(envFilePath) {
   try {
-    const envExists = existsSync7(envFilePath);
+    const envExists = existsSync8(envFilePath);
     if (!envExists) {
-      const mergedVars = mergeProcessEnvWithTemplate(SAMPLE_ENV_TEMPLATE);
-      const formattedContent = formatEnvFileWithTemplate(mergedVars, SAMPLE_ENV_TEMPLATE);
-      await fs7.writeFile(envFilePath, formattedContent, "utf8");
-      const processEnvCount = Object.keys(process.env).filter(
-        (key) => process.env[key] && process.env[key].trim() !== ""
-      ).length;
-      logger9.info(
-        `[Config] Created .env file with ${processEnvCount} variables from process.env merged with example variables at: ${envFilePath}`
-      );
+      await fs7.writeFile(envFilePath, SAMPLE_ENV_TEMPLATE, "utf8");
+      logger9.info(`[Config] Created .env file with template variables at: ${envFilePath}`);
     } else {
       const content = await fs7.readFile(envFilePath, "utf8");
       const trimmedContent = content.trim();
       if (trimmedContent === "") {
-        const mergedVars = mergeProcessEnvWithTemplate(SAMPLE_ENV_TEMPLATE);
-        const formattedContent = formatEnvFileWithTemplate(mergedVars, SAMPLE_ENV_TEMPLATE);
-        await fs7.writeFile(envFilePath, formattedContent, "utf8");
-        const processEnvCount = Object.keys(process.env).filter(
-          (key) => process.env[key] && process.env[key].trim() !== ""
-        ).length;
+        await fs7.writeFile(envFilePath, SAMPLE_ENV_TEMPLATE, "utf8");
         logger9.info(
-          `[Config] Populated empty .env file with ${processEnvCount} variables from process.env merged with example variables at: ${envFilePath}`
+          `[Config] Populated empty .env file with template variables at: ${envFilePath}`
         );
       } else {
         logger9.debug(`[Config] .env file already exists and has content at: ${envFilePath}`);
@@ -1840,11 +1696,11 @@ async function ensureElizaDir(targetProjectDir) {
   await ensureDir(dirs.elizaDir);
   const registryCachePath = path9.join(dirs.elizaDir, "registry-cache.json");
   const configPath = path9.join(dirs.elizaDir, "config.json");
-  if (!existsSync7(registryCachePath)) {
+  if (!existsSync8(registryCachePath)) {
     await fs7.writeFile(registryCachePath, JSON.stringify({}, null, 2), "utf8");
     logger9.debug(`Created registry cache file: ${registryCachePath}`);
   }
-  if (!existsSync7(configPath)) {
+  if (!existsSync8(configPath)) {
     await fs7.writeFile(configPath, JSON.stringify({ version: "1.0.0" }, null, 2), "utf8");
     logger9.debug(`Created config file: ${configPath}`);
   }
@@ -1874,7 +1730,7 @@ async function storePostgresUrl(url, envFilePath) {
   if (!url) return;
   try {
     let content = "";
-    if (existsSync7(envFilePath)) {
+    if (existsSync8(envFilePath)) {
       content = await fs7.readFile(envFilePath, "utf8");
     }
     const lines = content.split("\n").filter((line) => !line.startsWith("POSTGRES_URL="));
@@ -1891,7 +1747,7 @@ async function storePgliteDataDir(dataDir, envFilePath) {
   if (!dataDir) return;
   try {
     let content = "";
-    if (existsSync7(envFilePath)) {
+    if (existsSync8(envFilePath)) {
       content = await fs7.readFile(envFilePath, "utf8");
     }
     const lines = content.split("\n").filter((line) => !line.startsWith("PGLITE_DATA_DIR="));
@@ -1905,8 +1761,8 @@ async function storePgliteDataDir(dataDir, envFilePath) {
   }
 }
 async function promptAndStorePostgresUrl(envFilePath) {
-  clack3.intro("\u{1F5C4}\uFE0F  PostgreSQL Configuration");
-  const response = await clack3.text({
+  clack2.intro("\u{1F5C4}\uFE0F  PostgreSQL Configuration");
+  const response = await clack2.text({
     message: "Enter your Postgres URL:",
     placeholder: "postgresql://user:password@host:port/dbname",
     validate: (value) => {
@@ -1918,20 +1774,20 @@ async function promptAndStorePostgresUrl(envFilePath) {
       return void 0;
     }
   });
-  if (clack3.isCancel(response)) {
-    clack3.cancel("Operation cancelled.");
+  if (clack2.isCancel(response)) {
+    clack2.cancel("Operation cancelled.");
     return null;
   }
-  const spinner2 = clack3.spinner();
+  const spinner2 = clack2.spinner();
   spinner2.start("Saving PostgreSQL configuration...");
   try {
     await storePostgresUrl(response, envFilePath);
     spinner2.stop("PostgreSQL configuration saved successfully!");
-    clack3.outro("\u2713 Database connection configured");
+    clack2.outro("\u2713 Database connection configured");
     return response;
   } catch (error) {
     spinner2.stop("Failed to save configuration");
-    clack3.log.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    clack2.log.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   }
 }
@@ -1951,7 +1807,7 @@ async function storeOpenAIKey(key, envFilePath) {
   if (!key) return;
   try {
     let content = "";
-    if (existsSync7(envFilePath)) {
+    if (existsSync8(envFilePath)) {
       content = await fs7.readFile(envFilePath, "utf8");
     }
     const lines = content.split("\n").filter((line) => !line.startsWith("OPENAI_API_KEY="));
@@ -1968,7 +1824,7 @@ async function storeGoogleKey(key, envFilePath) {
   if (!key) return;
   try {
     let content = "";
-    if (existsSync7(envFilePath)) {
+    if (existsSync8(envFilePath)) {
       content = await fs7.readFile(envFilePath, "utf8");
     }
     const lines = content.split("\n").filter((line) => !line.startsWith("GOOGLE_GENERATIVE_AI_API_KEY="));
@@ -1985,7 +1841,7 @@ async function storeAnthropicKey(key, envFilePath) {
   if (!key) return;
   try {
     let content = "";
-    if (existsSync7(envFilePath)) {
+    if (existsSync8(envFilePath)) {
       content = await fs7.readFile(envFilePath, "utf8");
     }
     const lines = content.split("\n").filter((line) => !line.startsWith("ANTHROPIC_API_KEY="));
@@ -1999,13 +1855,13 @@ async function storeAnthropicKey(key, envFilePath) {
   }
 }
 async function promptAndStoreProviderConfig(config, envFilePath) {
-  clack3.intro(`${config.icon} ${config.name} Configuration`);
+  clack2.intro(`${config.icon} ${config.name} Configuration`);
   if (config.noteText) {
-    clack3.note(config.noteText, "API Key Information");
+    clack2.note(config.noteText, "API Key Information");
   }
   const results = {};
   for (const input of config.inputs) {
-    const promptFn = input.type === "password" ? clack3.password : clack3.text;
+    const promptFn = input.type === "password" ? clack2.password : clack2.text;
     const promptConfig = {
       message: input.message,
       validate: input.validate
@@ -2013,22 +1869,22 @@ async function promptAndStoreProviderConfig(config, envFilePath) {
     if (input.placeholder) promptConfig.placeholder = input.placeholder;
     if (input.initialValue) promptConfig.initialValue = input.initialValue;
     const response = await promptFn(promptConfig);
-    if (clack3.isCancel(response)) {
-      clack3.cancel("Operation cancelled.");
+    if (clack2.isCancel(response)) {
+      clack2.cancel("Operation cancelled.");
       return null;
     }
     results[input.key] = input.type === "text" ? response.trim() : response;
   }
-  const spinner2 = clack3.spinner();
+  const spinner2 = clack2.spinner();
   spinner2.start(`Saving ${config.name} configuration...`);
   try {
     await config.storeFunction(results, envFilePath);
     spinner2.stop(`${config.name} configuration saved successfully!`);
-    clack3.outro(`\u2713 ${config.successMessage}`);
+    clack2.outro(`\u2713 ${config.successMessage}`);
     return results;
   } catch (error) {
     spinner2.stop("Failed to save configuration");
-    clack3.log.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    clack2.log.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
     return null;
   }
 }
@@ -2051,8 +1907,8 @@ async function promptAndStoreOpenAIKey(envFilePath) {
     storeFunction: async (results, envPath) => {
       const isValid = isValidOpenAIKey(results.key);
       if (!isValid) {
-        clack3.log.warn("Invalid API key format detected. Expected format: sk-...");
-        clack3.log.warn("The key has been saved but may not work correctly.");
+        clack2.log.warn("Invalid API key format detected. Expected format: sk-...");
+        clack2.log.warn("The key has been saved but may not work correctly.");
       }
       await storeOpenAIKey(results.key, envPath);
     },
@@ -2080,8 +1936,8 @@ async function promptAndStoreAnthropicKey(envFilePath) {
     storeFunction: async (results, envPath) => {
       const isValid = isValidAnthropicKey(results.key);
       if (!isValid) {
-        clack3.log.warn("Invalid API key format detected. Expected format: sk-ant-...");
-        clack3.log.warn("The key has been saved but may not work correctly.");
+        clack2.log.warn("Invalid API key format detected. Expected format: sk-ant-...");
+        clack2.log.warn("The key has been saved but may not work correctly.");
       }
       await storeAnthropicKey(results.key, envPath);
     },
@@ -2103,7 +1959,7 @@ async function storeOllamaConfig(config, envFilePath) {
   if (!config.endpoint || !config.model) return;
   try {
     let content = "";
-    if (existsSync7(envFilePath)) {
+    if (existsSync8(envFilePath)) {
       content = await fs7.readFile(envFilePath, "utf8");
     }
     const lines = content.split("\n").filter(
@@ -2157,7 +2013,7 @@ async function promptAndStoreOllamaEmbeddingConfig(envFilePath) {
     storeFunction: async (results, envPath) => {
       try {
         let content = "";
-        if (existsSync7(envPath)) {
+        if (existsSync8(envPath)) {
           content = await fs7.readFile(envPath, "utf8");
         }
         const lines = content.split("\n").filter(
@@ -2258,10 +2114,10 @@ async function promptAndStoreGoogleKey(envFilePath) {
     storeFunction: async (results, envPath) => {
       const isValid = isValidGoogleKey(results.key);
       if (!isValid) {
-        clack3.log.warn(
+        clack2.log.warn(
           "Invalid API key format detected. Expected format: 39 character alphanumeric key"
         );
-        clack3.log.warn("The key has been saved but may not work correctly.");
+        clack2.log.warn("The key has been saved but may not work correctly.");
       }
       await storeGoogleKey(results.key, envPath);
     },
@@ -2278,7 +2134,7 @@ async function storeOpenRouterKey(key, envFilePath) {
   if (!key) return;
   try {
     let content = "";
-    if (existsSync7(envFilePath)) {
+    if (existsSync8(envFilePath)) {
       content = await fs7.readFile(envFilePath, "utf8");
     }
     const lines = content.split("\n").filter((line) => !line.startsWith("OPENROUTER_API_KEY="));
@@ -2310,8 +2166,8 @@ async function promptAndStoreOpenRouterKey(envFilePath) {
     storeFunction: async (results, envPath) => {
       const isValid = isValidOpenRouterKey(results.key);
       if (!isValid) {
-        clack3.log.warn("Invalid API key format detected. Expected format: sk-or-...");
-        clack3.log.warn("The key has been saved but may not work correctly.");
+        clack2.log.warn("Invalid API key format detected. Expected format: sk-or-...");
+        clack2.log.warn("The key has been saved but may not work correctly.");
       }
       await storeOpenRouterKey(results.key, envPath);
     },
@@ -2373,73 +2229,10 @@ async function resolveConfigPaths(cwd, config) {
 }
 async function loadEnvironment(projectDir = process.cwd()) {
   const envPath = resolveEnvFile(projectDir);
-  if (existsSync7(envPath)) {
+  if (existsSync8(envPath)) {
     dotenv2.config({ path: envPath });
   }
 }
-function mergeProcessEnvWithTemplate(templateContent) {
-  const result = {};
-  const processedKeys = /* @__PURE__ */ new Set();
-  const templateLines = templateContent.split("\n");
-  const templateVars = {};
-  for (const line of templateLines) {
-    const trimmedLine = line.trim();
-    if (trimmedLine && !trimmedLine.startsWith("#") && trimmedLine.includes("=")) {
-      const equalIndex = trimmedLine.indexOf("=");
-      const key = trimmedLine.substring(0, equalIndex).trim();
-      const value = trimmedLine.substring(equalIndex + 1).trim();
-      if (key) {
-        templateVars[key] = value;
-      }
-    }
-  }
-  for (const [key, value] of Object.entries(process.env)) {
-    if (value && value.trim() !== "") {
-      result[key] = value;
-      processedKeys.add(key);
-    }
-  }
-  for (const [key, value] of Object.entries(templateVars)) {
-    if (!processedKeys.has(key)) {
-      result[key] = value;
-      processedKeys.add(key);
-    }
-  }
-  return result;
-}
-function formatEnvFileWithTemplate(envVars, templateContent) {
-  const lines = [];
-  const processedKeys = /* @__PURE__ */ new Set();
-  const templateLines = templateContent.split("\n");
-  for (const line of templateLines) {
-    const trimmedLine = line.trim();
-    if (!trimmedLine || trimmedLine.startsWith("#") || !trimmedLine.includes("=")) {
-      lines.push(line);
-    } else {
-      const equalIndex = trimmedLine.indexOf("=");
-      const key = trimmedLine.substring(0, equalIndex).trim();
-      if (key && envVars.hasOwnProperty(key)) {
-        lines.push(`${key}=${envVars[key]}`);
-        processedKeys.add(key);
-      } else {
-        lines.push(line);
-      }
-    }
-  }
-  const newVars = [];
-  for (const [key, value] of Object.entries(envVars)) {
-    if (!processedKeys.has(key)) {
-      newVars.push(`${key}=${value}`);
-    }
-  }
-  if (newVars.length > 0) {
-    lines.push("");
-    lines.push("### Additional Environment Variables from Runtime ###");
-    lines.push("# Variables found in process.env that were not in the template");
-    lines.push(...newVars);
-  }
-  return lines.join("\n");
-}
 
 // src/utils/get-package-info.ts
 async function getPackageVersion(packageName) {
@@ -2479,9 +2272,9 @@ async function getPackageInfo() {
 import { promises as fs8 } from "fs";
 import path10 from "path";
 import { logger as logger10 } from "@elizaos/core";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { execa as execa5 } from "execa";
-import * as clack4 from "@clack/prompts";
+import * as clack3 from "@clack/prompts";
 var GITHUB_API_URL = "https://api.github.com";
 async function validateGitHubToken(token) {
   try {
@@ -2711,10 +2504,10 @@ async function createBranch(token, owner, repo, branch, baseBranch = "main") {
     return false;
   }
 }
-async function getFileContent(token, owner, repo, path19, branch = "main") {
+async function getFileContent(token, owner, repo, path20, branch = "main") {
   try {
     const response = await fetch(
-      `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path19}?ref=${branch}`,
+      `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path20}?ref=${branch}`,
       {
         headers: {
           Authorization: `token ${token}`,
@@ -2731,14 +2524,14 @@ async function getFileContent(token, owner, repo, path19, branch = "main") {
     return null;
   }
 }
-async function updateFile(token, owner, repo, path19, content, message, branch = "main") {
+async function updateFile(token, owner, repo, path20, content, message, branch = "main") {
   try {
-    const existingContent = await getFileContent(token, owner, repo, path19, branch);
+    const existingContent = await getFileContent(token, owner, repo, path20, branch);
     const method = "PUT";
     let sha;
     if (existingContent !== null) {
       const response2 = await fetch(
-        `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path19}?ref=${branch}`,
+        `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path20}?ref=${branch}`,
         {
           headers: {
             Authorization: `token ${token}`,
@@ -2751,7 +2544,7 @@ async function updateFile(token, owner, repo, path19, content, message, branch =
         sha = data.sha;
       }
     }
-    const fileUrl = `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path19}`;
+    const fileUrl = `${GITHUB_API_URL}/repos/${owner}/${repo}/contents/${path20}`;
     logger10.info(`Updating file at: ${fileUrl}`);
     const requestBody = {
       message,
@@ -2777,7 +2570,7 @@ async function updateFile(token, owner, repo, path19, content, message, branch =
     logger10.error(`Failed to update file: ${response.status} ${response.statusText}`);
     logger10.error(`Response body: ${errorBody}`);
     if (response.status === 404) {
-      logger10.error(`Repository or path not found: ${owner}/${repo}/${path19}`);
+      logger10.error(`Repository or path not found: ${owner}/${repo}/${path20}`);
       const repoCheck = await fetch(`${GITHUB_API_URL}/repos/${owner}/${repo}`, {
         headers: {
           Authorization: `token ${token}`,
@@ -2856,7 +2649,7 @@ async function getGitHubCredentials() {
     }
     logger10.warn("Invalid GitHub token found in environment variables");
   }
-  const { getGitHubToken: getGitHubToken2 } = await import("./registry-BQSPZS3F.js");
+  const { getGitHubToken: getGitHubToken2 } = await import("./registry-FBPEGL2T.js");
   const token = await getGitHubToken2() || void 0;
   if (token) {
     const isValid2 = await validateGitHubToken(token);
@@ -2871,8 +2664,8 @@ async function getGitHubCredentials() {
       logger10.warn("Stored GitHub token is invalid, will prompt for new credentials");
     }
   }
-  clack4.intro("\u{1F510} GitHub Authentication Required");
-  clack4.note(
+  clack3.intro("\u{1F510} GitHub Authentication Required");
+  clack3.note(
     `To create a GitHub Personal Access Token (Classic):
 1. Go to https://github.com/settings/tokens/new
 2. Give your token a descriptive name (e.g., "ElizaOS CLI")
@@ -2887,20 +2680,20 @@ async function getGitHubCredentials() {
 NOTE: You must use a Classic token, not a Fine-grained token`,
     "Setup Instructions"
   );
-  const promptedUsername = await clack4.text({
+  const promptedUsername = await clack3.text({
     message: "Enter your GitHub username:",
     validate: (value) => value ? void 0 : "Username is required"
   });
-  if (clack4.isCancel(promptedUsername)) {
-    clack4.cancel("Operation cancelled.");
+  if (clack3.isCancel(promptedUsername)) {
+    clack3.cancel("Operation cancelled.");
     return null;
   }
-  const promptedToken = await clack4.password({
+  const promptedToken = await clack3.password({
     message: "Enter your GitHub Personal Access Token (with repo, read:org, and workflow scopes):",
     validate: (value) => value ? void 0 : "Token is required"
   });
-  if (clack4.isCancel(promptedToken)) {
-    clack4.cancel("Operation cancelled.");
+  if (clack3.isCancel(promptedToken)) {
+    clack3.cancel("Operation cancelled.");
     return null;
   }
   const isValid = await validateGitHubToken(promptedToken);
@@ -2916,10 +2709,10 @@ async function saveGitHubCredentials(username, token) {
   const envInfo = await UserEnvironment.getInstanceInfo();
   const { elizaDir, envFilePath } = envInfo.paths;
   logger10.debug("[GitHub] Saving credentials");
-  if (!existsSync8(elizaDir)) {
+  if (!existsSync9(elizaDir)) {
     await fs8.mkdir(elizaDir, { recursive: true });
   }
-  if (!existsSync8(envFilePath)) {
+  if (!existsSync9(envFilePath)) {
     await fs8.writeFile(envFilePath, "", { encoding: "utf8" });
   }
   const currentContent = await fs8.readFile(envFilePath, "utf8");
@@ -2943,11 +2736,11 @@ async function saveGitHubCredentials(username, token) {
   process.env.GITHUB_TOKEN = token;
   logger10.success("GitHub credentials saved");
 }
-async function ensureDirectory(token, repo, path19, branch) {
+async function ensureDirectory(token, repo, path20, branch) {
   try {
     try {
       const response = await fetch(
-        `${GITHUB_API_URL}/repos/${repo}/contents/${path19}?ref=${branch}`,
+        `${GITHUB_API_URL}/repos/${repo}/contents/${path20}?ref=${branch}`,
         {
           headers: {
             Authorization: `token ${token}`,
@@ -2956,27 +2749,27 @@ async function ensureDirectory(token, repo, path19, branch) {
         }
       );
       if (response.status === 200) {
-        logger10.info(`Directory ${path19} already exists`);
+        logger10.info(`Directory ${path20} already exists`);
         return true;
       }
     } catch (error) {
-      logger10.info(`Directory ${path19} doesn't exist, creating it`);
+      logger10.info(`Directory ${path20} doesn't exist, creating it`);
     }
-    const placeholderPath = `${path19}/.gitkeep`;
+    const placeholderPath = `${path20}/.gitkeep`;
     const result = await updateFile(
       token,
       repo,
       placeholderPath,
       "",
       // Empty content for placeholder
-      `Create directory: ${path19}`,
+      `Create directory: ${path20}`,
       branch
     );
     if (result) {
-      logger10.success(`Created directory: ${path19}`);
+      logger10.success(`Created directory: ${path20}`);
       return true;
     }
-    logger10.error(`Failed to create directory: ${path19}`);
+    logger10.error(`Failed to create directory: ${path20}`);
     return false;
   } catch (error) {
     logger10.error(
@@ -3071,7 +2864,7 @@ async function createGitHubRepository(token, repoName, description, isPrivate =
 }
 async function pushToGitHub(cwd, repoUrl, branch = "main") {
   try {
-    const gitDirExists = existsSync8(path10.join(cwd, ".git"));
+    const gitDirExists = existsSync9(path10.join(cwd, ".git"));
     let hasCorrectRemote = false;
     if (gitDirExists) {
       try {
@@ -3367,7 +3160,7 @@ async function setAgentConfig(opts) {
 
 // src/commands/agent/actions/lifecycle.ts
 import { logger as logger12 } from "@elizaos/core";
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
 import path12 from "path";
 async function startAgent(options) {
   try {
@@ -3414,7 +3207,7 @@ async function startAgent(options) {
       if (options.path) {
         try {
           const filePath = path12.resolve(process.cwd(), options.path);
-          if (!existsSync9(filePath)) {
+          if (!existsSync10(filePath)) {
             throw new Error(`File not found at path: ${filePath}`);
           }
           const fileContent = readFileSync6(filePath, "utf8");
@@ -3622,18 +3415,18 @@ agent.command("set").description("Update agent configuration").requiredOption("-
 agent.command("clear-memories").alias("clear").description("Clear all memories for an agent").requiredOption("-n, --name <name>", "agent id, name, or index number from list").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).action(clearAgentMemories);
 
 // src/utils/handle-error.ts
-import colors2 from "yoctocolors";
+import colors from "yoctocolors";
 function handleError(error) {
   const isNoSpace = error instanceof Error && (error.message.includes("no space left on device") || error.message.includes("ENOSPC")) || typeof error === "string" && (error.includes("no space left on device") || error.includes("ENOSPC"));
   if (isNoSpace) {
     logger13.error(
-      colors2.red("ERROR: No space left on device! Please free up disk space and try again.")
+      colors.red("ERROR: No space left on device! Please free up disk space and try again.")
     );
     if (error instanceof Error) {
-      logger13.error(colors2.red(error.message));
-      logger13.error(colors2.red(error.stack || ""));
+      logger13.error(colors.red(error.message));
+      logger13.error(colors.red(error.stack || ""));
     } else {
-      logger13.error(colors2.red(String(error)));
+      logger13.error(colors.red(String(error)));
     }
   } else {
     logger13.error("An error occurred:", error);
@@ -3661,7 +3454,17 @@ async function checkServer(opts) {
 }
 
 // src/utils/helpers.ts
-import colors3 from "yoctocolors";
+import colors2 from "yoctocolors";
+import path13 from "path";
+function getDisplayDirectory(targetDir) {
+  if (targetDir === ".") {
+    return path13.basename(process.cwd());
+  }
+  if (targetDir.startsWith("/") || targetDir.match(/^[a-zA-Z]:[\\\/]/) || targetDir.startsWith("\\\\")) {
+    return path13.basename(targetDir);
+  }
+  return targetDir;
+}
 function displayAgent(data, title = "Agent Review") {
   logHeader(title);
   console.log(`Name: ${data.name}`);
@@ -3678,7 +3481,7 @@ function displayAgent(data, title = "Agent Review") {
   displaySection("Post Examples", data.postExamples);
   if (data.messageExamples && data.messageExamples.length > 0) {
     console.log(`
-${colors3.cyan("Message Examples:")}`);
+${colors2.cyan("Message Examples:")}`);
     console.log(
       data.messageExamples.map((conversation, i) => {
         const messages = formatConversation(conversation);
@@ -3698,7 +3501,7 @@ function formatConversation(conversation) {
 function displaySection(title, items) {
   if (!items || items.length === 0) return;
   console.log(`
-${colors3.cyan(`${title}:`)}`);
+${colors2.cyan(`${title}:`)}`);
   for (const item of items) {
     console.log(`  ${item}`);
   }
@@ -3708,10 +3511,10 @@ function logHeader(title) {
   const titleStr = `=== ${title} ===`;
   const paddedTitle = " ".repeat(padding) + titleStr + " ".repeat(padding);
   const borderLength = paddedTitle.length;
-  const topBorder = colors3.green(`\u250C${"\u2500".repeat(borderLength)}\u2510`);
-  const bottomBorder = colors3.green(`\u2514${"\u2500".repeat(borderLength)}\u2518`);
-  const coloredTitle = `${" ".repeat(padding)}=== ${colors3.green(title)} ===${" ".repeat(padding)}`;
-  const middleRow = colors3.green("\u2502") + coloredTitle + colors3.green("\u2502");
+  const topBorder = colors2.green(`\u250C${"\u2500".repeat(borderLength)}\u2510`);
+  const bottomBorder = colors2.green(`\u2514${"\u2500".repeat(borderLength)}\u2518`);
+  const coloredTitle = `${" ".repeat(padding)}=== ${colors2.green(title)} ===${" ".repeat(padding)}`;
+  const middleRow = colors2.green("\u2502") + coloredTitle + colors2.green("\u2502");
   console.log(`
 ${topBorder}
 ${middleRow}
@@ -3720,18 +3523,18 @@ ${bottomBorder}`);
 
 // src/utils/install-plugin.ts
 import { logger as logger18 } from "@elizaos/core";
-import { existsSync as existsSync13 } from "fs";
-import path16 from "path";
+import { existsSync as existsSync14 } from "fs";
+import path17 from "path";
 
 // src/utils/load-plugin.ts
 import { logger as logger15 } from "@elizaos/core";
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
-import path14 from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
+import path15 from "path";
 
 // src/utils/plugin-context.ts
 import { logger as logger14 } from "@elizaos/core";
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
-import path13 from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+import path14 from "path";
 function normalizeForComparison(name) {
   const normalized = normalizePluginName(name)[0] || name;
   return normalized.toLowerCase();
@@ -3742,7 +3545,7 @@ function detectPluginContext(pluginName) {
   if (directoryInfo.type !== "elizaos-plugin" || !directoryInfo.hasPackageJson) {
     return { isLocalDevelopment: false };
   }
-  const packageJsonPath = path13.join(cwd, "package.json");
+  const packageJsonPath = path14.join(cwd, "package.json");
   let packageInfo;
   try {
     packageInfo = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
@@ -3752,13 +3555,13 @@ function detectPluginContext(pluginName) {
   }
   const normalizedRequestedPlugin = normalizeForComparison(pluginName);
   const normalizedCurrentPackage = normalizeForComparison(packageInfo.name);
-  const dirName = path13.basename(cwd);
+  const dirName = path14.basename(cwd);
   const normalizedDirName = normalizeForComparison(dirName);
   const isCurrentPlugin = normalizedRequestedPlugin === normalizedCurrentPackage || normalizedRequestedPlugin === normalizedDirName;
   if (isCurrentPlugin) {
     const mainEntry = packageInfo.main || "dist/index.js";
-    const localPath = path13.resolve(cwd, mainEntry);
-    const needsBuild = !existsSync10(localPath);
+    const localPath = path14.resolve(cwd, mainEntry);
+    const needsBuild = !existsSync11(localPath);
     logger14.debug(`Detected local plugin development: ${pluginName}`);
     logger14.debug(`Expected output: ${localPath}`);
     logger14.debug(`Needs build: ${needsBuild}`);
@@ -3780,7 +3583,7 @@ async function ensurePluginBuilt(context) {
     logger14.info("Plugin not built, attempting to build...");
     try {
       await buildProject(process.cwd(), true);
-      if (localPath && existsSync10(localPath)) {
+      if (localPath && existsSync11(localPath)) {
         logger14.success("Plugin built successfully");
         return true;
       } else {
@@ -3817,20 +3620,20 @@ Local plugin development detected for: ${pluginName}`);
 // src/utils/load-plugin.ts
 var DEFAULT_ENTRY_POINT = "dist/index.js";
 function getGlobalNodeModulesPath() {
-  const nodeDir = path14.dirname(process.execPath);
+  const nodeDir = path15.dirname(process.execPath);
   if (process.platform === "win32") {
-    return path14.join(nodeDir, "node_modules");
+    return path15.join(nodeDir, "node_modules");
   } else {
-    return path14.join(nodeDir, "..", "lib", "node_modules");
+    return path15.join(nodeDir, "..", "lib", "node_modules");
   }
 }
 function resolveNodeModulesPath(repository, ...segments) {
-  return path14.resolve(process.cwd(), "node_modules", repository, ...segments);
+  return path15.resolve(process.cwd(), "node_modules", repository, ...segments);
 }
 async function readPackageJson(repository) {
   const packageJsonPath = resolveNodeModulesPath(repository, "package.json");
   try {
-    if (existsSync11(packageJsonPath)) {
+    if (existsSync12(packageJsonPath)) {
       return JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
     }
   } catch (error) {
@@ -3861,7 +3664,7 @@ var importStrategies = [
           provideLocalPluginGuidance(repository, context);
           return null;
         }
-        if (context.localPath && existsSync11(context.localPath)) {
+        if (context.localPath && existsSync12(context.localPath)) {
           logger15.info(`Loading local development plugin: ${repository}`);
           return tryImporting(context.localPath, "local development plugin", repository);
         }
@@ -3878,8 +3681,8 @@ var importStrategies = [
     tryImport: async (repository) => {
       if (repository.startsWith("@elizaos/plugin-")) {
         const pluginName = repository.replace("@elizaos/", "");
-        const workspacePath = path14.resolve(process.cwd(), "..", pluginName, "dist", "index.js");
-        if (existsSync11(workspacePath)) {
+        const workspacePath = path15.resolve(process.cwd(), "..", pluginName, "dist", "index.js");
+        if (existsSync12(workspacePath)) {
           return tryImporting(workspacePath, "workspace dependency", repository);
         }
       }
@@ -3897,10 +3700,10 @@ var importStrategies = [
   {
     name: "global node_modules",
     tryImport: async (repository) => {
-      const globalPath = path14.resolve(getGlobalNodeModulesPath(), repository);
-      if (!existsSync11(path14.dirname(globalPath))) {
+      const globalPath = path15.resolve(getGlobalNodeModulesPath(), repository);
+      if (!existsSync12(path15.dirname(globalPath))) {
         logger15.debug(
-          `Global node_modules directory not found at ${path14.dirname(globalPath)}, skipping for ${repository}`
+          `Global node_modules directory not found at ${path15.dirname(globalPath)}, skipping for ${repository}`
         );
         return null;
       }
@@ -3962,8 +3765,8 @@ async function loadPluginModule(repository) {
 
 // src/utils/package-manager.ts
 import { logger as logger16 } from "@elizaos/core";
-import { existsSync as existsSync12 } from "fs";
-import path15 from "path";
+import { existsSync as existsSync13 } from "fs";
+import path16 from "path";
 import { execa as execa6 } from "execa";
 async function getPackageManager() {
   logger16.debug("[PackageManager] Using bun as the package manager for ElizaOS CLI");
@@ -3985,8 +3788,8 @@ function getInstallCommand(isGlobal) {
   return ["add", ...isGlobal ? ["-g"] : []];
 }
 async function removeFromBunLock(packageName, directory) {
-  const lockFilePath = path15.join(directory, "bun.lock");
-  if (!existsSync12(lockFilePath)) {
+  const lockFilePath = path16.join(directory, "bun.lock");
+  if (!existsSync13(lockFilePath)) {
     logger16.debug(`No bun.lock file found at ${lockFilePath}, skipping removal`);
     return;
   }
@@ -4070,10 +3873,10 @@ function getCliDirectory() {
   try {
     const cliPath = process.argv[1];
     if (cliPath.includes("node_modules/@elizaos/cli")) {
-      const cliDir = path16.dirname(
+      const cliDir = path17.dirname(
         cliPath.split("node_modules/@elizaos/cli")[0] + "node_modules/@elizaos/cli"
       );
-      if (existsSync13(path16.join(cliDir, "package.json"))) {
+      if (existsSync14(path17.join(cliDir, "package.json"))) {
         return cliDir;
       }
     }
@@ -4571,7 +4374,7 @@ import {
   logger as logger20
 } from "@elizaos/core";
 import * as fs9 from "fs";
-import * as path17 from "path";
+import * as path18 from "path";
 import { pathToFileURL } from "url";
 var safeLogger = {
   debug: logger20?.debug || console.log,
@@ -4755,14 +4558,14 @@ export const myPlugin = {
       return;
     }
     try {
-      const e2eDir = path17.join(process.cwd(), "e2e");
+      const e2eDir = path18.join(process.cwd(), "e2e");
       if (!fs9.existsSync(e2eDir)) {
         safeLogger.debug("No e2e directory found, skipping e2e tests");
         return;
       }
       safeLogger.info("\nRunning e2e tests...");
       const walk = (dir) => fs9.readdirSync(dir, { withFileTypes: true }).flatMap(
-        (entry) => entry.isDirectory() ? walk(path17.join(dir, entry.name)) : entry.name.match(/\.test\.(t|j)sx?$/) ? [path17.join(dir, entry.name)] : []
+        (entry) => entry.isDirectory() ? walk(path18.join(dir, entry.name)) : entry.name.match(/\.test\.(t|j)sx?$/) ? [path18.join(dir, entry.name)] : []
       );
       const testFiles = walk(e2eDir);
       if (testFiles.length === 0) {
@@ -4770,16 +4573,16 @@ export const myPlugin = {
         return;
       }
       safeLogger.info(`Found ${testFiles.length} e2e test files`);
-      const distE2eDir = path17.join(process.cwd(), "dist", "e2e");
+      const distE2eDir = path18.join(process.cwd(), "dist", "e2e");
       const hasDistE2e = fs9.existsSync(distE2eDir);
       for (const testFile of testFiles) {
         try {
-          const fileName = path17.basename(testFile);
-          const fileNameWithoutExt = path17.basename(testFile, ".test.ts");
+          const fileName = path18.basename(testFile);
+          const fileNameWithoutExt = path18.basename(testFile, ".test.ts");
           safeLogger.info(`Loading test file: ${fileName}`);
           let moduleImportPath = testFile;
           if (hasDistE2e) {
-            const distFile = path17.join(distE2eDir, `${fileNameWithoutExt}.test.js`);
+            const distFile = path18.join(distE2eDir, `${fileNameWithoutExt}.test.js`);
             if (fs9.existsSync(distFile)) {
               moduleImportPath = distFile;
               safeLogger.debug(`Using compiled version from ${distFile}`);
@@ -4856,8 +4659,8 @@ import { logger as logger21 } from "@elizaos/core";
 import dotenv3 from "dotenv";
 import { execa as execa8 } from "execa";
 import { HttpsProxyAgent } from "https-proxy-agent";
-import { existsSync as existsSync15, promises as fs10 } from "fs";
-import path18 from "path";
+import { existsSync as existsSync16, promises as fs10 } from "fs";
+import path19 from "path";
 
 // src/utils/registry/constants.ts
 var REGISTRY_ORG = "elizaos-plugins";
@@ -4868,10 +4671,10 @@ var REGISTRY_GITHUB_URL = `https://github.com/${REGISTRY_REPO}`;
 var RAW_REGISTRY_URL = REGISTRY_URL;
 
 // src/utils/registry/index.ts
-var ELIZA_DIR = path18.join(process.cwd(), ".eliza");
-var REGISTRY_SETTINGS_FILE = path18.join(ELIZA_DIR, "registrysettings.json");
-var ENV_FILE = resolveEnvFile() || path18.join(ELIZA_DIR, ".env");
-var REGISTRY_CACHE_FILE = path18.join(ELIZA_DIR, "registry-cache.json");
+var ELIZA_DIR = path19.join(process.cwd(), ".eliza");
+var REGISTRY_SETTINGS_FILE = path19.join(ELIZA_DIR, "registrysettings.json");
+var ENV_FILE = resolveEnvFile() || path19.join(ELIZA_DIR, ".env");
+var REGISTRY_CACHE_FILE = path19.join(ELIZA_DIR, "registry-cache.json");
 var REQUIRED_ENV_VARS = ["GITHUB_TOKEN"];
 var REQUIRED_SETTINGS = ["defaultRegistry"];
 async function ensureElizaDir2() {
@@ -4919,13 +4722,13 @@ async function setEnvVar(key, value) {
 async function getGitHubToken() {
   try {
     const envPath = resolveEnvFile();
-    if (envPath && existsSync15(envPath)) {
+    if (envPath && existsSync16(envPath)) {
       const envContent = await fs10.readFile(envPath, "utf-8");
       const env = dotenv3.parse(envContent);
       return env.GITHUB_TOKEN;
     }
-    const globalEnvPath = path18.join(ELIZA_DIR, ".env");
-    if (existsSync15(globalEnvPath) && globalEnvPath !== envPath) {
+    const globalEnvPath = path19.join(ELIZA_DIR, ".env");
+    if (existsSync16(globalEnvPath) && globalEnvPath !== envPath) {
       const envContent = await fs10.readFile(globalEnvPath, "utf-8");
       const env = dotenv3.parse(envContent);
       return env.GITHUB_TOKEN;
@@ -4942,7 +4745,7 @@ async function setGitHubToken(token) {
   try {
     let envContent = "";
     try {
-      if (existsSync15(ENV_FILE)) {
+      if (existsSync16(ENV_FILE)) {
         envContent = await fs10.readFile(ENV_FILE, "utf-8");
       }
     } catch (error) {
@@ -5034,7 +4837,7 @@ async function getLocalRegistryIndex() {
     );
   }
   try {
-    if (existsSync15(REGISTRY_CACHE_FILE)) {
+    if (existsSync16(REGISTRY_CACHE_FILE)) {
       const cacheContent = await fs10.readFile(REGISTRY_CACHE_FILE, "utf-8");
       const cachedRegistry = JSON.parse(cacheContent);
       logger21.debug("Using cached registry index");
@@ -5246,11 +5049,11 @@ async function getPackageDetails(packageName) {
     if (response.status !== 200) {
       return null;
     }
-    const text5 = await response.text();
+    const text4 = await response.text();
     try {
-      return JSON.parse(text5);
+      return JSON.parse(text4);
     } catch {
-      logger21.warn(`Invalid JSON response received from registry for package ${packageName}:`, text5);
+      logger21.warn(`Invalid JSON response received from registry for package ${packageName}:`, text4);
       return null;
     }
   } catch (error) {
@@ -5387,21 +5190,13 @@ export {
   promptWithNav,
   promptForMultipleItems,
   confirmAction,
-  getEnvFilePath,
-  readEnvFile,
-  writeEnvFile,
-  promptForEnvVars,
-  validateEnvVars,
-  getMissingEnvVars,
-  validatePluginEnvVars,
   getConfigFilePath,
   loadConfig,
   saveConfig,
-  checkPluginRequirements,
-  getPluginStatus,
   copyDir,
   copyTemplate,
   copyClientDist,
+  isRunningFromNodeModules,
   getVersion,
   getCliInstallTag,
   isUtf8Locale,
@@ -5409,6 +5204,10 @@ export {
   showUpdateNotification,
   checkAndShowUpdateNotification,
   displayBanner,
+  createEnvFileService,
+  getEnvFilePath,
+  readEnvFile,
+  writeEnvFile,
   isValidPostgresUrl,
   getElizaDirectories,
   setupEnvFile,
@@ -5438,8 +5237,6 @@ export {
   configSchema,
   resolveConfigPaths,
   loadEnvironment,
-  mergeProcessEnvWithTemplate,
-  formatEnvFileWithTemplate,
   getPackageVersion,
   getLocalPackages,
   getPackageInfo,
@@ -5484,6 +5281,7 @@ export {
   pushToGitHub,
   handleError,
   checkServer,
+  getDisplayDirectory,
   displayAgent,
   logHeader,
   detectPluginContext,