@elizaos/cli 1.4.4 → 1.4.5

package/dist/parameter-override-ALOPPXCE.js

@@ -0,0 +1,487 @@
+import "./chunk-2ESYSVXG.js";
+
+// src/commands/scenario/src/path-parser.ts
+var pathCache = /* @__PURE__ */ new Map();
+function parseParameterPath(path) {
+  if (pathCache.has(path)) {
+    return pathCache.get(path);
+  }
+  if (!path || typeof path !== "string") {
+    throw new Error("Path must be a non-empty string");
+  }
+  if (path.startsWith(".") || path.endsWith(".")) {
+    throw new Error("Path cannot start or end with a dot");
+  }
+  const segments = [];
+  let hasArrayAccess = false;
+  let currentSegment = "";
+  let i = 0;
+  let lastCharWasArrayClose = false;
+  while (i < path.length) {
+    const char = path[i];
+    if (char === ".") {
+      if (currentSegment === "" && !lastCharWasArrayClose) {
+        throw new Error("Empty segment in path (double dots or leading/trailing dots not allowed)");
+      } else if (currentSegment === "" && i === 0) {
+        throw new Error("Path cannot start or end with a dot");
+      } else if (currentSegment !== "") {
+        segments.push(currentSegment);
+        currentSegment = "";
+      }
+      lastCharWasArrayClose = false;
+    } else if (char === "[") {
+      if (currentSegment === "") {
+        throw new Error("Array access must follow a property name");
+      }
+      segments.push(currentSegment);
+      currentSegment = "";
+      const closingBracket = path.indexOf("]", i);
+      if (closingBracket === -1) {
+        throw new Error("Missing closing bracket for array index");
+      }
+      const indexStr = path.substring(i + 1, closingBracket);
+      if (!/^\d+$/.test(indexStr)) {
+        throw new Error(`Invalid array index: ${indexStr}`);
+      }
+      const index = parseInt(indexStr, 10);
+      segments.push(index);
+      hasArrayAccess = true;
+      i = closingBracket;
+      lastCharWasArrayClose = true;
+    } else if (char === "]") {
+      throw new Error("Unexpected closing bracket");
+    } else {
+      currentSegment += char;
+      lastCharWasArrayClose = false;
+    }
+    i++;
+  }
+  if (currentSegment !== "") {
+    segments.push(currentSegment);
+  } else if (path.endsWith(".")) {
+    throw new Error("Path cannot start or end with a dot");
+  }
+  if (segments.length === 0) {
+    throw new Error("Path cannot be empty");
+  }
+  for (const segment of segments) {
+    if (typeof segment === "string") {
+      if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(segment)) {
+        throw new Error(`Invalid property name in path: '${segment}'`);
+      }
+    }
+  }
+  const result = {
+    segments,
+    hasArrayAccess,
+    originalPath: path
+  };
+  pathCache.set(path, result);
+  return result;
+}
+function isValidPathSyntax(path) {
+  try {
+    parseParameterPath(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeParameterPath(path) {
+  if (!path || typeof path !== "string") {
+    return "";
+  }
+  let normalized = path.trim();
+  normalized = normalized.replace(/\.+/g, ".");
+  normalized = normalized.replace(/^\.+|\.+$/g, "");
+  return normalized;
+}
+
+// src/commands/scenario/src/deep-clone.ts
+var cloneCache = /* @__PURE__ */ new WeakMap();
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (cloneCache.has(obj)) {
+    throw new Error("Circular reference detected in object to clone");
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (obj instanceof Error) {
+    const cloned = new obj.constructor(obj.message);
+    cloned.stack = obj.stack;
+    cloned.name = obj.name;
+    return cloned;
+  }
+  if (Array.isArray(obj)) {
+    cloneCache.set(obj, true);
+    try {
+      const cloned = obj.map((item) => deepClone(item));
+      cloneCache.delete(obj);
+      return cloned;
+    } catch (error) {
+      cloneCache.delete(obj);
+      throw error;
+    }
+  }
+  if (obj.constructor === Object || obj.constructor === void 0) {
+    cloneCache.set(obj, true);
+    try {
+      const cloned = {};
+      for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+          cloned[key] = deepClone(obj[key]);
+        }
+      }
+      cloneCache.delete(obj);
+      return cloned;
+    } catch (error) {
+      cloneCache.delete(obj);
+      throw error;
+    }
+  }
+  try {
+    const cloned = Object.create(Object.getPrototypeOf(obj));
+    cloneCache.set(obj, true);
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        cloned[key] = deepClone(obj[key]);
+      }
+    }
+    cloneCache.delete(obj);
+    return cloned;
+  } catch {
+    return obj;
+  }
+}
+function hasCircularReference(obj) {
+  const visited = /* @__PURE__ */ new WeakSet();
+  function checkCircular(current) {
+    if (current === null || typeof current !== "object") {
+      return false;
+    }
+    if (visited.has(current)) {
+      return true;
+    }
+    visited.add(current);
+    if (Array.isArray(current)) {
+      for (const item of current) {
+        if (checkCircular(item)) {
+          return true;
+        }
+      }
+    } else {
+      for (const key in current) {
+        if (current.hasOwnProperty(key)) {
+          if (checkCircular(current[key])) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  return checkCircular(obj);
+}
+function deepCloneWithLimit(obj, maxDepth = 50) {
+  function cloneWithDepth(current, depth) {
+    if (depth >= maxDepth) {
+      if (typeof current === "object" && current !== null) {
+        if (Array.isArray(current)) {
+          return [...current];
+        }
+        return { ...current };
+      }
+      return current;
+    }
+    if (current === null || typeof current !== "object") {
+      return current;
+    }
+    if (current instanceof Date) {
+      return new Date(current.getTime());
+    }
+    if (current instanceof RegExp) {
+      return new RegExp(current.source, current.flags);
+    }
+    if (Array.isArray(current)) {
+      return current.map((item) => cloneWithDepth(item, depth + 1));
+    }
+    const cloned = {};
+    for (const key in current) {
+      if (current.hasOwnProperty(key)) {
+        cloned[key] = cloneWithDepth(current[key], depth + 1);
+      }
+    }
+    return cloned;
+  }
+  return cloneWithDepth(obj, 0);
+}
+
+// src/commands/scenario/src/parameter-override.ts
+function validateParameterPath(obj, path) {
+  if (!obj || typeof obj !== "object") {
+    return {
+      isValid: false,
+      error: "Target object is null or not an object",
+      pathExists: false,
+      targetType: typeof obj
+    };
+  }
+  try {
+    const parsedPath = parseParameterPath(path);
+    let current = obj;
+    let currentPath = "";
+    for (let i = 0; i < parsedPath.segments.length; i++) {
+      const segment = parsedPath.segments[i];
+      if (typeof segment === "number") {
+        currentPath += `[${segment}]`;
+        if (!Array.isArray(current)) {
+          return {
+            isValid: false,
+            error: `Expected array at path '${currentPath}', but found ${typeof current}`,
+            pathExists: false,
+            targetType: typeof current
+          };
+        }
+        if (segment >= current.length || segment < 0) {
+          return {
+            isValid: false,
+            error: `Array index ${segment} is out of bounds at path '${currentPath}' (array length: ${current.length})`,
+            suggestion: segment >= current.length ? `Use index 0-${current.length - 1} or add more elements to the array` : "Array indices must be non-negative",
+            pathExists: false,
+            targetType: "array"
+          };
+        }
+        current = current[segment];
+      } else {
+        currentPath += currentPath ? `.${segment}` : segment;
+        if (!current || typeof current !== "object") {
+          return {
+            isValid: false,
+            error: `Expected object at path '${currentPath}', but found ${typeof current}`,
+            pathExists: false,
+            targetType: typeof current
+          };
+        }
+        if (!(segment in current)) {
+          const availableProps = Object.keys(current).slice(0, 5);
+          const suggestion = availableProps.length > 0 ? `Available properties: ${availableProps.join(", ")}${Object.keys(current).length > 5 ? "..." : ""}` : "Object has no properties";
+          return {
+            isValid: false,
+            error: `Property '${segment}' does not exist at path '${currentPath}'`,
+            suggestion,
+            pathExists: false,
+            targetType: "object"
+          };
+        }
+        current = current[segment];
+      }
+    }
+    return {
+      isValid: true,
+      pathExists: true,
+      targetType: Array.isArray(current) ? "array" : typeof current
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    let suggestion = "";
+    if (errorMessage.includes("bracket")) {
+      suggestion = "Use bracket notation for arrays: run[0].input instead of run.0.input";
+    } else if (errorMessage.includes("invalid")) {
+      suggestion = "Check path syntax: use dots for objects and brackets for arrays";
+    }
+    return {
+      isValid: false,
+      error: `Invalid path format: ${errorMessage}`,
+      suggestion,
+      pathExists: false
+    };
+  }
+}
+function validateParameterPathLegacy(obj, path) {
+  const result = validateParameterPath(obj, path);
+  return result.isValid;
+}
+function getValueAtPath(obj, path) {
+  const parsedPath = parseParameterPath(path);
+  let current = obj;
+  for (let i = 0; i < parsedPath.segments.length; i++) {
+    const segment = parsedPath.segments[i];
+    if (typeof segment === "number") {
+      if (!Array.isArray(current)) {
+        throw new Error(
+          `Expected array at path segment, but found ${typeof current} in path: ${path}`
+        );
+      }
+      if (segment >= current.length || segment < 0) {
+        throw new Error(`Array index out of bounds: ${segment} in path: ${path}`);
+      }
+      current = current[segment];
+    } else {
+      if (!current || typeof current !== "object") {
+        throw new Error(
+          `Expected object at path segment, but found ${typeof current} in path: ${path}`
+        );
+      }
+      if (!(segment in current)) {
+        throw new Error(`Property '${segment}' not found in path: ${path}`);
+      }
+      current = current[segment];
+    }
+  }
+  return current;
+}
+function setValueAtPath(obj, path, value) {
+  const parsedPath = parseParameterPath(path);
+  let current = obj;
+  for (let i = 0; i < parsedPath.segments.length - 1; i++) {
+    const segment = parsedPath.segments[i];
+    if (typeof segment === "number") {
+      if (!Array.isArray(current)) {
+        throw new Error(
+          `Expected array at path segment, but found ${typeof current} in path: ${path}`
+        );
+      }
+      if (segment >= current.length || segment < 0) {
+        throw new Error(`Array index out of bounds: ${segment} in path: ${path}`);
+      }
+      current = current[segment];
+    } else {
+      if (!current || typeof current !== "object") {
+        throw new Error(
+          `Expected object at path segment, but found ${typeof current} in path: ${path}`
+        );
+      }
+      if (!(segment in current)) {
+        throw new Error(`Property '${segment}' not found in path: ${path}`);
+      }
+      current = current[segment];
+    }
+  }
+  const finalSegment = parsedPath.segments[parsedPath.segments.length - 1];
+  if (typeof finalSegment === "number") {
+    if (!Array.isArray(current)) {
+      throw new Error(
+        `Expected array for final segment, but found ${typeof current} in path: ${path}`
+      );
+    }
+    if (finalSegment >= current.length || finalSegment < 0) {
+      throw new Error(`Array index out of bounds: ${finalSegment} in path: ${path}`);
+    }
+    current[finalSegment] = value;
+  } else {
+    if (!current || typeof current !== "object") {
+      throw new Error(
+        `Expected object for final segment, but found ${typeof current} in path: ${path}`
+      );
+    }
+    current[finalSegment] = value;
+  }
+}
+function applyParameterOverride(scenario, path, value) {
+  const clonedScenario = deepClone(scenario);
+  setValueAtPath(clonedScenario, path, value);
+  return clonedScenario;
+}
+function applyMatrixOverrides(baseScenario, overrides) {
+  const parameterOverrides = Object.entries(overrides).map(
+    ([path, value]) => ({
+      path,
+      value
+    })
+  );
+  return applyParameterOverrides(baseScenario, parameterOverrides);
+}
+function applyParameterOverrides(baseScenario, overrides) {
+  if (!baseScenario || typeof baseScenario !== "object") {
+    throw new Error("Base scenario must be a valid object");
+  }
+  if (!Array.isArray(overrides)) {
+    throw new Error("Overrides must be an array");
+  }
+  const modifiedScenario = deepClone(baseScenario);
+  for (const override of overrides) {
+    if (!override || typeof override !== "object") {
+      throw new Error("Each override must be an object with path and value properties");
+    }
+    if (!override.path || typeof override.path !== "string") {
+      throw new Error("Override path must be a non-empty string");
+    }
+    try {
+      const parsedPath = parseParameterPath(override.path);
+      let current = modifiedScenario;
+      for (let i = 0; i < parsedPath.segments.length; i++) {
+        const segment = parsedPath.segments[i];
+        if (typeof segment === "number") {
+          if (!Array.isArray(current)) {
+            throw new Error(`Expected array but found ${typeof current} at path: ${override.path}`);
+          }
+          if (segment >= current.length || segment < 0) {
+            throw new Error(`Array index out of bounds: ${segment} in path: ${override.path}`);
+          }
+          current = current[segment];
+        } else {
+          if (!current || typeof current !== "object" || !(segment in current)) {
+            throw new Error(`Invalid parameter path: ${override.path}`);
+          }
+          current = current[segment];
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw new Error(`Invalid parameter path: ${override.path}`);
+    }
+    try {
+      setValueAtPath(modifiedScenario, override.path, override.value);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to apply override for path '${override.path}': ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  return modifiedScenario;
+}
+function combinationToOverrides(combination) {
+  return Object.entries(combination).map(([path, value]) => ({
+    path,
+    value
+  }));
+}
+function validateMatrixParameterPaths(baseScenario, matrixAxes) {
+  const invalidPaths = [];
+  for (const axis of matrixAxes) {
+    const validation = validateParameterPath(baseScenario, axis.parameter);
+    if (!validation.isValid) {
+      invalidPaths.push(axis.parameter);
+    }
+  }
+  return {
+    valid: invalidPaths.length === 0,
+    invalidPaths
+  };
+}
+export {
+  applyMatrixOverrides,
+  applyParameterOverride,
+  applyParameterOverrides,
+  combinationToOverrides,
+  deepClone,
+  deepCloneWithLimit,
+  getValueAtPath,
+  hasCircularReference,
+  isValidPathSyntax,
+  normalizeParameterPath,
+  parseParameterPath,
+  setValueAtPath,
+  validateMatrixParameterPaths,
+  validateParameterPath,
+  validateParameterPathLegacy
+};

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

@@ -6,7 +6,7 @@ import {
   bunExecInherit,
   bunExecSimple
 } from "./chunk-I4L4T7QX.js";
-import "./chunk-3RG5ZIWI.js";
+import "./chunk-2ESYSVXG.js";
 
 // src/utils/plugin-creator.ts
 import Anthropic from "@anthropic-ai/sdk";

package/dist/process-manager-IU2A3BTQ.js

@@ -0,0 +1,9 @@
+import {
+  ProcessManager,
+  processManager
+} from "./chunk-I57T3WPO.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  ProcessManager,
+  processManager
+};

package/dist/{registry-ELONUC44.js → registry-65KMEA7N.js}

@@ -24,11 +24,11 @@ import {
   setEnvVar,
   setGitHubToken,
   validateDataDir
-} from "./chunk-N5G5XSGP.js";
+} from "./chunk-Q6M2K53X.js";
 import "./chunk-FQYWRHLX.js";
 import "./chunk-GXWWPFBO.js";
 import "./chunk-I4L4T7QX.js";
-import "./chunk-3RG5ZIWI.js";
+import "./chunk-2ESYSVXG.js";
 export {
   checkDataDir,
   ensureElizaDir,

package/dist/resource-monitor-EHZSH2P6.js

@@ -0,0 +1,15 @@
+import {
+  ResourceMonitor,
+  calculateDiskUsage,
+  createResourceMonitor,
+  formatBytes,
+  getSystemResources
+} from "./chunk-3AEYIKBZ.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  ResourceMonitor,
+  calculateDiskUsage,
+  createResourceMonitor,
+  formatBytes,
+  getSystemResources
+};

package/dist/run-isolation-PGLZ37Y7.js

@@ -0,0 +1,29 @@
+import {
+  checkDiskSpace,
+  cleanupIsolatedEnvironment,
+  createIsolatedEnvironment,
+  createIsolatedEnvironmentVariables,
+  ensureIsolatedDatabase,
+  estimateRunDiskSpace,
+  generateRunId,
+  getIsolatedTempDir,
+  monitorIsolatedResources,
+  resetRunSequence,
+  validateIsolationContext,
+  writeTemporaryScenario
+} from "./chunk-LBZLMFFF.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  checkDiskSpace,
+  cleanupIsolatedEnvironment,
+  createIsolatedEnvironment,
+  createIsolatedEnvironmentVariables,
+  ensureIsolatedDatabase,
+  estimateRunDiskSpace,
+  generateRunId,
+  getIsolatedTempDir,
+  monitorIsolatedResources,
+  resetRunSequence,
+  validateIsolationContext,
+  writeTemporaryScenario
+};

package/dist/runtime-factory-Q4U5YBNV.js

@@ -0,0 +1,22 @@
+import {
+  askAgentViaApi,
+  createScenarioAgent,
+  createScenarioServer,
+  createScenarioServerAndAgent,
+  shutdownScenarioServer
+} from "./chunk-PUZHCSGF.js";
+import "./chunk-WX37MM4G.js";
+import "./chunk-I57T3WPO.js";
+import "./chunk-5IWKEMEF.js";
+import "./chunk-Q6M2K53X.js";
+import "./chunk-FQYWRHLX.js";
+import "./chunk-GXWWPFBO.js";
+import "./chunk-I4L4T7QX.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  askAgentViaApi,
+  createScenarioAgent,
+  createScenarioServer,
+  createScenarioServerAndAgent,
+  shutdownScenarioServer
+};

package/dist/schema-C25LVPEK.js

@@ -0,0 +1,17 @@
+import {
+  CapabilityCheckSchema,
+  EnhancedEvaluationResultSchema,
+  EvaluationSchema,
+  LLMJudgeResultSchema,
+  ScenarioRunResultSchema,
+  ScenarioSchema
+} from "./chunk-NHKLUXNE.js";
+import "./chunk-2ESYSVXG.js";
+export {
+  CapabilityCheckSchema,
+  EnhancedEvaluationResultSchema,
+  EvaluationSchema,
+  LLMJudgeResultSchema,
+  ScenarioRunResultSchema,
+  ScenarioSchema
+};