@elizaos/core 1.5.4 → 1.5.5

package/src/settings.ts

@@ -1,409 +0,0 @@
-// @ts-ignore
-import crypto from 'crypto-browserify';
-import { createUniqueUuid } from './entities';
-import { getEnv } from './utils/environment';
-import { BufferUtils } from './utils/buffer';
-import { logger } from './logger';
-import type {
-  Character,
-  IAgentRuntime,
-  OnboardingConfig,
-  Setting,
-  World,
-  WorldSettings,
-} from './types';
-
-/**
- * Creates a Setting object from a configSetting object by omitting the 'value' property.
- *
- * @param {Omit<Setting, 'value'>} configSetting - The configSetting object to create the Setting from.
- * @returns {Setting} A new Setting object created from the provided configSetting object.
- */
-export function createSettingFromConfig(configSetting: Omit<Setting, 'value'>): Setting {
-  return {
-    name: configSetting.name,
-    description: configSetting.description,
-    usageDescription: configSetting.usageDescription || '',
-    value: null,
-    required: configSetting.required,
-    validation: configSetting.validation || undefined,
-    public: configSetting.public || false,
-    secret: configSetting.secret || false,
-    dependsOn: configSetting.dependsOn || [],
-    onSetAction: configSetting.onSetAction || undefined,
-    visibleIf: configSetting.visibleIf || undefined,
-  };
-}
-
-/**
- * Retrieves the salt based on env variable SECRET_SALT
- *
- * @returns {string} The salt for the agent.
- */
-export function getSalt(): string {
-  const secretSalt = getEnv('SECRET_SALT', 'secretsalt') || 'secretsalt';
-
-  if (secretSalt === 'secretsalt') {
-    logger.error('SECRET_SALT is not set or using default value');
-  }
-
-  const salt = secretSalt;
-
-  //logger.debug(`Generated salt with length: ${salt.length} (truncated for security)`);
-  return salt;
-}
-
-/**
- * Common encryption function for string values
- * @param {string} value - The string value to encrypt
- * @param {string} salt - The salt to use for encryption
- * @returns {string} - The encrypted value in 'iv:encrypted' format
- */
-export function encryptStringValue(value: string, salt: string): string {
-  // Check if value is undefined or null
-  if (value === undefined || value === null) {
-    logger.debug('Attempted to encrypt undefined or null value');
-    return value; // Return the value as is (undefined or null)
-  }
-
-  if (typeof value === 'boolean' || typeof value === 'number') {
-    logger.debug('Value is a boolean or number, returning as is');
-    return value;
-  }
-
-  if (typeof value !== 'string') {
-    logger.debug(`Value is not a string (type: ${typeof value}), returning as is`);
-    return value;
-  }
-
-  // Check if value is already encrypted (has the format "iv:encrypted")
-  const parts = value.split(':');
-  if (parts.length === 2) {
-    try {
-      // Try to parse the first part as hex to see if it's already encrypted
-      const possibleIv = BufferUtils.fromHex(parts[0]);
-      if (possibleIv.length === 16) {
-        // Value is likely already encrypted, return as is
-        logger.debug('Value appears to be already encrypted, skipping re-encryption');
-        return value;
-      }
-    } catch (e) {
-      // Not a valid hex string, proceed with encryption
-    }
-  }
-
-  // Create key and iv from the salt
-  const key = crypto.createHash('sha256').update(salt).digest().slice(0, 32);
-  const iv = BufferUtils.randomBytes(16);
-
-  // Encrypt the value
-  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
-  let encrypted = cipher.update(value, 'utf8', 'hex');
-  encrypted += cipher.final('hex');
-
-  // Store IV with the encrypted value so we can decrypt it later
-  return `${BufferUtils.toHex(iv)}:${encrypted}`;
-}
-
-/**
- * Common decryption function for string values
- * @param {string} value - The encrypted value in 'iv:encrypted' format
- * @param {string} salt - The salt to use for decryption
- * @returns {string} - The decrypted string value
- */
-export function decryptStringValue(value: string, salt: string): string {
-  try {
-    // Check if value is undefined or null
-    if (value === undefined || value === null) {
-      //logger.debug('Attempted to decrypt undefined or null value');
-      return value; // Return the value as is (undefined or null)
-    }
-
-    if (typeof value === 'boolean' || typeof value === 'number') {
-      //logger.debug('Value is a boolean or number, returning as is');
-      return value;
-    }
-    if (typeof value !== 'string') {
-      logger.debug(`Value is not a string (type: ${typeof value}), returning as is`);
-      return value;
-    }
-
-    // Split the IV and encrypted value
-    const parts = value.split(':');
-    if (parts.length !== 2) {
-      /*
-      logger.debug(
-        `Invalid encrypted value format - expected 'iv:encrypted', returning original value`
-      );
-      */
-      return value; // Return the original value without decryption
-    }
-
-    const iv = BufferUtils.fromHex(parts[0]);
-    const encrypted = parts[1];
-
-    // Verify IV length
-    if (iv.length !== 16) {
-      if (iv.length) {
-        logger.debug(`Invalid IV length (${iv.length}) - expected 16 bytes`);
-      }
-      return value; // Return the original value without decryption
-    }
-
-    // Create key from the salt
-    const key = crypto.createHash('sha256').update(salt).digest().slice(0, 32);
-
-    // Decrypt the value
-    const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
-    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
-    decrypted += decipher.final('utf8');
-
-    return decrypted;
-  } catch (error) {
-    logger.error(`Error decrypting value: ${error}`);
-    // Return the encrypted value on error
-    return value;
-  }
-}
-
-/**
- * Applies salt to the value of a setting
- * Only applies to secret settings with string values
- */
-export function saltSettingValue(setting: Setting, salt: string): Setting {
-  const settingCopy = { ...setting };
-
-  // Only encrypt string values in secret settings
-  if (setting.secret === true && typeof setting.value === 'string' && setting.value) {
-    settingCopy.value = encryptStringValue(setting.value, salt);
-  }
-
-  return settingCopy;
-}
-
-/**
- * Removes salt from the value of a setting
- * Only applies to secret settings with string values
- */
-export function unsaltSettingValue(setting: Setting, salt: string): Setting {
-  const settingCopy = { ...setting };
-
-  // Only decrypt string values in secret settings
-  if (setting.secret === true && typeof setting.value === 'string' && setting.value) {
-    settingCopy.value = decryptStringValue(setting.value, salt);
-  }
-
-  return settingCopy;
-}
-
-/**
- * Applies salt to all settings in a WorldSettings object
- */
-export function saltWorldSettings(worldSettings: WorldSettings, salt: string): WorldSettings {
-  const saltedSettings: WorldSettings = {};
-
-  for (const [key, setting] of Object.entries(worldSettings)) {
-    saltedSettings[key] = saltSettingValue(setting, salt);
-  }
-
-  return saltedSettings;
-}
-
-/**
- * Removes salt from all settings in a WorldSettings object
- */
-export function unsaltWorldSettings(worldSettings: WorldSettings, salt: string): WorldSettings {
-  const unsaltedSettings: WorldSettings = {};
-
-  for (const [key, setting] of Object.entries(worldSettings)) {
-    unsaltedSettings[key] = unsaltSettingValue(setting, salt);
-  }
-
-  return unsaltedSettings;
-}
-
-/**
- * Updates settings state in world metadata
- */
-export async function updateWorldSettings(
-  runtime: IAgentRuntime,
-  serverId: string,
-  worldSettings: WorldSettings
-): Promise<boolean> {
-  const worldId = createUniqueUuid(runtime, serverId);
-  const world = await runtime.getWorld(worldId);
-
-  if (!world) {
-    logger.error(`No world found for server ${serverId}`);
-    return false;
-  }
-
-  // Initialize metadata if it doesn't exist
-  if (!world.metadata) {
-    world.metadata = {};
-  }
-
-  // Apply salt to settings before saving
-  const salt = getSalt();
-  const saltedSettings = saltWorldSettings(worldSettings, salt);
-
-  // Update settings state
-  world.metadata.settings = saltedSettings;
-
-  // Save updated world
-  await runtime.updateWorld(world);
-
-  return true;
-}
-
-/**
- * Gets settings state from world metadata
- */
-export async function getWorldSettings(
-  runtime: IAgentRuntime,
-  serverId: string
-): Promise<WorldSettings | null> {
-  const worldId = createUniqueUuid(runtime, serverId);
-  const world = await runtime.getWorld(worldId);
-
-  if (!world || !world.metadata?.settings) {
-    return null;
-  }
-
-  // Get settings from metadata
-  const saltedSettings = world.metadata.settings as WorldSettings;
-
-  // Remove salt from settings before returning
-  const salt = getSalt();
-  return unsaltWorldSettings(saltedSettings, salt);
-}
-
-/**
- * Initializes settings configuration for a server
- */
-export async function initializeOnboarding(
-  runtime: IAgentRuntime,
-  world: World,
-  config: OnboardingConfig
-): Promise<WorldSettings | null> {
-  // Check if settings state already exists
-  if (world.metadata?.settings) {
-    logger.info(`Onboarding state already exists for server ${world.serverId}`);
-    // Get settings from metadata and remove salt
-    const saltedSettings = world.metadata.settings as WorldSettings;
-    const salt = getSalt();
-    return unsaltWorldSettings(saltedSettings, salt);
-  }
-
-  // Create new settings state
-  const worldSettings: WorldSettings = {};
-
-  // Initialize settings from config
-  if (config.settings) {
-    for (const [key, configSetting] of Object.entries(config.settings)) {
-      worldSettings[key] = createSettingFromConfig(configSetting);
-    }
-  }
-
-  // Save settings state to world metadata
-  if (!world.metadata) {
-    world.metadata = {};
-  }
-
-  // No need to salt here as the settings are just initialized with null values
-  world.metadata.settings = worldSettings;
-
-  await runtime.updateWorld(world);
-
-  logger.info(`Initialized settings config for server ${world.serverId}`);
-  return worldSettings;
-}
-
-/**
- * Encrypts sensitive data in a Character object
- * @param {Character} character - The character object to encrypt secrets for
- * @returns {Character} - A copy of the character with encrypted secrets
- */
-export function encryptedCharacter(character: Character): Character {
-  // Create a deep copy to avoid modifying the original
-  const encryptedChar = JSON.parse(JSON.stringify(character));
-  const salt = getSalt();
-
-  // Encrypt character.settings.secrets if it exists
-  if (encryptedChar.settings?.secrets) {
-    encryptedChar.settings.secrets = encryptObjectValues(encryptedChar.settings.secrets, salt);
-  }
-
-  // Encrypt character.secrets if it exists
-  if (encryptedChar.secrets) {
-    encryptedChar.secrets = encryptObjectValues(encryptedChar.secrets, salt);
-  }
-
-  return encryptedChar;
-}
-
-/**
- * Decrypts sensitive data in a Character object
- * @param {Character} character - The character object with encrypted secrets
- * @param {IAgentRuntime} runtime - The runtime information needed for salt generation
- * @returns {Character} - A copy of the character with decrypted secrets
- */
-export function decryptedCharacter(character: Character, _runtime: IAgentRuntime): Character {
-  // Create a deep copy to avoid modifying the original
-  const decryptedChar = JSON.parse(JSON.stringify(character));
-  const salt = getSalt();
-
-  // Decrypt character.settings.secrets if it exists
-  if (decryptedChar.settings?.secrets) {
-    decryptedChar.settings.secrets = decryptObjectValues(decryptedChar.settings.secrets, salt);
-  }
-
-  // Decrypt character.secrets if it exists
-  if (decryptedChar.secrets) {
-    decryptedChar.secrets = decryptObjectValues(decryptedChar.secrets, salt);
-  }
-
-  return decryptedChar;
-}
-
-/**
- * Helper function to encrypt all string values in an object
- * @param {Record<string, any>} obj - Object with values to encrypt
- * @param {string} salt - The salt to use for encryption
- * @returns {Record<string, any>} - Object with encrypted values
- */
-export function encryptObjectValues(obj: Record<string, any>, salt: string): Record<string, any> {
-  const result: Record<string, any> = {};
-
-  for (const [key, value] of Object.entries(obj)) {
-    if (typeof value === 'string' && value) {
-      result[key] = encryptStringValue(value, salt);
-    } else {
-      result[key] = value;
-    }
-  }
-
-  return result;
-}
-
-/**
- * Helper function to decrypt all string values in an object
- * @param {Record<string, any>} obj - Object with encrypted values
- * @param {string} salt - The salt to use for decryption
- * @returns {Record<string, any>} - Object with decrypted values
- */
-export function decryptObjectValues(obj: Record<string, any>, salt: string): Record<string, any> {
-  const result: Record<string, any> = {};
-
-  for (const [key, value] of Object.entries(obj)) {
-    if (typeof value === 'string' && value) {
-      result[key] = decryptStringValue(value, salt);
-    } else {
-      result[key] = value;
-    }
-  }
-
-  return result;
-}
-
-export { decryptStringValue as decryptSecret };

