@elizaos/cli 1.2.3 → 1.2.5

package/dist/bun-exec-4BOHUSSZ.js

@@ -0,0 +1,21 @@
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+import {
+  ProcessExecutionError,
+  ProcessTimeoutError,
+  bunExec,
+  bunExecInherit,
+  bunExecSimple,
+  commandExists
+} from "./chunk-EVE5GO74.js";
+import "./chunk-AQ6OMR2A.js";
+export {
+  ProcessExecutionError,
+  ProcessTimeoutError,
+  bunExec,
+  bunExecInherit,
+  bunExecSimple,
+  commandExists
+};

package/dist/chunk-6ZB77OJK.js

@@ -0,0 +1,154 @@
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+import {
+  bunExec,
+  bunExecInherit
+} from "./chunk-EVE5GO74.js";
+
+// src/utils/emoji-handler.ts
+import { logger } from "@elizaos/core";
+var config = {
+  enabled: true,
+  forceDisable: false
+};
+var EMOJIS = {
+  // Status indicators
+  success: { emoji: "\u2705", fallback: "[OK]" },
+  error: { emoji: "\u274C", fallback: "[ERROR]" },
+  warning: { emoji: "\u26A0\uFE0F", fallback: "[WARNING]" },
+  info: { emoji: "\u2139\uFE0F", fallback: "[INFO]" },
+  // Actions
+  rocket: { emoji: "\u{1F680}", fallback: ">>" },
+  sparkles: { emoji: "\u2728", fallback: "*" },
+  party: { emoji: "\u{1F389}", fallback: "[DONE]" },
+  // Objects/Tools
+  package: { emoji: "\u{1F4E6}", fallback: "[PKG]" },
+  link: { emoji: "\u{1F517}", fallback: "[LINK]" },
+  lightbulb: { emoji: "\u{1F4A1}", fallback: "[TIP]" },
+  clipboard: { emoji: "\u{1F4CB}", fallback: "[LIST]" },
+  // Platforms
+  penguin: { emoji: "\u{1F427}", fallback: "[LINUX]" },
+  globe: { emoji: "\u{1F310}", fallback: "[WEB]" },
+  // Arrows and pointers
+  rightArrow: { emoji: "\u2192", fallback: "->" },
+  bullet: { emoji: "\u2022", fallback: "*" }
+};
+function detectEmojiSupport() {
+  if (config.forceDisable) {
+    return false;
+  }
+  const term = process.env.TERM || "";
+  const termProgram = process.env.TERM_PROGRAM || "";
+  const colorTerm = process.env.COLORTERM;
+  const ciEnv = process.env.CI;
+  if (ciEnv === "true" || process.env.GITHUB_ACTIONS) {
+    return false;
+  }
+  if (process.platform === "win32") {
+    if (termProgram === "vscode" || process.env.WT_SESSION || process.env.WT_PROFILE_ID || termProgram === "Windows Terminal") {
+      return true;
+    }
+    if (process.env.PSModulePath && process.env.POWERSHELL_TELEMETRY_OPTOUT !== void 0) {
+      return true;
+    }
+    return false;
+  }
+  if (process.platform === "darwin" || process.platform === "linux") {
+    if (termProgram === "vscode" || termProgram === "iTerm.app" || termProgram === "Apple_Terminal" || term.includes("xterm") || term.includes("screen") || colorTerm) {
+      return true;
+    }
+  }
+  if (term.includes("256color") || term.includes("truecolor")) {
+    return true;
+  }
+  return false;
+}
+function getEmoji(key) {
+  const emojiDef = EMOJIS[key];
+  if (!emojiDef) {
+    logger.warn(`Unknown emoji key: ${key}`);
+    return "";
+  }
+  return config.enabled && detectEmojiSupport() ? emojiDef.emoji : emojiDef.fallback;
+}
+function configureEmojis(newConfig) {
+  config = { ...config, ...newConfig };
+}
+function withEmoji(key, message, spacing = true) {
+  const emoji2 = getEmoji(key);
+  const space = spacing && emoji2 ? " " : "";
+  return `${emoji2}${space}${message}`;
+}
+var emoji = {
+  success: (msg) => withEmoji("success", msg),
+  error: (msg) => withEmoji("error", msg),
+  warning: (msg) => withEmoji("warning", msg),
+  info: (msg) => withEmoji("info", msg),
+  rocket: (msg) => withEmoji("rocket", msg),
+  package: (msg) => withEmoji("package", msg),
+  link: (msg) => withEmoji("link", msg),
+  tip: (msg) => withEmoji("lightbulb", msg),
+  list: (msg) => withEmoji("clipboard", msg),
+  penguin: (msg) => withEmoji("penguin", msg),
+  bullet: (msg) => withEmoji("bullet", msg)
+};
+function initializeEmojiSupport() {
+  const supported = detectEmojiSupport();
+  if (process.env.DEBUG || process.env.ELIZA_DEBUG) {
+    logger.debug(
+      `Emoji support: ${supported ? "enabled" : "disabled"} (platform: ${process.platform}, term: ${process.env.TERM || "unknown"})`
+    );
+  }
+}
+initializeEmojiSupport();
+
+// src/utils/bun-installation-helper.ts
+import { logger as logger2 } from "@elizaos/core";
+function displayBunInstallationTipCompact() {
+  return "Please install Bun from https://bun.sh";
+}
+
+// src/utils/run-bun.ts
+async function runBunCommand(args, cwd, silent = false) {
+  const finalArgs = [...args];
+  const isInstallCommand = args[0] === "install";
+  const isCI = process.env.CI || process.env.ELIZA_TEST_MODE === "true";
+  if (isCI && isInstallCommand) {
+    if (!finalArgs.includes("--frozen-lockfile")) {
+      finalArgs.push("--frozen-lockfile");
+    }
+    console.info("\u2705 Using CI-optimized flags for faster installation...");
+  }
+  try {
+    const result = silent ? await bunExec("bun", finalArgs, { cwd }) : await bunExecInherit("bun", finalArgs, { cwd });
+    if (silent && !result.success) {
+      throw new Error(
+        `Bun command failed with exit code ${result.exitCode}: ${result.stderr || result.stdout}`
+      );
+    }
+  } catch (error) {
+    if (error.code === "ENOENT" || error.message?.includes("bun: command not found")) {
+      throw new Error(`Bun command not found. ${displayBunInstallationTipCompact()}`);
+    }
+    if (isCI && isInstallCommand && (error.message?.includes("frozen-lockfile") || error.message?.includes("install"))) {
+      console.warn("CI-optimized install failed, retrying with basic args...");
+      const retryResult = silent ? await bunExec("bun", args, { cwd }) : await bunExecInherit("bun", args, { cwd });
+      if (silent && !retryResult.success) {
+        throw new Error(
+          `Bun command failed with exit code ${retryResult.exitCode}: ${retryResult.stderr || retryResult.stdout}`
+        );
+      }
+    } else {
+      throw error;
+    }
+  }
+}
+
+export {
+  configureEmojis,
+  emoji,
+  displayBunInstallationTipCompact,
+  runBunCommand
+};

