@elizaos/ui 2.0.0-alpha.24 → 2.0.0-alpha.333

package/packages/typescript/src/features/advanced-capabilities/personality/services/character-file-manager.js

@@ -0,0 +1,478 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { z } from "zod";
+import { logger } from "../../../../logger.js";
+import { Service } from "../../../../types/service.js";
+import { PersonalityServiceType } from "../types.js";
+// Validation schema for character modifications
+const CharacterModificationSchema = z.object({
+    name: z.string().optional().describe("Character name"),
+    system: z
+        .string()
+        .optional()
+        .describe("System prompt that defines agent behavior and instructions"),
+    bio: z.array(z.string()).optional(),
+    messageExamples: z
+        .array(z.array(z.object({
+        name: z.string(),
+        content: z.object({
+            text: z.string(),
+            actions: z.array(z.string()).optional(),
+        }),
+    })))
+        .optional(),
+    topics: z.array(z.string()).optional(),
+    style: z
+        .object({
+        all: z.array(z.string()).optional(),
+        chat: z.array(z.string()).optional(),
+        post: z.array(z.string()).optional(),
+    })
+        .optional(),
+    settings: z
+        .record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()]))
+        .optional(),
+});
+/**
+ * Service for safely managing character file modifications
+ * Handles backup, validation, and atomic updates of character files
+ */
+export class CharacterFileManager extends Service {
+    static serviceType = PersonalityServiceType.CHARACTER_MANAGEMENT;
+    capabilityDescription = "Manages safe character file modifications with backup and validation";
+    characterFilePath = null;
+    backupDir;
+    maxBackups = 10;
+    validationRules = new Map();
+    constructor(runtime) {
+        super(runtime);
+        this.backupDir = path.join(process.cwd(), ".eliza", "character-backups");
+        this.setupValidationRules();
+    }
+    static async start(runtime) {
+        const manager = new CharacterFileManager(runtime);
+        await manager.initialize();
+        return manager;
+    }
+    async initialize() {
+        // Ensure backup directory exists
+        await fs.ensureDir(this.backupDir);
+        // Try to detect the character file path
+        await this.detectCharacterFile();
+        logger.debug({ characterFile: this.characterFilePath, backupDir: this.backupDir }, "CharacterFileManager initialized");
+    }
+    async detectCharacterFile() {
+        const character = this.runtime.character;
+        // Look for character file in common locations
+        const possiblePaths = [
+            // Current working directory
+            path.join(process.cwd(), `${character.name}.json`),
+            path.join(process.cwd(), "character.json"),
+            // Agent directory
+            path.join(process.cwd(), "agent", `${character.name}.json`),
+            path.join(process.cwd(), "agent", "character.json"),
+            // Characters directory
+            path.join(process.cwd(), "characters", `${character.name}.json`),
+            path.join(process.cwd(), "characters", "character.json"),
+            // Relative paths
+            path.join(process.cwd(), "..", "characters", `${character.name}.json`),
+            path.join(process.cwd(), "..", "..", "characters", `${character.name}.json`),
+        ];
+        for (const filePath of possiblePaths) {
+            if (await fs.pathExists(filePath)) {
+                try {
+                    const content = await fs.readJSON(filePath);
+                    if (content.name === character.name) {
+                        this.characterFilePath = filePath;
+                        logger.debug({ path: filePath }, "Character file detected");
+                        return;
+                    }
+                }
+                catch {
+                    // Continue searching
+                }
+            }
+        }
+        logger.debug("No character file on disk, operating in memory-only mode");
+    }
+    setupValidationRules() {
+        // Name validation - ensure safe and reasonable names
+        this.validationRules.set("name", (value) => {
+            if (typeof value !== "string") {
+                return false;
+            }
+            const name = value;
+            return (name.length > 0 &&
+                name.length < 100 &&
+                /^[a-zA-Z0-9\s\-_]+$/.test(name) && // Alphanumeric, spaces, hyphens, underscores only
+                !name.toLowerCase().includes("admin") && // Prevent impersonation
+                !name.toLowerCase().includes("system") &&
+                !name.toLowerCase().includes("root") &&
+                !name.trim().startsWith(" ") && // No leading/trailing spaces
+                !name.trim().endsWith(" "));
+        });
+        // System prompt validation - ensure safe and reasonable content
+        this.validationRules.set("system", (value) => {
+            if (typeof value !== "string") {
+                return false;
+            }
+            const system = value;
+            return (system.length > 10 && // Minimum meaningful length
+                system.length < 10000 && // Maximum reasonable length
+                !system.includes("<script>") && // Basic XSS protection
+                !system.includes("javascript:") &&
+                !system.includes("eval(") &&
+                !system.includes("Function(") &&
+                !system.toLowerCase().includes("ignore previous instructions") && // Prompt injection protection
+                !system.toLowerCase().includes("disregard") &&
+                !system.toLowerCase().includes("forget everything"));
+        });
+        // Bio validation - ensure reasonable length and content
+        this.validationRules.set("bio", (value) => {
+            if (!Array.isArray(value)) {
+                return false;
+            }
+            return value.every((item) => typeof item === "string" &&
+                item.length > 0 &&
+                item.length < 500 &&
+                !item.includes("<script>") && // Basic XSS protection
+                !item.includes("javascript:"));
+        });
+        // Topics validation
+        this.validationRules.set("topics", (value) => {
+            if (!Array.isArray(value)) {
+                return false;
+            }
+            return value.every((topic) => typeof topic === "string" &&
+                topic.length > 0 &&
+                topic.length < 100 &&
+                /^[a-zA-Z0-9\s\-_]+$/.test(topic));
+        });
+    }
+    async createBackup() {
+        if (!this.characterFilePath) {
+            logger.warn("No character file path available for backup");
+            return null;
+        }
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+            const backupFileName = `${path.basename(this.characterFilePath, ".json")}-${timestamp}.json`;
+            const backupPath = path.join(this.backupDir, backupFileName);
+            await fs.copy(this.characterFilePath, backupPath);
+            // Clean up old backups
+            await this.cleanupOldBackups();
+            logger.info({ backupPath }, "Character backup created");
+            return backupPath;
+        }
+        catch (error) {
+            logger.error({ error: error instanceof Error ? error.message : String(error) }, "Failed to create character backup");
+            return null;
+        }
+    }
+    async cleanupOldBackups() {
+        try {
+            const files = await fs.readdir(this.backupDir);
+            const backupFiles = files
+                .filter((file) => file.endsWith(".json"))
+                .map((file) => ({
+                name: file,
+                path: path.join(this.backupDir, file),
+                stat: fs.statSync(path.join(this.backupDir, file)),
+            }))
+                .sort((a, b) => b.stat.mtime.getTime() - a.stat.mtime.getTime());
+            // Keep only the most recent backups
+            const filesToDelete = backupFiles.slice(this.maxBackups);
+            for (const file of filesToDelete) {
+                await fs.unlink(file.path);
+            }
+            if (filesToDelete.length > 0) {
+                logger.info(`Cleaned up ${filesToDelete.length} old backups`);
+            }
+        }
+        catch (error) {
+            logger.error({ error: error instanceof Error ? error.message : String(error) }, "Error cleaning up old backups");
+        }
+    }
+    validateModification(modification) {
+        const errors = [];
+        try {
+            // Schema validation
+            CharacterModificationSchema.parse(modification);
+        }
+        catch (error) {
+            errors.push(`Schema validation failed: ${error.message}`);
+            return { valid: false, errors };
+        }
+        // Additional validation rules
+        for (const [field, validator] of this.validationRules.entries()) {
+            if (modification[field] !== undefined) {
+                if (!validator(modification[field])) {
+                    errors.push(`Invalid ${field}: failed validation rules`);
+                }
+            }
+        }
+        // Safety checks
+        const bioVal = modification.bio;
+        if (Array.isArray(bioVal) && bioVal.length > 20) {
+            errors.push("Too many bio elements - maximum 20 allowed");
+        }
+        const topicsVal = modification.topics;
+        if (Array.isArray(topicsVal) && topicsVal.length > 50) {
+            errors.push("Too many topics - maximum 50 allowed");
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    async applyModification(modification) {
+        // Validate modification
+        const validation = this.validateModification(modification);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: `Validation failed: ${validation.errors.join(", ")}`,
+            };
+        }
+        try {
+            // Create backup first
+            await this.createBackup();
+            // Get current character
+            const currentCharacter = { ...this.runtime.character };
+            const previousName = typeof this.runtime.character.name === "string"
+                ? this.runtime.character.name
+                : undefined;
+            // Apply modifications using merge logic (additive, not replacement)
+            // Handle name modification - direct replacement
+            if (modification.name) {
+                const oldName = currentCharacter.name;
+                currentCharacter.name = modification.name;
+                logger.info({ oldName, newName: modification.name }, "Character name changed");
+            }
+            // Handle system prompt modification - this is a direct replacement, not additive
+            if (modification.system) {
+                const oldSystem = currentCharacter.system || "No system prompt";
+                currentCharacter.system = modification.system;
+                logger.info({
+                    oldLength: oldSystem.length,
+                    newLength: modification.system.length,
+                    changed: oldSystem !== modification.system,
+                }, "System prompt modified");
+            }
+            if (modification.bio) {
+                const currentBio = Array.isArray(currentCharacter.bio)
+                    ? currentCharacter.bio
+                    : typeof currentCharacter.bio === "string"
+                        ? [currentCharacter.bio]
+                        : [];
+                // Add new bio elements, avoiding duplicates
+                const newBioElements = modification.bio.filter((newBio) => !currentBio.some((existing) => existing.toLowerCase().includes(newBio.toLowerCase()) ||
+                    newBio.toLowerCase().includes(existing.toLowerCase())));
+                currentCharacter.bio = [...currentBio, ...newBioElements];
+            }
+            if (modification.topics) {
+                const currentTopics = currentCharacter.topics || [];
+                const newTopics = modification.topics.filter((topic) => !currentTopics.includes(topic));
+                currentCharacter.topics = [...currentTopics, ...newTopics];
+            }
+            if (modification.messageExamples) {
+                const currentExamples = currentCharacter.messageExamples || [];
+                const newExampleGroups = modification.messageExamples.map((group) => ({
+                    examples: group.map((item) => ({
+                        name: item.name ?? "",
+                        content: {
+                            text: item.content?.text ?? "",
+                            ...(item.content?.actions
+                                ? { actions: item.content.actions }
+                                : {}),
+                        },
+                    })),
+                }));
+                currentCharacter.messageExamples = [
+                    ...currentExamples,
+                    ...newExampleGroups,
+                ];
+            }
+            if (modification.style) {
+                currentCharacter.style = {
+                    ...currentCharacter.style,
+                    ...modification.style,
+                };
+            }
+            if (modification.settings) {
+                currentCharacter.settings = {
+                    ...currentCharacter.settings,
+                    ...modification.settings,
+                };
+            }
+            // Write to file if available
+            if (this.characterFilePath) {
+                await fs.writeJSON(this.characterFilePath, currentCharacter, {
+                    spaces: 2,
+                });
+                logger.info("Character file updated successfully");
+            }
+            const persistenceService = this.runtime.getService("eliza_character_persistence");
+            if (persistenceService) {
+                const persistenceResult = await persistenceService.persistCharacter({
+                    character: currentCharacter,
+                    previousCharacter: this.runtime.character,
+                    previousName,
+                    source: "agent",
+                });
+                if (!persistenceResult.success) {
+                    return {
+                        success: false,
+                        error: persistenceResult.error ?? "Failed to persist character changes",
+                    };
+                }
+            }
+            // Update runtime character only after persistence succeeds.
+            Object.assign(this.runtime.character, currentCharacter);
+            return { success: true };
+        }
+        catch (error) {
+            logger.error({ error: error instanceof Error ? error.message : String(error) }, "Failed to apply character modification");
+            return {
+                success: false,
+                error: `Application failed: ${error.message}`,
+            };
+        }
+    }
+    async getModificationHistory(limit = 10) {
+        const memories = await this.runtime.getMemories({
+            entityId: this.runtime.agentId,
+            count: limit,
+            tableName: "character_modifications",
+        });
+        return memories.map((memory) => {
+            const meta = memory.metadata;
+            return {
+                timestamp: typeof meta?.timestamp === "number" ? meta.timestamp : undefined,
+                modification: meta?.after ?? meta?.changes ?? meta?.modification,
+                filePath: typeof meta?.filePath === "string"
+                    ? meta.filePath
+                    : (this.characterFilePath ?? undefined),
+            };
+        });
+    }
+    async getAvailableBackups() {
+        if (!(await fs.pathExists(this.backupDir))) {
+            return [];
+        }
+        const files = await fs.readdir(this.backupDir);
+        const backups = [];
+        for (const file of files) {
+            if (file.endsWith(".json")) {
+                const filePath = path.join(this.backupDir, file);
+                const stat = await fs.stat(filePath);
+                // Extract timestamp from filename (format: character-YYYYMMDD-HHMMSS.json)
+                const timestampMatch = file.match(/character-(\d{8})-(\d{6})\.json/);
+                let timestamp = stat.mtime.getTime();
+                if (timestampMatch) {
+                    const dateStr = timestampMatch[1];
+                    const timeStr = timestampMatch[2];
+                    const year = parseInt(dateStr.substring(0, 4), 10);
+                    const month = parseInt(dateStr.substring(4, 6), 10) - 1;
+                    const day = parseInt(dateStr.substring(6, 8), 10);
+                    const hour = parseInt(timeStr.substring(0, 2), 10);
+                    const minute = parseInt(timeStr.substring(2, 4), 10);
+                    const second = parseInt(timeStr.substring(4, 6), 10);
+                    timestamp = new Date(year, month, day, hour, minute, second).getTime();
+                }
+                backups.push({
+                    path: filePath,
+                    timestamp,
+                    size: stat.size,
+                });
+            }
+        }
+        return backups.sort((a, b) => b.timestamp - a.timestamp);
+    }
+    async restoreFromBackup(backupPath) {
+        try {
+            // Validate backup file exists and is readable
+            if (!(await fs.pathExists(backupPath))) {
+                return { success: false, error: "Backup file not found" };
+            }
+            // Read and validate backup content
+            const backupContent = await fs.readJSON(backupPath);
+            if (!backupContent.name || typeof backupContent.name !== "string") {
+                return {
+                    success: false,
+                    error: "Invalid backup file format - missing character name",
+                };
+            }
+            // Create a backup of the current state before restoration
+            const currentBackupPath = await this.createBackup();
+            const previousCharacter = {
+                ...this.runtime.character,
+            };
+            // If we have a character file path, update the file
+            if (this.characterFilePath) {
+                await fs.writeJSON(this.characterFilePath, backupContent, {
+                    spaces: 2,
+                });
+            }
+            const persistenceService = this.runtime.getService("eliza_character_persistence");
+            if (persistenceService) {
+                const persistenceResult = await persistenceService.persistCharacter({
+                    character: backupContent,
+                    previousCharacter,
+                    previousName: typeof this.runtime.character.name === "string"
+                        ? this.runtime.character.name
+                        : undefined,
+                    source: "restore",
+                });
+                if (!persistenceResult.success) {
+                    return {
+                        success: false,
+                        error: persistenceResult.error ?? "Failed to restore character",
+                    };
+                }
+            }
+            // Update runtime character only after persistence succeeds.
+            Object.assign(this.runtime.character, backupContent);
+            logger.info({
+                backupPath,
+                characterName: backupContent.name,
+                currentBackup: currentBackupPath,
+            }, "Character restored from backup");
+            return { success: true };
+        }
+        catch (error) {
+            logger.error({ error: error instanceof Error ? error.message : String(error) }, "Failed to restore from backup");
+            return {
+                success: false,
+                error: `Restoration failed: ${error.message}`,
+            };
+        }
+    }
+    async restoreFromHistory(entryIndex) {
+        const history = await this.getModificationHistory(50);
+        if (entryIndex < 0 || entryIndex >= history.length) {
+            return { success: false, error: "Invalid history entry index" };
+        }
+        const entry = history[entryIndex];
+        if (!entry.filePath) {
+            return {
+                success: false,
+                error: "No file path available for this history entry",
+            };
+        }
+        if (entry.timestamp === undefined) {
+            return {
+                success: false,
+                error: "No timestamp available for this history entry",
+            };
+        }
+        const entryTimestamp = entry.timestamp;
+        // Find the corresponding backup file
+        const backups = await this.getAvailableBackups();
+        const backup = backups.find((b) => Math.abs(b.timestamp - entryTimestamp) < 60000);
+        if (!backup) {
+            return { success: false, error: "Corresponding backup file not found" };
+        }
+        return await this.restoreFromBackup(backup.path);
+    }
+    async stop() {
+        logger.info("CharacterFileManager stopped");
+    }
+}