package/src/test_resources/constants.ts

@@ -1,12 +0,0 @@
-import type { UUID } from '@elizaos/core';
-
-export const SERVER_URL = 'http://localhost:7998';
-export const SUPABASE_URL = 'https://pronvzrzfwsptkojvudd.supabase.co';
-export const SUPABASE_ANON_KEY =
-  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InByb252enJ6ZndzcHRrb2p2dWRkIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MDY4NTYwNDcsImV4cCI6MjAyMjQzMjA0N30.I6_-XrqssUb2SWYg5DjsUqSodNS3_RPoET3-aPdqywM';
-export const TEST_EMAIL = 'testuser123@example.com';
-export const TEST_PASSWORD = 'mock_password_123!@#';
-export const TEST_EMAIL_2 = 'testuser234@example.com';
-export const TEST_PASSWORD_2 = 'mock_password_234!@#';
-
-export const zeroUuid = '00000000-0000-0000-0000-000000000000' as UUID;

package/src/test_resources/testSetup.ts

@@ -1,21 +0,0 @@
-import dotenv from 'dotenv';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-// Get the current file's directory
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Resolve paths relative to packages/core directory
-const packageRoot = path.resolve(__dirname, '../..');
-const envTestPath = path.join(packageRoot, '.env.test');
-const envPath = path.join(packageRoot, '.env');
-
-const result = dotenv.config({ path: envTestPath });
-if (result.error) {
-  console.error('Error loading .env.test. Loading .env instead');
-  const result2 = dotenv.config({ path: envPath });
-  if (result2.error) {
-    console.error('Error loading .env:', result2.error);
-  }
-}

