@elizaos/cli 1.3.2 → 1.4.3

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env bun
 import {
   create
-} from "./chunk-T2QDIXGU.js";
+} from "./chunk-NSNXXD3I.js";
 import {
   getElizaCharacter
-} from "./chunk-5GUS4CFO.js";
+} from "./chunk-HOC6B3QV.js";
 import {
   TestRunner,
   UserEnvironment,
@@ -44,18 +44,18 @@ import {
   testPublishToNpm,
   tryDelegateToLocalCli,
   validateDataDir
-} from "./chunk-E6XYTE3A.js";
+} from "./chunk-N5G5XSGP.js";
 import {
   configureEmojis,
   emoji,
   runBunCommand
-} from "./chunk-FDEDLANP.js";
+} from "./chunk-FQYWRHLX.js";
 import "./chunk-GXWWPFBO.js";
 import {
   bunExec,
   bunExecInherit,
   bunExecSimple
-} from "./chunk-D3Q2UZLZ.js";
+} from "./chunk-I4L4T7QX.js";
 import "./chunk-3RG5ZIWI.js";
 
 // src/commands/dev/index.ts
@@ -424,14 +424,14 @@ function hasElizaOSCli(packageJsonPath) {
     try {
       packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
     } catch (parseError) {
-      logger.debug(`Error parsing JSON in package.json at ${packageJsonPath}:`, parseError);
+      logger.debug({ error: parseError, packageJsonPath }, `Error parsing JSON in package.json`);
       return false;
     }
     const dependencies = packageJson.dependencies || {};
     const devDependencies = packageJson.devDependencies || {};
     return "@elizaos/cli" in dependencies || "@elizaos/cli" in devDependencies;
   } catch (error) {
-    logger.debug(`Error reading package.json at ${packageJsonPath}:`, error);
+    logger.debug({ error, packageJsonPath }, `Error reading package.json`);
     return false;
   }
 }
@@ -475,12 +475,12 @@ async function installElizaOSCli(cwd = process.cwd()) {
       return true;
     } else {
       logger.warn("\u26A0 Failed to install @elizaos/cli as dev dependency (optional)");
-      logger.debug("Installation error:", result.error);
+      logger.debug({ error: result.error }, "Installation error:");
       return false;
     }
   } catch (error) {
     logger.warn("\u26A0 Failed to install @elizaos/cli as dev dependency (optional)");
-    logger.debug("Installation error:", error);
+    logger.debug({ error }, "Installation error:");
     return false;
   }
 }
@@ -1215,7 +1215,7 @@ var extractPluginEnvRequirements = async (packageName, cwd) => {
     for (const possiblePath of possiblePaths) {
       if (existsSync9(possiblePath)) {
         packageJsonPath = possiblePath;
-        logger3.debug(`Found plugin package.json at: ${packageJsonPath}`);
+        logger3.debug({ packageJsonPath }, `Found plugin package.json at:`);
         break;
       }
     }
@@ -1228,7 +1228,7 @@ var extractPluginEnvRequirements = async (packageName, cwd) => {
             const pkgJsonPath = path9.join(nodeModulesPath, pkg, "package.json");
             if (existsSync9(pkgJsonPath)) {
               packageJsonPath = pkgJsonPath;
-              logger3.debug(`Found matching plugin package.json at: ${packageJsonPath}`);
+              logger3.debug({ packageJsonPath }, `Found matching plugin package.json at:`);
               break;
             }
           }
@@ -1236,8 +1236,8 @@ var extractPluginEnvRequirements = async (packageName, cwd) => {
       }
     }
     if (!packageJsonPath) {
-      logger3.debug(`Plugin package.json not found for: ${packageName}`);
-      logger3.debug(`Searched paths: ${possiblePaths.join(", ")}`);
+      logger3.debug({ packageName }, `Plugin package.json not found`);
+      logger3.debug({ paths: possiblePaths }, `Searched paths:`);
       return {};
     }
     const packageJsonContent = readFileSync2(packageJsonPath, "utf-8");