package/dist/chunk-AQ6OMR2A.js

@@ -0,0 +1,14 @@
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/{chunk-JZG5QBNT.js → chunk-ECH6TQ7M.js}

@@ -12,11 +12,11 @@ import {
   selectEmbeddingModel,
   validateCreateOptions,
   validateProjectName
-} from "./chunk-2XI6N7KN.js";
+} from "./chunk-JR4V32X7.js";
 import {
   displayBanner,
   handleError
-} from "./chunk-PSSTO76B.js";
+} from "./chunk-X5K7QYAH.js";
 
 // src/commands/create/index.ts
 import { Command } from "commander";

package/dist/chunk-EVE5GO74.js

@@ -0,0 +1,183 @@
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+
+// src/utils/bun-exec.ts
+import { logger } from "@elizaos/core";
+var COMMAND_EXISTS_TIMEOUT_MS = 5e3;
+var ProcessExecutionError = class extends Error {
+  constructor(message, exitCode, stderr, command) {
+    super(message);
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.command = command;
+    this.name = "ProcessExecutionError";
+  }
+};
+var ProcessTimeoutError = class extends Error {
+  constructor(message, command, timeout) {
+    super(message);
+    this.command = command;
+    this.timeout = timeout;
+    this.name = "ProcessTimeoutError";
+  }
+};
+function escapeShellArg(arg) {
+  if (arg === "") {
+    return '""';
+  }
+  const escaped = JSON.stringify(arg);
+  return escaped;
+}
+async function readStreamSafe(stream, streamName) {
+  if (!stream || typeof stream === "number") {
+    return "";
+  }
+  try {
+    const text = await new Response(stream).text();
+    return text;
+  } catch (error) {
+    logger.debug(`[bunExec] Error reading ${streamName}:`, error);
+    return "";
+  }
+}
+async function bunExec(command, args = [], options = {}) {
+  let proc = null;
+  let timeoutId = null;
+  try {
+    const escapedArgs = args.map(escapeShellArg);
+    const fullCommand = [command, ...escapedArgs].join(" ");
+    logger.debug(`[bunExec] Executing: ${fullCommand}`);
+    proc = Bun.spawn([command, ...args], {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      stdout: options.stdout || options.stdio || "pipe",
+      stderr: options.stderr || options.stdio || "pipe"
+    });
+    if (options.signal) {
+      options.signal.addEventListener("abort", () => {
+        if (proc && proc.exitCode === null) {
+          proc.kill();
+        }
+      });
+    }
+    const timeoutPromise = new Promise((_, reject) => {
+      if (options.timeout && options.timeout > 0) {
+        const timeoutMs = options.timeout;
+        timeoutId = setTimeout(() => {
+          if (proc && proc.exitCode === null) {
+            proc.kill();
+          }
+          reject(
+            new ProcessTimeoutError(
+              `Command timed out after ${timeoutMs}ms`,
+              fullCommand,
+              timeoutMs
+            )
+          );
+        }, timeoutMs);
+      }
+    });
+    const [stdout, stderr, exitCode] = await Promise.race([
+      // Normal execution path - all operations run concurrently
+      Promise.all([
+        readStreamSafe(proc.stdout, "stdout"),
+        readStreamSafe(proc.stderr, "stderr"),
+        proc.exited
+      ]),
+      // Timeout path
+      timeoutPromise
+    ]);
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    const success = exitCode === 0;
+    if (!success && options.stdio !== "ignore") {
+      logger.debug(`[bunExec] Command failed with exit code ${exitCode}`);
+      if (stderr) {
+        logger.debug(`[bunExec] stderr: ${stderr}`);
+      }
+    }
+    return {
+      stdout: stdout.trim(),
+      stderr: stderr.trim(),
+      exitCode,
+      success
+    };
+  } catch (error) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    if (error instanceof ProcessTimeoutError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      throw new ProcessExecutionError(
+        `Command execution failed: ${error.message}`,
+        null,
+        "",
+        command
+      );
+    }
+    throw error;
+  } finally {
+    if (proc && proc.exitCode === null) {
+      try {
+        proc.kill();
+        logger.debug("[bunExec] Killed still-running process in cleanup");
+      } catch (cleanupError) {
+        logger.debug(
+          "[bunExec] Process cleanup error (process may have already exited):",
+          cleanupError
+        );
+      }
+    }
+  }
+}
+async function bunExecSimple(command, args = [], options = {}) {
+  const result = await bunExec(command, args, options);
+  if (!result.success && options.stdio !== "ignore") {
+    throw new ProcessExecutionError(
+      `Command failed: ${command} ${args.map(escapeShellArg).join(" ")}`,
+      result.exitCode,
+      result.stderr,
+      command
+    );
+  }
+  return { stdout: result.stdout };
+}
+async function bunExecInherit(command, args = [], options = {}) {
+  return bunExec(command, args, {
+    ...options,
+    stdio: "inherit"
+  });
+}
+async function commandExists(command) {
+  try {
+    if (process.platform === "win32") {
+      const result = await bunExec("where", [command], {
+        stdio: "ignore",
+        timeout: COMMAND_EXISTS_TIMEOUT_MS
+      });
+      return result.success;
+    } else {
+      const result = await bunExec("which", [command], {
+        stdio: "ignore",
+        timeout: COMMAND_EXISTS_TIMEOUT_MS
+      });
+      return result.success;
+    }
+  } catch {
+    return false;
+  }
+}
+
+export {
+  ProcessExecutionError,
+  ProcessTimeoutError,
+  bunExec,
+  bunExecSimple,
+  bunExecInherit,
+  commandExists
+};