package/src/test_resources/types.ts

@@ -1,22 +0,0 @@
-/**
- * Interface representing a User.
- * @typedef {Object} User
- * @property {string} id - The user's ID.
- * @property {string} [email] - The user's email (optional).
- * @property {string} [phone] - The user's phone number (optional).
- * @property {string} [role] - The user's role (optional).
- */
-/**
- * Represents a User with optional properties.
- * @typedef {Object} User
- * @property {string} id - The unique identifier for the user.
- * @property {string} [email] - The email address of the user (optional).
- * @property {string} [phone] - The phone number of the user (optional).
- * @property {string} [role] - The role of the user (optional).
- */
-export interface User {
-  id: string;
-  email?: string;
-  phone?: string;
-  role?: string;
-}

package/src/types/agent.ts

@@ -1,112 +0,0 @@
-import type { DirectoryItem } from './knowledge';
-import type { Content, UUID } from './primitives';
-import type { State } from './state';
-
-/**
- * Example message for demonstration
- */
-export interface MessageExample {
-  /** Associated user */
-  name: string;
-
-  /** Message content */
-  content: Content;
-}
-
-export type TemplateType =
-  | string
-  | ((options: { state: State | { [key: string]: string } }) => string);
-
-/**
- * Configuration for an agent's character, defining its personality, knowledge, and capabilities.
- * This is a central piece of an agent's definition, used by the `AgentRuntime` to initialize and operate the agent.
- * It includes:
- * - `id`: Optional unique identifier for the character.
- * - `name`, `username`: Identifying names for the character.
- * - `system`: A system prompt that guides the agent's overall behavior.
- * - `templates`: A map of prompt templates for various situations (e.g., message generation, summarization).
- * - `bio`: A textual biography or description of the character.
- * - `messageExamples`, `postExamples`: Examples of how the character communicates.
- * - `topics`, `adjectives`: Keywords describing the character's knowledge areas and traits.
- * - `knowledge`: Paths to knowledge files or directories to be loaded into the agent's memory.
- * - `plugins`: A list of plugin names to be loaded for this character.
- * - `settings`, `secrets`: Configuration key-value pairs, with secrets being handled more securely.
- * - `style`: Guidelines for the character's writing style in different contexts (chat, post).
- */
-export interface Character {
-  /** Optional unique identifier */
-  id?: UUID;
-
-  /** Character name */
-  name: string;
-
-  /** Optional username */
-  username?: string;
-
-  /** Optional system prompt */
-  system?: string;
-
-  /** Optional prompt templates */
-  templates?: {
-    [key: string]: TemplateType;
-  };
-
-  /** Character biography */
-  bio: string | string[];
-
-  /** Example messages */
-  messageExamples?: MessageExample[][];
-
-  /** Example posts */
-  postExamples?: string[];
-
-  /** Known topics */
-  topics?: string[];
-
-  /** Character traits */
-  adjectives?: string[];
-
-  /** Optional knowledge base */
-  knowledge?: (string | { path: string; shared?: boolean } | DirectoryItem)[];
-
-  /** Available plugins */
-  plugins?: string[];
-
-  /** Optional configuration */
-  settings?: {
-    [key: string]: string | boolean | number | Record<string, any>;
-  };
-
-  /** Optional secrets */
-  secrets?: {
-    [key: string]: string | boolean | number;
-  };
-
-  /** Writing style guides */
-  style?: {
-    all?: string[];
-    chat?: string[];
-    post?: string[];
-  };
-}
-
-export enum AgentStatus {
-  ACTIVE = 'active',
-  INACTIVE = 'inactive',
-}
-
-/**
- * Represents an operational agent, extending the `Character` definition with runtime status and timestamps.
- * While `Character` defines the blueprint, `Agent` represents an instantiated and potentially running version.
- * It includes:
- * - `enabled`: A boolean indicating if the agent is currently active or disabled.
- * - `status`: The current operational status, typically `AgentStatus.ACTIVE` or `AgentStatus.INACTIVE`.
- * - `createdAt`, `updatedAt`: Timestamps for when the agent record was created and last updated in the database.
- * This interface is primarily used by the `IDatabaseAdapter` for agent management.
- */
-export interface Agent extends Character {
-  enabled?: boolean;
-  status?: AgentStatus;
-  createdAt: number;
-  updatedAt: number;
-}