@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/features/secrets/storage/interface.js

@@ -0,0 +1,92 @@
+/**
+ * Storage Interface Definitions
+ *
+ * Defines the contract that all storage backends must implement.
+ * Designed for ElizaOS native storage patterns.
+ */
+/**
+ * Abstract base class for secret storage implementations
+ *
+ * Provides common functionality and enforces the storage interface.
+ */
+export class BaseSecretStorage {
+    /**
+     * Create a default secret configuration
+     */
+    createDefaultConfig(key, context, partial) {
+        return {
+            type: partial?.type ?? "secret",
+            required: partial?.required ?? false,
+            description: partial?.description ?? `Secret: ${key}`,
+            canGenerate: partial?.canGenerate ?? false,
+            validationMethod: partial?.validationMethod,
+            status: partial?.status ?? "valid",
+            lastError: partial?.lastError,
+            attempts: partial?.attempts ?? 0,
+            createdAt: partial?.createdAt ?? Date.now(),
+            validatedAt: partial?.validatedAt ?? Date.now(),
+            plugin: partial?.plugin ?? context.level,
+            level: context.level,
+            ownerId: context.userId,
+            worldId: context.worldId,
+            encrypted: partial?.encrypted ?? true,
+            permissions: partial?.permissions ?? [],
+            sharedWith: partial?.sharedWith ?? [],
+            expiresAt: partial?.expiresAt,
+        };
+    }
+}
+/**
+ * Composite storage that delegates to multiple backends based on context
+ */
+export class CompositeSecretStorage {
+    storageType = "memory";
+    globalStorage;
+    worldStorage;
+    userStorage;
+    constructor(options) {
+        this.globalStorage = options.globalStorage;
+        this.worldStorage = options.worldStorage;
+        this.userStorage = options.userStorage;
+    }
+    async initialize() {
+        await Promise.all([
+            this.globalStorage.initialize(),
+            this.worldStorage.initialize(),
+            this.userStorage.initialize(),
+        ]);
+    }
+    getStorageForContext(context) {
+        switch (context.level) {
+            case "global":
+                return this.globalStorage;
+            case "world":
+                return this.worldStorage;
+            case "user":
+                return this.userStorage;
+            default:
+                return this.globalStorage;
+        }
+    }
+    async exists(key, context) {
+        return this.getStorageForContext(context).exists(key, context);
+    }
+    async get(key, context) {
+        return this.getStorageForContext(context).get(key, context);
+    }
+    async set(key, value, context, config) {
+        return this.getStorageForContext(context).set(key, value, context, config);
+    }
+    async delete(key, context) {
+        return this.getStorageForContext(context).delete(key, context);
+    }
+    async list(context) {
+        return this.getStorageForContext(context).list(context);
+    }
+    async getConfig(key, context) {
+        return this.getStorageForContext(context).getConfig(key, context);
+    }
+    async updateConfig(key, context, config) {
+        return this.getStorageForContext(context).updateConfig(key, context, config);
+    }
+}

package/packages/typescript/src/features/secrets/storage/memory-store.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Memory-based Secret Storage
+ *
+ * In-memory storage backend for secrets. Useful for testing and
+ * ephemeral environments where persistence is not required.
+ */
+import type { SecretConfig, SecretContext, SecretMetadata, StorageBackend } from "../types.ts";
+import { BaseSecretStorage } from "./interface.ts";
+/**
+ * Memory-based secret storage implementation
+ */
+export declare class MemorySecretStorage extends BaseSecretStorage {
+    readonly storageType: StorageBackend;
+    private store;
+    initialize(): Promise<void>;
+    exists(key: string, context: SecretContext): Promise<boolean>;
+    get(key: string, context: SecretContext): Promise<string | null>;
+    set(key: string, value: string, context: SecretContext, config?: Partial<SecretConfig>): Promise<boolean>;
+    delete(key: string, context: SecretContext): Promise<boolean>;
+    list(context: SecretContext): Promise<SecretMetadata>;
+    getConfig(key: string, context: SecretContext): Promise<SecretConfig | null>;
+    updateConfig(key: string, context: SecretContext, config: Partial<SecretConfig>): Promise<boolean>;
+    /**
+     * Generate a storage key from the secret key and context
+     */
+    private generateStorageKey;
+    /**
+     * Get the storage key prefix for a context level
+     */
+    private getContextPrefix;
+    /**
+     * Extract the original key from a storage key
+     */
+    private extractOriginalKey;
+    /**
+     * Clear all stored secrets (for testing)
+     */
+    clear(): void;
+    /**
+     * Get the number of stored secrets (for testing)
+     */
+    size(): number;
+}
+//# sourceMappingURL=memory-store.d.ts.map

