@elizaos/cli 1.3.0 → 1.3.2

package/dist/{chunk-2ALAPQLV.js → chunk-E6XYTE3A.js}

@@ -4,9 +4,10 @@ import {
   runBunCommand
 } from "./chunk-FDEDLANP.js";
 import {
+  createApiClientConfig,
   getAgentRuntimeUrl,
-  getAgentsBaseUrl
-} from "./chunk-4O6EZU37.js";
+  getAuthHeaders
+} from "./chunk-GXWWPFBO.js";
 import {
   bunExec,
   bunExecInherit,
@@ -2761,7 +2762,7 @@ async function getGitHubCredentials() {
     }
     logger10.warn("Invalid GitHub token found in environment variables");
   }
-  const { getGitHubToken: getGitHubToken2 } = await import("./registry-N626N4VG.js");
+  const { getGitHubToken: getGitHubToken2 } = await import("./registry-433S5F3Y.js");
   const token = await getGitHubToken2() || void 0;
   if (token) {
     const isValid2 = await validateGitHubToken(token);
@@ -3057,38 +3058,34 @@ async function pushToGitHub(cwd, repoUrl, branch = "main") {
 }
 
 // src/utils/handle-error.ts
-import { logger as logger13 } from "@elizaos/core";
+import { logger as logger12 } from "@elizaos/core";
 
 // src/commands/agent/index.ts
 import { Command } from "commander";
 
 // src/commands/agent/actions/crud.ts
-import { logger as logger11 } from "@elizaos/core";
-import { writeFileSync, readFileSync as readFileSync5 } from "fs";
+import { AgentsService as AgentsService2, MemoryService } from "@elizaos/api-client";
+import { asUUID } from "@elizaos/core";
+import { readFileSync as readFileSync5, writeFileSync } from "fs";
 import path11 from "path";
 
 // src/commands/agent/utils/validation.ts
 import { z as z2 } from "zod";
+import { AgentsService } from "@elizaos/api-client";
 var AgentBasicSchema = z2.object({
   id: z2.string(),
   name: z2.string(),
   status: z2.string().optional()
 }).passthrough();
 var AgentsListResponseSchema = z2.object({
-  success: z2.boolean(),
-  data: z2.object({
-    agents: z2.array(AgentBasicSchema)
-  }).optional()
+  agents: z2.array(AgentBasicSchema)
 });
 async function getAgents(opts) {
-  const baseUrl = getAgentsBaseUrl(opts);
-  const response = await fetch(baseUrl);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch agents list: ${response.statusText}`);
-  }
-  const rawData = await response.json();
-  const validatedData = AgentsListResponseSchema.parse(rawData);
-  return validatedData.data?.agents || [];
+  const config = createApiClientConfig(opts);
+  const agentsService = new AgentsService(config);
+  const result = await agentsService.listAgents();
+  const validatedData = AgentsListResponseSchema.parse(result);
+  return validatedData.agents;
 }
 async function resolveAgentId(idOrNameOrIndex, opts) {
   const agents = await getAgents(opts);
@@ -3138,33 +3135,21 @@ async function listAgents(opts) {
 }
 
 // src/commands/agent/actions/crud.ts
-async function safeJsonParse(response) {
-  try {
-    return await response.json();
-  } catch (error) {
-    console.error("Failed to parse response as JSON:", error);
-    return null;
-  }
-}
-async function handleErrorResponse(response, defaultMessage) {
-  const errorData = await safeJsonParse(response);
-  throw new Error(errorData?.error?.message || defaultMessage);
-}
 async function getAgent(opts) {
   try {
     const resolvedAgentId = await resolveAgentId(opts.name, opts);
-    const baseUrl = getAgentsBaseUrl(opts);
+    const config = createApiClientConfig(opts);
+    const agentsService = new AgentsService2(config);
     console.info(`Getting agent ${resolvedAgentId}`);
-    const response = await fetch(`${baseUrl}/${resolvedAgentId}`);
-    if (!response.ok) {
-      logger11.error(`Failed to get agent`);
-      process.exit(1);
-    }
-    const responseData = await safeJsonParse(response);
-    if (!responseData) {
-      throw new Error("Failed to parse agent data from server response");
+    let agentId;
+    try {
+      agentId = asUUID(resolvedAgentId);
+    } catch (error) {
+      throw new Error(
+        `Invalid agent ID format: ${resolvedAgentId}. Please provide a valid UUID, agent name, or index.`
+      );
     }
-    const agent2 = responseData.data;
+    const agent2 = await agentsService.getAgent(agentId);
     if (!agent2) {
       throw new Error("No agent data received from server");
     }
@@ -3190,14 +3175,18 @@ async function getAgent(opts) {
 async function removeAgent(opts) {
   try {
     const resolvedAgentId = await resolveAgentId(opts.name, opts);
-    const baseUrl = getAgentsBaseUrl(opts);
+    const config = createApiClientConfig(opts);
+    const agentsService = new AgentsService2(config);
     console.info(`Removing agent ${resolvedAgentId}`);
-    const response = await fetch(`${baseUrl}/${resolvedAgentId}`, {
-      method: "DELETE"
-    });
-    if (!response.ok) {
-      await handleErrorResponse(response, `Failed to remove agent: ${response.statusText}`);
+    let agentId;
+    try {
+      agentId = asUUID(resolvedAgentId);
+    } catch (error) {
+      throw new Error(
+        `Invalid agent ID format: ${resolvedAgentId}. Please provide a valid UUID, agent name, or index.`
+      );
     }
+    await agentsService.deleteAgent(agentId);
     console.log(`Successfully removed agent ${opts.name}`);
     return;
   } catch (error) {
@@ -3208,19 +3197,19 @@ async function removeAgent(opts) {
 async function clearAgentMemories(opts) {
   try {
     const resolvedAgentId = await resolveAgentId(opts.name, opts);
-    const baseUrl = getAgentsBaseUrl(opts);
+    const config = createApiClientConfig(opts);
+    const memoryService = new MemoryService(config);
     console.info(`Clearing all memories for agent ${resolvedAgentId}`);
-    const response = await fetch(`${baseUrl}/${resolvedAgentId}/memories`, {
-      method: "DELETE"
-    });
-    if (!response.ok) {
-      await handleErrorResponse(response, `Failed to clear agent memories: ${response.statusText}`);
+    let agentId;
+    try {
+      agentId = asUUID(resolvedAgentId);
+    } catch (error) {
+      throw new Error(
+        `Invalid agent ID format: ${resolvedAgentId}. Please provide a valid UUID, agent name, or index.`
+      );
     }
-    const data = await safeJsonParse(response);
-    const result = data?.data || null;
-    console.log(
-      `Successfully cleared ${result?.deletedCount || 0} memories for agent ${opts.name}`
-    );
+    const result = await memoryService.clearAgentMemories(agentId);
+    console.log(`Successfully cleared ${result?.deleted || 0} memories for agent ${opts.name}`);
     return;
   } catch (error) {
     await checkServer(opts);
@@ -3251,20 +3240,20 @@ async function setAgentConfig(opts) {
     } else {
       throw new Error("Please provide either a config JSON string (-c) or a config file path (-f)");
     }
-    const response = await fetch(`${getAgentsBaseUrl(opts)}/${resolvedAgentId}`, {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(config)
-    });
-    if (!response.ok) {
-      await handleErrorResponse(
-        response,
-        `Failed to update agent configuration: ${response.statusText}`
+    const clientConfig = createApiClientConfig(opts);
+    const agentsService = new AgentsService2(clientConfig);
+    let agentId;
+    try {
+      agentId = asUUID(resolvedAgentId);
+    } catch (error) {
+      throw new Error(
+        `Invalid agent ID format: ${resolvedAgentId}. Please provide a valid UUID, agent name, or index.`
       );
     }
-    const data = await safeJsonParse(response);
-    const result = data?.data || null;
-    console.log(`Successfully updated configuration for agent ${result?.id || resolvedAgentId}`);
+    const updatedAgent = await agentsService.updateAgent(agentId, config);
+    console.log(
+      `Successfully updated configuration for agent ${updatedAgent?.id || resolvedAgentId}`
+    );
   } catch (error) {
     await checkServer(opts);
     handleError(error);
@@ -3272,10 +3261,13 @@ async function setAgentConfig(opts) {
 }
 
 // src/commands/agent/actions/lifecycle.ts
-import { logger as logger12 } from "@elizaos/core";
+import { logger as logger11, asUUID as asUUID2 } from "@elizaos/core";
 import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
 import path12 from "path";
+import { AgentsService as AgentsService3 } from "@elizaos/api-client";
 async function startAgent(options) {
+  const config = createApiClientConfig(options);
+  const agentsService = new AgentsService3(config);
   try {
     const hasValidInput = options.path || options.remoteCharacter || options.name && options.name !== true && options.name !== "";
     if (!hasValidInput) {
@@ -3296,26 +3288,17 @@ async function startAgent(options) {
     }
     const response = await (async () => {
       const payload = {};
-      const headers = { "Content-Type": "application/json" };
-      const baseUrl = getAgentsBaseUrl(options);
       let characterName = null;
       async function createCharacter(payload2) {
-        const response2 = await fetch(baseUrl, {
-          method: "POST",
-          headers,
-          body: JSON.stringify(payload2)
-        });
-        if (!response2.ok) {
-          const errorText = await response2.text();
-          logger12.error(`Server returned ${response2.status}: ${errorText}`);
-          return null;
-        }
-        const data2 = await response2.json();
-        if (!data2?.data?.character?.name) {
-          logger12.error(`Unexpected response format:`, data2);
+        try {
+          const agent2 = await agentsService.createAgent(payload2);
+          return agent2.name || agent2.id;
+        } catch (error) {
+          logger11.error(
+            `Failed to create agent: ${error instanceof Error ? error.message : String(error)}`
+          );
           return null;
         }
-        return data2.data.character.name;
       }
       if (options.path) {
         try {
@@ -3327,7 +3310,7 @@ async function startAgent(options) {
           payload.characterJson = JSON.parse(fileContent);
           characterName = await createCharacter(payload);
           if (!characterName) {
-            logger12.error("Failed to create character from file. Check server logs for details.");
+            logger11.error("Failed to create character from file. Check server logs for details.");
           }
         } catch (error) {
           console.error("Error reading or parsing local JSON file:", error);
@@ -3344,7 +3327,7 @@ async function startAgent(options) {
         payload.characterPath = options.remoteCharacter;
         characterName = await createCharacter(payload);
         if (!characterName) {
-          logger12.error(
+          logger11.error(
             "Failed to create character from remote URL. Check server logs for details."
           );
         }
@@ -3355,20 +3338,18 @@ async function startAgent(options) {
       if (characterName) {
         try {
           const agentId = await resolveAgentId(characterName, options);
-          return await fetch(`${baseUrl}/${agentId}/start`, {
-            method: "POST",
-            headers
-          });
+          const result2 = await agentsService.startAgent(asUUID2(agentId));
+          return { ok: true, json: async () => ({ data: result2 }) };
         } catch (error) {
           throw error;
         }
       }
-      return await fetch(baseUrl, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({})
-        // Empty body for default agent start
-      });
+      try {
+        const agent2 = await agentsService.createAgent({});
+        return { ok: true, json: async () => ({ data: agent2 }) };
+      } catch (error) {
+        throw error;
+      }
     })();
     if (!response.ok) {
       let errorData = null;
@@ -3424,6 +3405,8 @@ You can create a new agent with: elizaos create -t agent ${agentName.toLowerCase
   }
 }
 async function stopAgent(opts) {
+  const config = createApiClientConfig(opts);
+  const agentsService = new AgentsService3(config);
   try {
     const hasValidName = opts.name && opts.name !== true && opts.name !== "";
     if (!hasValidName && !opts.all) {
@@ -3434,11 +3417,11 @@ async function stopAgent(opts) {
       process.exit(1);
     }
     if (opts.all) {
-      logger12.info("Stopping all ElizaOS agents...");
+      logger11.info("Stopping all ElizaOS agents...");
       if (process.platform === "win32") {
-        logger12.error("The --all flag requires Unix-like commands (pgrep, kill).");
-        logger12.error("On Windows, please use WSL 2 or stop agents individually with --name.");
-        logger12.error("See: https://learn.microsoft.com/en-us/windows/wsl/install-manual");
+        logger11.error("The --all flag requires Unix-like commands (pgrep, kill).");
+        logger11.error("On Windows, please use WSL 2 or stop agents individually with --name.");
+        logger11.error("See: https://learn.microsoft.com/en-us/windows/wsl/install-manual");
         process.exit(1);
       }
       try {
@@ -3458,9 +3441,9 @@ async function stopAgent(opts) {
           } catch (pgrepError) {
           }
         }
-        logger12.success("All ElizaOS agents stopped successfully!");
+        logger11.success("All ElizaOS agents stopped successfully!");
       } catch (error) {
-        logger12.error(
+        logger11.error(
           `Error stopping processes: ${error instanceof Error ? error.message : String(error)}`
         );
         process.exit(1);
@@ -3468,14 +3451,9 @@ async function stopAgent(opts) {
       return;
     }
     const resolvedAgentId = await resolveAgentId(opts.name, opts);
-    const baseUrl = getAgentsBaseUrl(opts);
     console.info(`Stopping agent ${resolvedAgentId}`);
-    const response = await fetch(`${baseUrl}/${resolvedAgentId}/stop`, { method: "POST" });
-    if (!response.ok) {
-      const errorData = await response.json();
-      throw new Error(errorData.error?.message || `Failed to stop agent: ${response.statusText}`);
-    }
-    logger12.success(`Successfully stopped agent ${opts.name}`);
+    await agentsService.stopAgent(asUUID2(resolvedAgentId));
+    logger11.success(`Successfully stopped agent ${opts.name}`);
     console.log(`Agent ${opts.name} stopped successfully!`);
   } catch (error) {
     await checkServer(opts);
@@ -3485,9 +3463,9 @@ async function stopAgent(opts) {
 
 // src/commands/agent/index.ts
 var agent = new Command().name("agent").description("Manage ElizaOS agents");
-agent.command("list").alias("ls").description("List available agents").option("-j, --json", "output as JSON").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).action(listAgents);
-agent.command("get").alias("g").description("Get agent details").requiredOption("-n, --name <name>", "agent id, name, or index number from list").option("-j, --json", "display agent configuration as JSON in the console").option("-o, --output [file]", "save agent config to JSON (defaults to {name}.json)").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).action(getAgent);
-agent.command("start").alias("s").description("Start an agent with a character profile").option("-n, --name <name>", "Name of an existing agent to start").option("--path <path>", "Path to local character JSON file").option("--remote-character <url>", "URL to remote character JSON file").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).addHelpText(
+agent.command("list").alias("ls").description("List available agents").option("-j, --json", "output as JSON").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).option("--auth-token <token>", "API authentication token").action(listAgents);
+agent.command("get").alias("g").description("Get agent details").requiredOption("-n, --name <name>", "agent id, name, or index number from list").option("-j, --json", "display agent configuration as JSON in the console").option("-o, --output [file]", "save agent config to JSON (defaults to {name}.json)").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).option("--auth-token <token>", "API authentication token").action(getAgent);
+agent.command("start").alias("s").description("Start an agent with a character profile").option("-n, --name <name>", "Name of an existing agent to start").option("--path <path>", "Path to local character JSON file").option("--remote-character <url>", "URL to remote character JSON file").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).option("--auth-token <token>", "API authentication token").addHelpText(
   "after",
   `
 Examples:
@@ -3520,46 +3498,49 @@ Required configuration:
     throw error;
   }
 });
