@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

package/dist/packages/agent/src/services/sandbox-manager.js

@@ -1,418 +0,0 @@
-/** Sandbox container lifecycle: create, exec, health check, teardown. */
-import { mkdirSync } from "node:fs";
-import os from "node:os";
-import { join } from "node:path";
-import { createEngine, detectBestEngine, } from "./sandbox-engine.js";
-/**
- * Quote a single argv token using POSIX single-quote rules so the engine's
- * string-based command parser round-trips it back to exactly one argument.
- * Single-quoted strings preserve every character except `'`, which is encoded
- * as the standard `'\''` sequence.
- */
-function shQuote(token) {
-    if (token.length === 0)
-        return "''";
-    if (/^[A-Za-z0-9_+\-./=:@%]+$/.test(token))
-        return token;
-    return `'${token.replace(/'/g, "'\\''")}'`;
-}
-// ── Implementation ───────────────────────────────────────────────────────────
-export class SandboxManager {
-    state = "uninitialized";
-    config;
-    engine;
-    containerId = null;
-    browserContainerId = null;
-    eventLog = [];
-    lifecycleQueue = Promise.resolve();
-    constructor(config) {
-        this.config = {
-            image: "eliza-sandbox:bookworm-slim",
-            containerPrefix: "eliza-sandbox",
-            workdir: "/workspace",
-            network: "none",
-            user: "1000:1000",
-            capDrop: ["ALL"],
-            memory: "512m",
-            cpus: 1,
-            pidsLimit: 256,
-            ...config,
-        };
-        this.engine = config.engineType
-            ? createEngine(config.engineType)
-            : detectBestEngine();
-    }
-    getState() {
-        return this.state;
-    }
-    getMode() {
-        return this.config.mode;
-    }
-    isReady() {
-        return this.state === "ready";
-    }
-    getMainContainerConfig() {
-        const image = this.config.image ?? "eliza-sandbox:bookworm-slim";
-        const containerPrefix = this.config.containerPrefix ?? "eliza-sandbox";
-        const workdir = this.config.workdir ?? "/workspace";
-        const network = this.config.network ?? "none";
-        const user = this.config.user ?? "1000:1000";
-        const wsRoot = this.config.workspaceRoot ??
-            join(process.env.HOME ?? process.env.USERPROFILE ?? os.tmpdir(), ".eliza", "sandbox-workspace");
-        mkdirSync(wsRoot, { recursive: true });
-        return { image, containerPrefix, workdir, network, user, wsRoot };
-    }
-    async createMainContainer() {
-        const config = this.getMainContainerConfig();
-        return this.engine.runContainer({
-            image: config.image,
-            name: `${config.containerPrefix}-${Date.now()}`,
-            detach: true,
-            mounts: [
-                { host: config.wsRoot, container: config.workdir, readonly: false },
-            ],
-            env: this.config.env ?? {},
-            network: config.network,
-            user: config.user,
-            capDrop: this.config.capDrop ?? [],
-            memory: this.config.memory,
-            cpus: this.config.cpus,
-            pidsLimit: this.config.pidsLimit,
-            readOnlyRoot: this.config.readOnlyRoot,
-            dns: this.config.dns,
-        });
-    }
-    async cleanupContainer(containerId) {
-        if (!containerId)
-            return;
-        await this.engine.stopContainer(containerId);
-        await this.engine.removeContainer(containerId);
-    }
-    setState(newState) {
-        const oldState = this.state;
-        this.state = newState;
-        this.emitEvent({
-            timestamp: Date.now(),
-            type: "state_change",
-            detail: `${oldState} → ${newState}`,
-        });
-    }
-    queueLifecycle(operation) {
-        const run = this.lifecycleQueue.then(operation, operation);
-        this.lifecycleQueue = run.then(() => undefined, () => undefined);
-        return run;
-    }
-    async start() {
-        return await this.queueLifecycle(async () => {
-            if (this.config.mode === "off") {
-                if (this.state !== "stopped") {
-                    this.setState("stopped");
-                }
-                return;
-            }
-            if (this.config.mode === "light") {
-                if (this.state !== "ready") {
-                    this.setState("ready");
-                }
-                return;
-            }
-            if (this.state === "ready" ||
-                this.state === "initializing" ||
-                this.state === "recovering") {
-                return;
-            }
-            // Standard / Max: create container
-            this.setState("initializing");
-            try {
-                const config = this.getMainContainerConfig();
-                if (!this.engine.isAvailable()) {
-                    throw new Error(`Container engine "${this.engine.engineType}" is not available. Install Docker or Apple Container.`);
-                }
-                if (!this.engine.imageExists(config.image)) {
-                    try {
-                        await this.engine.pullImage(config.image);
-                    }
-                    catch {
-                        throw new Error(`Sandbox image "${config.image}" not found. Build with: scripts/sandbox-setup.sh`);
-                    }
-                }
-                // Cleanup orphans from previous runs
-                const orphans = this.engine.listContainers(config.containerPrefix);
-                for (const id of orphans) {
-                    await this.engine.stopContainer(id);
-                    await this.engine.removeContainer(id);
-                }
-                this.containerId = await this.createMainContainer();
-                this.emitEvent({
-                    timestamp: Date.now(),
-                    type: "container_start",
-                    detail: `Container started: ${this.containerId}`,
-                });
-                // Start browser container if configured
-                if (this.config.browser?.enabled && this.config.browser?.autoStart) {
-                    try {
-                        this.browserContainerId = await this.createBrowserContainer();
-                    }
-                    catch (err) {
-                        this.emitEvent({
-                            timestamp: Date.now(),
-                            type: "error",
-                            detail: `Browser container start failed: ${String(err)}`,
-                        });
-                        // Non-fatal: sandbox can work without browser
-                    }
-                }
-                // Health check
-                const healthy = await this.healthCheck();
-                if (healthy) {
-                    this.setState("ready");
-                }
-                else {
-                    this.setState("degraded");
-                }
-            }
-            catch (err) {
-                this.emitEvent({
-                    timestamp: Date.now(),
-                    type: "error",
-                    detail: `Sandbox start failed: ${String(err)}`,
-                });
-                this.setState("degraded");
-                throw err;
-            }
-        });
-    }
-    async recover() {
-        return await this.queueLifecycle(async () => {
-            if (this.state !== "degraded") {
-                return; // Only recover from degraded
-            }
-            this.setState("recovering");
-            this.emitEvent({
-                timestamp: Date.now(),
-                type: "state_change",
-                detail: "Attempting recovery from degraded state",
-            });
-            try {
-                const config = this.getMainContainerConfig();
-                await this.cleanupContainer(this.containerId);
-                await this.cleanupContainer(this.browserContainerId);
-                this.containerId = null;
-                this.browserContainerId = null;
-                const orphans = this.engine.listContainers(config.containerPrefix);
-                for (const id of orphans) {
-                    await this.engine.stopContainer(id);
-                    await this.engine.removeContainer(id);
-                }
-                this.containerId = await this.createMainContainer();
-                const healthy = await this.healthCheck();
-                if (healthy) {
-                    this.setState("ready");
-                }
-                else {
-                    this.setState("degraded");
-                }
-            }
-            catch (err) {
-                this.emitEvent({
-                    timestamp: Date.now(),
-                    type: "error",
-                    detail: `Recovery failed: ${String(err)}`,
-                });
-                this.setState("degraded");
-            }
-        });
-    }
-    async stop() {
-        return await this.queueLifecycle(async () => {
-            if (this.state === "stopped") {
-                return;
-            }
-            if (this.state === "uninitialized") {
-                this.setState("stopped");
-                return;
-            }
-            this.setState("stopping");
-            try {
-                await this.cleanupContainer(this.browserContainerId);
-                await this.cleanupContainer(this.containerId);
-                this.browserContainerId = null;
-                this.containerId = null;
-            }
-            catch (err) {
-                this.emitEvent({
-                    timestamp: Date.now(),
-                    type: "error",
-                    detail: `Sandbox stop error: ${String(err)}`,
-                });
-            }
-            this.setState("stopped");
-        });
-    }
-    async exec(options) {
-        const start = Date.now();
-        if (this.config.mode === "off" || this.config.mode === "light") {
-            // In off/light mode, refuse sandbox exec — caller must use local
-            return {
-                exitCode: 1,
-                stdout: "",
-                stderr: "Sandbox exec not available in current mode",
-                durationMs: Date.now() - start,
-                executedInSandbox: false,
-            };
-        }
-        if (!this.containerId || this.state !== "ready") {
-            this.emitEvent({
-                timestamp: Date.now(),
-                type: "exec_denied",
-                detail: `Sandbox not ready (state=${this.state})`,
-            });
-            return {
-                exitCode: 1,
-                stdout: "",
-                stderr: `Sandbox not ready (state=${this.state})`,
-                durationMs: Date.now() - start,
-                executedInSandbox: false,
-            };
-        }
-        this.emitEvent({
-            timestamp: Date.now(),
-            type: "exec",
-            detail: options.command.substring(0, 200),
-            metadata: {
-                workdir: options.workdir ?? this.config.workdir ?? "/workspace",
-            },
-        });
-        try {
-            const result = await this.engine.execInContainer({
-                containerId: this.containerId,
-                command: options.command,
-                workdir: options.workdir,
-                env: options.env,
-                timeoutMs: options.timeoutMs,
-                stdin: options.stdin,
-            });
-            return {
-                ...result,
-                executedInSandbox: true,
-            };
-        }
-        catch (err) {
-            this.emitEvent({
-                timestamp: Date.now(),
-                type: "error",
-                detail: `Sandbox exec failed: ${String(err)}`,
-                metadata: {
-                    command: options.command.substring(0, 200),
-                },
-            });
-            return {
-                exitCode: 1,
-                stdout: "",
-                stderr: `Exec error: ${String(err)}`,
-                durationMs: Date.now() - start,
-                executedInSandbox: false,
-            };
-        }
-    }
-    /**
-     * Argv-aware variant of {@link exec}. Builds a properly-quoted command
-     * string from `cmd` + `args` and forwards to the underlying engine. Use
-     * this from the shell-execution router so callers that already have
-     * argv-shaped requests don't have to re-quote and risk shell-injection
-     * mismatches.
-     */
-    async run(options) {
-        const tokens = [options.cmd, ...options.args].map(shQuote).join(" ");
-        return this.exec({
-            command: tokens,
-            workdir: options.workdir,
-            env: options.env,
-            timeoutMs: options.timeoutMs,
-            stdin: options.stdin,
-        });
-    }
-    getBrowserCdpEndpoint() {
-        if (!this.browserContainerId)
-            return null;
-        const port = this.config.browser?.cdpPort ?? 9222;
-        return `http://localhost:${port}`;
-    }
-    getBrowserWsEndpoint() {
-        if (!this.browserContainerId)
-            return null;
-        const port = this.config.browser?.cdpPort ?? 9222;
-        return `ws://localhost:${port}`;
-    }
-    getBrowserNoVncEndpoint() {
-        if (!this.browserContainerId)
-            return null;
-        const noVncEnabled = this.config.browser?.enableNoVnc ?? false;
-        const headless = this.config.browser?.headless ?? false;
-        if (!noVncEnabled || headless)
-            return null;
-        const port = this.config.browser?.noVncPort ?? 6080;
-        return `http://localhost:${port}/vnc.html?autoconnect=true&resize=scale&view_only=true`;
-    }
-    async createBrowserContainer() {
-        const name = `${this.config.containerPrefix}-browser-${Date.now()}`;
-        const cdpPort = this.config.browser?.cdpPort ?? 9222;
-        const vncPort = this.config.browser?.vncPort ?? 5900;
-        const noVncPort = this.config.browser?.noVncPort ?? 6080;
-        const enableNoVnc = this.config.browser?.enableNoVnc ?? false;
-        const headless = this.config.browser?.headless ?? false;
-        const image = this.config.browser?.image ?? "eliza-sandbox-browser:bookworm-slim";
-        return this.engine.runContainer({
-            image,
-            name,
-            detach: true,
-            mounts: [],
-            env: {
-                ELIZA_BROWSER_CDP_PORT: String(cdpPort),
-                ELIZA_BROWSER_VNC_PORT: String(vncPort),
-                ELIZA_BROWSER_NOVNC_PORT: String(noVncPort),
-                ELIZA_BROWSER_ENABLE_NOVNC: enableNoVnc ? "1" : "0",
-                ELIZA_BROWSER_HEADLESS: headless ? "1" : "0",
-            },
-            network: "bridge",
-            user: "1000:1000",
-            capDrop: [],
-            ports: [
-                { host: cdpPort, container: cdpPort },
-                { host: vncPort, container: vncPort },
-                ...(enableNoVnc && !headless
-                    ? [{ host: noVncPort, container: noVncPort }]
-                    : []),
-            ],
-        });
-    }
-    async healthCheck() {
-        if (!this.containerId)
-            return false;
-        const healthy = await this.engine.healthCheck(this.containerId);
-        this.emitEvent({
-            timestamp: Date.now(),
-            type: "health_check",
-            detail: healthy ? "healthy" : "unhealthy",
-        });
-        return healthy;
-    }
-    emitEvent(event) {
-        this.eventLog.push(event);
-        // Keep bounded
-        if (this.eventLog.length > 1000) {
-            this.eventLog = this.eventLog.slice(-500);
-        }
-    }
-    getEventLog() {
-        return [...this.eventLog];
-    }
-    getStatus() {
-        return {
-            state: this.state,
-            mode: this.config.mode,
-            containerId: this.containerId,
-            browserContainerId: this.browserContainerId,
-        };
-    }
-}