package/packages/typescript/src/features/secrets/storage/memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/secrets/storage/memory-store.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACX,YAAY,EACZ,aAAa,EACb,cAAc,EACd,cAAc,EACd,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAUnD;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,iBAAiB;IACzD,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAY;IAEhD,OAAO,CAAC,KAAK,CAAwC;IAE/C,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;IAK7D,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAgBhE,GAAG,CACR,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,aAAa,EACtB,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAC5B,OAAO,CAAC,OAAO,CAAC;IAiBb,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;IAK7D,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAqBrD,SAAS,CACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IASzB,YAAY,CACjB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAC3B,OAAO,CAAC,OAAO,CAAC;IAgBnB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,IAAI,IAAI,MAAM;CAGd"}

package/packages/typescript/src/features/secrets/storage/memory-store.js

@@ -0,0 +1,142 @@
+/**
+ * Memory-based Secret Storage
+ *
+ * In-memory storage backend for secrets. Useful for testing and
+ * ephemeral environments where persistence is not required.
+ */
+import { BaseSecretStorage } from "./interface.js";
+/**
+ * Memory-based secret storage implementation
+ */
+export class MemorySecretStorage extends BaseSecretStorage {
+    storageType = "memory";
+    store = new Map();
+    async initialize() {
+        // Nothing to initialize for memory storage
+    }
+    async exists(key, context) {
+        const storageKey = this.generateStorageKey(key, context);
+        return this.store.has(storageKey);
+    }
+    async get(key, context) {
+        const storageKey = this.generateStorageKey(key, context);
+        const entry = this.store.get(storageKey);
+        if (!entry) {
+            return null;
+        }
+        // Check expiration
+        if (entry.config.expiresAt && entry.config.expiresAt < Date.now()) {
+            this.store.delete(storageKey);
+            return null;
+        }
+        return entry.value;
+    }
+    async set(key, value, context, config) {
+        const storageKey = this.generateStorageKey(key, context);
+        const existingEntry = this.store.get(storageKey);
+        const fullConfig = this.createDefaultConfig(key, context, {
+            ...existingEntry?.config,
+            ...config,
+        });
+        this.store.set(storageKey, {
+            value,
+            config: fullConfig,
+        });
+        return true;
+    }
+    async delete(key, context) {
+        const storageKey = this.generateStorageKey(key, context);
+        return this.store.delete(storageKey);
+    }
+    async list(context) {
+        const prefix = this.getContextPrefix(context);
+        const metadata = {};
+        for (const [storageKey, entry] of this.store) {
+            if (storageKey.startsWith(prefix)) {
+                const originalKey = this.extractOriginalKey(storageKey, context);
+                if (originalKey) {
+                    // Check expiration
+                    if (entry.config.expiresAt && entry.config.expiresAt < Date.now()) {
+                        this.store.delete(storageKey);
+                        continue;
+                    }
+                    metadata[originalKey] = { ...entry.config };
+                }
+            }
+        }
+        return metadata;
+    }
+    async getConfig(key, context) {
+        const storageKey = this.generateStorageKey(key, context);
+        const entry = this.store.get(storageKey);
+        if (!entry) {
+            return null;
+        }
+        return { ...entry.config };
+    }
+    async updateConfig(key, context, config) {
+        const storageKey = this.generateStorageKey(key, context);
+        const entry = this.store.get(storageKey);
+        if (!entry) {
+            return false;
+        }
+        entry.config = {
+            ...entry.config,
+            ...config,
+        };
+        this.store.set(storageKey, entry);
+        return true;
+    }
+    /**
+     * Generate a storage key from the secret key and context
+     */
+    generateStorageKey(key, context) {
+        switch (context.level) {
+            case "global":
+                return `global:${context.agentId}:${key}`;
+            case "world":
+                return `world:${context.worldId}:${key}`;
+            case "user":
+                return `user:${context.userId}:${key}`;
+            default:
+                return `unknown:${key}`;
+        }
+    }
+    /**
+     * Get the storage key prefix for a context level
+     */
+    getContextPrefix(context) {
+        switch (context.level) {
+            case "global":
+                return `global:${context.agentId}:`;
+            case "world":
+                return `world:${context.worldId}:`;
+            case "user":
+                return `user:${context.userId}:`;
+            default:
+                return "";
+        }
+    }
+    /**
+     * Extract the original key from a storage key
+     */
+    extractOriginalKey(storageKey, context) {
+        const prefix = this.getContextPrefix(context);
+        if (!storageKey.startsWith(prefix)) {
+            return null;
+        }
+        return storageKey.slice(prefix.length);
+    }
+    /**
+     * Clear all stored secrets (for testing)
+     */
+    clear() {
+        this.store.clear();
+    }
+    /**
+     * Get the number of stored secrets (for testing)
+     */
+    size() {
+        return this.store.size;
+    }
+}