-agent.command("stop").alias("st").description("Stop an agent").option("-n, --name <name>", "agent id, name, or index number from list").option("--all", "stop all running agents").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).action(stopAgent);
-agent.command("remove").alias("rm").description("Remove 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(removeAgent);
-agent.command("set").description("Update agent configuration").requiredOption("-n, --name <name>", "agent id, name, or index number from list").option("-c, --config <json>", "agent configuration as JSON string").option("-f, --file <path>", "path to agent configuration JSON file").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).action(setAgentConfig);
-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);
+agent.command("stop").alias("st").description("Stop an agent").option("-n, --name <name>", "agent id, name, or index number from list").option("--all", "stop all running agents").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).option("--auth-token <token>", "API authentication token").action(stopAgent);
+agent.command("remove").alias("rm").description("Remove 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)).option("--auth-token <token>", "API authentication token").action(removeAgent);
+agent.command("set").description("Update agent configuration").requiredOption("-n, --name <name>", "agent id, name, or index number from list").option("-c, --config <json>", "agent configuration as JSON string").option("-f, --file <path>", "path to agent configuration JSON file").option("-r, --remote-url <url>", "URL of the remote agent runtime").option("-p, --port <port>", "Port to listen on", (val) => Number.parseInt(val)).option("--auth-token <token>", "API authentication token").action(setAgentConfig);
+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)).option("--auth-token <token>", "API authentication token").action(clearAgentMemories);
 
 // src/utils/handle-error.ts
 import colors3 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(
+    logger12.error(
       colors3.red("ERROR: No space left on device! Please free up disk space and try again.")
     );
     if (error instanceof Error) {
-      logger13.error(colors3.red(error.message));
-      logger13.error(colors3.red(error.stack || ""));
+      logger12.error(colors3.red(error.message));
+      logger12.error(colors3.red(error.stack || ""));
     } else {
-      logger13.error(colors3.red(String(error)));
+      logger12.error(colors3.red(String(error)));
     }
   } else {
-    logger13.error("An error occurred:", error);
+    logger12.error("An error occurred:", error);
     if (error instanceof Error) {
-      logger13.error("Error details:", error.message);
-      logger13.error("Stack trace:", error.stack);
+      logger12.error("Error details:", error.message);
+      logger12.error("Stack trace:", error.stack);
     } else {
-      logger13.error("Unknown error type:", typeof error);
-      logger13.error("Error value:", error);
+      logger12.error("Unknown error type:", typeof error);
+      logger12.error("Error value:", error);
     }
   }
   process.exit(1);
 }
 async function checkServer(opts) {
   try {
-    const response = await fetch(`${getAgentRuntimeUrl(opts)}/api/agents`);
+    const authHeaders = getAuthHeaders(opts);
+    const response = await fetch(`${getAgentRuntimeUrl(opts)}/api/agents`, {
+      headers: authHeaders
+    });
     if (!response.ok) {
       throw new Error(`Server responded with ${response.status}: ${response.statusText}`);
     }
-    logger13.success("ElizaOS server is running");
+    logger12.success("ElizaOS server is running");
   } catch (error) {
-    logger13.error("Unable to connect to ElizaOS server, likely not running or not accessible!");
+    logger12.error("Unable to connect to ElizaOS server, likely not running or not accessible!");
     process.exit(1);
   }
 }
