@elizaos/core 1.5.4 → 1.5.5

package/src/utils/buffer.ts

@@ -1,312 +0,0 @@
-/**
- * Browser and Node.js compatible buffer abstraction
- * This module provides a unified interface for buffer operations
- * that works in both browser and Node.js environments.
- *
- * In browsers, we use Uint8Array as a Buffer replacement.
- * In Node.js, we use the native Buffer.
- */
-
-/**
- * Type representing a buffer-like object that works in both environments
- */
-export type BufferLike = Buffer | Uint8Array;
-
-/**
- * Check if we're in a Node.js environment with Buffer support
- */
-function hasNativeBuffer(): boolean {
-  return typeof Buffer !== 'undefined' && typeof Buffer.from === 'function';
-}
-
-/**
- * Convert a hex string to a buffer-like object
- * @param hex - The hexadecimal string to convert
- * @returns A BufferLike object
- */
-export function fromHex(hex: string): BufferLike {
-  // Clean the hex string to remove non-hex characters
-  const cleanHex = hex.replace(/[^0-9a-fA-F]/g, '');
-
-  if (hasNativeBuffer()) {
-    // Use native Buffer in Node.js
-    return Buffer.from(cleanHex, 'hex');
-  }
-
-  // Browser implementation using Uint8Array
-  const bytes = new Uint8Array(cleanHex.length / 2);
-
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = parseInt(cleanHex.substr(i * 2, 2), 16);
-  }
-
-  return bytes;
-}
-
-/**
- * Convert a string to a buffer-like object
- * @param str - The string to convert
- * @param encoding - The encoding to use (default: 'utf8')
- * @returns A BufferLike object
- */
-export function fromString(
-  str: string,
-  encoding: 'utf8' | 'utf-8' | 'base64' = 'utf8'
-): BufferLike {
-  if (hasNativeBuffer()) {
-    // Use native Buffer in Node.js
-    const enc = encoding === 'utf-8' ? 'utf8' : encoding;
-    return Buffer.from(str, enc as BufferEncoding);
-  }
-
-  // Browser implementation
-  if (encoding === 'base64') {
-    // Decode base64 string
-    const binaryString = atob(str);
-    const bytes = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-      bytes[i] = binaryString.charCodeAt(i);
-    }
-    return bytes;
-  }
-
-  // UTF-8 encoding using TextEncoder (standard browser API)
-  const encoder = new TextEncoder();
-  return encoder.encode(str);
-}
-
-/**
- * Convert a buffer-like object to a hexadecimal string
- * @param buffer - The buffer to convert
- * @returns A hexadecimal string
- */
-export function toHex(buffer: BufferLike): string {
-  if (hasNativeBuffer() && Buffer.isBuffer(buffer)) {
-    // Use native Buffer method in Node.js
-    return buffer.toString('hex');
-  }
-
-  // Browser implementation
-  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-  let hex = '';
-  for (let i = 0; i < bytes.length; i++) {
-    const byte = bytes[i].toString(16);
-    hex += byte.length === 1 ? '0' + byte : byte;
-  }
-  return hex;
-}
-
-/**
- * Convert a buffer-like object to a string
- * @param buffer - The buffer to convert
- * @param encoding - The encoding to use (default: 'utf8')
- * @returns A string
- */
-export function toString(
-  buffer: BufferLike,
-  encoding: 'utf8' | 'utf-8' | 'base64' | 'hex' = 'utf8'
-): string {
-  if (hasNativeBuffer() && Buffer.isBuffer(buffer)) {
-    // Use native Buffer method in Node.js
-    const enc = encoding === 'utf-8' ? 'utf8' : encoding;
-    return buffer.toString(enc as BufferEncoding);
-  }
-
-  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-
-  // Handle different encodings
-  if (encoding === 'hex') {
-    return toHex(bytes);
-  }
-
-  if (encoding === 'base64') {
-    // Convert to base64
-    let binaryString = '';
-    for (let i = 0; i < bytes.length; i++) {
-      binaryString += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binaryString);
-  }
-
-  // UTF-8 decoding using TextDecoder (standard browser API)
-  const decoder = new TextDecoder();
-  return decoder.decode(bytes);
-}
-
-/**
- * Check if an object is a Buffer or buffer-like object
- * @param obj - The object to check
- * @returns True if the object is buffer-like
- */
-export function isBuffer(obj: any): obj is BufferLike {
-  if (!obj) {
-    return false;
-  }
-
-  if (hasNativeBuffer() && Buffer.isBuffer(obj)) {
-    return true;
-  }
-
-  // Check for Uint8Array or similar typed arrays
-  return (
-    obj instanceof Uint8Array ||
-    obj instanceof ArrayBuffer ||
-    (typeof obj === 'object' &&
-      obj.buffer instanceof ArrayBuffer &&
-      typeof obj.byteLength === 'number' &&
-      !Array.isArray(obj))
-  );
-}
-
-/**
- * Create a buffer of a specific size filled with zeros
- * @param size - The size of the buffer
- * @returns A BufferLike object
- */
-export function alloc(size: number): BufferLike {
-  if (hasNativeBuffer()) {
-    return Buffer.alloc(size);
-  }
-
-  return new Uint8Array(size);
-}
-
-/**
- * Create a buffer from an array of bytes
- * @param bytes - Array of byte values
- * @returns A BufferLike object
- */
-export function fromBytes(bytes: number[] | Uint8Array): BufferLike {
-  if (hasNativeBuffer()) {
-    return Buffer.from(bytes);
-  }
-
-  return new Uint8Array(bytes);
-}
-
-/**
- * Concatenate multiple buffers
- * @param buffers - Array of buffers to concatenate
- * @returns A new BufferLike object
- */
-export function concat(buffers: BufferLike[]): BufferLike {
-  if (hasNativeBuffer() && buffers.every((b) => Buffer.isBuffer(b))) {
-    return Buffer.concat(buffers as Buffer[]);
-  }
-
-  // Calculate total length
-  let totalLength = 0;
-  for (const buffer of buffers) {
-    totalLength += buffer.length;
-  }
-
-  // Create result buffer
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-
-  for (const buffer of buffers) {
-    const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-    result.set(bytes, offset);
-    offset += bytes.length;
-  }
-
-  return result;
-}
-
-/**
- * Slice a buffer to create a new buffer
- * @param buffer - The buffer to slice
- * @param start - Start index
- * @param end - End index (optional)
- * @returns A new BufferLike object
- */
-export function slice(buffer: BufferLike, start: number, end?: number): BufferLike {
-  if (hasNativeBuffer() && Buffer.isBuffer(buffer)) {
-    return buffer.slice(start, end);
-  }
-
-  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-  return bytes.slice(start, end);
-}
-
-/**
- * Compare two buffers for equality
- * @param a - First buffer
- * @param b - Second buffer
- * @returns True if buffers are equal
- */
-export function equals(a: BufferLike, b: BufferLike): boolean {
-  if (a.length !== b.length) {
-    return false;
-  }
-
-  const bytesA = a instanceof Uint8Array ? a : new Uint8Array(a);
-  const bytesB = b instanceof Uint8Array ? b : new Uint8Array(b);
-
-  for (let i = 0; i < bytesA.length; i++) {
-    if (bytesA[i] !== bytesB[i]) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Get the byte length of a buffer
- * @param buffer - The buffer
- * @returns The byte length
- */
-export function byteLength(buffer: BufferLike): number {
-  return buffer.length;
-}
-
-/**
- * Create a random buffer of specified size
- * @param size - The size of the buffer
- * @returns A BufferLike object filled with random bytes
- */
-export function randomBytes(size: number): BufferLike {
-  if (hasNativeBuffer()) {
-    // In Node.js, use crypto.randomBytes if available
-    try {
-      const crypto = require('crypto');
-      return crypto.randomBytes(size);
-    } catch {
-      // Fall back to manual generation
-    }
-  }
-
-  // Browser implementation using crypto.getRandomValues
-  const bytes = new Uint8Array(size);
-
-  if (typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.getRandomValues) {
-    globalThis.crypto.getRandomValues(bytes);
-  } else {
-    // Fallback: less secure random generation
-    for (let i = 0; i < size; i++) {
-      bytes[i] = Math.floor(Math.random() * 256);
-    }
-  }
-
-  return bytes;
-}
-
-// Export a namespace-like object for compatibility
-export const BufferUtils = {
-  fromHex,
-  fromString,
-  fromBytes,
-  toHex,
-  toString,
-  isBuffer,
-  alloc,
-  concat,
-  slice,
-  equals,
-  byteLength,
-  randomBytes,
-};
-
-// Export type for use in other modules
-export type { BufferLike as Buffer };

package/src/utils/environment.ts

@@ -1,316 +0,0 @@
-/**
- * Browser and Node.js compatible environment variable abstraction
- * This module provides a unified interface for accessing environment variables
- * that works in both browser and Node.js environments.
- */
-
-/**
- * Type representing the runtime environment
- */
-export type RuntimeEnvironment = 'node' | 'browser' | 'unknown';
-
-/**
- * Interface for environment configuration
- */
-export interface EnvironmentConfig {
-  [key: string]: string | boolean | number | undefined;
-}
-
-/**
- * Detect the current runtime environment
- */
-export function detectEnvironment(): RuntimeEnvironment {
-  // Check for Node.js
-  if (typeof process !== 'undefined' && process.versions && process.versions.node) {
-    return 'node';
-  }
-
-  // Check for browser
-  if (
-    typeof globalThis !== 'undefined' &&
-    typeof (globalThis as any).window !== 'undefined' &&
-    typeof (globalThis as any).window.document !== 'undefined'
-  ) {
-    return 'browser';
-  }
-
-  return 'unknown';
-}
-
-/**
- * Environment variable storage for browser environments
- */
-class BrowserEnvironmentStore {
-  private store: EnvironmentConfig = {};
-
-  constructor() {
-    // Load from window.ENV if available (common pattern for browser apps)
-    if (
-      typeof globalThis !== 'undefined' &&
-      (globalThis as any).window &&
-      (globalThis as any).window.ENV
-    ) {
-      this.store = { ...(globalThis as any).window.ENV };
-    }
-
-    // Also check for __ENV__ (another common pattern)
-    if (typeof globalThis !== 'undefined' && (globalThis as any).__ENV__) {
-      this.store = { ...this.store, ...(globalThis as any).__ENV__ };
-    }
-  }
-
-  get(key: string): string | undefined {
-    const value = this.store[key];
-    return value !== undefined ? String(value) : undefined;
-  }
-
-  set(key: string, value: string | boolean | number): void {
-    this.store[key] = value;
-  }
-
-  has(key: string): boolean {
-    return key in this.store;
-  }
-
-  getAll(): EnvironmentConfig {
-    return { ...this.store };
-  }
-}
-
-/**
- * Environment abstraction class
- */
-class Environment {
-  private runtime: RuntimeEnvironment;
-  private browserStore?: BrowserEnvironmentStore;
-  private cache: Map<string, string | undefined> = new Map();
-
-  constructor() {
-    this.runtime = detectEnvironment();
-
-    if (this.runtime === 'browser') {
-      this.browserStore = new BrowserEnvironmentStore();
-    }
-  }
-
-  /**
-   * Get the current runtime environment
-   */
-  getRuntime(): RuntimeEnvironment {
-    return this.runtime;
-  }
-
-  /**
-   * Check if running in Node.js
-   */
-  isNode(): boolean {
-    return this.runtime === 'node';
-  }
-
-  /**
-   * Check if running in browser
-   */
-  isBrowser(): boolean {
-    return this.runtime === 'browser';
-  }
-
-  /**
-   * Get an environment variable
-   */
-  get(key: string, defaultValue?: string): string | undefined {
-    // Check cache first
-    if (this.cache.has(key)) {
-      const cached = this.cache.get(key);
-      return cached === undefined && defaultValue !== undefined ? defaultValue : cached;
-    }
-
-    let value: string | undefined;
-
-    switch (this.runtime) {
-      case 'node':
-        // In Node.js, use process.env
-        if (typeof process !== 'undefined' && process.env) {
-          value = process.env[key];
-        }
-        break;
-
-      case 'browser':
-        // In browser, use our store
-        if (this.browserStore) {
-          value = this.browserStore.get(key);
-        }
-        break;
-
-      default:
-        value = undefined;
-    }
-
-    // Cache the result
-    this.cache.set(key, value);
-
-    return value === undefined && defaultValue !== undefined ? defaultValue : value;
-  }
-
-  /**
-   * Set an environment variable (mainly for browser/testing)
-   */
-  set(key: string, value: string | boolean | number): void {
-    const stringValue = String(value);
-
-    // Clear cache
-    this.cache.delete(key);
-
-    switch (this.runtime) {
-      case 'node':
-        if (typeof process !== 'undefined' && process.env) {
-          process.env[key] = stringValue;
-        }
-        break;
-
-      case 'browser':
-        if (this.browserStore) {
-          this.browserStore.set(key, value);
-        }
-        break;
-    }
-  }
-
-  /**
-   * Check if an environment variable exists
-   */
-  has(key: string): boolean {
-    const value = this.get(key);
-    return value !== undefined;
-  }
-
-  /**
-   * Get all environment variables (filtered for safety)
-   */
-  getAll(): EnvironmentConfig {
-    switch (this.runtime) {
-      case 'node':
-        if (typeof process !== 'undefined' && process.env) {
-          return { ...process.env };
-        }
-        break;
-
-      case 'browser':
-        if (this.browserStore) {
-          return this.browserStore.getAll();
-        }
-        break;
-    }
-
-    return {};
-  }
-
-  /**
-   * Get a boolean environment variable
-   */
-  getBoolean(key: string, defaultValue = false): boolean {
-    const value = this.get(key);
-
-    if (value === undefined) {
-      return defaultValue;
-    }
-
-    // Common truthy values
-    return ['true', '1', 'yes', 'on'].includes(value.toLowerCase());
-  }
-
-  /**
-   * Get a number environment variable
-   */
-  getNumber(key: string, defaultValue?: number): number | undefined {
-    const value = this.get(key);
-
-    if (value === undefined) {
-      return defaultValue;
-    }
-
-    const parsed = Number(value);
-    return isNaN(parsed) ? defaultValue : parsed;
-  }
-
-  /**
-   * Clear the cache (useful for testing)
-   */
-  clearCache(): void {
-    this.cache.clear();
-  }
-}
-
-/**
- * Singleton instance of the Environment class
- */
-let environmentInstance: Environment | null = null;
-
-/**
- * Get the singleton Environment instance
- */
-export function getEnvironment(): Environment {
-  if (!environmentInstance) {
-    environmentInstance = new Environment();
-  }
-  return environmentInstance;
-}
-
-/**
- * Convenience function to get an environment variable
- */
-export function getEnv(key: string, defaultValue?: string): string | undefined {
-  return getEnvironment().get(key, defaultValue);
-}
-
-/**
- * Convenience function to set an environment variable
- */
-export function setEnv(key: string, value: string | boolean | number): void {
-  getEnvironment().set(key, value);
-}
-
-/**
- * Convenience function to check if an environment variable exists
- */
-export function hasEnv(key: string): boolean {
-  return getEnvironment().has(key);
-}
-
-/**
- * Convenience function to get a boolean environment variable
- */
-export function getBooleanEnv(key: string, defaultValue = false): boolean {
-  return getEnvironment().getBoolean(key, defaultValue);
-}
-
-/**
- * Convenience function to get a number environment variable
- */
-export function getNumberEnv(key: string, defaultValue?: number): number | undefined {
-  return getEnvironment().getNumber(key, defaultValue);
-}
-
-/**
- * Initialize browser environment with config
- * This should be called early in browser apps to set up environment
- */
-export function initBrowserEnvironment(config: EnvironmentConfig): void {
-  const env = getEnvironment();
-  if (env.isBrowser()) {
-    Object.entries(config).forEach(([key, value]) => {
-      if (value !== undefined) {
-        env.set(key, value);
-      }
-    });
-  }
-}
-
-/**
- * Export the current runtime for convenience
- */
-export const currentRuntime = detectEnvironment();
-
-/**
- * Re-export the Environment class for advanced usage
- */
-export { Environment };