@elizaos/core 1.5.3-beta.3 → 1.5.5-alpha.10

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/browser.ts

@@ -1,145 +0,0 @@
-import { Service, ServiceType } from './service';
-
-export interface BrowserNavigationOptions {
-  timeout?: number;
-  waitUntil?: 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
-  viewport?: {
-    width: number;
-    height: number;
-  };
-  userAgent?: string;
-  headers?: Record<string, string>;
-}
-
-export interface ScreenshotOptions {
-  fullPage?: boolean;
-  clip?: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  };
-  format?: 'png' | 'jpeg' | 'webp';
-  quality?: number;
-  omitBackground?: boolean;
-}
-
-export interface ElementSelector {
-  selector: string;
-  text?: string;
-  timeout?: number;
-}
-
-export interface ExtractedContent {
-  text: string;
-  html: string;
-  links: Array<{
-    url: string;
-    text: string;
-  }>;
-  images: Array<{
-    src: string;
-    alt?: string;
-  }>;
-  title?: string;
-  metadata?: Record<string, string>;
-}
-
-export interface ClickOptions {
-  timeout?: number;
-  force?: boolean;
-  waitForNavigation?: boolean;
-}
-
-export interface TypeOptions {
-  delay?: number;
-  timeout?: number;
-  clear?: boolean;
-}
-
-/**
- * Interface for browser automation services
- */
-export abstract class IBrowserService extends Service {
-  static override readonly serviceType = ServiceType.BROWSER;
-
-  public readonly capabilityDescription = 'Web browser automation and scraping capabilities';
-
-  /**
-   * Navigate to a URL
-   * @param url - URL to navigate to
-   * @param options - Navigation options
-   * @returns Promise resolving when navigation completes
-   */
-  abstract navigate(url: string, options?: BrowserNavigationOptions): Promise<void>;
-
-  /**
-   * Take a screenshot of the current page
-   * @param options - Screenshot options
-   * @returns Promise resolving to screenshot buffer
-   */
-  abstract screenshot(options?: ScreenshotOptions): Promise<Buffer>;
-
-  /**
-   * Extract text and content from the current page
-   * @param selector - Optional CSS selector to extract from specific element
-   * @returns Promise resolving to extracted content
-   */
-  abstract extractContent(selector?: string): Promise<ExtractedContent>;
-
-  /**
-   * Click on an element
-   * @param selector - CSS selector or element selector
-   * @param options - Click options
-   * @returns Promise resolving when click completes
-   */
-  abstract click(selector: string | ElementSelector, options?: ClickOptions): Promise<void>;
-
-  /**
-   * Type text into an input field
-   * @param selector - CSS selector for input field
-   * @param text - Text to type
-   * @param options - Typing options
-   * @returns Promise resolving when typing completes
-   */
-  abstract type(selector: string, text: string, options?: TypeOptions): Promise<void>;
-
-  /**
-   * Wait for an element to appear
-   * @param selector - CSS selector or element selector
-   * @returns Promise resolving when element is found
-   */
-  abstract waitForElement(selector: string | ElementSelector): Promise<void>;
-
-  /**
-   * Evaluate JavaScript in the browser context
-   * @param script - JavaScript code to evaluate
-   * @param args - Arguments to pass to the script
-   * @returns Promise resolving to evaluation result
-   */
-  abstract evaluate<T = any>(script: string, ...args: any[]): Promise<T>;
-
-  /**
-   * Get the current page URL
-   * @returns Promise resolving to current URL
-   */
-  abstract getCurrentUrl(): Promise<string>;
-
-  /**
-   * Go back in browser history
-   * @returns Promise resolving when navigation completes
-   */
-  abstract goBack(): Promise<void>;
-
-  /**
-   * Go forward in browser history
-   * @returns Promise resolving when navigation completes
-   */
-  abstract goForward(): Promise<void>;
-
-  /**
-   * Refresh the current page
-   * @returns Promise resolving when refresh completes
-   */
-  abstract refresh(): Promise<void>;
-}