package/dist/packages/agent/src/services/self-updater.d.ts

@@ -1,21 +0,0 @@
-/**
- * Detects the installation method and runs the appropriate upgrade command.
- * Falls back to npm if detection is ambiguous.
- */
-import type { ReleaseChannel } from "../config/types.eliza.ts";
-export type InstallMethod = "npm-global" | "bun-global" | "homebrew" | "snap" | "apt" | "flatpak" | "local-dev" | "unknown";
-export interface UpdateResult {
-    success: boolean;
-    method: InstallMethod;
-    command: string;
-    previousVersion: string;
-    newVersion: string | null;
-    error: string | null;
-}
-export declare function detectInstallMethod(): InstallMethod;
-export declare function buildUpdateCommand(method: InstallMethod, channel: ReleaseChannel): {
-    command: string;
-    args: string[];
-} | null;
-export declare function performUpdate(currentVersion: string, channel: ReleaseChannel, method?: InstallMethod): Promise<UpdateResult>;
-//# sourceMappingURL=self-updater.d.ts.map

package/dist/packages/agent/src/services/self-updater.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"self-updater.d.ts","sourceRoot":"","sources":["../../../../../src/services/self-updater.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAK/D,MAAM,MAAM,aAAa,GACrB,YAAY,GACZ,YAAY,GACZ,UAAU,GACV,MAAM,GACN,KAAK,GACL,SAAS,GACT,WAAW,GACX,SAAS,CAAC;AAEd,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AA8BD,wBAAgB,mBAAmB,IAAI,aAAa,CAyBnD;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,cAAc,GACtB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAkC5C;AA6CD,wBAAsB,aAAa,CACjC,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,cAAc,EACvB,MAAM,CAAC,EAAE,aAAa,GACrB,OAAO,CAAC,YAAY,CAAC,CAsCvB"}

