@elizaos/cli 1.4.2 → 1.4.4

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env bun
 import {
   create
-} from "./chunk-FSSUAWXQ.js";
+} from "./chunk-NSNXXD3I.js";
 import {
   getElizaCharacter
-} from "./chunk-SMZBJQJR.js";
+} from "./chunk-HOC6B3QV.js";
 import {
   TestRunner,
   UserEnvironment,
@@ -44,7 +44,7 @@ import {
   testPublishToNpm,
   tryDelegateToLocalCli,
   validateDataDir
-} from "./chunk-D3QSET5H.js";
+} from "./chunk-N5G5XSGP.js";
 import {
   configureEmojis,
   emoji,
@@ -2422,13 +2422,13 @@ var SimpleMigrationAgent = class extends EventTarget {
     if (eventHandlers.has(handler)) {
       return this;
     }
-    const wrappedHandler = (e) => {
+    const wrappedHandler = ((e) => {
       if (e instanceof CustomEvent) {
         handler(e.detail);
       } else {
         handler(void 0);
       }
-    };
+    });
     eventHandlers.set(handler, wrappedHandler);
     this.addEventListener(event, wrappedHandler);
     return this;
@@ -3535,7 +3535,8 @@ async function generatePackageMetadata(packageJson, cliVersion, username) {
     // node, browser, or universal
     runtimeVersion: cliVersion,
     // Compatible CLI/runtime version
-    repository: packageJson.repository?.url || "",
+    ...packageJson.repository?.url && { repository: packageJson.repository.url },
+    // Only include if present
     maintainers: packageJson.maintainers || [username],
     publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
     publishedBy: username,
@@ -4186,6 +4187,14 @@ var publish = new Command5().name("publish").description("Publish a plugin to np
         replacement.replace();
       }
     });
+    if (opts.npm && packageJson.repository) {
+      delete packageJson.repository;
+      console.info("Removed repository field for npm-only publishing");
+    }
+    if (opts.npm && packageJson.bugs) {
+      delete packageJson.bugs;
+      console.info("Removed bugs field for npm-only publishing");
+    }
     const finalPluginName = packageJson.name.startsWith("@") ? packageJson.name.split("/")[1] : packageJson.name;
     await fs9.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), "utf-8");
     await validatePluginRequirements(cwd, packageJson);
@@ -5017,45 +5026,46 @@ import { Command as Command9 } from "commander";
 // src/commands/tee/phala-wrapper.ts
 import { Command as Command8 } from "commander";
 import { spawn } from "child_process";
