@elizaos/cli 1.4.3 → 1.4.5

package/dist/chunk-WX37MM4G.js

@@ -0,0 +1,292 @@
+import {
+  UserEnvironment,
+  createEnvFileService,
+  detectPluginContext,
+  getCliInstallTag,
+  installPlugin,
+  loadPluginModule,
+  provideLocalPluginGuidance
+} from "./chunk-Q6M2K53X.js";
+
+// src/commands/start/actions/agent-start.ts
+import {
+  AgentRuntime,
+  encryptedCharacter,
+  logger as logger3,
+  stringToUuid
+} from "@elizaos/core";
+import { plugin as sqlPlugin } from "@elizaos/plugin-sql";
+
+// src/commands/start/utils/config-utils.ts
+import dotenv from "dotenv";
+
+// src/commands/env/utils/file-operations.ts
+import { existsSync } from "fs";
+import path from "path";
+async function getLocalEnvPath() {
+  const localEnvPath = path.join(process.cwd(), ".env");
+  return existsSync(localEnvPath) ? localEnvPath : null;
+}
+async function parseEnvFile(filePath) {
+  const service = createEnvFileService(filePath);
+  return service.read();
+}
+async function writeEnvFile(filePath, envVars) {
+  const service = createEnvFileService(filePath);
+  await service.write(envVars, {
+    preserveComments: true,
+    updateProcessEnv: true
+  });
+}
+async function resetEnvFile(filePath) {
+  try {
+    if (!existsSync(filePath)) {
+      return false;
+    }
+    const service = createEnvFileService(filePath);
+    const envVars = await service.read();
+    if (Object.keys(envVars).length === 0) {
+      return false;
+    }
+    const resetVars = Object.keys(envVars).reduce((acc, key) => {
+      acc[key] = "";
+      return acc;
+    }, {});
+    await service.write(resetVars, {
+      preserveComments: true,
+      updateProcessEnv: false
+      // Don't update process.env with empty values
+    });
+    return true;
+  } catch (error) {
+    console.error(
+      `Error resetting environment file: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+}
+
+// src/commands/start/utils/config-utils.ts
+async function loadEnvConfig() {
+  const envInfo = await UserEnvironment.getInstanceInfo();
+  if (envInfo.paths.envFilePath) {
+    dotenv.config({ path: envInfo.paths.envFilePath });
+  }
+  return process.env;
+}
+function hasCharacterSecrets(character) {
+  return character?.settings?.secrets && Object.keys(character.settings.secrets).length > 0;
+}
+function ensureCharacterSettings(character) {
+  if (!character.settings) {
+    character.settings = {};
+  }
+}
+async function loadLocalEnvSecrets() {
+  const envPath = await getLocalEnvPath();
+  if (!envPath) {
+    return null;
+  }
+  return await parseEnvFile(envPath);
+}
+async function setDefaultSecretsFromEnv(character) {
+  ensureCharacterSettings(character);
+  if (hasCharacterSecrets(character)) {
+    return false;
+  }
+  const envSecrets = await loadLocalEnvSecrets();
+  if (!envSecrets) {
+    return false;
+  }
+  character.settings.secrets = envSecrets;
+  return true;
+}
+
+// src/commands/start/utils/dependency-resolver.ts
+import { logger } from "@elizaos/core";
+function resolvePluginDependencies(availablePlugins, isTestMode = false) {
+  const resolutionOrder = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(pluginName) {
+    if (!availablePlugins.has(pluginName)) {
+      logger.warn(`Plugin dependency "${pluginName}" not found and will be skipped.`);
+      return;
+    }
+    if (visited.has(pluginName)) return;
+    if (visiting.has(pluginName)) {
+      logger.error(`Circular dependency detected involving plugin: ${pluginName}`);
+      return;
+    }
+    visiting.add(pluginName);
+    const plugin = availablePlugins.get(pluginName);
+    if (plugin) {
+      const deps = [...plugin.dependencies || []];
+      if (isTestMode) {
+        deps.push(...plugin.testDependencies || []);
+      }
+      for (const dep of deps) {
+        visit(dep);
+      }
+    }
+    visiting.delete(pluginName);
+    visited.add(pluginName);
+    resolutionOrder.push(pluginName);
+  }
+  for (const name of availablePlugins.keys()) {
+    if (!visited.has(name)) {
+      visit(name);
+    }
+  }
+  const finalPlugins = resolutionOrder.map((name) => availablePlugins.get(name)).filter((p) => p);
+  logger.info({ plugins: finalPlugins.map((p) => p.name) }, `Final plugins being loaded:`);
+  return finalPlugins;
+}
+
+// src/commands/start/utils/plugin-utils.ts
+import { logger as logger2 } from "@elizaos/core";
+function isValidPluginShape(obj) {
+  if (!obj || typeof obj !== "object" || !obj.name) {
+    return false;
+  }
+  return !!(obj.init || obj.services || obj.providers || obj.actions || obj.evaluators || obj.description);
+}
+async function loadAndPreparePlugin(pluginName) {
+  const version = getCliInstallTag();
+  let pluginModule;
+  const context = detectPluginContext(pluginName);
+  if (context.isLocalDevelopment) {
+    try {
+      pluginModule = await loadPluginModule(pluginName);
+      if (!pluginModule) {
+        logger2.error(`Failed to load local plugin ${pluginName}.`);
+        provideLocalPluginGuidance(pluginName, context);
+        return null;
+      }
+    } catch (error) {
+      logger2.error(`Error loading local plugin ${pluginName}: ${error}`);
+      provideLocalPluginGuidance(pluginName, context);
+      return null;
+    }
+  } else {
+    try {
+      pluginModule = await loadPluginModule(pluginName);
+      if (!pluginModule) {
+        logger2.info(`Plugin ${pluginName} not available, installing...`);
+        await installPlugin(pluginName, process.cwd(), version);
+        pluginModule = await loadPluginModule(pluginName);
+      }
+    } catch (error) {
+      logger2.error(`Failed to process plugin ${pluginName}: ${error}`);
+      return null;
+    }
+  }
+  if (!pluginModule) {
+    logger2.error(`Failed to load module for plugin ${pluginName}.`);
+    return null;
+  }
+  const expectedFunctionName = `${pluginName.replace(/^@elizaos\/plugin-/, "").replace(/^@elizaos\//, "").replace(/-./g, (match) => match[1].toUpperCase())}Plugin`;
+  const exportsToCheck = [
+    pluginModule[expectedFunctionName],
+    pluginModule.default,
+    ...Object.values(pluginModule)
+  ];
+  for (const potentialPlugin of exportsToCheck) {
+    if (isValidPluginShape(potentialPlugin)) {
+      return potentialPlugin;
+    }
+  }
+  logger2.warn(`Could not find a valid plugin export in ${pluginName}.`);
+  return null;
+}
+
+// src/commands/start/actions/agent-start.ts
+async function startAgent(character, server, init, plugins = [], options = {}) {
+  character.id ??= stringToUuid(character.name);
+  if (!hasCharacterSecrets(character)) {
+    await setDefaultSecretsFromEnv(character);
+  }
+  const loadedPlugins = /* @__PURE__ */ new Map();
+  const pluginsToLoad = new Set(character.plugins || []);
+  for (const p of plugins) {
+    if (typeof p === "string") {
+      pluginsToLoad.add(p);
+    } else if (isValidPluginShape(p) && !loadedPlugins.has(p.name)) {
+      loadedPlugins.set(p.name, p);
+      (p.dependencies || []).forEach((dep) => pluginsToLoad.add(dep));
+      if (options.isTestMode) {
+        (p.testDependencies || []).forEach((dep) => pluginsToLoad.add(dep));
+      }
+    }
+  }
+  const allAvailablePlugins = /* @__PURE__ */ new Map();
+  for (const p of loadedPlugins.values()) {
+    allAvailablePlugins.set(p.name, p);
+  }
+  for (const name of pluginsToLoad) {
+    if (!allAvailablePlugins.has(name)) {
+      const loaded = await loadAndPreparePlugin(name);
+      if (loaded) {
+        allAvailablePlugins.set(loaded.name, loaded);
+      }
+    }
+  }
+  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 AgentRuntime({
+    character: encryptedCharacter(character),
+    plugins: finalPlugins,
+    settings: await loadEnvConfig()
+  });
+  const initWrapper = async (runtime2) => {
+    if (init) {
+      await init(runtime2);
+    }
+  };
+  await initWrapper(runtime);
+  await runtime.initialize();
+  try {
+    const migrationService = runtime.getService("database_migration");
+    if (migrationService) {
+      logger3.info("Discovering plugin schemas for dynamic migration...");
+      migrationService.discoverAndRegisterPluginSchemas(finalPlugins);
+      logger3.info("Running all plugin migrations...");
+      await migrationService.runAllPluginMigrations();
+      logger3.info("All plugin migrations completed successfully");
+    } else {
+      logger3.warn("DatabaseMigrationService not found - plugin schema migrations skipped");
+    }
+  } catch (error) {
+    logger3.error({ error }, "Failed to run plugin migrations:");
+    throw error;
+  }
+  server.registerAgent(runtime);
+  logger3.log(`Started ${runtime.character.name} as ${runtime.agentId}`);
+  return runtime;
+}
+async function stopAgent(runtime, server) {
+  await runtime.close();
+  server.unregisterAgent(runtime.agentId);
+  logger3.success(`Agent ${runtime.character.name} stopped successfully!`);
+}
+
+export {
+  getLocalEnvPath,
+  parseEnvFile,
+  writeEnvFile,
+  resetEnvFile,
+  loadEnvConfig,
+  setDefaultSecretsFromEnv,
+  loadAndPreparePlugin,
+  startAgent,
+  stopAgent
+};

package/dist/chunk-XFJIHUT3.js

@@ -0,0 +1,6 @@
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/generated/version.js
+var packageVersion = "22.15.0";
+
+export {
+  packageVersion
+};