package/dist/packages/agent/src/services/self-updater.js

@@ -1,162 +0,0 @@
-/**
- * Detects the installation method and runs the appropriate upgrade command.
- * Falls back to npm if detection is ambiguous.
- */
-import { execSync, spawn } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { CHANNEL_DIST_TAGS } from "./update-checker.js";
-const NPM_PACKAGE_NAME = "elizaos";
-function whichSync(binary) {
-    try {
-        return execSync(`which ${binary}`, {
-            stdio: ["ignore", "pipe", "ignore"],
-            timeout: 5_000,
-        })
-            .toString()
-            .trim();
-    }
-    catch {
-        return null;
-    }
-}
-function isLocalDev() {
-    try {
-        const rootPkg = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json");
-        const content = JSON.parse(fs.readFileSync(rootPkg, "utf-8"));
-        return content.devDependencies !== undefined;
-    }
-    catch {
-        return false;
-    }
-}
-export function detectInstallMethod() {
-    const elizaBin = whichSync("eliza");
-    if (!elizaBin) {
-        return isLocalDev() ? "local-dev" : "unknown";
-    }
-    let resolved;
-    try {
-        resolved = fs.realpathSync(elizaBin);
-    }
-    catch {
-        resolved = elizaBin;
-    }
-    if (resolved.includes("/Cellar/") || resolved.includes("/homebrew/"))
-        return "homebrew";
-    if (resolved.includes("/snap/"))
-        return "snap";
-    if (resolved.includes("/flatpak/") || resolved.includes("ai.eliza.Eliza"))
-        return "flatpak";
-    if (resolved.startsWith("/usr/") && !resolved.includes("node_modules"))
-        return "apt";
-    if (resolved.includes("/.bun/"))
-        return "bun-global";
-    if (resolved.includes("node_modules"))
-        return "npm-global";
-    return "unknown";
-}
-export function buildUpdateCommand(method, channel) {
-    const spec = `${NPM_PACKAGE_NAME}@${CHANNEL_DIST_TAGS[channel]}`;
-    switch (method) {
-        case "npm-global":
-            return { command: "npm", args: ["install", "-g", spec] };
-        case "bun-global":
-            return { command: "bun", args: ["install", "-g", spec] };
-        case "homebrew":
-            return { command: "brew", args: ["upgrade", "eliza"] };
-        case "snap": {
-            // nightly → edge (snap doesn't have a "nightly" channel)
-            const snapCh = channel === "nightly" ? "edge" : channel === "beta" ? "beta" : "stable";
-            return {
-                command: "sudo",
-                args: ["snap", "refresh", "eliza", `--channel=${snapCh}`],
-            };
-        }
-        case "apt":
-            return {
-                command: "sh",
-                args: [
-                    "-c",
-                    "sudo apt-get update && sudo apt-get install --only-upgrade -y eliza",
-                ],
-            };
-        case "flatpak":
-            return { command: "flatpak", args: ["update", "ai.eliza.Eliza"] };
-        case "local-dev":
-            return null;
-        case "unknown":
-            return { command: "npm", args: ["install", "-g", spec] };
-    }
-}
-function runCommand(command, args) {
-    return new Promise((resolve) => {
-        const child = spawn(command, args, {
-            stdio: ["inherit", "inherit", "pipe"],
-            // shell:true removed — all update commands are safe to run directly.
-            // The apt case uses sh -c explicitly, so no shell wrapper is needed.
-        });
-        let stderr = "";
-        child.stderr?.on("data", (chunk) => {
-            stderr += chunk.toString();
-            process.stderr.write(chunk);
-        });
-        child.on("error", (err) => {
-            resolve({ exitCode: 1, stderr: err.message });
-        });
-        child.on("close", (code) => {
-            resolve({ exitCode: code ?? 1, stderr });
-        });
-    });
-}
-function readPostUpdateVersion() {
-    try {
-        const output = execSync("eliza --version", {
-            stdio: ["ignore", "pipe", "ignore"],
-            timeout: 10_000,
-        })
-            .toString()
-            .trim();
-        // Version output may include a prefix like "eliza/2.0.0"
-        const match = output.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
-        return match?.[1] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function performUpdate(currentVersion, channel, method) {
-    method ??= detectInstallMethod();
-    const cmdInfo = buildUpdateCommand(method, channel);
-    if (!cmdInfo) {
-        return {
-            success: false,
-            method,
-            command: "",
-            previousVersion: currentVersion,
-            newVersion: null,
-            error: "Cannot auto-update a local development install. Use git pull instead.",
-        };
-    }
-    const commandString = `${cmdInfo.command} ${cmdInfo.args.join(" ")}`;
-    const { exitCode, stderr } = await runCommand(cmdInfo.command, cmdInfo.args);
-    if (exitCode !== 0) {
-        return {
-            success: false,
-            method,
-            command: commandString,
-            previousVersion: currentVersion,
-            newVersion: null,
-            error: stderr || `Update command exited with code ${exitCode}.`,
-        };
-    }
-    return {
-        success: true,
-        method,
-        command: commandString,
-        previousVersion: currentVersion,
-        newVersion: readPostUpdateVersion(),
-        error: null,
-    };
-}

package/dist/packages/agent/src/services/send-handler-availability.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"send-handler-availability.d.ts","sourceRoot":"","sources":["../../../../../src/services/send-handler-availability.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAU,MAAM,eAAe,CAAC;AAQ3D,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,GACb,OAAO,CAMT;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GACb,IAAI,CASN;AAED,wBAAgB,oCAAoC,IAAI,IAAI,CAE3D"}

package/dist/packages/agent/src/services/send-handler-availability.js

@@ -1,20 +0,0 @@
-import { logger } from "@elizaos/core";
-const missingSendHandlerLogs = new Set();
-export function hasRuntimeSendHandler(runtime, source) {
-    const sendHandlers = runtime.sendHandlers;
-    if (!(sendHandlers instanceof Map)) {
-        return true;
-    }
-    return sendHandlers.has(source);
-}
-export function logMissingSendHandlerOnce(context, source) {
-    const key = `${context}:${source}`;
-    if (missingSendHandlerLogs.has(key)) {
-        return;
-    }
-    missingSendHandlerLogs.add(key);
-    logger.info(`[${context}] Send handler "${source}" is not registered yet; skipping delivery until runtime wiring completes`);
-}
-export function _resetMissingSendHandlerLogsForTests() {
-    missingSendHandlerLogs.clear();
-}