@@ -3633,17 +3614,17 @@ ${bottomBorder}`);
 }
 
 // src/utils/install-plugin.ts
-import { logger as logger18 } from "@elizaos/core";
+import { logger as logger17 } from "@elizaos/core";
 import { existsSync as existsSync14 } from "fs";
 import path17 from "path";
 
 // src/utils/load-plugin.ts
-import { logger as logger15 } from "@elizaos/core";
+import { logger as logger14 } from "@elizaos/core";
 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 { logger as logger13 } from "@elizaos/core";
 import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
 import path14 from "path";
 function normalizeForComparison(name) {
@@ -3661,7 +3642,7 @@ function detectPluginContext(pluginName) {
   try {
     packageInfo = JSON.parse(readFileSync7(packageJsonPath, "utf-8"));
   } catch (error) {
-    logger14.debug(`Failed to parse package.json: ${error}`);
+    logger13.debug(`Failed to parse package.json: ${error}`);
     return { isLocalDevelopment: false };
   }
   const normalizedRequestedPlugin = normalizeForComparison(pluginName);
@@ -3673,9 +3654,9 @@ function detectPluginContext(pluginName) {
     const mainEntry = packageInfo.main || "dist/index.js";
     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}`);
+    logger13.debug(`Detected local plugin development: ${pluginName}`);
+    logger13.debug(`Expected output: ${localPath}`);
+    logger13.debug(`Needs build: ${needsBuild}`);
     return {
       isLocalDevelopment: true,
       localPath,
@@ -3691,41 +3672,41 @@ async function ensurePluginBuilt(context) {
   }
   const { packageInfo, localPath } = context;
   if (packageInfo.scripts?.build) {
-    logger14.info("Plugin not built, attempting to build...");
+    logger13.info("Plugin not built, attempting to build...");
     try {
       await buildProject(process.cwd(), true);
       if (localPath && existsSync11(localPath)) {
-        logger14.success("Plugin built successfully");
+        logger13.success("Plugin built successfully");
         return true;
       } else {
-        logger14.error(`Build completed but expected output not found: ${localPath}`);
+        logger13.error(`Build completed but expected output not found: ${localPath}`);
         return false;
       }
     } catch (error) {
-      logger14.error(`Build failed: ${error}`);
+      logger13.error(`Build failed: ${error}`);
       return false;
     }
   }
-  logger14.error(`Plugin not built and no build script found in package.json`);
-  logger14.info(`Add a "build" script to package.json or run 'bun run build' manually`);
+  logger13.error(`Plugin not built and no build script found in package.json`);
+  logger13.info(`Add a "build" script to package.json or run 'bun run build' manually`);
   return false;
 }
 function provideLocalPluginGuidance(pluginName, context) {
   if (!context.isLocalDevelopment) {
     return;
   }
-  logger14.info(`
+  logger13.info(`
 Local plugin development detected for: ${pluginName}`);
   if (context.needsBuild) {
-    logger14.info("To fix this issue:");
-    logger14.info("1. Build the plugin: bun run build");
-    logger14.info("2. Verify the output exists at: " + context.localPath);
-    logger14.info("3. Re-run the test command");
+    logger13.info("To fix this issue:");
+    logger13.info("1. Build the plugin: bun run build");
+    logger13.info("2. Verify the output exists at: " + context.localPath);
+    logger13.info("3. Re-run the test command");
   } else {
-    logger14.info("Plugin appears to be built but failed to load.");
-    logger14.info("Try rebuilding: bun run build");
+    logger13.info("Plugin appears to be built but failed to load.");
+    logger13.info("Try rebuilding: bun run build");
   }
-  logger14.info("\nFor more information, see the plugin development guide.");
+  logger13.info("\nFor more information, see the plugin development guide.");
 }
 
 // src/utils/load-plugin.ts
@@ -3780,7 +3761,7 @@ async function readPackageJson(repository) {
       return JSON.parse(readFileSync8(packageJsonPath, "utf-8"));
     }
   } catch (error) {
-    logger15.debug(`Failed to read package.json for '${repository}':`, error);
+    logger14.debug(`Failed to read package.json for '${repository}':`, error);
   }
   return null;
 }
@@ -3799,10 +3780,10 @@ async function tryImporting(importPath, strategy, repository) {
   try {
     const pathToImport = normalizeImportPath(importPath);
     const module = await import(pathToImport);
-    logger15.success(`Successfully loaded plugin '${repository}' using ${strategy} (${importPath})`);
+    logger14.success(`Successfully loaded plugin '${repository}' using ${strategy} (${importPath})`);
     return module;
   } catch (error) {
-    logger15.debug(`Import failed using ${strategy} ('${importPath}'):`, error);
+    logger14.debug(`Import failed using ${strategy} ('${importPath}'):`, error);
     return null;
   }
 }
@@ -3813,17 +3794,17 @@ var importStrategies = [
     tryImport: async (repository) => {
       const context = detectPluginContext(repository);
       if (context.isLocalDevelopment) {
-        logger15.debug(`Detected local development for plugin: ${repository}`);
+        logger14.debug(`Detected local development for plugin: ${repository}`);
         const isBuilt = await ensurePluginBuilt(context);
         if (!isBuilt) {
           provideLocalPluginGuidance(repository, context);
           return null;
         }
         if (context.localPath && existsSync12(context.localPath)) {
-          logger15.info(`Loading local development plugin: ${repository}`);
+          logger14.info(`Loading local development plugin: ${repository}`);
           return tryImporting(context.localPath, "local development plugin", repository);
         }
-        logger15.warn(`Plugin built but output not found at expected path: ${context.localPath}`);
+        logger14.warn(`Plugin built but output not found at expected path: ${context.localPath}`);
         provideLocalPluginGuidance(repository, context);
         return null;
       }
@@ -3857,7 +3838,7 @@ var importStrategies = [
     tryImport: async (repository) => {
       const globalPath = path15.resolve(getGlobalNodeModulesPath(), repository);
       if (!existsSync12(path15.dirname(globalPath))) {
-        logger15.debug(
+        logger14.debug(
           `Global node_modules directory not found at ${path15.dirname(globalPath)}, skipping for ${repository}`
         );
         return null;
@@ -3907,23 +3888,23 @@ function getStrategiesForPlugin(repository) {
 async function loadPluginModule(repository) {
   const isElizaOS = isElizaOSPackageName(repository);
   const strategies = getStrategiesForPlugin(repository);
-  logger15.debug(
+  logger14.debug(
     `Loading ${isElizaOS ? "ElizaOS" : "third-party"} plugin: ${repository} (${strategies.length} strategies)`
   );
   for (const strategy of strategies) {
     const result = await strategy.tryImport(repository);
     if (result) return result;
   }
-  logger15.warn(`Failed to load plugin module '${repository}' using all relevant strategies.`);
+  logger14.warn(`Failed to load plugin module '${repository}' using all relevant strategies.`);
   return null;
 }
 
 // src/utils/package-manager.ts
-import { logger as logger16 } from "@elizaos/core";
+import { logger as logger15 } from "@elizaos/core";
 import { existsSync as existsSync13 } from "fs";
 import path16 from "path";
 async function getPackageManager() {
-  logger16.debug("[PackageManager] Using bun as the package manager for ElizaOS CLI");
+  logger15.debug("[PackageManager] Using bun as the package manager for ElizaOS CLI");
   return "bun";
 }
 async function isGlobalInstallation() {
@@ -3944,7 +3925,7 @@ function getInstallCommand(isGlobal) {
 async function removeFromBunLock(packageName, directory) {
   const lockFilePath = path16.join(directory, "bun.lock");
   if (!existsSync13(lockFilePath)) {
-    logger16.debug(`No bun.lock file found at ${lockFilePath}, skipping removal`);
+    logger15.debug(`No bun.lock file found at ${lockFilePath}, skipping removal`);
     return;
   }
   try {
@@ -3952,18 +3933,18 @@ async function removeFromBunLock(packageName, directory) {
       cwd: directory
     });
     if (result.success) {
-      logger16.debug(`Successfully removed ${packageName} from bun.lock`);
+      logger15.debug(`Successfully removed ${packageName} from bun.lock`);
     } else {
       if (result.stderr?.includes("not found") || result.stderr?.includes("No such package")) {
-        logger16.debug(`Package ${packageName} not found in lockfile (expected for cleanup)`);
+        logger15.debug(`Package ${packageName} not found in lockfile (expected for cleanup)`);
       } else {
-        logger16.warn(
+        logger15.warn(
           `Failed to remove ${packageName} from bun.lock: ${result.stderr || "Unknown error"}`
         );
       }
     }
   } catch (error) {
-    logger16.warn(`Unexpected error removing ${packageName} from bun.lock: ${error.message}`);
+    logger15.warn(`Unexpected error removing ${packageName} from bun.lock: ${error.message}`);
   }
 }
 async function executeInstallation(packageName, versionOrTag = "", directory = process.cwd()) {
@@ -3981,11 +3962,11 @@ async function executeInstallation(packageName, versionOrTag = "", directory = p
     return { success: true, installedIdentifier };
   } catch (error) {
     if (error.code === "ENOENT" || error.message?.includes("bun: command not found")) {
-      logger16.warn(
+      logger15.warn(
         `Installation failed - bun command not found. ${displayBunInstallationTipCompact()}`
       );
     } else {
-      logger16.warn(`Installation failed for ${finalSpecifier}: ${error.message}`);
+      logger15.warn(`Installation failed for ${finalSpecifier}: ${error.message}`);
     }
     return { success: false, installedIdentifier: null };
   }
@@ -4002,21 +3983,21 @@ async function executeInstallationWithFallback(packageName, versionOrTag = "", d
   if (result.success || !githubFallback) {
     return result;
   }
-  logger16.debug(`npm installation failed, attempting GitHub fallback: ${githubFallback}`);
+  logger15.debug(`npm installation failed, attempting GitHub fallback: ${githubFallback}`);
   await removeFromBunLock(packageName, directory);
   const githubSpecifier = `github:${githubFallback}${versionOrTag ? `#${versionOrTag}` : ""}`;
   return await executeInstallation(githubSpecifier, "", directory);
 }
 
 // src/utils/plugin-discovery.ts
-import { logger as logger17 } from "@elizaos/core";
+import { logger as logger16 } from "@elizaos/core";
 async function fetchPluginRegistry() {
   try {
     const resp = await fetch(
       "https://raw.githubusercontent.com/elizaos-plugins/registry/refs/heads/main/generated-registry.json"
     );
     if (!resp.ok) {
-      logger17.error(`Failed to fetch plugin registry: ${resp.statusText}`);
+      logger16.error(`Failed to fetch plugin registry: ${resp.statusText}`);
       throw new Error(`Failed to fetch registry: ${resp.statusText}`);
     }
     const raw = await resp.json();
@@ -4040,54 +4021,54 @@ function getCliDirectory() {
     }
     return null;
   } catch (error) {
-    logger18.error("Failed to determine CLI directory:", error);
+    logger17.error("Failed to determine CLI directory:", error);
     return null;
   }
 }
 async function verifyPluginImport(repository, context) {
   const loadedModule = await loadPluginModule(repository);
   if (loadedModule) {
-    logger18.debug(`Successfully verified plugin ${repository} ${context} after installation.`);
+    logger17.debug(`Successfully verified plugin ${repository} ${context} after installation.`);
     return true;
   } else {
-    logger18.warn(`Plugin ${repository} installed ${context} but could not be loaded/verified.`);
+    logger17.warn(`Plugin ${repository} installed ${context} but could not be loaded/verified.`);
     return false;
   }
 }
 async function attemptInstallation(packageName, versionString, directory, context, skipVerification = false) {
-  logger18.debug(`Attempting to install plugin ${context}...`);
+  logger17.debug(`Attempting to install plugin ${context}...`);
   try {
     const installResult = await executeInstallation(packageName, versionString, directory);
     if (!installResult.success || !installResult.installedIdentifier) {
-      logger18.warn(`Installation failed for plugin ${context}`);
+      logger17.warn(`Installation failed for plugin ${context}`);
       return false;
     }
     if (packageName.startsWith("github:")) {
       return true;
     }
     if (skipVerification || process.env.ELIZA_SKIP_PLUGIN_VERIFY) {
-      logger18.info(
+      logger17.info(
         `Installation successful for ${installResult.installedIdentifier}, skipping verification`
       );
       return true;
     }
-    logger18.debug(
+    logger17.debug(
       `Installation successful for ${installResult.installedIdentifier}, verifying import...`
     );
     return await verifyPluginImport(installResult.installedIdentifier, context);
   } catch (installError) {
-    logger18.warn(
+    logger17.warn(
       `Error during installation attempt ${context}: ${installError instanceof Error ? installError.message : String(installError)}`
     );
     return false;
   }
 }
 async function installPlugin(packageName, cwd, versionSpecifier, skipVerification = false) {
-  logger18.debug(`Installing plugin: ${packageName}`);
+  logger17.debug(`Installing plugin: ${packageName}`);
   const context = detectPluginContext(packageName);
   if (context.isLocalDevelopment) {
-    logger18.warn(`Prevented self-installation of plugin ${packageName}`);
-    logger18.info(
+    logger17.warn(`Prevented self-installation of plugin ${packageName}`);
+    logger17.info(
       `You're developing this plugin locally. Use 'bun run build' to build it instead of installing.`
     );
     return false;
@@ -4129,7 +4110,7 @@ async function installPlugin(packageName, cwd, versionSpecifier, skipVerificatio
     }
   }
   if (!key) {
-    logger18.warn(
+    logger17.warn(
       `Plugin ${packageName} not found in registry cache, attempting direct installation`
     );
     return await attemptInstallation(
@@ -4173,7 +4154,7 @@ async function installPlugin(packageName, cwd, versionSpecifier, skipVerificatio
     const spec = `github:${info.git.repo}${githubVersion ? `#${githubVersion}` : ""}`;
     return await attemptInstallation(spec, "", cliDir, "in CLI directory", skipVerification);
   }
-  logger18.error(`Failed to install plugin ${packageName}`);
+  logger17.error(`Failed to install plugin ${packageName}`);
   return false;
 }
 
@@ -4181,7 +4162,7 @@ async function installPlugin(packageName, cwd, versionSpecifier, skipVerificatio
 import { spawn } from "child_process";
 import { existsSync as existsSync15 } from "fs";
 import path18 from "path";
-import { logger as logger19 } from "@elizaos/core";
+import { logger as logger18 } from "@elizaos/core";
 function isRunningFromLocalCli() {
   try {
     const currentScriptPath = process.argv[1];
@@ -4197,7 +4178,7 @@ function isRunningFromLocalCli() {
     const isInLocalCli = path18.resolve(currentScriptPath) === path18.resolve(expectedLocalCliPath);
     return isInLocalCli;
   } catch (error) {
-    logger19.debug("Error checking if running from local CLI:", error);
+    logger18.debug("Error checking if running from local CLI:", error);
     return false;
   }
 }
@@ -4235,7 +4216,7 @@ function setupLocalEnvironment() {
 }
 async function delegateToLocalCli(localCliPath) {
   return new Promise((resolve2, reject) => {
-    logger19.info("Using local @elizaos/cli installation");
+    logger18.info("Using local @elizaos/cli installation");
     const nodeExecutable = process.execPath;
     const args = process.argv.slice(2);
     const env = setupLocalEnvironment();
@@ -4255,7 +4236,7 @@ async function delegateToLocalCli(localCliPath) {
       resolve2();
     });
     childProcess.on("error", (error) => {
-      logger19.error(`Failed to start local CLI: ${error.message}`);
+      logger18.error(`Failed to start local CLI: ${error.message}`);
       reject(error);
     });
     const forwardSignal = (signal) => {
@@ -4305,27 +4286,31 @@ function isTestOrCiEnvironment() {
 async function tryDelegateToLocalCli() {
   try {
     if (isTestOrCiEnvironment()) {
-      logger19.debug("Running in test or CI environment, skipping local CLI delegation");
+      logger18.debug("Running in test or CI environment, skipping local CLI delegation");
       return false;
     }
     const args = process.argv.slice(2);
     if (args.length > 0 && args[0] === "update") {
-      logger19.debug("Update command detected, skipping local CLI delegation");
+      logger18.debug("Update command detected, skipping local CLI delegation");
+      return false;
+    }
+    if (args.length > 0 && (args[0] === "-v" || args[0] === "--version")) {
+      logger18.debug("Version command detected, skipping local CLI delegation");
       return false;
     }
     if (isRunningFromLocalCli()) {
-      logger19.debug("Already running from local CLI, continuing execution");
+      logger18.debug("Already running from local CLI, continuing execution");
       return false;
     }
     const localCliPath = getLocalCliPath();
     if (!localCliPath) {
-      logger19.debug("No local CLI found, using global installation");
+      logger18.debug("No local CLI found, using global installation");
       return false;
     }
     if (process.env._ELIZA_CLI_DELEGATION_DEPTH) {
       const depth = parseInt(process.env._ELIZA_CLI_DELEGATION_DEPTH, 10);
       if (depth > 0) {
-        logger19.debug("Delegation depth exceeded, preventing infinite loop");
+        logger18.debug("Delegation depth exceeded, preventing infinite loop");
         return false;
       }
     }
@@ -4333,8 +4318,8 @@ async function tryDelegateToLocalCli() {
     await delegateToLocalCli(localCliPath);
     return true;
   } catch (error) {
-    logger19.error("Error during local CLI delegation:", error);
-    logger19.info("Falling back to global CLI installation");
+    logger18.error("Error during local CLI delegation:", error);
+    logger18.info("Falling back to global CLI installation");
     return false;
   }
 }
@@ -4353,7 +4338,7 @@ function getCliContext() {
 // src/utils/module-loader.ts
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
-import { logger as logger20 } from "@elizaos/core";
+import { logger as logger19 } from "@elizaos/core";
 import path19 from "path";
 import { existsSync as existsSync16 } from "fs";
 var ModuleLoader = class {
@@ -4372,10 +4357,10 @@ var ModuleLoader = class {
   detectProjectPath() {
     const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
     if (monorepoRoot) {
-      logger20.debug(`Using monorepo root: ${monorepoRoot}`);
+      logger19.debug(`Using monorepo root: ${monorepoRoot}`);
       return monorepoRoot;
     }
-    logger20.debug(`Using current working directory: ${process.cwd()}`);
+    logger19.debug(`Using current working directory: ${process.cwd()}`);
     return process.cwd();
   }
   /**
@@ -4388,29 +4373,29 @@ var ModuleLoader = class {
    */
   async load(moduleName) {
     if (this.asyncCache.has(moduleName)) {
-      logger20.debug(`Using cached module: ${moduleName}`);
+      logger19.debug(`Using cached module: ${moduleName}`);
       return this.asyncCache.get(moduleName);
     }
     try {
       const localModulePath = path19.join(this.projectPath, "node_modules", moduleName);
       const isLocalModule = existsSync16(localModulePath);
       if (isLocalModule) {
-        logger20.info(`Using local ${moduleName} installation`);
+        logger19.info(`Using local ${moduleName} installation`);
       } else {
-        logger20.info(`Using global ${moduleName} installation`);
+        logger19.info(`Using global ${moduleName} installation`);
       }
       const modulePath = this.require.resolve(moduleName);
-      logger20.debug(`Loading ${moduleName} from: ${modulePath}`);
+      logger19.debug(`Loading ${moduleName} from: ${modulePath}`);
       if (isLocalModule && !modulePath.includes(this.projectPath)) {
-        logger20.warn(`Expected local module but resolved to global: ${modulePath}`);
+        logger19.warn(`Expected local module but resolved to global: ${modulePath}`);
       }
       const module = await import(pathToFileURL(modulePath).href);
       this.asyncCache.set(moduleName, module);
-      logger20.info(`Loaded ${moduleName} from ${isLocalModule ? "local" : "global"} installation`);
+      logger19.info(`Loaded ${moduleName} from ${isLocalModule ? "local" : "global"} installation`);
       return module;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger20.error(`Failed to load module ${moduleName}: ${errorMessage}`);
+      logger19.error(`Failed to load module ${moduleName}: ${errorMessage}`);
       throw new Error(
         `Cannot find module '${moduleName}' in project at ${this.projectPath}.
 Please ensure it's installed by running:
@@ -4430,29 +4415,29 @@ Original error: ${errorMessage}`
    */
   loadSync(moduleName) {
     if (this.syncCache.has(moduleName)) {
-      logger20.debug(`Using cached module: ${moduleName}`);
+      logger19.debug(`Using cached module: ${moduleName}`);
       return this.syncCache.get(moduleName);
     }
     try {
       const localModulePath = path19.join(this.projectPath, "node_modules", moduleName);
       const isLocalModule = existsSync16(localModulePath);
       if (isLocalModule) {
-        logger20.info(`Using local ${moduleName} installation`);
+        logger19.info(`Using local ${moduleName} installation`);
       } else {
-        logger20.info(`Using global ${moduleName} installation`);
+        logger19.info(`Using global ${moduleName} installation`);
       }
       const modulePath = this.require.resolve(moduleName);
-      logger20.debug(`Loading ${moduleName} from: ${modulePath}`);
+      logger19.debug(`Loading ${moduleName} from: ${modulePath}`);
       if (isLocalModule && !modulePath.includes(this.projectPath)) {
-        logger20.warn(`Expected local module but resolved to global: ${modulePath}`);
+        logger19.warn(`Expected local module but resolved to global: ${modulePath}`);
       }
       const module = this.require(modulePath);
       this.syncCache.set(moduleName, module);
-      logger20.info(`Loaded ${moduleName} from ${isLocalModule ? "local" : "global"} installation`);
+      logger19.info(`Loaded ${moduleName} from ${isLocalModule ? "local" : "global"} installation`);
       return module;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger20.error(`Failed to load module ${moduleName}: ${errorMessage}`);
+      logger19.error(`Failed to load module ${moduleName}: ${errorMessage}`);
       throw new Error(
         `Cannot find module '${moduleName}' in project at ${this.projectPath}.
 Please ensure it's installed by running:
@@ -4538,22 +4523,22 @@ async function findNextAvailablePort(startPort) {
 }
 
 // src/utils/publisher.ts
-import { logger as logger21 } from "@elizaos/core";
+import { logger as logger20 } from "@elizaos/core";
 async function testPublishToNpm(cwd) {
   try {
     await bunExec("npm", ["whoami"]);
-    logger21.info("[\u2713] Logged in to npm");
-    logger21.info("Testing build...");
+    logger20.info("[\u2713] Logged in to npm");
+    logger20.info("Testing build...");
     await bunExec("npm", ["run", "build", "--dry-run"], { cwd });
-    logger21.info("[\u2713] Build test successful");
+    logger20.info("[\u2713] Build test successful");
     await bunExec("npm", ["access", "ls-packages"], { cwd });
-    logger21.info("[\u2713] Have publish permissions");
+    logger20.info("[\u2713] Have publish permissions");
     return true;
   } catch (error) {
-    logger21.error("Test failed:", error);
+    logger20.error("Test failed:", error);
     if (error instanceof Error) {
-      logger21.error(`Error message: ${error.message}`);
-      logger21.error(`Error stack: ${error.stack}`);
+      logger20.error(`Error message: ${error.message}`);
+      logger20.error(`Error stack: ${error.stack}`);
     }
     return false;
   }
@@ -4562,53 +4547,53 @@ async function testPublishToGitHub(packageJson, username) {
   try {
     const credentials = await getGitHubCredentials();
     if (!credentials) {
-      logger21.error("Failed to get GitHub credentials");
+      logger20.error("Failed to get GitHub credentials");
       return false;
     }
     const token = credentials.token;
-    logger21.info("[\u2713] GitHub credentials found");
+    logger20.info("[\u2713] GitHub credentials found");
     const response = await fetch("https://api.github.com/user", {
       headers: { Authorization: `token ${token}` }
     });
     if (!response.ok) {
-      logger21.error("Invalid GitHub token or insufficient permissions");
+      logger20.error("Invalid GitHub token or insufficient permissions");
       return false;
     }
-    logger21.info("[\u2713] GitHub token is valid");
+    logger20.info("[\u2713] GitHub token is valid");
     if (packageJson.packageType === "project") {
-      logger21.info("[\u2713] Project validation complete - GitHub token is valid");
+      logger20.info("[\u2713] Project validation complete - GitHub token is valid");
       return true;
     }
     const settings = await getRegistrySettings();
     const [registryOwner, registryRepo] = settings.defaultRegistry.split("/");
-    logger21.info(`Testing with registry: ${registryOwner}/${registryRepo}`);
+    logger20.info(`Testing with registry: ${registryOwner}/${registryRepo}`);
     const hasFork = await forkExists(token, registryRepo, username);
-    logger21.info(hasFork ? "[\u2713] Fork exists" : "[\u2713] Can create fork");
+    logger20.info(hasFork ? "[\u2713] Fork exists" : "[\u2713] Can create fork");
     if (!hasFork) {
-      logger21.info("Creating fork...");
+      logger20.info("Creating fork...");
       const forkCreated = await forkRepository(token, registryOwner, registryRepo);
       if (!forkCreated) {
-        logger21.error("Failed to create fork");
+        logger20.error("Failed to create fork");
         return false;
       }
-      logger21.info("[\u2713] Fork created");
+      logger20.info("[\u2713] Fork created");
       await new Promise((resolve2) => setTimeout(resolve2, 3e3));
     }
     const branchName = `test-${packageJson.name.replace(/^@[^/]+\//, "")}-${packageJson.version}`;
     const hasBranch = await branchExists(token, username, registryRepo, branchName);
-    logger21.info(hasBranch ? "[\u2713] Test branch exists" : "[\u2713] Can create branch");
+    logger20.info(hasBranch ? "[\u2713] Test branch exists" : "[\u2713] Can create branch");
     if (!hasBranch) {
-      logger21.info("Creating branch...");
+      logger20.info("Creating branch...");
       const branchCreated = await createBranch(token, username, registryRepo, branchName, "main");
       if (!branchCreated) {
-        logger21.error("Failed to create branch");
+        logger20.error("Failed to create branch");
         return false;
       }
-      logger21.info("[\u2713] Branch created");
+      logger20.info("[\u2713] Branch created");
     }
     const simpleName = packageJson.name.replace(/^@[^/]+\//, "").replace(/[^a-zA-Z0-9-]/g, "-");
     const testPath = `test-files/${simpleName}-test.json`;
-    logger21.info(`Attempting to create test file: ${testPath} in branch: ${branchName}`);
+    logger20.info(`Attempting to create test file: ${testPath} in branch: ${branchName}`);
     const dirCreated = await ensureDirectory(
       token,
       `${username}/${registryRepo}`,
@@ -4616,7 +4601,7 @@ async function testPublishToGitHub(packageJson, username) {
       branchName
     );
     if (!dirCreated) {
-      logger21.warn("Failed to create test directory, but continuing with file creation");
+      logger20.warn("Failed to create test directory, but continuing with file creation");
     }
     const canUpdate = await updateFile(
       token,
@@ -4629,53 +4614,53 @@ async function testPublishToGitHub(packageJson, username) {
       // Use the test branch instead of main
     );
     if (!canUpdate) {
-      logger21.error("Cannot update files in repository");
+      logger20.error("Cannot update files in repository");
       return false;
     }
-    logger21.info("[\u2713] Can create and update files");
+    logger20.info("[\u2713] Can create and update files");
     return true;
   } catch (error) {
-    logger21.error("Test failed:", error);
+    logger20.error("Test failed:", error);
     return false;
   }
 }
 async function publishToNpm(cwd) {
   try {
     await bunExec("npm", ["whoami"]);
-    logger21.info("Building package...");
+    logger20.info("Building package...");
     await bunExecInherit("npm", ["run", "build"], { cwd });
-    logger21.info("Publishing to npm...");
+    logger20.info("Publishing to npm...");
     await bunExecInherit("npm", ["publish"], { cwd });
     return true;
   } catch (error) {
-    logger21.error("Failed to publish to npm:", error);
+    logger20.error("Failed to publish to npm:", error);
     return false;
   }
 }
 async function publishToGitHub(cwd, packageJson, username, skipRegistry = false, isTest = false) {
   const credentials = await getGitHubCredentials();
   if (!credentials) {
-    logger21.error("Failed to get GitHub credentials");
+    logger20.error("Failed to get GitHub credentials");
     return false;
   }
   const token = credentials.token;
   if (!packageJson.packageType) {
-    logger21.error(
+    logger20.error(
       'Package type is required. Set "packageType" to either "plugin" or "project" in package.json'
     );
     return false;
   }
   if (packageJson.packageType !== "plugin" && packageJson.packageType !== "project") {
-    logger21.error(
+    logger20.error(
       `Invalid package type: ${packageJson.packageType}. Must be either "plugin" or "project"`
     );
     return false;
   }
   if (isTest) {
-    logger21.info("Running in test mode - no actual changes will be made");
+    logger20.info("Running in test mode - no actual changes will be made");
   }
   if (skipRegistry) {
-    logger21.info("Registry updates will be skipped as requested with --skip-registry flag");
+    logger20.info("Registry updates will be skipped as requested with --skip-registry flag");
   }
   if (!isTest) {
     const repoName = packageJson.name.replace(/^@[^/]+\//, "");
@@ -4688,24 +4673,24 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
     } else {
       topic = "elizaos-plugins";
     }
-    logger21.info(`Checking/creating GitHub repository: ${username}/${repoName}`);
+    logger20.info(`Checking/creating GitHub repository: ${username}/${repoName}`);
     const repoResult = await createGitHubRepository(token, repoName, description, false, [topic]);
     if (!repoResult.success) {
-      logger21.error(`Failed to create GitHub repository: ${repoResult.message}`);
+      logger20.error(`Failed to create GitHub repository: ${repoResult.message}`);
       return false;
     }
-    logger21.info(`Using repository: ${repoResult.repoUrl}`);
+    logger20.info(`Using repository: ${repoResult.repoUrl}`);
     const repoUrl = `https://${token}@github.com/${username}/${repoName}.git`;
-    logger21.info("Pushing code to GitHub...");
+    logger20.info("Pushing code to GitHub...");
     const pushSuccess = await pushToGitHub(cwd, repoUrl);
     if (!pushSuccess) {
-      logger21.error("Failed to push code to GitHub repository.");
+      logger20.error("Failed to push code to GitHub repository.");
       return false;
     }
-    logger21.success("Successfully pushed code to GitHub repository");
+    logger20.success("Successfully pushed code to GitHub repository");
     if (packageJson.packageType === "project" || skipRegistry) {
       const reason = packageJson.packageType === "project" ? "Projects do not need registry updates" : "Registry updates skipped as requested with --skip-registry flag";
-      logger21.info(`${packageJson.name} published to GitHub successfully. ${reason}`);
+      logger20.info(`${packageJson.name} published to GitHub successfully. ${reason}`);
       return {
         success: true,
         prUrl: repoResult.repoUrl
@@ -4714,7 +4699,7 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
   }
   if (packageJson.packageType === "project" || skipRegistry) {
     if (isTest) {
-      logger21.info("Test successful - project would be published to GitHub only");
+      logger20.info("Test successful - project would be published to GitHub only");
     }
     return true;
   }
@@ -4723,33 +4708,33 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
   const hasFork = await forkExists(token, registryRepo, username);
   let forkFullName;
   if (!hasFork && !isTest) {
-    logger21.info(`Creating fork of ${settings.defaultRegistry}...`);
+    logger20.info(`Creating fork of ${settings.defaultRegistry}...`);
     const fork = await forkRepository(token, registryOwner, registryRepo);
     if (!fork) {
-      logger21.error("Failed to fork registry repository.");
+      logger20.error("Failed to fork registry repository.");
       return false;
     }
     forkFullName = fork;
     await new Promise((resolve2) => setTimeout(resolve2, 2e3));
   } else {
     forkFullName = `${username}/${registryRepo}`;
-    logger21.info(`Using existing fork: ${forkFullName}`);
+    logger20.info(`Using existing fork: ${forkFullName}`);
   }
   const entityType = packageJson.packageType;
   const packageNameWithoutScope = packageJson.name.replace(/^@[^/]+\//, "");
   let branchName;
   if (entityType === "plugin" && packageNameWithoutScope.startsWith("plugin-")) {
     branchName = `${packageNameWithoutScope}-${packageJson.version}`;
-    logger21.info(`Using package name directly to avoid duplicate plugin prefix: ${branchName}`);
+    logger20.info(`Using package name directly to avoid duplicate plugin prefix: ${branchName}`);
   } else {
     branchName = `${entityType}-${packageNameWithoutScope}-${packageJson.version}`;
   }
   const hasBranch = await branchExists(token, username, registryRepo, branchName);
   if (!hasBranch && !isTest) {
-    logger21.info(`Creating branch ${branchName}...`);
+    logger20.info(`Creating branch ${branchName}...`);
     const created = await createBranch(token, username, registryRepo, branchName);
     if (!created) {
-      logger21.error("Failed to create branch.");
+      logger20.error("Failed to create branch.");
       return false;
     }
   }
@@ -4762,10 +4747,10 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
         const githubRepo = `github:${username}/${packageName}`;
         const index = JSON.parse(indexContent);
         if (index[registryPackageName]) {
-          logger21.warn(`Package ${registryPackageName} already exists in registry`);
+          logger20.warn(`Package ${registryPackageName} already exists in registry`);
           return false;
         }
-        logger21.info(`Adding registry entry: ${registryPackageName} -> ${githubRepo}`);
+        logger20.info(`Adding registry entry: ${registryPackageName} -> ${githubRepo}`);
         const lines = indexContent.split("\n");
         const newEntry = `    "${registryPackageName}": "${githubRepo}",`;
         let insertIndex = -1;
@@ -4794,7 +4779,7 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
           }
         }
         if (insertIndex === -1) {
-          logger21.error("Could not find insertion point in index.json");
+          logger20.error("Could not find insertion point in index.json");
           return false;
         }
         lines.splice(insertIndex, 0, newEntry);
@@ -4809,15 +4794,15 @@ async function publishToGitHub(cwd, packageJson, username, skipRegistry = false,
           branchName
         );
         if (!indexUpdated) {
-          logger21.error("Failed to update registry index.");
+          logger20.error("Failed to update registry index.");
           return false;
         }
       } else {
-        logger21.error("Could not fetch index.json from registry");
+        logger20.error("Could not fetch index.json from registry");
         return false;
       }
     } catch (error) {
-      logger21.error(
+      logger20.error(
         `Failed to update index.json: ${error instanceof Error ? error.message : String(error)}`
       );
       return false;
@@ -4839,20 +4824,20 @@ Submitted by: @${username}`,
       "main"
     );
     if (!prUrl) {
-      logger21.error("Failed to create pull request.");
+      logger20.error("Failed to create pull request.");
       return false;
     }
-    logger21.success(`Pull request created: ${prUrl}`);
+    logger20.success(`Pull request created: ${prUrl}`);
     return {
       success: true,
       prUrl
     };
   } else {
-    logger21.info("Test successful - all checks passed");
-    logger21.info("Would create:");
-    logger21.info(`- Branch: ${branchName}`);
-    logger21.info(`- Registry entry: ${registryPackageName} -> github:${username}/${packageName}`);
-    logger21.info(`- Pull request: Add ${registryPackageName} to registry`);
+    logger20.info("Test successful - all checks passed");
+    logger20.info("Would create:");
+    logger20.info(`- Branch: ${branchName}`);
+    logger20.info(`- Registry entry: ${registryPackageName} -> github:${username}/${packageName}`);
+    logger20.info(`- Pull request: Add ${registryPackageName} to registry`);
   }
   return true;
 }
@@ -4867,17 +4852,17 @@ async function resolveImport(importPath, config) {
 
 // src/utils/test-runner.ts
 import {
-  logger as logger22
+  logger as logger21
 } from "@elizaos/core";
 import * as fs9 from "fs";
 import * as path20 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 var safeLogger = {
-  debug: logger22?.debug || console.log,
-  info: logger22?.info || console.log,
-  warn: logger22?.warn || console.warn,
-  error: logger22?.error || console.error,
-  success: logger22?.success || console.log
+  debug: logger21?.debug || console.log,
+  info: logger21?.info || console.log,
+  warn: logger21?.warn || console.warn,
+  error: logger21?.error || console.error,
+  success: logger21?.success || console.log
 };
 var TestRunner = class {
   runtime;
@@ -5151,7 +5136,7 @@ Test Summary: ${this.stats.passed} passed, ${this.stats.failed} failed, ${this.s
 };
 
 // src/utils/registry/index.ts
-import { logger as logger23 } from "@elizaos/core";
+import { logger as logger22 } from "@elizaos/core";
 import dotenv3 from "dotenv";
 import { HttpsProxyAgent } from "https-proxy-agent";
 import { existsSync as existsSync18, promises as fs10 } from "fs";
@@ -5229,7 +5214,7 @@ async function getGitHubToken() {
       return env.GITHUB_TOKEN;
     }
   } catch (error) {
-    logger23.debug(
+    logger22.debug(
       `Error reading GitHub token: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -5255,9 +5240,9 @@ async function setGitHubToken(token) {
     }
     await fs10.writeFile(ENV_FILE, newContent);
     process.env.GITHUB_TOKEN = token;
-    logger23.debug("GitHub token saved successfully");
+    logger22.debug("GitHub token saved successfully");
   } catch (error) {
-    logger23.error(
+    logger22.error(
       `Failed to save GitHub token: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -5300,16 +5285,16 @@ async function saveRegistryCache(registry) {
   try {
     await ensureElizaDir2();
     await fs10.writeFile(REGISTRY_CACHE_FILE, JSON.stringify(registry, null, 2));
-    logger23.debug("Registry cache saved successfully");
+    logger22.debug("Registry cache saved successfully");
   } catch (error) {
-    logger23.debug(
+    logger22.debug(
       `Failed to save registry cache: ${error instanceof Error ? error.message : String(error)}`
     );
   }
 }
 async function getLocalRegistryIndex() {
   try {
-    logger23.debug("Fetching registry from public GitHub URL");
+    logger22.debug("Fetching registry from public GitHub URL");
     const response = await fetch(RAW_REGISTRY_URL);
     if (response.ok) {
       const rawData = await response.json();
@@ -5321,12 +5306,12 @@ async function getLocalRegistryIndex() {
           }
         }
         await saveRegistryCache(result);
-        logger23.debug("Successfully fetched registry from public GitHub URL");
+        logger22.debug("Successfully fetched registry from public GitHub URL");
         return result;
       }
     }
   } catch (error) {
-    logger23.debug(
+    logger22.debug(
       `Failed to fetch registry from public URL: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -5334,11 +5319,11 @@ async function getLocalRegistryIndex() {
     if (existsSync18(REGISTRY_CACHE_FILE)) {
       const cacheContent = await fs10.readFile(REGISTRY_CACHE_FILE, "utf-8");
       const cachedRegistry = JSON.parse(cacheContent);
-      logger23.debug("Using cached registry index");
+      logger22.debug("Using cached registry index");
       return cachedRegistry;
     }
   } catch (error) {
-    logger23.debug(
+    logger22.debug(
       `Failed to read registry cache: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -5355,7 +5340,7 @@ async function getLocalRegistryIndex() {
       }
       return { ...DEFAULT_REGISTRY, ...localRegistry };
     } catch (error) {
-      logger23.debug(
+      logger22.debug(
         `Failed to discover local plugins: ${error instanceof Error ? error.message : String(error)}`
       );
     }
@@ -5366,7 +5351,7 @@ async function getRegistryIndex() {
   const settings = await getRegistrySettings();
   const credentials = await getGitHubCredentials();
   if (!credentials) {
-    logger23.error("GitHub credentials not found. Please run login first.");
+    logger22.error("GitHub credentials not found. Please run login first.");
     process.exit(1);
   }
   const [owner, repo] = settings.defaultRegistry.split("/");
@@ -5423,7 +5408,7 @@ async function getPluginRepository(pluginName) {
     const registry = await getLocalRegistryIndex();
     for (const name of possibleNames) {
       if (registry[name]) {
-        logger23.debug(`Found plugin in registry as: ${name}`);
+        logger22.debug(`Found plugin in registry as: ${name}`);
         return registry[name];
       }
     }
@@ -5436,7 +5421,7 @@ async function getPluginRepository(pluginName) {
     }
     return null;
   } catch (error) {
-    logger23.debug(
+    logger22.debug(
       `Error getting plugin repository: ${error instanceof Error ? error.message : String(error)}`
     );
     return null;
@@ -5447,7 +5432,7 @@ async function repoHasBranch(repoUrl, branchName) {
     const { stdout } = await bunExecSimple("git", ["ls-remote", "--heads", repoUrl, branchName]);
     return stdout.includes(branchName);
   } catch (error) {
-    logger23.warn(
+    logger22.warn(
       `Failed to check for branch ${branchName} in ${repoUrl}: ${error instanceof Error ? error.message : String(error)}`
     );
     return false;
@@ -5470,7 +5455,7 @@ async function getPluginMetadata(pluginName) {
   const settings = await getRegistrySettings();
   const credentials = await getGitHubCredentials();
   if (!credentials) {
-    logger23.error("GitHub credentials not found. Please run login first.");
+    logger22.error("GitHub credentials not found. Please run login first.");
     process.exit(1);
   }
   const [owner, repo] = settings.defaultRegistry.split("/");
@@ -5499,7 +5484,7 @@ async function getPluginMetadata(pluginName) {
     }
     return metadata;
   } catch (error) {
-    logger23.error("Failed to fetch plugin metadata:", error);
+    logger22.error("Failed to fetch plugin metadata:", error);
     return null;
   }
 }
@@ -5513,7 +5498,7 @@ async function getPluginVersion(pluginName, version) {
       return packageDetails.latestVersion;
     }
   } catch (error) {
-    logger23.debug(
+    logger22.debug(
       `Error getting package details: ${error instanceof Error ? error.message : String(error)}`
     );
   }
@@ -5547,11 +5532,11 @@ async function getPackageDetails(packageName) {
     try {
       return JSON.parse(text4);
     } catch {
-      logger23.warn(`Invalid JSON response received from registry for package ${packageName}:`, text4);
+      logger22.warn(`Invalid JSON response received from registry for package ${packageName}:`, text4);
       return null;
     }
   } catch (error) {
-    logger23.warn(
+    logger22.warn(
       `Failed to fetch package details from registry: ${error instanceof Error ? error.message : String(error)}`
     );
     return null;
@@ -5568,14 +5553,14 @@ async function getBestPluginVersion(packageName, runtimeVersion) {
   const [runtimeMajor, runtimeMinor] = runtimeVersion.split(".").map(Number);
   const [packageMajor, packageMinor] = packageDetails.runtimeVersion.split(".").map(Number);
   if (runtimeMajor !== packageMajor) {
-    logger23.warn(
+    logger22.warn(
       `Plugin ${packageName} was built for runtime v${packageDetails.runtimeVersion}, but you're using v${runtimeVersion}`
     );
-    logger23.warn("This may cause compatibility issues.");
+    logger22.warn("This may cause compatibility issues.");
     return packageDetails.latestVersion;
   }
   if (runtimeMinor !== packageMinor) {
-    logger23.warn(
+    logger22.warn(
       `Plugin ${packageName} was built for runtime v${packageDetails.runtimeVersion}, you're using v${runtimeVersion}`
     );
   }
@@ -5637,7 +5622,7 @@ async function initializeDataDir() {
 async function validateDataDir() {
   const status = await checkDataDir();
   if (!status.exists) {
-    logger23.warn("ElizaOS data directory not found. Initializing...");
+    logger22.warn("ElizaOS data directory not found. Initializing...");
     await initializeDataDir();
     return false;
   }
@@ -5647,22 +5632,22 @@ async function validateDataDir() {
     const envContent = await fs10.readFile(envPath, "utf-8");
     const parsedEnv = dotenv3.parse(envContent);
     if (!parsedEnv.GITHUB_TOKEN) {
-      logger23.warn("GitHub token not found in environment");
+      logger22.warn("GitHub token not found in environment");
       isValid = false;
     }
   } else {
-    logger23.warn(".env file not found");
+    logger22.warn(".env file not found");
     isValid = false;
   }
   if (!status.env.hasAllKeys) {
-    logger23.warn(`Missing environment variables: ${status.env.missingKeys.join(", ")}`);
+    logger22.warn(`Missing environment variables: ${status.env.missingKeys.join(", ")}`);
     isValid = false;
   }
   if (!status.settings.exists) {
-    logger23.warn("Registry settings file not found");
+    logger22.warn("Registry settings file not found");
     isValid = false;
   } else if (!status.settings.hasAllKeys) {
-    logger23.warn(`Missing settings: ${status.settings.missingKeys.join(", ")}`);
+    logger22.warn(`Missing settings: ${status.settings.missingKeys.join(", ")}`);
     isValid = false;
   }
   return isValid;