package/packages/typescript/src/features/advanced-capabilities/personality/types.d.ts

@@ -0,0 +1,13 @@
+declare module "../../../types/service.ts" {
+    interface ServiceTypeRegistry {
+        CHARACTER_MANAGEMENT: "CHARACTER_MANAGEMENT";
+    }
+}
+export declare const PersonalityServiceType: {
+    CHARACTER_MANAGEMENT: "CHARACTER_MANAGEMENT";
+};
+/** Memory table for per-user interaction preferences. */
+export declare const USER_PREFS_TABLE = "user_personality_preferences";
+/** Maximum number of interaction preferences a single user can store. */
+export declare const MAX_PREFS_PER_USER = 10;
+//# sourceMappingURL=types.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/personality/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/personality/types.ts"],"names":[],"mappings":"AAEA,OAAO,QAAQ,2BAA2B,CAAC;IAC1C,UAAU,mBAAmB;QAC5B,oBAAoB,EAAE,sBAAsB,CAAC;KAC7C;CACD;AAGD,eAAO,MAAM,sBAAsB;;CAEK,CAAC;AAEzC,yDAAyD;AACzD,eAAO,MAAM,gBAAgB,iCAAiC,CAAC;AAE/D,yEAAyE;AACzE,eAAO,MAAM,kBAAkB,KAAK,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/personality/types.js

