@elizaos/cli 1.0.6 → 1.0.8

package/dist/chunk-F24MS2YR.js

@@ -0,0 +1,19 @@
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+
+// src/commands/shared/url-utils.ts
+function getAgentRuntimeUrl(opts) {
+  return opts.remoteUrl?.replace(/\/$/, "") || // Use the flag if provided
+  process.env.AGENT_RUNTIME_URL?.replace(/\/$/, "") || // Fallback to env var
+  `http://localhost:${opts.port || process.env.SERVER_PORT || "3000"}`;
+}
+function getAgentsBaseUrl(opts) {
+  return `${getAgentRuntimeUrl(opts)}/api/agents`;
+}
+
+export {
+  getAgentRuntimeUrl,
+  getAgentsBaseUrl
+};

package/dist/{chunk-7HDCC22V.js → chunk-IEKLJDUU.js}

@@ -764,7 +764,106 @@ var require_src = __commonJS({
   }
 });
 
+// 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();
+
 export {
+  configureEmojis,
+  emoji,
   require_ms,
   require_supports_color,
   require_src

package/dist/chunk-MA2ZXPG6.js

@@ -0,0 +1,260 @@
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+import {
+  __commonJS,
+  __require
+} from "./chunk-567UPUC7.js";
+
+// ../../node_modules/isexe/dist/cjs/posix.js
+var require_posix = __commonJS({
+  "../../node_modules/isexe/dist/cjs/posix.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.sync = exports.isexe = void 0;
+    var fs_1 = __require("fs");
+    var promises_1 = __require("fs/promises");
+    var isexe = async (path, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat(await (0, promises_1.stat)(path), options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    };
+    exports.isexe = isexe;
+    var sync = (path, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat((0, fs_1.statSync)(path), options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    };
+    exports.sync = sync;
+    var checkStat = (stat, options) => stat.isFile() && checkMode(stat, options);
+    var checkMode = (stat, options) => {
+      const myUid = options.uid ?? process.getuid?.();
+      const myGroups = options.groups ?? process.getgroups?.() ?? [];
+      const myGid = options.gid ?? process.getgid?.() ?? myGroups[0];
+      if (myUid === void 0 || myGid === void 0) {
+        throw new Error("cannot get uid or gid");
+      }
+      const groups = /* @__PURE__ */ new Set([myGid, ...myGroups]);
+      const mod = stat.mode;
+      const uid = stat.uid;
+      const gid = stat.gid;
+      const u = parseInt("100", 8);
+      const g = parseInt("010", 8);
+      const o = parseInt("001", 8);
+      const ug = u | g;
+      return !!(mod & o || mod & g && groups.has(gid) || mod & u && uid === myUid || mod & ug && myUid === 0);
+    };
+  }
+});
+
+// ../../node_modules/isexe/dist/cjs/win32.js
+var require_win32 = __commonJS({
+  "../../node_modules/isexe/dist/cjs/win32.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.sync = exports.isexe = void 0;
+    var fs_1 = __require("fs");
+    var promises_1 = __require("fs/promises");
+    var isexe = async (path, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat(await (0, promises_1.stat)(path), path, options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    };
+    exports.isexe = isexe;
+    var sync = (path, options = {}) => {
+      const { ignoreErrors = false } = options;
+      try {
+        return checkStat((0, fs_1.statSync)(path), path, options);
+      } catch (e) {
+        const er = e;
+        if (ignoreErrors || er.code === "EACCES")
+          return false;
+        throw er;
+      }
+    };
+    exports.sync = sync;
+    var checkPathExt = (path, options) => {
+      const { pathExt = process.env.PATHEXT || "" } = options;
+      const peSplit = pathExt.split(";");
+      if (peSplit.indexOf("") !== -1) {
+        return true;
+      }
+      for (let i = 0; i < peSplit.length; i++) {
+        const p = peSplit[i].toLowerCase();
+        const ext = path.substring(path.length - p.length).toLowerCase();
+        if (p && ext === p) {
+          return true;
+        }
+      }
+      return false;
+    };
+    var checkStat = (stat, path, options) => stat.isFile() && checkPathExt(path, options);
+  }
+});
+
+// ../../node_modules/isexe/dist/cjs/options.js
+var require_options = __commonJS({
+  "../../node_modules/isexe/dist/cjs/options.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/isexe/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "../../node_modules/isexe/dist/cjs/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.sync = exports.isexe = exports.posix = exports.win32 = void 0;
+    var posix = __importStar(require_posix());
+    exports.posix = posix;
+    var win32 = __importStar(require_win32());
+    exports.win32 = win32;
+    __exportStar(require_options(), exports);
+    var platform = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
+    var impl = platform === "win32" ? win32 : posix;
+    exports.isexe = impl.isexe;
+    exports.sync = impl.sync;
+  }
+});
+
+// ../../node_modules/which/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/which/lib/index.js"(exports, module) {
+    var { isexe, sync: isexeSync } = require_cjs();
+    var { join, delimiter, sep, posix } = __require("path");
+    var isWindows = process.platform === "win32";
+    var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
+    var rRel = new RegExp(`^\\.${rSlash.source}`);
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, {
+      path: optPath = process.env.PATH,
+      pathExt: optPathExt = process.env.PATHEXT,
+      delimiter: optDelimiter = delimiter
+    }) => {
+      const pathEnv = cmd.match(rSlash) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(optPath || /* istanbul ignore next: very unusual */
+        "").split(optDelimiter)
+      ];
+      if (isWindows) {
+        const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+        const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
+        if (cmd.includes(".") && pathExt[0] !== "") {
+          pathExt.unshift("");
+        }
+        return { pathEnv, pathExt, pathExtExe };
+      }
+      return { pathEnv, pathExt: [""] };
+    };
+    var getPathPart = (raw, cmd) => {
+      const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+      const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
+      return prefix + join(pathPart, cmd);
+    };
+    var which = async (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const envPart of pathEnv) {
+        const p = getPathPart(envPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    var whichSync = (cmd, opt = {}) => {
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (const pathEnvPart of pathEnv) {
+        const p = getPathPart(pathEnvPart, cmd);
+        for (const ext of pathExt) {
+          const withExt = p + ext;
+          const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+          if (is) {
+            if (!opt.all) {
+              return withExt;
+            }
+            found.push(withExt);
+          }
+        }
+      }
+      if (opt.all && found.length) {
+        return found;
+      }
+      if (opt.nothrow) {
+        return null;
+      }
+      throw getNotFoundError(cmd);
+    };
+    module.exports = which;
+    which.sync = whichSync;
+  }
+});
+
+export {
+  require_lib
+};