-import { elizaLogger } from "@elizaos/core";
-var phalaCliCommand = new Command8("phala").description("Official Phala Cloud CLI - Manage TEE deployments on Phala Cloud").allowUnknownOption().helpOption(false).action(async (_, command) => {
-  const args = command.args;
+import { logger as logger22 } from "@elizaos/core";
+var phalaCliCommand = new Command8("phala").description("Official Phala Cloud CLI - Manage TEE deployments on Phala Cloud").allowUnknownOption().helpOption(false).allowExcessArguments(true).passThroughOptions().argument("[args...]", "All arguments to pass to Phala CLI").action(async (...commandArgs) => {
+  const cmd = commandArgs[commandArgs.length - 1];
+  const raw = cmd?.parent?.rawArgs ?? cmd?.rawArgs ?? process.argv;
+  const idx = raw.findIndex((arg) => arg === "phala");
+  const args = idx >= 0 ? raw.slice(idx + 1) : Array.isArray(commandArgs[0]) ? commandArgs[0] : [];
   try {
-    elizaLogger.info("Running Phala CLI command:", ["phala", ...args].join(" "));
+    logger22.info({ args }, "Running Phala CLI command");
     const phalaProcess = spawn("npx", ["--yes", "phala", ...args], {
-      stdio: "inherit",
-      shell: true
+      stdio: "inherit"
     });
-    phalaProcess.on("error", (error) => {
-      elizaLogger.error("Failed to execute Phala CLI:", error);
-      if (error.message.includes("ENOENT")) {
-        elizaLogger.error(
-          `
-${emoji.error("Error: npx not found. Please install Node.js and npm:")}`
-        );
-        elizaLogger.error("   Visit https://nodejs.org or use a version manager like nvm");
-        elizaLogger.error(
+    phalaProcess.on("error", (err) => {
+      const error = err;
+      logger22.error({ error, args }, "Failed to execute Phala CLI");
+      if (error.code === "ENOENT") {
+        logger22.error(`
+${emoji.error("Error: npx not found. Please install Node.js and npm:")}`);
+        logger22.error("   Visit https://nodejs.org or use a version manager like nvm");
+        logger22.error(
           "   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash"
         );
       } else {
-        elizaLogger.error(`
+        logger22.error(`
 ${emoji.error("Error: Failed to execute Phala CLI")}`);
-        elizaLogger.error("   Try running directly: npx phala", args.join(" "));
+        logger22.error({ args }, "   Try running directly: npx phala [args]");
       }
       process.exit(1);
     });
     phalaProcess.on("exit", (code) => {
       if (code !== 0) {
-        elizaLogger.warn(`Phala CLI exited with code: ${code}`);
+        logger22.warn({ code }, "Phala CLI exited with non-zero code");
       }
       process.exit(code || 0);
     });
   } catch (error) {
-    elizaLogger.error("Error running Phala CLI:", error);
-    elizaLogger.error(`
+    logger22.error({ error, args }, "Error running Phala CLI");
+    logger22.error(`
 ${emoji.error("Error: Failed to run Phala CLI")}`);
-    elizaLogger.error("   Try running Phala CLI directly with: npx phala", args.join(" "));
-    elizaLogger.error("   Or visit https://www.npmjs.com/package/phala for more information");
+    logger22.error({ args }, "   Try running Phala CLI directly with: npx phala [args]");
+    logger22.error("   Or visit https://www.npmjs.com/package/phala for more information");
     process.exit(1);
   }
 }).configureHelp({
@@ -5077,17 +5087,17 @@ ${emoji.error("Error: Failed to run Phala CLI")}`);
 });
 
 // src/commands/tee/index.ts
-var teeCommand = new Command9("tee").description("Manage TEE deployments").addCommand(phalaCliCommand);
+var teeCommand = new Command9("tee").description("Manage TEE deployments").enablePositionalOptions().addCommand(phalaCliCommand);
 
 // src/commands/test/index.ts
-import { logger as logger28 } from "@elizaos/core";
+import { logger as logger29 } from "@elizaos/core";
 import { Command as Command10, Option as Option2 } from "commander";
 
 // src/commands/test/actions/run-all-tests.ts
-import { logger as logger26 } from "@elizaos/core";
+import { logger as logger27 } from "@elizaos/core";
 
 // src/commands/test/utils/project-utils.ts
-import { logger as logger22 } from "@elizaos/core";
+import { logger as logger23 } from "@elizaos/core";
 import * as fs12 from "fs";
 import path26 from "path";
 function getProjectType(testPath) {
@@ -5124,7 +5134,7 @@ async function installPluginDependencies(projectInfo) {
       };
       await fs12.promises.writeFile(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
     }
-    const { installPlugin: installPlugin2 } = await import("./utils-5HPZSIF6.js");
+    const { installPlugin: installPlugin2 } = await import("./utils-X6UXPLKD.js");
     for (const dependency of project.pluginModule.dependencies) {
       await installPlugin2(dependency, pluginsDir);
       const dependencyPath = path26.join(pluginsDir, "node_modules", dependency);
@@ -5132,7 +5142,7 @@ async function installPluginDependencies(projectInfo) {
         try {
           await runBunCommand(["install"], dependencyPath);
         } catch (error) {
-          logger22.warn(
+          logger23.warn(
             `[Test Command] Failed to install devDependencies for ${dependency}: ${error}`
           );
         }
@@ -5142,11 +5152,11 @@ async function installPluginDependencies(projectInfo) {
 }
 
 // src/commands/test/actions/component-tests.ts
-import { logger as logger24 } from "@elizaos/core";
+import { logger as logger25 } from "@elizaos/core";
 import path28 from "path";
 
 // src/utils/testing/tsc-validator.ts
-import { logger as logger23 } from "@elizaos/core";
+import { logger as logger24 } from "@elizaos/core";
 import path27 from "path";
 import { existsSync as existsSync18 } from "fs";
 async function runTypeCheck(projectPath, strict = true) {
@@ -5174,7 +5184,7 @@ async function runTypeCheck(projectPath, strict = true) {
       warnings: stderr.includes("warning") ? [stderr] : []
     };
   } catch (error) {
-    logger23.error({ error }, "TypeScript validation failed:");
+    logger24.error({ error }, "TypeScript validation failed:");
     return {
       success: false,
       errors: [`TypeScript validation error: ${error.message}`],
@@ -5188,38 +5198,38 @@ async function runComponentTests(testPath, options, projectInfo) {
   const cwd = process.cwd();
   const isPlugin2 = projectInfo.type === "elizaos-plugin";
   if (!options.skipTypeCheck) {
-    logger24.info("Running TypeScript validation...");
+    logger25.info("Running TypeScript validation...");
     const typeCheckResult = await runTypeCheck(cwd, true);
     if (!typeCheckResult.success) {
-      logger24.error("TypeScript validation failed:");
-      typeCheckResult.errors.forEach((error) => logger24.error(error));
+      logger25.error("TypeScript validation failed:");
+      typeCheckResult.errors.forEach((error) => logger25.error(error));
       return { failed: true };
     }
-    logger24.success("TypeScript validation passed");
+    logger25.success("TypeScript validation passed");
   }
   if (!options.skipBuild) {
     try {
-      logger24.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
+      logger25.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
       await buildProject(cwd, isPlugin2);
-      logger24.success(`Build completed successfully`);
+      logger25.success(`Build completed successfully`);
     } catch (buildError) {
-      logger24.error(`Build failed: ${buildError}`);
+      logger25.error(`Build failed: ${buildError}`);
       return { failed: true };
     }
   }
-  logger24.info("Running component tests...");
+  logger25.info("Running component tests...");
   const args = ["test", "--passWithNoTests"];
   if (options.name) {
     const baseName = processFilterName(options.name);
     if (baseName) {
-      logger24.info(`Using test filter: ${baseName}`);
+      logger25.info(`Using test filter: ${baseName}`);
       args.push("-t", baseName);
     }
   }
   const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
   const baseDir = monorepoRoot ?? process.cwd();
   const targetPath = testPath ? path28.resolve(baseDir, testPath) : process.cwd();
-  logger24.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
+  logger25.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
   try {
     const result = await bunExecInherit("bun", args, {
       cwd: targetPath,
@@ -5230,16 +5240,16 @@ async function runComponentTests(testPath, options, projectInfo) {
         // Override CI to empty string (some tools check existence, but most check truthiness)
       }
     });
-    logger24.info("Component tests completed");
+    logger25.info("Component tests completed");
     return { failed: !result.success };
   } catch (error) {
-    logger24.error({ error }, "Error running component tests:");
+    logger25.error({ error }, "Error running component tests:");
     return { failed: true };
   }
 }
 
 // src/commands/test/actions/e2e-tests.ts
-import { logger as logger25 } from "@elizaos/core";
+import { logger as logger26 } from "@elizaos/core";
 import * as dotenv2 from "dotenv";
 import * as fs13 from "fs";
 import path29 from "path";
@@ -5248,12 +5258,12 @@ async function runE2eTests(testPath, options, projectInfo) {
     try {
       const cwd = process.cwd();
       const isPlugin2 = projectInfo.type === "elizaos-plugin";
-      logger25.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
+      logger26.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
       await buildProject(cwd, isPlugin2);
-      logger25.info(`Build completed successfully`);
+      logger26.info(`Build completed successfully`);
     } catch (buildError) {
-      logger25.error(`Build error: ${buildError}`);
-      logger25.warn(`Attempting to continue with tests despite build error`);
+      logger26.error(`Build error: ${buildError}`);
+      logger26.warn(`Attempting to continue with tests despite build error`);
     }
   }
   let server;
@@ -5290,33 +5300,33 @@ async function runE2eTests(testPath, options, projectInfo) {
     process.env.PGLITE_DATA_DIR = elizaDbDir;
     console.info(`Set PGLITE_DATA_DIR to: ${elizaDbDir}`);
     if (fs13.existsSync(envFilePath)) {
-      logger25.info(`Loading environment variables from: ${envFilePath}`);
+      logger26.info(`Loading environment variables from: ${envFilePath}`);
       dotenv2.config({ path: envFilePath });
-      logger25.info("Environment variables loaded");
+      logger26.info("Environment variables loaded");
     } else {
-      logger25.warn(`Environment file not found: ${envFilePath}`);
+      logger26.warn(`Environment file not found: ${envFilePath}`);
     }
     const postgresUrl = process.env.POSTGRES_URL;
-    logger25.info(
+    logger26.info(
       `PostgreSQL URL for e2e tests: ${postgresUrl ? "found" : "not found (will use PGlite)"}`
     );
-    logger25.info("Creating server instance...");
+    logger26.info("Creating server instance...");
     server = new AgentServer();
-    logger25.info("Server instance created");
-    logger25.info("Initializing server...");
+    logger26.info("Server instance created");
+    logger26.info("Initializing server...");
     try {
       await server.initialize({
         dataDir: elizaDbDir,
         postgresUrl
       });
-      logger25.info("Server initialized successfully");
+      logger26.info("Server initialized successfully");
     } catch (initError) {
-      logger25.error({ error: initError }, "Server initialization failed:");
+      logger26.error({ error: initError }, "Server initialization failed:");
       throw initError;
     }
     let project;
     try {
-      logger25.info("Attempting to load project or plugin...");
+      logger26.info("Attempting to load project or plugin...");
       const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
       const baseDir = monorepoRoot ?? process.cwd();
       const targetPath = testPath ? path29.resolve(baseDir, testPath) : process.cwd();
@@ -5324,39 +5334,39 @@ async function runE2eTests(testPath, options, projectInfo) {
       if (!project || !project.agents || project.agents.length === 0) {
         throw new Error("No agents found in project configuration");
       }
-      logger25.info(`Found ${project.agents.length} agents`);
-      logger25.info("Setting up server properties...");
+      logger26.info(`Found ${project.agents.length} agents`);
+      logger26.info("Setting up server properties...");
       server.startAgent = async (character) => {
-        logger25.info(`Starting agent for character ${character.name}`);
+        logger26.info(`Starting agent for character ${character.name}`);
         return startAgent(character, server, void 0, [], { isTestMode: true });
       };
       server.loadCharacterTryPath = loadCharacterTryPath;
       server.jsonToCharacter = jsonToCharacter;
-      logger25.info("Server properties set up");
+      logger26.info("Server properties set up");
       const desiredPort = options.port || Number.parseInt(process.env.SERVER_PORT || "3000");
       const serverPort = await findNextAvailablePort(desiredPort);
       if (serverPort !== desiredPort) {
-        logger25.warn(`Port ${desiredPort} is in use for testing, using port ${serverPort} instead.`);
+        logger26.warn(`Port ${desiredPort} is in use for testing, using port ${serverPort} instead.`);
       }
-      logger25.info("Starting server...");
+      logger26.info("Starting server...");
       try {
         await server.start(serverPort);
-        logger25.info({ serverPort }, "Server started successfully on port");
+        logger26.info({ serverPort }, "Server started successfully on port");
       } catch (error) {
-        logger25.error({ error }, "Error starting server:");
+        logger26.error({ error }, "Error starting server:");
         if (error instanceof Error) {
-          logger25.error({ message: error.message }, "Error details:");
-          logger25.error({ stack: error.stack }, "Stack trace:");
+          logger26.error({ message: error.message }, "Error details:");
+          logger26.error({ stack: error.stack }, "Stack trace:");
         }
         throw error;
       }
       try {
-        logger25.info(
+        logger26.info(
           `Found ${project.agents.length} agents in ${project.isPlugin ? "plugin" : "project"}`
         );
         if (project.isPlugin || project.agents.length === 0) {
           process.env.ELIZA_TESTING_PLUGIN = "true";
-          logger25.info("Using default Eliza character as test agent");
+          logger26.info("Using default Eliza character as test agent");
           try {
             const pluginUnderTest = project.pluginModule;
             if (!pluginUnderTest) {
@@ -5379,16 +5389,16 @@ async function runE2eTests(testPath, options, projectInfo) {
               plugins: runtime.plugins
               // Pass all plugins, not just the one under test
             });
-            logger25.info("Default test agent started successfully");
+            logger26.info("Default test agent started successfully");
           } catch (pluginError) {
-            logger25.error({ error: pluginError }, `Error starting plugin test agent:`);
+            logger26.error({ error: pluginError }, `Error starting plugin test agent:`);
             throw pluginError;
           }
         } else {
           for (const agent2 of project.agents) {
             try {
               const originalCharacter = { ...agent2.character };
-              logger25.debug(`Starting agent: ${originalCharacter.name}`);
+              logger26.debug(`Starting agent: ${originalCharacter.name}`);
               const runtime = await startAgent(
                 originalCharacter,
                 server,
@@ -5401,31 +5411,31 @@ async function runE2eTests(testPath, options, projectInfo) {
               projectAgents.push(agent2);
               await new Promise((resolve2) => setTimeout(resolve2, 1e3));
             } catch (agentError) {
-              logger25.error(
+              logger26.error(
                 { error: agentError, agentName: agent2.character.name },
                 "Error starting agent"
               );
               if (agentError instanceof Error) {
-                logger25.error({ message: agentError.message }, "Error details:");
-                logger25.error({ stack: agentError.stack }, "Stack trace:");
+                logger26.error({ message: agentError.message }, "Error details:");
+                logger26.error({ stack: agentError.stack }, "Stack trace:");
               }
-              logger25.warn(`Skipping agent ${agent2.character.name} due to startup error`);
+              logger26.warn(`Skipping agent ${agent2.character.name} due to startup error`);
             }
           }
         }
         if (runtimes.length === 0) {
           throw new Error("Failed to start any agents from project");
         }
-        logger25.debug(`Successfully started ${runtimes.length} agents for testing`);
+        logger26.debug(`Successfully started ${runtimes.length} agents for testing`);
         let totalFailed = 0;
         let anyTestsFound = false;
         for (let i = 0; i < runtimes.length; i++) {
           const runtime = runtimes[i];
           const projectAgent = projectAgents[i];
           if (project.isPlugin) {
-            logger25.debug(`Running tests for plugin: ${project.pluginModule?.name}`);
+            logger26.debug(`Running tests for plugin: ${project.pluginModule?.name}`);
           } else {
-            logger25.debug(`Running tests for agent: ${runtime.character.name}`);
+            logger26.debug(`Running tests for agent: ${runtime.character.name}`);
           }
           const testRunner = new TestRunner(runtime, projectAgent);
           const currentDirInfo = projectInfo;
@@ -5446,17 +5456,17 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
         return { failed: anyTestsFound ? totalFailed > 0 : false };
       } catch (error) {
-        logger25.error({ error }, "Error in runE2eTests:");
+        logger26.error({ error }, "Error in runE2eTests:");
         if (error instanceof Error) {
-          logger25.error({ message: error.message }, "Error details:");
-          logger25.error({ stack: error.stack }, "Stack trace:");
+          logger26.error({ message: error.message }, "Error details:");
+          logger26.error({ stack: error.stack }, "Stack trace:");
         } else {
-          logger25.error({ type: typeof error }, "Unknown error type:");
-          logger25.error({ error }, "Error value:");
+          logger26.error({ type: typeof error }, "Unknown error type:");
+          logger26.error({ error }, "Error value:");
           try {
-            logger25.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
+            logger26.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
           } catch (e) {
-            logger25.error({ error: e }, "Could not stringify error:");
+            logger26.error({ error: e }, "Could not stringify error:");
           }
         }
         return { failed: true };
@@ -5479,33 +5489,33 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
       }
     } catch (error) {
-      logger25.error({ error }, "Error in runE2eTests:");
+      logger26.error({ error }, "Error in runE2eTests:");
       if (error instanceof Error) {
-        logger25.error({ message: error.message }, "Error details:");
-        logger25.error({ stack: error.stack }, "Stack trace:");
+        logger26.error({ message: error.message }, "Error details:");
+        logger26.error({ stack: error.stack }, "Stack trace:");
       } else {
-        logger25.error({ type: typeof error }, "Unknown error type:");
-        logger25.error({ error }, "Error value:");
+        logger26.error({ type: typeof error }, "Unknown error type:");
+        logger26.error({ error }, "Error value:");
         try {
-          logger25.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
+          logger26.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
         } catch (e) {
-          logger25.error({ error: e }, "Could not stringify error:");
+          logger26.error({ error: e }, "Could not stringify error:");
         }
       }
       return { failed: true };
     }
   } catch (error) {
-    logger25.error({ error }, "Error in runE2eTests:");
+    logger26.error({ error }, "Error in runE2eTests:");
     if (error instanceof Error) {
-      logger25.error({ message: error.message }, "Error details:");
-      logger25.error({ stack: error.stack }, "Stack trace:");
+      logger26.error({ message: error.message }, "Error details:");
+      logger26.error({ stack: error.stack }, "Stack trace:");
     } else {
-      logger25.error({ type: typeof error }, "Unknown error type:");
-      logger25.error({ error }, "Error value:");
+      logger26.error({ type: typeof error }, "Unknown error type:");
+      logger26.error({ error }, "Error value:");
       try {
-        logger25.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
+        logger26.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
       } catch (e) {
-        logger25.error({ error: e }, "Could not stringify error:");
+        logger26.error({ error: e }, "Could not stringify error:");
       }
     }
     return { failed: true };
@@ -5519,20 +5529,20 @@ async function runAllTests(testPath, options) {
   if (!options.skipBuild) {
     componentResult = await runComponentTests(testPath, options, projectInfo);
   } else {
-    logger26.info("Skipping component tests due to --skip-build option");
+    logger27.info("Skipping component tests due to --skip-build option");
   }
   const e2eResult = await runE2eTests(testPath, options, projectInfo);
   if (componentResult.failed || e2eResult.failed) {
     if (componentResult.failed) {
-      logger26.error("Component tests failed.");
+      logger27.error("Component tests failed.");
     }
     if (e2eResult.failed) {
-      logger26.error("E2E tests failed.");
+      logger27.error("E2E tests failed.");
     }
-    logger26.error("Test suite failed.");
+    logger27.error("Test suite failed.");
     process.exit(1);
   }
-  logger26.success("All tests passed successfully!");
+  logger27.success("All tests passed successfully!");
   process.exit(0);
 }
 
@@ -5540,7 +5550,7 @@ async function runAllTests(testPath, options) {
 import * as net from "net";
 
 // src/commands/test/utils/plugin-utils.ts
-import { logger as logger27 } from "@elizaos/core";
+import { logger as logger28 } from "@elizaos/core";
 import * as fs14 from "fs";
 import path30 from "path";
 
@@ -5556,31 +5566,31 @@ var test = new Command10().name("test").description("Run tests for the current p
   const projectInfo = getProjectType(testPath);
   await installPluginDependencies(projectInfo);
 }).action(async (testPath, options) => {
-  logger28.info("Starting tests...");
+  logger29.info("Starting tests...");
   try {
     const projectInfo = getProjectType(testPath);
     switch (options.type) {
       case "component":
-        logger28.info("Running component tests only...");
+        logger29.info("Running component tests only...");
         const componentResult = await runComponentTests(testPath, options, projectInfo);
         if (componentResult.failed) {
-          logger28.error("Component tests failed.");
+          logger29.error("Component tests failed.");
           process.exit(1);
         }
-        logger28.success("Component tests passed successfully!");
+        logger29.success("Component tests passed successfully!");
         break;
       case "e2e":
-        logger28.info("Running e2e tests only...");
+        logger29.info("Running e2e tests only...");
         const e2eResult = await runE2eTests(testPath, options, projectInfo);
         if (e2eResult.failed) {
-          logger28.error("E2E tests failed.");
+          logger29.error("E2E tests failed.");
           process.exit(1);
         }
-        logger28.success("E2E tests passed successfully!");
+        logger29.success("E2E tests passed successfully!");
         break;
       case "all":
       default:
-        logger28.info("Running all tests...");
+        logger29.info("Running all tests...");
         await runAllTests(testPath, options);
         break;
     }
@@ -5591,7 +5601,7 @@ var test = new Command10().name("test").description("Run tests for the current p
 });
 
 // src/index.ts
-import { logger as logger29 } from "@elizaos/core";
+import { logger as logger30 } from "@elizaos/core";
 import { Command as Command11 } from "commander";
 process.env.NODE_OPTIONS = "--no-deprecation";
 process.env.NODE_NO_WARNINGS = "1";
@@ -5612,19 +5622,19 @@ var shutdownState = {
 };
 async function gracefulShutdown(signal) {
   if (!shutdownState.tryInitiateShutdown()) {
-    logger29.debug(`Ignoring ${signal} - shutdown already in progress`);
+    logger30.debug(`Ignoring ${signal} - shutdown already in progress`);
     return;
   }
-  logger29.info(`Received ${signal}, shutting down gracefully...`);
+  logger30.info(`Received ${signal}, shutting down gracefully...`);
   try {
     const serverWasStopped = await stopServer();
     if (serverWasStopped) {
-      logger29.info("Server stopped successfully");
+      logger30.info("Server stopped successfully");
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    logger29.error(`Error stopping server: ${errorMessage}`);
-    logger29.debug({ error }, "Full error details:");
+    logger30.error(`Error stopping server: ${errorMessage}`);
+    logger30.debug({ error }, "Full error details:");
   }
   const exitCode = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 0;
   process.exit(exitCode);
@@ -5658,6 +5668,6 @@ async function main() {
   await program.parseAsync();
 }
 main().catch((error) => {
-  logger29.error({ error }, "An error occurred:");
+  logger30.error({ error }, "An error occurred:");
   process.exit(1);
 });

package/dist/{registry-RF6PW3EN.js → registry-ELONUC44.js}

@@ -24,7 +24,7 @@ import {
   setEnvVar,
   setGitHubToken,
   validateDataDir
-} from "./chunk-D3QSET5H.js";
+} from "./chunk-N5G5XSGP.js";
 import "./chunk-FQYWRHLX.js";
 import "./chunk-GXWWPFBO.js";
 import "./chunk-I4L4T7QX.js";

package/dist/templates/plugin-quick-starter/package.json

@@ -41,11 +41,11 @@
     "tsup.config.ts"
   ],
   "dependencies": {
-    "@elizaos/core": "1.4.2",
+    "@elizaos/core": "1.4.4",
     "zod": "^3.24.4"
   },
   "devDependencies": {
-    "@elizaos/cli": "1.4.2",
+    "@elizaos/cli": "1.4.4",
     "dotenv": "16.4.5",
     "prettier": "3.5.3",
     "tsup": "8.5.0",

package/dist/templates/plugin-quick-starter/src/__tests__/test-utils.ts

@@ -139,6 +139,7 @@ export function createMockRuntime(overrides: Partial<IAgentRuntime> = {}): IAgen
     getMemoriesByRoomIds: mock().mockResolvedValue([]),
     searchMemories: mock().mockResolvedValue([]),
     addEmbeddingToMemory: mock().mockImplementation(async (memory: Memory) => memory),
+    queueEmbeddingGeneration: mock().mockResolvedValue(undefined),
     getAllMemories: mock().mockResolvedValue([]),
     clearAllAgentMemories: mock().mockResolvedValue(undefined),
     updateMemory: mock().mockResolvedValue(true),