@@ -0,0 +1,8 @@
+// Export service type constant
+export const PersonalityServiceType = {
+    CHARACTER_MANAGEMENT: "CHARACTER_MANAGEMENT",
+};
+/** Memory table for per-user interaction preferences. */
+export const USER_PREFS_TABLE = "user_personality_preferences";
+/** Maximum number of interaction preferences a single user can store. */
+export const MAX_PREFS_PER_USER = 10;

package/packages/typescript/src/features/advanced-capabilities/providers/contacts.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "../../../types/index.ts";
+export declare const contactsProvider: Provider;
+//# sourceMappingURL=contacts.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/providers/contacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contacts.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/providers/contacts.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGX,QAAQ,EAGR,MAAM,yBAAyB,CAAC;AAKjC,eAAO,MAAM,gBAAgB,EAAE,QA6F9B,CAAC"}

package/packages/typescript/src/features/advanced-capabilities/providers/contacts.js

@@ -0,0 +1,77 @@
+import { requireProviderSpec } from "../../../generated/spec-helpers.js";
+// Get text content from centralized specs
+const spec = requireProviderSpec("CONTACTS");
+export const contactsProvider = {
+    name: spec.name,
+    description: spec.description,
+    get: async (runtime, _message, _state) => {
+        const relationshipsService = runtime.getService("relationships");
+        if (!relationshipsService) {
+            runtime.logger.warn("[ContactsProvider] RelationshipsService not available");
+            return { text: "", values: {}, data: {} };
+        }
+        // Get all contacts
+        const contacts = await relationshipsService.searchContacts({});
+        if (contacts.length === 0) {
+            return {
+                text: "No contacts in relationships.",
+                values: { contactCount: 0 },
+                data: {},
+            };
+        }
+        // Get entity details and categorize
+        const contactDetails = await Promise.all(contacts.map(async (contact) => {
+            const entity = await runtime.getEntityById(contact.entityId);
+            const displayName = typeof contact.customFields.displayName === "string"
+                ? contact.customFields.displayName
+                : null;
+            return {
+                id: contact.entityId,
+                name: entity?.names[0] || displayName || "Unknown",
+                categories: contact.categories,
+                tags: contact.tags,
+                preferences: contact.preferences,
+                lastModified: contact.lastModified,
+            };
+        }));
+        // Group by category
+        const grouped = {};
+        for (const contact of contactDetails) {
+            for (const cat of contact.categories) {
+                const bucket = grouped[cat];
+                if (bucket) {
+                    bucket.push(contact);
+                }
+                else {
+                    grouped[cat] = [contact];
+                }
+            }
+        }
+        const lines = [];
+        lines.push(`You have ${contacts.length} contacts in your relationships:`);
+        const categoryCounts = {};
+        for (const category in grouped) {
+            const items = grouped[category];
+            if (!items)
+                continue;
+            categoryCounts[category] = items.length;
+            lines.push("", `${category.charAt(0).toUpperCase() + category.slice(1)}s (${items.length}):`);
+            for (const item of items) {
+                let line = `- ${item.name}`;
+                if (item.tags.length > 0) {
+                    line += ` [${item.tags.join(", ")}]`;
+                }
+                lines.push(line);
+            }
+        }
+        const textSummary = lines.join("\n").trim();
+        return {
+            text: textSummary,
+            values: {
+                contactCount: contacts.length,
+                ...categoryCounts,
+            },
+            data: categoryCounts,
+        };
+    },
+};

package/packages/typescript/src/features/advanced-capabilities/providers/facts.d.ts

@@ -0,0 +1,11 @@
+import type { Provider } from "../../../types/index.ts";
+/**
+ * Function to get key facts that the agent knows.
+ * @param {IAgentRuntime} runtime - The runtime environment for the agent.
+ * @param {Memory} message - The message object containing relevant information.
+ * @param {State} [_state] - Optional state information.
+ * @returns {Object} An object containing values, data, and text related to the key facts.
+ */
+declare const factsProvider: Provider;
+export { factsProvider };
+//# sourceMappingURL=facts.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/providers/facts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facts.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/providers/facts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGX,QAAQ,EAER,MAAM,yBAAyB,CAAC;AAiFjC;;;;;;GAMG;AACH,QAAA,MAAM,aAAa,EAAE,QA2FpB,CAAC;AAEF,OAAO,EAAE,aAAa,EAAE,CAAC"}