@@ -1248,13 +1248,12 @@ var extractPluginEnvRequirements = async (packageName, cwd) => {
       return {};
     }
     logger3.debug(
-      `Found environment variables for ${packageName}: ${Object.keys(agentConfig.pluginParameters).join(", ")}`
+      { packageName, vars: Object.keys(agentConfig.pluginParameters) },
+      "Found environment variables"
     );
     return agentConfig.pluginParameters;
   } catch (error) {
-    logger3.debug(
-      `Error reading plugin package.json for ${packageName}: ${error instanceof Error ? error.message : String(error)}`
-    );
+    logger3.debug({ error, packageName }, "Error reading plugin package.json");
     return {};
   }
 };
@@ -2123,13 +2122,16 @@ var MigrationGuideLoader = class {
             keywords: config2.keywords
           });
         } catch (error) {
-          logger8.warn(`Failed to load migration guide: ${config2.name}`, error);
+          logger8.warn({ error, guideName: config2.name }, `Failed to load migration guide`);
         }
       } else {
-        logger8.warn(`Migration guide not found: ${guidePath}`);
+        logger8.warn({ guidePath }, `Migration guide not found`);
       }
     }
-    logger8.info(`Loaded ${this.guides.length} migration guides from ${this.guidesDir}`);
+    logger8.info(
+      { count: this.guides.length, guidesDir: this.guidesDir },
+      `Loaded migration guides`
+    );
   }
   createEmbeddedGuides(guideConfigs) {
     const embeddedGuides = {
@@ -2404,7 +2406,7 @@ var SimpleMigrationAgent = class extends EventTarget {
         logger9.info("Migration guide loader initialized successfully");
       }
     } catch (error) {
-      logger9.warn("Failed to initialize migration guide loader", error);
+      logger9.warn({ error }, "Failed to initialize migration guide loader");
       throw new Error("Cannot initialize migration system without guide access");
     }
   }
@@ -2420,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;
@@ -3194,7 +3196,7 @@ import { readFileSync as readFileSync5 } from "fs";
 import path14 from "path";
 async function generatePlugin(opts) {
   try {
-    const { PluginCreator } = await import("./plugin-creator-H26ZLR6H.js");
+    const { PluginCreator } = await import("./plugin-creator-TCUFII32.js");
     if (opts.apiKey) {
       process.env.ANTHROPIC_API_KEY = opts.apiKey;
     }
@@ -3533,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,
@@ -3619,10 +3622,19 @@ var ELIZAOS_ORG = "@elizaos";
 var FALLBACK_VERSION = "0.0.0";
 async function getVersion2() {
   try {
+    const directoryInfo = detectDirectoryType(process.cwd());
+    const isMonorepo = directoryInfo.type === "elizaos-monorepo";
+    if (isMonorepo) {
+      return "monorepo";
+    }
     const envInfo = await UserEnvironment.getInstance().getInfo();
-    return envInfo.cli.version;
+    const version = envInfo.cli.version;
+    if (isWorkspaceVersion(version)) {
+      return "monorepo";
+    }
+    return version;
   } catch (error) {
-    logger12.error("Error getting CLI version:", error);
+    logger12.error({ error }, "Error getting CLI version:");
     return FALLBACK_VERSION;
   }
 }
@@ -3728,7 +3740,10 @@ async function performCliUpdate(options = {}) {
       console.error("  curl -fsSL https://bun.sh/install | bash");
       console.error("  # or");
       console.error("  npm install -g bun");
-      logger13.debug("Bun error:", bunError instanceof Error ? bunError.message : String(bunError));
+      logger13.debug(
+        { error: bunError instanceof Error ? bunError.message : String(bunError) },
+        "Bun error:"
+      );
       return false;
     }
   } catch (error) {
@@ -4172,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);
@@ -4500,16 +4523,16 @@ async function loadProject(dir) {
           projectModule = await import(importUrl);
           logger16.info(`Loaded project from ${entryPoint}`);
           const exportKeys = Object.keys(projectModule);
-          logger16.debug(`Module exports: ${exportKeys.join(", ")}`);
+          logger16.debug({ exportKeys }, `Module exports:`);
           if (exportKeys.includes("default")) {
-            logger16.debug(`Default export type: ${typeof projectModule.default}`);
+            logger16.debug({ type: typeof projectModule.default }, `Default export type:`);
             if (typeof projectModule.default === "object" && projectModule.default !== null) {
-              logger16.debug(`Default export keys: ${Object.keys(projectModule.default).join(", ")}`);
+              logger16.debug({ keys: Object.keys(projectModule.default) }, `Default export keys:`);
             }
           }
           break;
         } catch (error) {
-          logger16.warn(`Failed to import project from ${entryPoint}:`, error);
+          logger16.warn({ error, entryPoint }, `Failed to import project`);
         }
       }
     }
