@elizaos/cli 1.4.3 → 1.4.5

package/dist/chunk-FWYHSCLF.js

@@ -0,0 +1,243 @@
+import {
+  require_src
+} from "./chunk-XPPESCCM.js";
+import {
+  CDPSessionEvent,
+  asyncDisposeSymbol,
+  bufferCount,
+  concatMap,
+  debugError,
+  filter,
+  from,
+  fromEmitterEvent,
+  fromEvent,
+  guarded,
+  lastValueFrom,
+  map,
+  takeUntil,
+  tap
+} from "./chunk-ABGBVB74.js";
+import {
+  __toESM
+} from "./chunk-2ESYSVXG.js";
+
+// ../../node_modules/puppeteer-core/lib/esm/puppeteer/node/ScreenRecorder.js
+var import_debug = __toESM(require_src(), 1);
+import { spawn, spawnSync } from "child_process";
+import { PassThrough } from "stream";
+var __runInitializers = function(thisArg, initializers, value) {
+  var useValue = arguments.length > 2;
+  for (var i = 0; i < initializers.length; i++) {
+    value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+  }
+  return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+  function accept(f) {
+    if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+    return f;
+  }
+  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+  var _, done = false;
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    var context = {};
+    for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+    for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+    context.addInitializer = function(f) {
+      if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+      extraInitializers.push(accept(f || null));
+    };
+    var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+    if (kind === "accessor") {
+      if (result === void 0) continue;
+      if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+      if (_ = accept(result.get)) descriptor.get = _;
+      if (_ = accept(result.set)) descriptor.set = _;
+      if (_ = accept(result.init)) initializers.unshift(_);
+    } else if (_ = accept(result)) {
+      if (kind === "field") initializers.unshift(_);
+      else descriptor[key] = _;
+    }
+  }
+  if (target) Object.defineProperty(target, contextIn.name, descriptor);
+  done = true;
+};
+var __setFunctionName = function(f, name, prefix) {
+  if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+  return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+var CRF_VALUE = 30;
+var DEFAULT_FPS = 30;
+var debugFfmpeg = (0, import_debug.default)("puppeteer:ffmpeg");
+var ScreenRecorder = (() => {
+  let _classSuper = PassThrough;
+  let _instanceExtraInitializers = [];
+  let _private_writeFrame_decorators;
+  let _private_writeFrame_descriptor;
+  let _stop_decorators;
+  return class ScreenRecorder extends _classSuper {
+    static {
+      const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+      __esDecorate(this, _private_writeFrame_descriptor = { value: __setFunctionName(async function(buffer) {
+        const error = await new Promise((resolve) => {
+          this.#process.stdin.write(buffer, resolve);
+        });
+        if (error) {
+          console.log(`ffmpeg failed to write: ${error.message}.`);
+        }
+      }, "#writeFrame") }, _private_writeFrame_decorators, { kind: "method", name: "#writeFrame", static: false, private: true, access: { has: (obj) => #writeFrame in obj, get: (obj) => obj.#writeFrame }, metadata: _metadata }, null, _instanceExtraInitializers);
+      __esDecorate(this, null, _stop_decorators, { kind: "method", name: "stop", static: false, private: false, access: { has: (obj) => "stop" in obj, get: (obj) => obj.stop }, metadata: _metadata }, null, _instanceExtraInitializers);
+      if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+    }
+    #page = __runInitializers(this, _instanceExtraInitializers);
+    #process;
+    #controller = new AbortController();
+    #lastFrame;
+    /**
+     * @internal
+     */
+    constructor(page, width, height, { speed, scale, crop, format, path } = {}) {
+      super({ allowHalfOpen: false });
+      path ??= "ffmpeg";
+      const { error } = spawnSync(path);
+      if (error) {
+        throw error;
+      }
+      this.#process = spawn(
+        path,
+        // See https://trac.ffmpeg.org/wiki/Encode/VP9 for more information on flags.
+        [
+          ["-loglevel", "error"],
+          // Reduces general buffering.
+          ["-avioflags", "direct"],
+          // Reduces initial buffering while analyzing input fps and other stats.
+          [
+            "-fpsprobesize",
+            "0",
+            "-probesize",
+            "32",
+            "-analyzeduration",
+            "0",
+            "-fflags",
+            "nobuffer"
+          ],
+          // Forces input to be read from standard input, and forces png input
+          // image format.
+          ["-f", "image2pipe", "-c:v", "png", "-i", "pipe:0"],
+          // Overwrite output and no audio.
+          ["-y", "-an"],
+          // This drastically reduces stalling when cpu is overbooked. By default
+          // VP9 tries to use all available threads?
+          ["-threads", "1"],
+          // Specifies the frame rate we are giving ffmpeg.
+          ["-framerate", `${DEFAULT_FPS}`],
+          // Specifies the encoding and format we are using.
+          this.#getFormatArgs(format ?? "webm"),
+          // Disable bitrate.
+          ["-b:v", "0"],
+          // Filters to ensure the images are piped correctly.
+          [
+            "-vf",
+            `${speed ? `setpts=${1 / speed}*PTS,` : ""}crop='min(${width},iw):min(${height},ih):0:0',pad=${width}:${height}:0:0${crop ? `,crop=${crop.width}:${crop.height}:${crop.x}:${crop.y}` : ""}${scale ? `,scale=iw*${scale}:-1` : ""}`
+          ],
+          "pipe:1"
+        ].flat(),
+        { stdio: ["pipe", "pipe", "pipe"] }
+      );
+      this.#process.stdout.pipe(this);
+      this.#process.stderr.on("data", (data) => {
+        debugFfmpeg(data.toString("utf8"));
+      });
+      this.#page = page;
+      const { client } = this.#page.mainFrame();
+      client.once(CDPSessionEvent.Disconnected, () => {
+        void this.stop().catch(debugError);
+      });
+      this.#lastFrame = lastValueFrom(fromEmitterEvent(client, "Page.screencastFrame").pipe(tap((event) => {
+        void client.send("Page.screencastFrameAck", {
+          sessionId: event.sessionId
+        });
+      }), filter((event) => {
+        return event.metadata.timestamp !== void 0;
+      }), map((event) => {
+        return {
+          buffer: Buffer.from(event.data, "base64"),
+          timestamp: event.metadata.timestamp
+        };
+      }), bufferCount(2, 1), concatMap(([{ timestamp: previousTimestamp, buffer }, { timestamp }]) => {
+        return from(Array(Math.round(DEFAULT_FPS * Math.max(timestamp - previousTimestamp, 0))).fill(buffer));
+      }), map((buffer) => {
+        void this.#writeFrame(buffer);
+        return [buffer, performance.now()];
+      }), takeUntil(fromEvent(this.#controller.signal, "abort"))), { defaultValue: [Buffer.from([]), performance.now()] });
+    }
+    #getFormatArgs(format) {
+      switch (format) {
+        case "webm":
+          return [
+            // Sets the codec to use.
+            ["-c:v", "vp9"],
+            // Sets the format
+            ["-f", "webm"],
+            // Sets the quality. Lower the better.
+            ["-crf", `${CRF_VALUE}`],
+            // Sets the quality and how efficient the compression will be.
+            ["-deadline", "realtime", "-cpu-used", "8"]
+          ].flat();
+        case "gif":
+          return [
+            // Sets the frame rate and uses a custom palette generated from the
+            // input.
+            [
+              "-vf",
+              "fps=5,split[s0][s1];[s0]palettegen=stats_mode=diff[p];[s1][p]paletteuse"
+            ],
+            // Sets the format
+            ["-f", "gif"]
+          ].flat();
+      }
+    }
+    get #writeFrame() {
+      return _private_writeFrame_descriptor.value;
+    }
+    /**
+     * Stops the recorder.
+     *
+     * @public
+     */
+    async stop() {
+      if (this.#controller.signal.aborted) {
+        return;
+      }
+      await this.#page._stopScreencast().catch(debugError);
+      this.#controller.abort();
+      const [buffer, timestamp] = await this.#lastFrame;
+      await Promise.all(Array(Math.max(1, Math.round(DEFAULT_FPS * (performance.now() - timestamp) / 1e3))).fill(buffer).map(this.#writeFrame.bind(this)));
+      this.#process.stdin.end();
+      await new Promise((resolve) => {
+        this.#process.once("close", resolve);
+      });
+    }
+    /**
+     * @internal
+     */
+    async [(_private_writeFrame_decorators = [guarded()], _stop_decorators = [guarded()], asyncDisposeSymbol)]() {
+      await this.stop();
+    }
+  };
+})();
+
+export {
+  ScreenRecorder
+};
+/*! Bundled license information:
+
+puppeteer-core/lib/esm/puppeteer/node/ScreenRecorder.js:
+  (**
+   * @license
+   * Copyright 2023 Google Inc.
+   * SPDX-License-Identifier: Apache-2.0
+   *)
+*/

package/dist/chunk-I57T3WPO.js

@@ -0,0 +1,165 @@
+// src/commands/scenario/src/process-manager.ts
+var ProcessManager = class {
+  processes = /* @__PURE__ */ new Map();
+  signalHandlersRegistered = false;
+  /**
+   * Register a process for tracking
+   */
+  registerProcess(runId, pid, type, port) {
+    console.log(
+      `\u{1F527} [ProcessManager] Registering process ${pid} for runId: ${runId} (type: ${type})`
+    );
+    this.processes.set(runId, {
+      pid,
+      runId,
+      type,
+      startTime: /* @__PURE__ */ new Date(),
+      port
+    });
+    if (!this.signalHandlersRegistered) {
+      this.registerSignalHandlers();
+      this.signalHandlersRegistered = true;
+    }
+  }
+  /**
+   * Unregister a process when it completes normally
+   */
+  unregisterProcess(runId) {
+    const processInfo = this.processes.get(runId);
+    if (processInfo) {
+      console.log(
+        `\u{1F527} [ProcessManager] Unregistering process ${processInfo.pid} for runId: ${runId}`
+      );
+      this.processes.delete(runId);
+    }
+  }
+  /**
+   * Get all registered processes
+   */
+  getProcesses() {
+    return new Map(this.processes);
+  }
+  /**
+   * Check if a process is still running
+   */
+  isProcessRunning(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Gracefully terminate a specific process
+   */
+  async terminateProcess(runId, timeout = 5e3) {
+    const processInfo = this.processes.get(runId);
+    if (!processInfo) {
+      console.log(`\u{1F527} [ProcessManager] No process found for runId: ${runId}`);
+      return true;
+    }
+    const { pid } = processInfo;
+    console.log(`\u{1F527} [ProcessManager] Terminating process ${pid} for runId: ${runId}`);
+    if (!this.isProcessRunning(pid)) {
+      console.log(`\u{1F527} [ProcessManager] Process ${pid} already terminated`);
+      this.unregisterProcess(runId);
+      return true;
+    }
+    try {
+      process.kill(pid, "SIGTERM");
+      const startTime = Date.now();
+      while (Date.now() - startTime < timeout) {
+        if (!this.isProcessRunning(pid)) {
+          console.log(`\u{1F527} [ProcessManager] Process ${pid} terminated gracefully`);
+          this.unregisterProcess(runId);
+          return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      console.log(`\u{1F527} [ProcessManager] Force killing process ${pid} after timeout`);
+      process.kill(pid, "SIGKILL");
+      this.unregisterProcess(runId);
+      return true;
+    } catch (error) {
+      console.log(`\u{1F527} [ProcessManager] Failed to terminate process ${pid}:`, error);
+      return false;
+    }
+  }
+  /**
+   * Terminate all registered processes
+   */
+  async terminateAllProcesses(timeout = 1e4) {
+    const processes = Array.from(this.processes.keys());
+    console.log(`\u{1F527} [ProcessManager] Terminating ${processes.length} processes`);
+    if (processes.length === 0) {
+      return;
+    }
+    const terminationPromises = processes.map(
+      (runId) => this.terminateProcess(runId, timeout / processes.length)
+    );
+    await Promise.allSettled(terminationPromises);
+    for (const [runId, processInfo] of this.processes.entries()) {
+      if (this.isProcessRunning(processInfo.pid)) {
+        console.log(`\u{1F527} [ProcessManager] Force killing remaining process ${processInfo.pid}`);
+        try {
+          process.kill(processInfo.pid, "SIGKILL");
+        } catch (error) {
+          console.log(`\u{1F527} [ProcessManager] Failed to force kill ${processInfo.pid}:`, error);
+        }
+      }
+    }
+    this.processes.clear();
+  }
+  /**
+   * Register signal handlers to cleanup on exit
+   */
+  registerSignalHandlers() {
+    console.log(`\u{1F527} [ProcessManager] Registering signal handlers`);
+    const handleExit = async (signal) => {
+      console.log(`\u{1F527} [ProcessManager] Received ${signal}, cleaning up processes...`);
+      await this.terminateAllProcesses();
+      console.log(`\u{1F527} [ProcessManager] Process cleanup completed`);
+      process.exit(0);
+    };
+    process.on("SIGINT", () => handleExit("SIGINT"));
+    process.on("SIGTERM", () => handleExit("SIGTERM"));
+    process.on("SIGUSR1", () => handleExit("SIGUSR1"));
+    process.on("SIGUSR2", () => handleExit("SIGUSR2"));
+    process.on("uncaughtException", async (error) => {
+      console.error(`\u{1F527} [ProcessManager] Uncaught exception:`, error);
+      await this.terminateAllProcesses();
+      process.exit(1);
+    });
+    process.on("unhandledRejection", async (reason, promise) => {
+      console.error(`\u{1F527} [ProcessManager] Unhandled rejection at:`, promise, "reason:", reason);
+      await this.terminateAllProcesses();
+      process.exit(1);
+    });
+  }
+  /**
+   * Get summary of managed processes
+   */
+  getSummary() {
+    const processes = Array.from(this.processes.values());
+    const byType = {};
+    let oldestProcess;
+    for (const proc of processes) {
+      byType[proc.type] = (byType[proc.type] || 0) + 1;
+      if (!oldestProcess || proc.startTime < oldestProcess.startTime) {
+        oldestProcess = proc;
+      }
+    }
+    return {
+      total: processes.length,
+      byType,
+      oldestProcess
+    };
+  }
+};
+var processManager = new ProcessManager();
+
+export {
+  ProcessManager,
+  processManager
+};

package/dist/chunk-LBZLMFFF.js

@@ -0,0 +1,221 @@
+// src/commands/scenario/src/run-isolation.ts
+import { promises as fs } from "fs";
+import { join, dirname } from "path";
+import { tmpdir } from "os";
+var runSequence = 0;
+function resetRunSequence() {
+  runSequence = 0;
+}
+function generateRunId() {
+  const sequence = String(runSequence++).padStart(3, "0");
+  const hash = Math.random().toString(16).substring(2, 10);
+  return `run-${sequence}-${hash}`;
+}
+async function createIsolatedEnvironment(runId, outputDir) {
+  const tempDir = join(outputDir, "temp", runId);
+  await fs.mkdir(tempDir, { recursive: true });
+  const dbPath = join(tempDir, "database");
+  const logsDir = join(tempDir, "logs");
+  const logPath = join(logsDir, "run.log");
+  const scenarioPath = join(tempDir, "scenario.yaml");
+  await fs.mkdir(dirname(logPath), { recursive: true });
+  await fs.mkdir(dbPath, { recursive: true });
+  const cleanup = async () => {
+    await cleanupIsolatedEnvironment({
+      runId,
+      tempDir,
+      dbPath,
+      logPath,
+      scenarioPath,
+      cleanup: () => Promise.resolve()
+    });
+  };
+  return {
+    runId,
+    tempDir,
+    dbPath,
+    logPath,
+    scenarioPath,
+    cleanup
+  };
+}
+async function cleanupIsolatedEnvironment(context) {
+  try {
+    await fs.rm(context.tempDir, { recursive: true, force: true });
+  } catch (error) {
+    console.warn(`Warning: Failed to cleanup isolated environment ${context.runId}:`, error);
+  }
+}
+async function ensureIsolatedDatabase(dbPath) {
+  try {
+    await fs.mkdir(dbPath, { recursive: true });
+    const dbConfig = {
+      type: "pglite",
+      path: dbPath,
+      isolated: true,
+      temporary: true
+    };
+    const configPath = join(dbPath, "config.json");
+    await fs.writeFile(configPath, JSON.stringify(dbConfig, null, 2));
+  } catch (error) {
+    throw new Error(
+      `Failed to setup isolated database: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function writeTemporaryScenario(scenarioPath, baseScenario, parameters) {
+  try {
+    const modifiedScenario = JSON.parse(JSON.stringify(baseScenario));
+    for (const [path, value] of Object.entries(parameters)) {
+      setNestedProperty(modifiedScenario, path, value);
+    }
+    await fs.writeFile(scenarioPath, JSON.stringify(modifiedScenario, null, 2));
+  } catch (error) {
+    throw new Error(
+      `Failed to write temporary scenario: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function setNestedProperty(obj, path, value) {
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    const arrayMatch2 = key.match(/^(.+)\[(\d+)\]$/);
+    if (arrayMatch2) {
+      const [, arrayKey, indexStr] = arrayMatch2;
+      const index = parseInt(indexStr, 10);
+      if (!current[arrayKey]) {
+        current[arrayKey] = [];
+      }
+      if (!current[arrayKey][index]) {
+        current[arrayKey][index] = {};
+      }
+      current = current[arrayKey][index];
+    } else {
+      if (!current[key]) {
+        current[key] = {};
+      }
+      current = current[key];
+    }
+  }
+  const finalKey = keys[keys.length - 1];
+  const arrayMatch = finalKey.match(/^(.+)\[(\d+)\]$/);
+  if (arrayMatch) {
+    const [, arrayKey, indexStr] = arrayMatch;
+    const index = parseInt(indexStr, 10);
+    if (!current[arrayKey]) {
+      current[arrayKey] = [];
+    }
+    current[arrayKey][index] = value;
+  } else {
+    current[finalKey] = value;
+  }
+}
+async function validateIsolationContext(context) {
+  try {
+    const tempDirExists = await fs.access(context.tempDir).then(() => true).catch(() => false);
+    const dbDirExists = await fs.access(context.dbPath).then(() => true).catch(() => false);
+    const logDirExists = await fs.access(dirname(context.logPath)).then(() => true).catch(() => false);
+    return tempDirExists && dbDirExists && logDirExists;
+  } catch {
+    return false;
+  }
+}
+function createIsolatedEnvironmentVariables(context) {
+  const baseEnv = { ...process.env };
+  const isolatedEnv = {
+    ...baseEnv,
+    // Point to isolated database
+    DATABASE_URL: `file://${context.dbPath}/database.db`,
+    PGLITE_DATABASE_PATH: context.dbPath,
+    // Set isolated temp directory
+    TMPDIR: context.tempDir,
+    TEMP: context.tempDir,
+    TMP: context.tempDir,
+    // Set log configuration
+    LOG_FILE: context.logPath,
+    LOG_LEVEL: "debug",
+    // Mark as isolated execution
+    ELIZA_ISOLATED_RUN: "true",
+    ELIZA_RUN_ID: context.runId,
+    // Disable any global state or caching
+    DISABLE_GLOBAL_CACHE: "true",
+    FORCE_ISOLATED_MODE: "true"
+  };
+  return isolatedEnv;
+}
+function getIsolatedTempDir(prefix = "eliza-matrix") {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  return join(tmpdir(), `${prefix}-${timestamp}-${random}`);
+}
+function estimateRunDiskSpace(baseScenario) {
+  const baseSize = 50 * 1024 * 1024;
+  const runCount = baseScenario.run?.length || 1;
+  const evaluationCount = baseScenario.run?.reduce((sum, run) => sum + (run.evaluations?.length || 0), 0) || 0;
+  const complexityMultiplier = 1 + runCount * 0.1 + evaluationCount * 0.05;
+  return Math.ceil(baseSize * complexityMultiplier);
+}
+async function checkDiskSpace(outputDir, estimatedSpace) {
+  try {
+    const stats = await fs.stat(outputDir);
+    return true;
+  } catch {
+    try {
+      await fs.mkdir(outputDir, { recursive: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+async function monitorIsolatedResources(context) {
+  try {
+    let totalSize = 0;
+    let fileCount = 0;
+    async function calculateSize(dirPath) {
+      try {
+        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join(dirPath, entry.name);
+          if (entry.isDirectory()) {
+            await calculateSize(fullPath);
+          } else {
+            const stats = await fs.stat(fullPath);
+            totalSize += stats.size;
+            fileCount++;
+          }
+        }
+      } catch {
+      }
+    }
+    await calculateSize(context.tempDir);
+    return {
+      diskUsage: totalSize,
+      fileCount,
+      directorySize: totalSize
+    };
+  } catch {
+    return {
+      diskUsage: 0,
+      fileCount: 0,
+      directorySize: 0
+    };
+  }
+}
+
+export {
+  resetRunSequence,
+  generateRunId,
+  createIsolatedEnvironment,
+  cleanupIsolatedEnvironment,
+  ensureIsolatedDatabase,
+  writeTemporaryScenario,
+  validateIsolationContext,
+  createIsolatedEnvironmentVariables,
+  getIsolatedTempDir,
+  estimateRunDiskSpace,
+  checkDiskSpace,
+  monitorIsolatedResources
+};