package/packages/typescript/src/features/secrets/storage/world-store.d.ts

@@ -0,0 +1,52 @@
+/**
+ * World Metadata Storage
+ *
+ * Stores world-level secrets in the world's metadata.secrets object.
+ * This is used for server/channel-specific configuration like Discord tokens.
+ */
+import type { IAgentRuntime } from "../../../types/index.ts";
+import { type KeyManager } from "../crypto/index.ts";
+import type { SecretConfig, SecretContext, SecretMetadata, StorageBackend } from "../types.ts";
+import { BaseSecretStorage } from "./interface.ts";
+/**
+ * World metadata-based storage for world-level secrets
+ *
+ * Secrets are stored in world.metadata.secrets with access control
+ * based on world roles (OWNER/ADMIN can write, all members can read).
+ */
+export declare class WorldMetadataStorage extends BaseSecretStorage {
+    readonly storageType: StorageBackend;
+    private runtime;
+    private keyManager;
+    private worldCache;
+    constructor(runtime: IAgentRuntime, keyManager: KeyManager);
+    initialize(): Promise<void>;
+    exists(key: string, context: SecretContext): Promise<boolean>;
+    get(key: string, context: SecretContext): Promise<string | null>;
+    set(key: string, value: string, context: SecretContext, config?: Partial<SecretConfig>): Promise<boolean>;
+    delete(key: string, context: SecretContext): Promise<boolean>;
+    list(context: SecretContext): Promise<SecretMetadata>;
+    getConfig(key: string, context: SecretContext): Promise<SecretConfig | null>;
+    updateConfig(key: string, context: SecretContext, config: Partial<SecretConfig>): Promise<boolean>;
+    /**
+     * Get a world from cache or database
+     */
+    private getWorld;
+    /**
+     * Get secrets object from world metadata
+     */
+    private getWorldSecrets;
+    /**
+     * Check if a user has write permission in a world
+     */
+    private checkWritePermission;
+    /**
+     * Clear the world cache
+     */
+    clearCache(): void;
+    /**
+     * Invalidate a specific world in the cache
+     */
+    invalidateWorld(worldId: string): void;
+}
+//# sourceMappingURL=world-store.d.ts.map

package/packages/typescript/src/features/secrets/storage/world-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-store.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/secrets/storage/world-store.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,yBAAyB,CAAC;AAE1E,OAAO,EAAqB,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,KAAK,EAEX,YAAY,EACZ,aAAa,EACb,cAAc,EACd,cAAc,EAEd,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAWnD;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,iBAAiB;IAC1D,QAAQ,CAAC,WAAW,EAAE,cAAc,CAAW;IAE/C,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,UAAU,CAAiC;gBAEvC,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,UAAU;IAMpD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;IAS7D,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IA2ChE,GAAG,CACR,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,aAAa,EACtB,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAC5B,OAAO,CAAC,OAAO,CAAC;IAiEb,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC;IA0C7D,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAgCrD,SAAS,CACd,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,aAAa,GACpB,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;IAmBzB,YAAY,CACjB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAC3B,OAAO,CAAC,OAAO,CAAC;IAwDnB;;OAEG;YACW,QAAQ;IAgBtB;;OAEG;YACW,eAAe;IAW7B;;OAEG;YACW,oBAAoB;IAwBlC;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAGtC"}

package/packages/typescript/src/features/secrets/storage/world-store.js