@@ -4517,13 +4540,13 @@ async function loadProject(dir) {
       throw new Error("Could not find project entry point");
     }
     const moduleIsPlugin = isPlugin(projectModule);
-    logger16.debug(`Is this a plugin? ${moduleIsPlugin}`);
+    logger16.debug({ moduleIsPlugin }, `Is this a plugin?`);
     if (moduleIsPlugin) {
       logger16.info("Detected plugin module instead of project");
       try {
         const plugin = extractPlugin(projectModule);
-        logger16.debug(`Found plugin: ${plugin.name} - ${plugin.description}`);
-        logger16.debug(`Plugin has the following properties: ${Object.keys(plugin).join(", ")}`);
+        logger16.debug({ name: plugin.name, description: plugin.description }, `Found plugin:`);
+        logger16.debug({ keys: Object.keys(plugin) }, `Plugin has the following properties:`);
         const completePlugin = {
           // Copy all other properties from the original plugin first
           ...plugin,
@@ -4565,7 +4588,7 @@ async function loadProject(dir) {
     const agents = [];
     if (projectModule.default && typeof projectModule.default === "object" && Array.isArray(projectModule.default.agents)) {
       agents.push(...projectModule.default.agents);
-      logger16.debug(`Found ${agents.length} agents in default export's agents array`);
+      logger16.debug({ count: agents.length }, `Found agents in default export's agents array`);
     } else {
       for (const [key, value] of Object.entries(projectModule)) {
         if (key === "default" && value && typeof value === "object") {
@@ -4575,7 +4598,7 @@ async function loadProject(dir) {
           }
         } else if (value && typeof value === "object" && value.character && value.init) {
           agents.push(value);
-          logger16.debug(`Found agent in named export: ${key}`);
+          logger16.debug({ key }, `Found agent in named export`);
         }
       }
     }
@@ -4588,7 +4611,7 @@ async function loadProject(dir) {
     };
     return project;
   } catch (error) {
-    logger16.error("Error loading project:", error);
+    logger16.error({ error }, "Error loading project:");
     throw error;
   }
 }
@@ -4694,7 +4717,7 @@ function resolvePluginDependencies(availablePlugins, isTestMode = false) {
     }
   }
   const finalPlugins = resolutionOrder.map((name) => availablePlugins.get(name)).filter((p) => p);
-  logger17.info(`Final plugins being loaded: ${finalPlugins.map((p) => p.name).join(", ")}`);
+  logger17.info({ plugins: finalPlugins.map((p) => p.name) }, `Final plugins being loaded:`);
   return finalPlugins;
 }
 
@@ -4762,7 +4785,6 @@ async function startAgent(character, server, init, plugins2 = [], options = {})
     await setDefaultSecretsFromEnv(character);
   }
   const loadedPlugins = /* @__PURE__ */ new Map();
-  loadedPlugins.set(sqlPlugin.name, sqlPlugin);
   const pluginsToLoad = new Set(character.plugins || []);
   for (const p of plugins2) {
     if (typeof p === "string") {
@@ -4787,6 +4809,16 @@ async function startAgent(character, server, init, plugins2 = [], options = {})
       }
     }
   }
+  let haveSql = false;
+  for (const n of allAvailablePlugins.keys()) {
+    if (n === sqlPlugin.name || n === "mysql") {
+      haveSql = true;
+      break;
+    }
+  }
+  if (!haveSql) {
+    allAvailablePlugins.set(sqlPlugin.name, sqlPlugin);
+  }
   const finalPlugins = resolvePluginDependencies(allAvailablePlugins, options.isTestMode);
   const runtime = new AgentRuntime2({
     character: encryptedCharacter(character),
@@ -4812,7 +4844,7 @@ async function startAgent(character, server, init, plugins2 = [], options = {})
       logger19.warn("DatabaseMigrationService not found - plugin schema migrations skipped");
     }
   } catch (error) {
-    logger19.error("Failed to run plugin migrations:", error);
+    logger19.error({ error }, "Failed to run plugin migrations:");
     throw error;
   }
   server.registerAgent(runtime);
