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

package/services/virtual-filesystem.js

@@ -0,0 +1,482 @@
+import crypto from "node:crypto";
+import fsp from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { resolveStateDir } from "../config/paths.js";
+import { writeJsonAtomic } from "../utils/atomic-json.js";
+const DEFAULT_QUOTA_BYTES = 50 * 1024 * 1024;
+const DEFAULT_MAX_FILE_BYTES = 10 * 1024 * 1024;
+export class VirtualFilesystemError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "VirtualFilesystemError";
+    }
+}
+export class VirtualFilesystemService {
+    projectId;
+    projectRoot;
+    filesRoot;
+    snapshotsRoot;
+    quotaBytes;
+    maxFileBytes;
+    now;
+    constructor(options) {
+        this.projectId = sanitizeProjectId(options.projectId);
+        const stateDir = options.stateDir ?? resolveStateDir(process.env, os.homedir);
+        this.projectRoot = path.join(stateDir, "agent-vfs", "projects", this.projectId);
+        this.filesRoot = path.join(this.projectRoot, "files");
+        this.snapshotsRoot = path.join(this.projectRoot, "snapshots");
+        this.quotaBytes = options.quotaBytes ?? DEFAULT_QUOTA_BYTES;
+        this.maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+        this.now = options.now ?? (() => new Date());
+    }
+    async initialize() {
+        await fsp.mkdir(this.filesRoot, { recursive: true, mode: 0o700 });
+        await fsp.mkdir(this.snapshotsRoot, { recursive: true, mode: 0o700 });
+    }
+    async writeFile(virtualPath, contents) {
+        const data = typeof contents === "string"
+            ? Buffer.from(contents)
+            : Buffer.from(contents);
+        if (data.byteLength > this.maxFileBytes) {
+            throw new VirtualFilesystemError(`File exceeds max file size of ${this.maxFileBytes} bytes`, "QUOTA_EXCEEDED");
+        }
+        const target = this.resolvePath(virtualPath);
+        await this.ensureSafeParentDirectory(target);
+        await this.rejectSymlinkIfExists(target);
+        const existingSize = await this.fileSizeIfExists(target);
+        const current = await this.measureFiles();
+        const nextBytes = current.bytes - existingSize + data.byteLength;
+        if (nextBytes > this.quotaBytes) {
+            throw new VirtualFilesystemError(`Project quota exceeded: ${nextBytes}/${this.quotaBytes} bytes`, "QUOTA_EXCEEDED");
+        }
+        await fsp.mkdir(path.dirname(target), { recursive: true, mode: 0o700 });
+        await fsp.writeFile(target, data, { mode: 0o600 });
+        return this.entryFor(target);
+    }
+    async readFile(virtualPath, encoding = "utf-8") {
+        const target = this.resolvePath(virtualPath);
+        await this.assertFile(target);
+        return fsp.readFile(target, encoding);
+    }
+    async readFileBytes(virtualPath) {
+        const target = this.resolvePath(virtualPath);
+        await this.assertFile(target);
+        return fsp.readFile(target);
+    }
+    async list(virtualPath = ".", options = {}) {
+        const target = this.resolvePath(virtualPath);
+        await this.assertDirectory(target);
+        const entries = await this.listEntries(target, Boolean(options.recursive));
+        return entries.sort((a, b) => a.path.localeCompare(b.path));
+    }
+    async delete(virtualPath, options = {}) {
+        const target = this.resolvePath(virtualPath);
+        await this.ensureSafeParentDirectory(target);
+        await this.rejectSymlinkIfExists(target);
+        try {
+            await fsp.rm(target, {
+                recursive: Boolean(options.recursive),
+                force: false,
+            });
+        }
+        catch (error) {
+            if (isNodeErrno(error, "ENOENT")) {
+                throw new VirtualFilesystemError("Path not found", "NOT_FOUND");
+            }
+            throw error;
+        }
+    }
+    async createSnapshot(note) {
+        await this.initialize();
+        const id = snapshotId(this.now());
+        const snapshotDir = path.join(this.snapshotsRoot, id);
+        const snapshotFilesRoot = path.join(snapshotDir, "files");
+        await fsp.mkdir(snapshotFilesRoot, { recursive: true, mode: 0o700 });
+        await fsp.cp(this.filesRoot, snapshotFilesRoot, {
+            recursive: true,
+            errorOnExist: false,
+            force: true,
+            dereference: false,
+        });
+        const stats = await this.measureTree(snapshotFilesRoot);
+        const snapshot = {
+            id,
+            projectId: this.projectId,
+            createdAt: this.now().toISOString(),
+            root: snapshotFilesRoot,
+            filesBytes: stats.bytes,
+            fileCount: stats.fileCount,
+            ...(note ? { note } : {}),
+        };
+        await writeJsonAtomic(path.join(snapshotDir, "snapshot.json"), snapshot);
+        return snapshot;
+    }
+    async getSnapshot(id) {
+        const snapshot = await this.readSnapshot(id);
+        if (!snapshot) {
+            throw new VirtualFilesystemError(`Snapshot not found: ${id}`, "SNAPSHOT_NOT_FOUND");
+        }
+        return snapshot;
+    }
+    async listSnapshots() {
+        await this.initialize();
+        const entries = await fsp.readdir(this.snapshotsRoot, {
+            withFileTypes: true,
+        });
+        const snapshots = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const snapshot = await this.readSnapshot(entry.name);
+            if (snapshot)
+                snapshots.push(snapshot);
+        }
+        return snapshots.sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+    }
+    async diffSnapshots(beforeSnapshotId, afterSnapshotId) {
+        const before = await this.snapshotFilesRoot(beforeSnapshotId);
+        const after = await this.snapshotFilesRoot(afterSnapshotId);
+        const beforeIndex = await this.indexTree(before);
+        const afterIndex = await this.indexTree(after);
+        return diffIndexes(beforeIndex, afterIndex);
+    }
+    async diffCurrent(snapshotId) {
+        const before = await this.snapshotFilesRoot(snapshotId);
+        const beforeIndex = await this.indexTree(before);
+        const afterIndex = await this.indexTree(this.filesRoot);
+        return diffIndexes(beforeIndex, afterIndex);
+    }
+    async rollback(snapshotId) {
+        const snapshotRoot = await this.snapshotFilesRoot(snapshotId);
+        const previous = await this.createSnapshot(`pre-rollback:${snapshotId}`);
+        await fsp.rm(this.filesRoot, { recursive: true, force: true });
+        await fsp.mkdir(this.filesRoot, { recursive: true, mode: 0o700 });
+        await fsp.cp(snapshotRoot, this.filesRoot, {
+            recursive: true,
+            errorOnExist: false,
+            force: true,
+            dereference: false,
+        });
+        const rollback = {
+            snapshotId,
+            projectId: this.projectId,
+            rolledBackAt: this.now().toISOString(),
+            previousSnapshotId: previous.id,
+        };
+        await writeJsonAtomic(path.join(this.projectRoot, "last-rollback.json"), rollback);
+        return rollback;
+    }
+    async quota() {
+        const stats = await this.measureFiles();
+        return {
+            usedBytes: stats.bytes,
+            fileCount: stats.fileCount,
+            quotaBytes: this.quotaBytes,
+            maxFileBytes: this.maxFileBytes,
+        };
+    }
+    resolveVirtualPath(virtualPath) {
+        return toVirtualPath(this.resolvePath(virtualPath), this.filesRoot);
+    }
+    /**
+     * Resolve a virtual path to its absolute on-disk location, applying the same
+     * traversal/symlink rules used by readFile/writeFile. The returned path is
+     * always inside the project's `filesRoot` and is the path Node/Bun will use
+     * if you `pathToFileURL()` it for a dynamic import. The path is not required
+     * to exist — callers that need existence should `readFile` it first.
+     */
+    resolveDiskPath(virtualPath) {
+        return this.resolvePath(virtualPath);
+    }
+    async exportFiles(snapshotId) {
+        const root = snapshotId
+            ? await this.snapshotFilesRoot(snapshotId)
+            : this.filesRoot;
+        const files = [];
+        const walk = async (dir) => {
+            for (const dirent of await fsp.readdir(dir, { withFileTypes: true })) {
+                const realPath = path.join(dir, dirent.name);
+                if (dirent.isSymbolicLink()) {
+                    throw new VirtualFilesystemError("Symlinks are not allowed in the VFS", "SYMLINK_DENIED");
+                }
+                if (dirent.isDirectory()) {
+                    await walk(realPath);
+                    continue;
+                }
+                if (!dirent.isFile())
+                    continue;
+                const stat = await fsp.lstat(realPath);
+                const bytes = await fsp.readFile(realPath);
+                files.push({
+                    path: toVirtualPath(realPath, root),
+                    type: "file",
+                    size: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                    bytes,
+                });
+            }
+        };
+        await walk(root);
+        return files.sort((a, b) => a.path.localeCompare(b.path));
+    }
+    resolvePath(virtualPath) {
+        const normalized = normalizeVirtualPath(virtualPath);
+        const resolved = path.resolve(this.filesRoot, normalized);
+        if (!isWithin(this.filesRoot, resolved)) {
+            throw new VirtualFilesystemError("Path escapes virtual filesystem root", "PATH_TRAVERSAL");
+        }
+        return resolved;
+    }
+    async ensureSafeParentDirectory(target) {
+        const relativeParent = path.relative(this.filesRoot, path.dirname(target));
+        if (!relativeParent)
+            return;
+        let current = this.filesRoot;
+        for (const segment of relativeParent.split(path.sep)) {
+            current = path.join(current, segment);
+            const stat = await lstatOrNull(current);
+            if (!stat)
+                continue;
+            if (stat.isSymbolicLink()) {
+                throw new VirtualFilesystemError(`Symlink path component denied: ${toVirtualPath(current, this.filesRoot)}`, "SYMLINK_DENIED");
+            }
+            if (!stat.isDirectory()) {
+                throw new VirtualFilesystemError("Parent path is not a directory", "NOT_DIRECTORY");
+            }
+        }
+    }
+    async rejectSymlinkIfExists(target) {
+        const stat = await lstatOrNull(target);
+        if (stat?.isSymbolicLink()) {
+            throw new VirtualFilesystemError("Symlinks are not allowed in the VFS", "SYMLINK_DENIED");
+        }
+    }
+    async assertFile(target) {
+        await this.ensureSafeParentDirectory(target);
+        const stat = await lstatOrNull(target);
+        if (!stat) {
+            throw new VirtualFilesystemError("File not found", "NOT_FOUND");
+        }
+        if (stat.isSymbolicLink()) {
+            throw new VirtualFilesystemError("Symlinks are not allowed in the VFS", "SYMLINK_DENIED");
+        }
+        if (!stat.isFile()) {
+            throw new VirtualFilesystemError("Path is not a file", "NOT_FILE");
+        }
+    }
+    async assertDirectory(target) {
+        await this.ensureSafeParentDirectory(target);
+        const stat = await lstatOrNull(target);
+        if (!stat) {
+            throw new VirtualFilesystemError("Directory not found", "NOT_FOUND");
+        }
+        if (stat.isSymbolicLink()) {
+            throw new VirtualFilesystemError("Symlinks are not allowed in the VFS", "SYMLINK_DENIED");
+        }
+        if (!stat.isDirectory()) {
+            throw new VirtualFilesystemError("Path is not a directory", "NOT_DIRECTORY");
+        }
+    }
+    async entryFor(realPath) {
+        const stat = await fsp.lstat(realPath);
+        return {
+            path: toVirtualPath(realPath, this.filesRoot),
+            type: stat.isDirectory() ? "directory" : "file",
+            size: stat.isFile() ? stat.size : 0,
+            mtimeMs: stat.mtimeMs,
+        };
+    }
+    async listEntries(realDir, recursive) {
+        const dirents = await fsp.readdir(realDir, { withFileTypes: true });
+        const entries = [];
+        for (const dirent of dirents) {
+            const realPath = path.join(realDir, dirent.name);
+            if (dirent.isSymbolicLink()) {
+                throw new VirtualFilesystemError("Symlinks are not allowed in the VFS", "SYMLINK_DENIED");
+            }
+            const entry = await this.entryFor(realPath);
+            entries.push(entry);
+            if (recursive && dirent.isDirectory()) {
+                entries.push(...(await this.listEntries(realPath, true)));
+            }
+        }
+        return entries;
+    }
+    async measureFiles() {
+        return this.measureTree(this.filesRoot);
+    }
+    async measureTree(root) {
+        const stat = await lstatOrNull(root);
+        if (!stat)
+            return { bytes: 0, fileCount: 0 };
+        if (stat.isSymbolicLink()) {
+            throw new VirtualFilesystemError("Symlinks are not allowed in the VFS", "SYMLINK_DENIED");
+        }
+        if (stat.isFile()) {
+            return { bytes: stat.size, fileCount: 1 };
+        }
+        if (!stat.isDirectory()) {
+            return { bytes: 0, fileCount: 0 };
+        }
+        let bytes = 0;
+        let fileCount = 0;
+        for (const entry of await fsp.readdir(root, { withFileTypes: true })) {
+            const child = path.join(root, entry.name);
+            const stats = await this.measureTree(child);
+            bytes += stats.bytes;
+            fileCount += stats.fileCount;
+        }
+        return { bytes, fileCount };
+    }
+    async fileSizeIfExists(realPath) {
+        const stat = await lstatOrNull(realPath);
+        if (!stat)
+            return 0;
+        if (stat.isSymbolicLink()) {
+            throw new VirtualFilesystemError("Symlinks are not allowed in the VFS", "SYMLINK_DENIED");
+        }
+        if (!stat.isFile()) {
+            throw new VirtualFilesystemError("Path is not a file", "NOT_FILE");
+        }
+        return stat.size;
+    }
+    async readSnapshot(id) {
+        const normalizedId = normalizeSnapshotId(id);
+        const metadataPath = path.join(this.snapshotsRoot, normalizedId, "snapshot.json");
+        const raw = await fsp.readFile(metadataPath, "utf-8").catch(() => null);
+        return raw ? JSON.parse(raw) : null;
+    }
+    async snapshotFilesRoot(id) {
+        const snapshot = await this.getSnapshot(id);
+        const root = path.join(this.snapshotsRoot, normalizeSnapshotId(snapshot.id), "files");
+        if (!isWithin(this.snapshotsRoot, root)) {
+            throw new VirtualFilesystemError("Snapshot path escapes snapshot root", "PATH_TRAVERSAL");
+        }
+        return root;
+    }
+    async indexTree(root) {
+        const index = new Map();
+        const walk = async (dir) => {
+            for (const dirent of await fsp.readdir(dir, { withFileTypes: true })) {
+                const realPath = path.join(dir, dirent.name);
+                if (dirent.isSymbolicLink()) {
+                    throw new VirtualFilesystemError("Symlinks are not allowed in the VFS", "SYMLINK_DENIED");
+                }
+                const stat = await fsp.lstat(realPath);
+                const entry = {
+                    path: toVirtualPath(realPath, root),
+                    type: stat.isDirectory() ? "directory" : "file",
+                    size: stat.isFile() ? stat.size : 0,
+                    mtimeMs: stat.mtimeMs,
+                    ...(stat.isFile() ? { hash: await sha256(realPath) } : {}),
+                };
+                index.set(entry.path, entry);
+                if (dirent.isDirectory()) {
+                    await walk(realPath);
+                }
+            }
+        };
+        await walk(root);
+        return index;
+    }
+}
+export function createVirtualFilesystemService(options) {
+    return new VirtualFilesystemService(options);
+}
+function sanitizeProjectId(projectId) {
+    const normalized = projectId.trim();
+    if (!normalized ||
+        normalized === "." ||
+        normalized === ".." ||
+        normalized.length > 120 ||
+        !/^[a-zA-Z0-9._-]+$/.test(normalized)) {
+        throw new VirtualFilesystemError("Invalid VFS project id", "INVALID_PATH");
+    }
+    return normalized;
+}
+function normalizeVirtualPath(input) {
+    if (typeof input !== "string" || input.includes("\0")) {
+        throw new VirtualFilesystemError("Invalid virtual path", "INVALID_PATH");
+    }
+    const value = input.trim().replace(/\\/g, "/");
+    if (!value || value === "." || value === "/") {
+        return ".";
+    }
+    const segments = value.split("/").filter(Boolean);
+    if (segments.some((segment) => segment === "." || segment === "..")) {
+        throw new VirtualFilesystemError("Path traversal segments are not allowed", "PATH_TRAVERSAL");
+    }
+    return segments.join(path.sep);
+}
+function normalizeSnapshotId(id) {
+    if (!/^[a-zA-Z0-9._-]+$/.test(id)) {
+        throw new VirtualFilesystemError("Invalid snapshot id", "INVALID_PATH");
+    }
+    return id;
+}
+function isWithin(root, candidate) {
+    const relative = path.relative(path.resolve(root), path.resolve(candidate));
+    return (relative === "" ||
+        (!relative.startsWith("..") && !path.isAbsolute(relative)));
+}
+function toVirtualPath(realPath, root) {
+    const relative = path.relative(root, realPath).replace(/\\/g, "/");
+    return relative ? `/${relative}` : "/";
+}
+async function lstatOrNull(realPath) {
+    try {
+        return await fsp.lstat(realPath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function snapshotId(now) {
+    const stamp = now.toISOString().replace(/[:.]/g, "-");
+    return `${stamp}-${crypto.randomBytes(4).toString("hex")}`;
+}
+async function sha256(realPath) {
+    const hash = crypto.createHash("sha256");
+    hash.update(await fsp.readFile(realPath));
+    return hash.digest("hex");
+}
+function isNodeErrno(error, code) {
+    return (typeof error === "object" &&
+        error !== null &&
+        error.code === code);
+}
+function diffIndexes(before, after) {
+    const paths = new Set([...before.keys(), ...after.keys()]);
+    const diff = [];
+    for (const entryPath of [...paths].sort()) {
+        const beforeEntry = before.get(entryPath);
+        const afterEntry = after.get(entryPath);
+        if (!beforeEntry && afterEntry) {
+            diff.push({ path: entryPath, status: "added", after: afterEntry });
+            continue;
+        }
+        if (beforeEntry && !afterEntry) {
+            diff.push({ path: entryPath, status: "deleted", before: beforeEntry });
+            continue;
+        }
+        if (!beforeEntry || !afterEntry)
+            continue;
+        const same = beforeEntry.type === afterEntry.type &&
+            beforeEntry.size === afterEntry.size &&
+            beforeEntry.hash === afterEntry.hash;
+        if (!same) {
+            diff.push({
+                path: entryPath,
+                status: "modified",
+                before: beforeEntry,
+                after: afterEntry,
+            });
+        }
+    }
+    return diff;
+}

package/shared/conversation-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-format.d.ts","sourceRoot":"","sources":["../../src/shared/conversation-format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AA2BjE,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,MAAM,GACb,MAAM,CA2BR;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,MAAM,CAKvD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAYlE"}

package/shared/conversation-format.js

@@ -0,0 +1,69 @@
+import { asNonEmptyString, asRecord } from "@elizaos/shared";
+const readString = asNonEmptyString;
+function normalizeName(value) {
+    return value.trim().toLowerCase();
+}
+function formatExternalSpeakerLabel(displayName, userName, source) {
+    if (displayName &&
+        userName &&
+        normalizeName(displayName) !== normalizeName(userName)) {
+        if (source === "discord") {
+            return `${displayName} (discord username: ${userName})`;
+        }
+        return `${displayName} (username: ${userName})`;
+    }
+    return displayName ?? userName ?? "user";
+}
+export function formatSpeakerLabel(runtime, memory) {
+    if (memory.entityId === runtime.agentId) {
+        return runtime.character.name ?? "agent";
+    }
+    const metadata = asRecord(memory.metadata);
+    const content = asRecord(memory.content);
+    const defaultMetadata = asRecord(metadata?.default);
+    const source = readString(content?.source);
+    const sourceMetadata = source ? asRecord(metadata?.[source]) : null;
+    const displayName = readString(metadata?.entityName) ??
+        readString(metadata?.displayName) ??
+        readString(sourceMetadata?.displayName) ??
+        readString(sourceMetadata?.name) ??
+        readString(defaultMetadata?.name) ??
+        readString(metadata?.name);
+    const userName = readString(metadata?.entityUserName) ??
+        readString(sourceMetadata?.userName) ??
+        readString(sourceMetadata?.username) ??
+        readString(defaultMetadata?.username) ??
+        readString(metadata?.userName) ??
+        readString(metadata?.username);
+    return formatExternalSpeakerLabel(displayName, userName, source);
+}
+/**
+ * Format a Room into a "[source] name" tag for display in provider output.
+ */
+export function roomSourceTag(room) {
+    if (!room)
+        return "[unknown]";
+    const source = room.source || room.type;
+    const name = room.name || room.id.slice(0, 8);
+    return `[${source}] ${name}`;
+}
+/**
+ * Format a createdAt timestamp as a human-readable relative string.
+ */
+export function formatRelativeTimestamp(createdAt) {
+    if (!createdAt)
+        return "";
+    const date = new Date(createdAt);
+    const now = Date.now();
+    const diffMs = now - date.getTime();
+    if (diffMs < 60_000)
+        return "just now";
+    const minutes = Math.floor(diffMs / 60_000);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    return `${days}d ago`;
+}

package/shared/ui-catalog-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-catalog-prompt.d.ts","sourceRoot":"","sources":["../../src/shared/ui-catalog-prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,UAAU,QAAQ;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAChC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAMD,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAqzB3D,CAAC;AAMF,mEAAmE;AACnE,wBAAgB,iBAAiB,IAAI,MAAM,EAAE,CAE5C;AAED,MAAM,WAAW,6BAA6B;IAC5C,+EAA+E;IAC/E,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,CAAC,EAAE,6BAA6B,GACtC,MAAM,CAyBR;AAMD,gEAAgE;AAChE,eAAO,MAAM,8BAA8B,2JAC0G,CAAC;AAEtJ,4EAA4E;AAC5E,eAAO,MAAM,0BAA0B,kjBAIyG,CAAC;AAEjJ,qEAAqE;AACrE,eAAO,MAAM,eAAe,o8CAgC0D,CAAC;AAEvF,4BAA4B;AAC5B,eAAO,MAAM,eAAe,icAO2G,CAAC;AAExI,6BAA6B;AAC7B,eAAO,MAAM,gBAAgB,wRAEuO,CAAC;AAErQ,0BAA0B;AAC1B,eAAO,MAAM,aAAa,siBAqBnB,CAAC;AAER,0BAA0B;AAC1B,eAAO,MAAM,aAAa,wxBAwBW,CAAC;AAEtC,sBAAsB;AACtB,eAAO,MAAM,SAAS,gvBAuBqI,CAAC;AAE5J,uCAAuC;AACvC,eAAO,MAAM,SAAS,kfAewH,CAAC;AAE/I;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAOd,CAAC;AAMf,6CAA6C;AAC7C,eAAO,MAAM,mBAAmB,i0CAUzB,CAAC;AAER,6EAA6E;AAC7E,eAAO,MAAM,eAAe,g3DAyBU,CAAC;AAMvC,MAAM,WAAW,oBAAoB;IACnC,qDAAqD;IACrD,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,iDAAiD;IACjD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,8DAA8D;IAC9D,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B;;;;;OAKG;IACH,IAAI,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,MAAM,CAuB5E"}

package/shared/workspace-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-resolution.d.ts","sourceRoot":"","sources":["../../src/shared/workspace-resolution.ts"],"names":[],"mappings":"AAyCA,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAa1E;AAED,wBAAgB,iCAAiC,CAC/C,YAAY,EAAE,MAAM,GACnB,OAAO,CAET;AAED,wBAAgB,+BAA+B,CAC7C,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,OAAO,GAAE,MAAM,MAAmB,EAClC,GAAG,GAAE,MAAM,MAAoB,GAC9B,MAAM,CAqCR;AAED,eAAO,MAAM,2BAA2B,QAAoC,CAAC"}

package/shared/workspace-resolution.js

@@ -0,0 +1,82 @@
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { readWorkspaceFolderConfig } from "@elizaos/core";
+import { resolveStateDir, resolveUserPath } from "../config/paths.js";
+const EXPLICIT_WORKSPACE_DIR_KEYS = ["ELIZA_WORKSPACE_DIR"];
+const EXPLICIT_STATE_DIR_KEYS = ["ELIZA_STATE_DIR"];
+const PROJECT_WORKSPACE_MARKERS = [
+    "AGENTS.md",
+    "CLAUDE.md",
+    "package.json",
+    "skills",
+    ".git",
+];
+function readWorkspaceDirOverride(env) {
+    for (const key of EXPLICIT_WORKSPACE_DIR_KEYS) {
+        const value = env[key]?.trim();
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function hasExplicitStateDirOverride(env) {
+    return EXPLICIT_STATE_DIR_KEYS.some((key) => Boolean(env[key]?.trim()));
+}
+function isLikelyPackagedRuntimeDir(dir) {
+    if (typeof dir !== "string")
+        return false;
+    const normalized = dir.replace(/\\/g, "/").toLowerCase();
+    return (normalized.includes("/eliza-dist") ||
+        normalized.includes("/contents/resources/app/") ||
+        normalized.includes("/resources/app/") ||
+        normalized.includes("/self-extraction/"));
+}
+export function shouldUseRuntimeCwdWorkspace(candidateDir) {
+    const resolvedDir = resolveUserPath(candidateDir);
+    if (!resolvedDir ||
+        typeof resolvedDir !== "string" ||
+        isLikelyPackagedRuntimeDir(resolvedDir)) {
+        return false;
+    }
+    return PROJECT_WORKSPACE_MARKERS.some((marker) => existsSync(path.join(resolvedDir, marker)));
+}
+export function shouldBootstrapWorkspaceInitFiles(candidateDir) {
+    return !shouldUseRuntimeCwdWorkspace(candidateDir);
+}
+export function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir, cwd = process.cwd) {
+    const explicitWorkspaceDir = readWorkspaceDirOverride(env);
+    if (explicitWorkspaceDir) {
+        return resolveUserPath(explicitWorkspaceDir);
+    }
+    // Store-distributed desktop builds write the user-picked workspace folder
+    // to <stateDir>/workspace-folder.json via the Electrobun desktop RPC.
+    // Honor that file as a higher-priority signal than the project-cwd auto-
+    // detect heuristic so the user's explicit choice always wins under the
+    // sandbox. Falls through silently when the file is absent or unreadable.
+    try {
+        const persisted = readWorkspaceFolderConfig(env);
+        if (persisted?.path?.trim()) {
+            return resolveUserPath(persisted.path);
+        }
+    }
+    catch {
+        // Ignore — fall through to cwd / state-dir defaults.
+    }
+    if (!hasExplicitStateDirOverride(env)) {
+        const runtimeCwd = typeof cwd === "function" ? cwd() : undefined;
+        if (typeof runtimeCwd === "string" &&
+            runtimeCwd.trim() &&
+            shouldUseRuntimeCwdWorkspace(runtimeCwd.trim())) {
+            return resolveUserPath(runtimeCwd);
+        }
+    }
+    const profile = env.ELIZA_PROFILE?.trim();
+    const stateDir = resolveStateDir(env, homedir);
+    if (profile && profile.toLowerCase() !== "default") {
+        return path.join(stateDir, `workspace-${profile}`);
+    }
+    return path.join(stateDir, "workspace");
+}
+export const DEFAULT_AGENT_WORKSPACE_DIR = resolveDefaultAgentWorkspaceDir();

package/test-support/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test-support/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC"}

package/test-support/process-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-helpers.d.ts","sourceRoot":"","sources":["../../src/test-support/process-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,KAAK,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,gBAAgB,GACxB,YAAY,CAmBd"}

package/test-support/route-test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-test-helpers.d.ts","sourceRoot":"","sources":["../../src/test-support/route-test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGjE,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEhD,MAAM,MAAM,qBAAqB,CAAC,QAAQ,GAAG,OAAO,IAAI;IACtD,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,QAAQ,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,eAAe,CAAC,KAAK,GAAG,SAAS,EAAE,QAAQ,GAAG,OAAO,IAAI;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,eAAe,CAAC,EAAE,QAAQ,CAAC;IAC3B,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,kBAAkB,CAAC,KAAK,EAAE,QAAQ,IAAI;IAChD,GAAG,EAAE,eAAe,CAAC;IACrB,GAAG,EAAE,cAAc,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,QAAQ,CAAC;IAClB,YAAY,EAAE,MAAM,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAC1C,IAAI,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACrE,KAAK,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CACzE,CAAC;AAEF,KAAK,mBAAmB,CAAC,QAAQ,GAAG,OAAO,IACvC;IACE,OAAO,EAAE,QAAQ,CAAC;IAClB,eAAe,CAAC,EAAE,SAAS,CAAC;CAC7B,GACD;IACE,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,eAAe,EAAE,MAAM,QAAQ,CAAC;CACjC,CAAC;AAEN,wBAAgB,kBAAkB,CAChC,KAAK,GAAG,SAAS,EACjB,QAAQ,GAAG,OAAO,EAClB,QAAQ,GAAG,OAAO,EAElB,OAAO,EAAE,CAAC,GAAG,EAAE,kBAAkB,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,EACvE,OAAO,EAAE,mBAAmB,CAAC,QAAQ,CAAC,GACrC,CACD,IAAI,EAAE,eAAe,CAAC,KAAK,EAAE,QAAQ,CAAC,KACnC,OAAO,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,CA8D5C"}

package/test-support/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../src/test-support/test-helpers.ts"],"names":[],"mappings":"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"}

package/test-utils/sqlite-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-compat.d.ts","sourceRoot":"","sources":["../../src/test-utils/sqlite-compat.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,WAAW,GACnB,MAAM,GACN,MAAM,GACN,MAAM,GACN,OAAO,GACP,UAAU,GACV,IAAI,CAAC;AAET,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;AAEpD,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,qBAAqB;IACpC,GAAG,CAAC,GAAG,MAAM,EAAE,WAAW,EAAE,GAAG,SAAS,EAAE,CAAC;IAC3C,GAAG,CAAC,GAAG,MAAM,EAAE,WAAW,EAAE,GAAG,SAAS,GAAG,IAAI,CAAC;IAChD,GAAG,CAAC,GAAG,MAAM,EAAE,WAAW,EAAE,GAAG,eAAe,CAAC;CAChD;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,qBAAqB,CAAC;IAC5C,KAAK,IAAI,IAAI,CAAC;CACf;AAED,MAAM,WAAW,6BAA6B;IAC5C,KAAK,QAAQ,EAAE,MAAM,GAAG,oBAAoB,CAAC;CAC9C;AA6QD,eAAO,MAAM,SAAS,SAAiB,CAAC;AACxC,eAAO,MAAM,YAAY,EAAwB,6BAA6B,CAAC;AAC/E,MAAM,MAAM,kBAAkB,GAAG,YAAY,CAAC,6BAA6B,CAAC,CAAC"}