@@ -0,0 +1,292 @@
+/**
+ * World Metadata Storage
+ *
+ * Stores world-level secrets in the world's metadata.secrets object.
+ * This is used for server/channel-specific configuration like Discord tokens.
+ */
+import { logger } from "../../../logger.js";
+import { Role } from "../../../types/index.js";
+import { isEncryptedSecret } from "../crypto/index.js";
+import { PermissionDeniedError, StorageError } from "../types.js";
+import { BaseSecretStorage } from "./interface.js";
+/**
+ * World metadata-based storage for world-level secrets
+ *
+ * Secrets are stored in world.metadata.secrets with access control
+ * based on world roles (OWNER/ADMIN can write, all members can read).
+ */
+export class WorldMetadataStorage extends BaseSecretStorage {
+    storageType = "world";
+    runtime;
+    keyManager;
+    worldCache = new Map();
+    constructor(runtime, keyManager) {
+        super();
+        this.runtime = runtime;
+        this.keyManager = keyManager;
+    }
+    async initialize() {
+        logger.debug("[WorldMetadataStorage] Initialized");
+    }
+    async exists(key, context) {
+        if (!context.worldId) {
+            return false;
+        }
+        const secrets = await this.getWorldSecrets(context.worldId);
+        return key in secrets;
+    }
+    async get(key, context) {
+        if (!context.worldId) {
+            logger.warn("[WorldMetadataStorage] Cannot get secret without worldId");
+            return null;
+        }
+        const secrets = await this.getWorldSecrets(context.worldId);
+        const stored = secrets[key];
+        if (stored === undefined || stored === null) {
+            return null;
+        }
+        // Handle different storage formats
+        if (typeof stored === "string") {
+            return stored;
+        }
+        if (typeof stored === "object") {
+            const storedSecret = stored;
+            // Check expiration
+            if (storedSecret.config?.expiresAt &&
+                storedSecret.config.expiresAt < Date.now()) {
+                await this.delete(key, context);
+                return null;
+            }
+            // Handle encrypted value
+            if (isEncryptedSecret(storedSecret.value)) {
+                return this.keyManager.decrypt(storedSecret.value);
+            }
+            if (typeof storedSecret.value === "string") {
+                return storedSecret.value;
+            }
+        }
+        return null;
+    }
+    async set(key, value, context, config) {
+        if (!context.worldId) {
+            throw new StorageError("Cannot set world secret without worldId");
+        }
+        // Check write permission
+        if (context.requesterId) {
+            const hasPermission = await this.checkWritePermission(context.worldId, context.requesterId);
+            if (!hasPermission) {
+                throw new PermissionDeniedError(key, "write", context);
+            }
+        }
+        const world = await this.getWorld(context.worldId);
+        if (!world) {
+            throw new StorageError(`World not found: ${context.worldId}`);
+        }
+        // Ensure metadata structure exists
+        if (!world.metadata) {
+            world.metadata = {};
+        }
+        // Use type assertion to access secrets (stored in world metadata)
+        const worldMeta = world.metadata;
+        if (!worldMeta.secrets) {
+            worldMeta.secrets = {};
+        }
+        const secrets = worldMeta.secrets;
+        const existingStored = secrets[key];
+        const existingConfig = typeof existingStored === "object" ? existingStored.config : undefined;
+        const fullConfig = this.createDefaultConfig(key, context, {
+            ...existingConfig,
+            ...config,
+            worldId: context.worldId,
+        });
+        // Encrypt value if encryption is enabled
+        const shouldEncrypt = fullConfig.encrypted !== false;
+        const storedValue = shouldEncrypt
+            ? this.keyManager.encrypt(value)
+            : value;
+        const storedSecret = {
+            value: storedValue,
+            config: fullConfig,
+        };
+        secrets[key] = storedSecret;
+        worldMeta.secrets = secrets;
+        await this.runtime.updateWorld(world);
+        this.worldCache.set(context.worldId, world);
+        logger.debug(`[WorldMetadataStorage] Set secret: ${key} for world: ${context.worldId}`);
+        return true;
+    }
+    async delete(key, context) {
+        if (!context.worldId) {
+            return false;
+        }
+        // Check write permission
+        if (context.requesterId) {
+            const hasPermission = await this.checkWritePermission(context.worldId, context.requesterId);
+            if (!hasPermission) {
+                throw new PermissionDeniedError(key, "delete", context);
+            }
+        }
+        const world = await this.getWorld(context.worldId);
+        if (!world) {
+            return false;
+        }
+        const metadata = world.metadata;
+        if (!metadata?.secrets) {
+            return false;
+        }
+        const secrets = metadata.secrets;
+        if (!(key in secrets)) {
+            return false;
+        }
+        delete secrets[key];
+        metadata.secrets = secrets;
+        await this.runtime.updateWorld(world);
+        this.worldCache.set(context.worldId, world);
+        logger.debug(`[WorldMetadataStorage] Deleted secret: ${key} from world: ${context.worldId}`);
+        return true;
+    }
+    async list(context) {
+        if (!context.worldId) {
+            return {};
+        }
+        const secrets = await this.getWorldSecrets(context.worldId);
+        const metadata = {};
+        for (const [key, stored] of Object.entries(secrets)) {
+            if (typeof stored === "object" && stored !== null) {
+                const storedSecret = stored;
+                // Check expiration
+                if (storedSecret.config?.expiresAt &&
+                    storedSecret.config.expiresAt < Date.now()) {
+                    continue;
+                }
+                if (storedSecret.config) {
+                    metadata[key] = { ...storedSecret.config };
+                }
+            }
+            else {
+                // Legacy string format
+                metadata[key] = this.createDefaultConfig(key, context);
+            }
+        }
+        return metadata;
+    }
+    async getConfig(key, context) {
+        if (!context.worldId) {
+            return null;
+        }
+        const secrets = await this.getWorldSecrets(context.worldId);
+        const stored = secrets[key];
+        if (!stored) {
+            return null;
+        }
+        if (typeof stored === "object" && "config" in stored) {
+            return { ...stored.config };
+        }
+        return this.createDefaultConfig(key, context);
+    }
+    async updateConfig(key, context, config) {
+        if (!context.worldId) {
+            return false;
+        }
+        // Check write permission
+        if (context.requesterId) {
+            const hasPermission = await this.checkWritePermission(context.worldId, context.requesterId);
+            if (!hasPermission) {
+                throw new PermissionDeniedError(key, "write", context);
+            }
+        }
+        const world = await this.getWorld(context.worldId);
+        if (!world) {
+            return false;
+        }
+        const metadata = world.metadata;
+        if (!metadata?.secrets) {
+            return false;
+        }
+        const secrets = metadata.secrets;
+        const stored = secrets[key];
+        if (!stored) {
+            return false;
+        }
+        if (typeof stored === "object" && "config" in stored) {
+            const storedSecret = stored;
+            storedSecret.config = {
+                ...storedSecret.config,
+                ...config,
+            };
+            secrets[key] = storedSecret;
+        }
+        else {
+            // Upgrade legacy format
+            const defaultConfig = this.createDefaultConfig(key, context);
+            const storedSecret = {
+                value: stored,
+                config: { ...defaultConfig, ...config },
+            };
+            secrets[key] = storedSecret;
+        }
+        metadata.secrets = secrets;
+        await this.runtime.updateWorld(world);
+        this.worldCache.set(context.worldId, world);
+        return true;
+    }
+    /**
+     * Get a world from cache or database
+     */
+    async getWorld(worldId) {
+        // Check cache first
+        const cached = this.worldCache.get(worldId);
+        if (cached) {
+            return cached;
+        }
+        // Load from database
+        const world = await this.runtime.getWorld(worldId);
+        if (world) {
+            this.worldCache.set(worldId, world);
+        }
+        return world;
+    }
+    /**
+     * Get secrets object from world metadata
+     */
+    async getWorldSecrets(worldId) {
+        const world = await this.getWorld(worldId);
+        const metadata = world?.metadata;
+        if (!metadata?.secrets) {
+            return {};
+        }
+        return metadata.secrets;
+    }
+    /**
+     * Check if a user has write permission in a world
+     */
+    async checkWritePermission(worldId, userId) {
+        const world = await this.getWorld(worldId);
+        if (!world) {
+            return false;
+        }
+        // Agent always has permission
+        if (userId === this.runtime.agentId) {
+            return true;
+        }
+        // Check world roles
+        const roles = world.metadata?.roles;
+        if (!roles) {
+            return false;
+        }
+        const userRole = roles[userId];
+        return userRole === Role.OWNER || userRole === Role.ADMIN;
+    }
+    /**
+     * Clear the world cache
+     */
+    clearCache() {
+        this.worldCache.clear();
+    }
+    /**
+     * Invalidate a specific world in the cache
+     */
+    invalidateWorld(worldId) {
+        this.worldCache.delete(worldId);
+    }
+}