@@ -4872,13 +4904,13 @@ async function startAgents(options) {
   const desiredPort = options.port || Number.parseInt(process.env.SERVER_PORT || "3000");
   const serverPort = await findNextAvailablePort(desiredPort);
   if (serverPort !== desiredPort) {
-    logger20.warn(`Port ${desiredPort} is in use, using port ${serverPort} instead`);
+    logger20.warn({ desiredPort, serverPort }, "Port is in use, using alternate port");
   }
   process.env.SERVER_PORT = serverPort.toString();
   try {
     await server.start(serverPort);
   } catch (error) {
-    logger20.error(`Failed to start server on port ${serverPort}:`, error);
+    logger20.error({ error, serverPort }, `Failed to start server on port:`);
     throw error;
   }
   if (options.projectAgents && options.projectAgents.length > 0) {
@@ -4956,7 +4988,7 @@ var start = new Command7().name("start").description("Build and start the Eliza
             throw new Error(`Invalid character file: ${resolvedPath}`);
           }
         } catch (e) {
-          logger21.error(`Failed to load character from ${resolvedPath}:`, e);
+          logger21.error({ error: e, resolvedPath }, `Failed to load character from path:`);
           throw new Error(`Invalid character file: ${resolvedPath}`);
         }
       }
@@ -4978,7 +5010,7 @@ var start = new Command7().name("start").description("Build and start the Eliza
           }
         }
       } catch (e) {
-        logger21.debug("Failed to load project agents, will use default character:", e);
+        logger21.debug({ error: e }, "Failed to load project agents, will use default character:");
       }
     }
     await startAgents({ ...options, characters, projectAgents });
@@ -5101,7 +5133,7 @@ async function installPluginDependencies(projectInfo) {
       };
       await fs12.promises.writeFile(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
     }
-    const { installPlugin: installPlugin2 } = await import("./utils-DBLSDYBF.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);
@@ -5120,7 +5152,6 @@ async function installPluginDependencies(projectInfo) {
 
 // src/commands/test/actions/component-tests.ts
 import { logger as logger24 } from "@elizaos/core";
-import { spawn as spawn2 } from "child_process";
 import path28 from "path";
 
 // src/utils/testing/tsc-validator.ts
@@ -5152,7 +5183,7 @@ async function runTypeCheck(projectPath, strict = true) {
       warnings: stderr.includes("warning") ? [stderr] : []
     };
   } catch (error) {
-    logger23.error("TypeScript validation failed:", error);
+    logger23.error({ error }, "TypeScript validation failed:");
     return {
       success: false,
       errors: [`TypeScript validation error: ${error.message}`],
@@ -5186,40 +5217,34 @@ async function runComponentTests(testPath, options, projectInfo) {
     }
   }
   logger24.info("Running component tests...");
-  return new Promise((resolve2) => {
-    const args = ["test", "--passWithNoTests"];
-    if (options.name) {
-      const baseName = processFilterName(options.name);
-      if (baseName) {
-        logger24.info(`Using test filter: ${baseName}`);
-        args.push("-t", baseName);
-      }
-    }
-    const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
-    const baseDir = monorepoRoot ?? process.cwd();
-    const targetPath = testPath ? path28.resolve(baseDir, testPath) : process.cwd();
-    logger24.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
-    const child = spawn2("bun", args, {
-      stdio: "inherit",
-      shell: false,
+  const args = ["test", "--passWithNoTests"];
+  if (options.name) {
+    const baseName = processFilterName(options.name);
+    if (baseName) {
+      logger24.info(`Using test filter: ${baseName}`);
+      args.push("-t", baseName);
+    }
+  }
+  const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
+  const baseDir = monorepoRoot ?? process.cwd();
+  const targetPath = testPath ? path28.resolve(baseDir, testPath) : process.cwd();
+  logger24.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
+  try {
+    const result = await bunExecInherit("bun", args, {
       cwd: targetPath,
       env: {
-        ...process.env,
         FORCE_COLOR: "1",
         // Force color output
         CI: ""
         // Override CI to empty string (some tools check existence, but most check truthiness)
       }
     });
-    child.on("close", (code) => {
-      logger24.info("Component tests completed");
-      resolve2({ failed: code !== 0 });
-    });
-    child.on("error", (error) => {
-      logger24.error("Error running component tests:", error);
-      resolve2({ failed: true });
-    });
-  });
+    logger24.info("Component tests completed");
+    return { failed: !result.success };
+  } catch (error) {
+    logger24.error({ error }, "Error running component tests:");
+    return { failed: true };
+  }
 }
 
 // src/commands/test/actions/e2e-tests.ts
@@ -5295,7 +5320,7 @@ async function runE2eTests(testPath, options, projectInfo) {
       });
       logger25.info("Server initialized successfully");
     } catch (initError) {
-      logger25.error("Server initialization failed:", initError);
+      logger25.error({ error: initError }, "Server initialization failed:");
       throw initError;
     }
     let project;
@@ -5325,12 +5350,12 @@ async function runE2eTests(testPath, options, projectInfo) {
       logger25.info("Starting server...");
       try {
         await server.start(serverPort);
-        logger25.info("Server started successfully on port", serverPort);
+        logger25.info({ serverPort }, "Server started successfully on port");
       } catch (error) {
-        logger25.error("Error starting server:", error);
+        logger25.error({ error }, "Error starting server:");
         if (error instanceof Error) {
-          logger25.error("Error details:", error.message);
-          logger25.error("Stack trace:", error.stack);
+          logger25.error({ message: error.message }, "Error details:");
+          logger25.error({ stack: error.stack }, "Stack trace:");
         }
         throw error;
       }
@@ -5365,7 +5390,7 @@ async function runE2eTests(testPath, options, projectInfo) {
             });
             logger25.info("Default test agent started successfully");
           } catch (pluginError) {
-            logger25.error(`Error starting plugin test agent: ${pluginError}`);
+            logger25.error({ error: pluginError }, `Error starting plugin test agent:`);
             throw pluginError;
           }
         } else {
@@ -5385,10 +5410,13 @@ async function runE2eTests(testPath, options, projectInfo) {
               projectAgents.push(agent2);
               await new Promise((resolve2) => setTimeout(resolve2, 1e3));
             } catch (agentError) {
-              logger25.error(`Error starting agent ${agent2.character.name}:`, agentError);
+              logger25.error(
+                { error: agentError, agentName: agent2.character.name },
+                "Error starting agent"
+              );
               if (agentError instanceof Error) {
-                logger25.error("Error details:", agentError.message);
-                logger25.error("Stack trace:", agentError.stack);
+                logger25.error({ message: agentError.message }, "Error details:");
+                logger25.error({ stack: agentError.stack }, "Stack trace:");
               }
               logger25.warn(`Skipping agent ${agent2.character.name} due to startup error`);
             }
@@ -5427,17 +5455,17 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
         return { failed: anyTestsFound ? totalFailed > 0 : false };
       } catch (error) {
-        logger25.error("Error in runE2eTests:", error);
+        logger25.error({ error }, "Error in runE2eTests:");
         if (error instanceof Error) {
-          logger25.error("Error details:", error.message);
-          logger25.error("Stack trace:", error.stack);
+          logger25.error({ message: error.message }, "Error details:");
+          logger25.error({ stack: error.stack }, "Stack trace:");
         } else {
-          logger25.error("Unknown error type:", typeof error);
-          logger25.error("Error value:", error);
+          logger25.error({ type: typeof error }, "Unknown error type:");
+          logger25.error({ error }, "Error value:");
           try {
-            logger25.error("Stringified error:", JSON.stringify(error, null, 2));
+            logger25.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
           } catch (e) {
-            logger25.error("Could not stringify error:", e);
+            logger25.error({ error: e }, "Could not stringify error:");
           }
         }
         return { failed: true };
@@ -5460,33 +5488,33 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
       }
     } catch (error) {
-      logger25.error("Error in runE2eTests:", error);
+      logger25.error({ error }, "Error in runE2eTests:");
       if (error instanceof Error) {
-        logger25.error("Error details:", error.message);
-        logger25.error("Stack trace:", error.stack);
+        logger25.error({ message: error.message }, "Error details:");
+        logger25.error({ stack: error.stack }, "Stack trace:");
       } else {
-        logger25.error("Unknown error type:", typeof error);
-        logger25.error("Error value:", error);
+        logger25.error({ type: typeof error }, "Unknown error type:");
+        logger25.error({ error }, "Error value:");
         try {
-          logger25.error("Stringified error:", JSON.stringify(error, null, 2));
+          logger25.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
         } catch (e) {
-          logger25.error("Could not stringify error:", e);
+          logger25.error({ error: e }, "Could not stringify error:");
         }
       }
       return { failed: true };
     }
   } catch (error) {
-    logger25.error("Error in runE2eTests:", error);
+    logger25.error({ error }, "Error in runE2eTests:");
     if (error instanceof Error) {
-      logger25.error("Error details:", error.message);
-      logger25.error("Stack trace:", error.stack);
+      logger25.error({ message: error.message }, "Error details:");
+      logger25.error({ stack: error.stack }, "Stack trace:");
     } else {
-      logger25.error("Unknown error type:", typeof error);
-      logger25.error("Error value:", error);
+      logger25.error({ type: typeof error }, "Unknown error type:");
+      logger25.error({ error }, "Error value:");
       try {
-        logger25.error("Stringified error:", JSON.stringify(error, null, 2));
+        logger25.error({ stringified: JSON.stringify(error, null, 2) }, "Stringified error:");
       } catch (e) {
-        logger25.error("Could not stringify error:", e);
+        logger25.error({ error: e }, "Could not stringify error:");
       }
     }
     return { failed: true };
@@ -5496,15 +5524,21 @@ async function runE2eTests(testPath, options, projectInfo) {
 // src/commands/test/actions/run-all-tests.ts
 async function runAllTests(testPath, options) {
   const projectInfo = getProjectType(testPath);
+  let componentResult = { failed: false };
   if (!options.skipBuild) {
-    const componentResult = await runComponentTests(testPath, options, projectInfo);
-    if (componentResult.failed) {
-      logger26.error("Component tests failed. Continuing to e2e tests...");
-    }
+    componentResult = await runComponentTests(testPath, options, projectInfo);
+  } else {
+    logger26.info("Skipping component tests due to --skip-build option");
   }
   const e2eResult = await runE2eTests(testPath, options, projectInfo);
-  if (e2eResult.failed) {
-    logger26.error("E2E tests failed.");
+  if (componentResult.failed || e2eResult.failed) {
+    if (componentResult.failed) {
+      logger26.error("Component tests failed.");
+    }
+    if (e2eResult.failed) {
+      logger26.error("E2E tests failed.");
+    }
+    logger26.error("Test suite failed.");
     process.exit(1);
   }
   logger26.success("All tests passed successfully!");
@@ -5599,7 +5633,7 @@ async function gracefulShutdown(signal) {
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     logger29.error(`Error stopping server: ${errorMessage}`);
-    logger29.debug("Full error details:", error);
+    logger29.debug({ error }, "Full error details:");
   }
   const exitCode = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 0;
   process.exit(exitCode);
@@ -5633,6 +5667,6 @@ async function main() {
   await program.parseAsync();
 }
 main().catch((error) => {
-  logger29.error("An error occurred:", error);
+  logger29.error({ error }, "An error occurred:");
   process.exit(1);
 });

package/dist/{plugin-creator-H26ZLR6H.js → plugin-creator-TCUFII32.js}

@@ -1,11 +1,11 @@
 import {
   runBunCommand
-} from "./chunk-FDEDLANP.js";
+} from "./chunk-FQYWRHLX.js";
 import {
   bunExec,
   bunExecInherit,
   bunExecSimple
-} from "./chunk-D3Q2UZLZ.js";
+} from "./chunk-I4L4T7QX.js";
 import "./chunk-3RG5ZIWI.js";
 
 // src/utils/plugin-creator.ts

package/dist/{registry-433S5F3Y.js → registry-ELONUC44.js}

@@ -24,10 +24,10 @@ import {
   setEnvVar,
   setGitHubToken,
   validateDataDir
-} from "./chunk-E6XYTE3A.js";
-import "./chunk-FDEDLANP.js";
+} from "./chunk-N5G5XSGP.js";
+import "./chunk-FQYWRHLX.js";
 import "./chunk-GXWWPFBO.js";
-import "./chunk-D3Q2UZLZ.js";
+import "./chunk-I4L4T7QX.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   checkDataDir,