@elizaos/cli 1.0.2 → 1.0.3

package/templates/project-tee-starter/__tests__/provider.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, it, vi, beforeAll, afterAll } from 'vitest';
+import plugin from '../src/plugin';
+import type { IAgentRuntime, Memory, State, Provider } from '@elizaos/core';
+import { logger } from '@elizaos/core';
+import { v4 as uuidv4 } from 'uuid';
+import dotenv from 'dotenv';
+import teeStarterPlugin from '../src/plugin';
+
+// Setup environment variables
+dotenv.config();
+
+// Set up logging to capture issues
+beforeAll(() => {
+  vi.spyOn(logger, 'info');
+  vi.spyOn(logger, 'error');
+  vi.spyOn(logger, 'warn');
+  vi.spyOn(logger, 'debug');
+});
+
+afterAll(() => {
+  vi.restoreAllMocks();
+});
+
+// Helper function to document test results
+function documentTestResult(testName: string, result: any, error: Error | null = null) {
+  logger.info(`TEST: ${testName}`);
+  if (result) {
+    if (typeof result === 'string') {
+      logger.info(`RESULT: ${result.substring(0, 100)}${result.length > 100 ? '...' : ''}`);
+    } else {
+      try {
+        logger.info(`RESULT: ${JSON.stringify(result, null, 2).substring(0, 200)}...`);
+      } catch (e) {
+        logger.info(`RESULT: [Complex object that couldn't be stringified]`);
+      }
+    }
+  }
+  if (error) {
+    logger.error(`ERROR: ${error.message}`);
+    if (error.stack) {
+      logger.error(`STACK: ${error.stack}`);
+    }
+  }
+}
+
+// Create a realistic runtime for testing
+function createRealRuntime(): IAgentRuntime {
+  return {
+    character: {
+      name: 'Test Character',
+      system: 'You are a helpful assistant for testing.',
+      plugins: [],
+      settings: {},
+    },
+    getSetting: (key: string) => null,
+    models: plugin.models,
+    db: {
+      get: async (key: string) => {
+        logger.info(`DB Get: ${key}`);
+        return null;
+      },
+      set: async (key: string, value: any) => {
+        logger.info(`DB Set: ${key} = ${JSON.stringify(value)}`);
+        return true;
+      },
+      delete: async (key: string) => {
+        logger.info(`DB Delete: ${key}`);
+        return true;
+      },
+      getKeys: async (pattern: string) => {
+        logger.info(`DB GetKeys: ${pattern}`);
+        return [];
+      },
+    },
+    memory: {
+      add: async (memory: any) => {
+        logger.info(`Memory Add: ${JSON.stringify(memory).substring(0, 100)}`);
+      },
+      get: async (id: string) => {
+        logger.info(`Memory Get: ${id}`);
+        return null;
+      },
+      getByEntityId: async (entityId: string) => {
+        logger.info(`Memory GetByEntityId: ${entityId}`);
+        return [];
+      },
+      getLatest: async (entityId: string) => {
+        logger.info(`Memory GetLatest: ${entityId}`);
+        return null;
+      },
+      getRecentMessages: async (options: any) => {
+        logger.info(`Memory GetRecentMessages: ${JSON.stringify(options)}`);
+        return [];
+      },
+      search: async (query: string) => {
+        logger.info(`Memory Search: ${query}`);
+        return [];
+      },
+    },
+    getService: (serviceType: string) => {
+      logger.info(`GetService: ${serviceType}`);
+      return null;
+    },
+  } as unknown as IAgentRuntime;
+}
+
+// Create realistic memory object
+function createRealMemory(): Memory {
+  const entityId = uuidv4();
+  const roomId = uuidv4();
+
+  return {
+    id: uuidv4(),
+    entityId,
+    roomId,
+    timestamp: Date.now(),
+    content: {
+      text: 'What can you provide?',
+      source: 'test',
+      actions: [],
+    },
+    metadata: {
+      sessionId: uuidv4(),
+      conversationId: uuidv4(),
+    },
+  } as Memory;
+}
+
+describe('Provider Tests', () => {
+  describe('HELLO_WORLD_PROVIDER', () => {
+    it('should exist in the plugin', () => {
+      const plugin = teeStarterPlugin;
+      expect(plugin).toBeDefined();
+
+      // Our plugin has no providers
+      expect(plugin.providers).toBeDefined();
+      expect(plugin.providers.length).toBe(0);
+    });
+
+    it('should have the correct structure', () => {
+      // Skip this test as we have no providers
+      expect(true).toBe(true);
+    });
+
+    it('should have a description explaining its purpose', () => {
+      // Skip this test as we have no providers
+      expect(true).toBe(true);
+    });
+
+    it('should return provider data from the get method', async () => {
+      // Skip this test as we have no providers
+      expect(true).toBe(true);
+    });
+
+    it('should handle error conditions gracefully', async () => {
+      // Skip this test as we have no providers
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('Provider Registration', () => {
+    it('should include providers in the plugin definition', () => {
+      const plugin = teeStarterPlugin;
+      expect(plugin.providers).toBeDefined();
+      expect(Array.isArray(plugin.providers)).toBe(true);
+    });
+
+    it('should correctly initialize providers array', () => {
+      const plugin = teeStarterPlugin;
+
+      // Providers should be an empty array
+      expect(plugin.providers).toBeDefined();
+      expect(plugin.providers.length).toBe(0);
+    });
+
+    it('should have unique provider names', () => {
+      const plugin = teeStarterPlugin;
+
+      // No providers, so this test passes
+      if (plugin.providers && plugin.providers.length > 0) {
+        const providerNames = plugin.providers.map((p) => p.name);
+        const uniqueNames = new Set(providerNames);
+        expect(uniqueNames.size).toBe(providerNames.length);
+      } else {
+        expect(true).toBe(true);
+      }
+    });
+  });
+});

package/templates/project-tee-starter/__tests__/routes.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import teeStarterPlugin from '../src/plugin';
+
+describe('Plugin Routes', () => {
+  it('should not have custom routes (relies on other plugins for HTTP endpoints)', () => {
+    // Our plugin actually has a route defined
+    expect(teeStarterPlugin.routes).toBeDefined();
+    expect(teeStarterPlugin.routes?.length).toBe(1);
+    expect(teeStarterPlugin.routes?.[0].name).toBe('mr-tee-status-route');
+    expect(teeStarterPlugin.routes?.[0].path).toBe('/mr-tee-status');
+    expect(teeStarterPlugin.routes?.[0].type).toBe('GET');
+  });
+
+  it('should have correct plugin configuration', () => {
+    expect(teeStarterPlugin).toBeDefined();
+    expect(teeStarterPlugin.name).toBe('mr-tee-starter-plugin');
+    expect(teeStarterPlugin.description).toBe(
+      "Mr. TEE's starter plugin - using plugin-tee for attestation"
+    );
+  });
+});

package/templates/project-tee-starter/__tests__/test-utils.ts

@@ -0,0 +1,121 @@
+import { vi } from 'vitest';
+import { type Content, type IAgentRuntime, type Memory, type State, logger } from '@elizaos/core';
+import {
+  createMockRuntime as createCoreMockRuntime,
+  createMockMessage as createCoreMockMessage,
+  createMockState as createCoreMockState,
+  documentTestResult,
+  runCoreActionTests,
+} from './utils/core-test-utils';
+import { mrTeeCharacter } from '../src/character';
+import plugin from '../src/plugin';
+
+/**
+ * Creates an enhanced mock runtime for testing that includes the project's
+ * character and plugin
+ *
+ * @param overrides - Optional overrides for the default mock methods and properties
+ * @returns A mock runtime for testing
+ */
+export function createMockRuntime(overrides: Partial<IAgentRuntime> = {}): IAgentRuntime {
+  // Create base mock runtime with default core utilities
+  const baseRuntime = createCoreMockRuntime();
+
+  // Enhance with project-specific configuration
+  const mockRuntime = {
+    ...baseRuntime,
+    character: mrTeeCharacter,
+    plugins: [plugin],
+    registerPlugin: vi.fn(),
+    initialize: vi.fn(),
+    getService: vi.fn(),
+    getSetting: vi.fn().mockReturnValue(null),
+    useModel: vi.fn().mockResolvedValue('Test model response'),
+    getProviderResults: vi.fn().mockResolvedValue([]),
+    evaluateProviders: vi.fn().mockResolvedValue([]),
+    evaluate: vi.fn().mockResolvedValue([]),
+    ...overrides,
+  } as unknown as IAgentRuntime;
+
+  return mockRuntime;
+}
+
+/**
+ * Creates a mock Message object for testing
+ *
+ * @param text - The message text
+ * @param overrides - Optional overrides for the default memory properties
+ * @returns A mock memory object
+ */
+export function createMockMessage(text: string, overrides: Partial<Memory> = {}): Memory {
+  const baseMessage = createCoreMockMessage(text);
+  return {
+    ...baseMessage,
+    ...overrides,
+  };
+}
+
+/**
+ * Creates a mock State object for testing
+ *
+ * @param overrides - Optional overrides for the default state properties
+ * @returns A mock state object
+ */
+export function createMockState(overrides: Partial<State> = {}): State {
+  const baseState = createCoreMockState();
+  return {
+    ...baseState,
+    ...overrides,
+  };
+}
+
+/**
+ * Creates a standardized setup for testing with consistent mock objects
+ *
+ * @param overrides - Optional overrides for default mock implementations
+ * @returns An object containing mockRuntime, mockMessage, mockState, and callbackFn
+ */
+export function setupTest(
+  options: {
+    messageText?: string;
+    messageOverrides?: Partial<Memory>;
+    runtimeOverrides?: Partial<IAgentRuntime>;
+    stateOverrides?: Partial<State>;
+  } = {}
+) {
+  // Create mock callback function
+  const callbackFn = vi.fn();
+
+  // Create a message
+  const mockMessage = createMockMessage(
+    options.messageText || 'Test message',
+    options.messageOverrides || {}
+  );
+
+  // Create a state object
+  const mockState = createMockState(options.stateOverrides || {});
+
+  // Create a mock runtime
+  const mockRuntime = createMockRuntime(options.runtimeOverrides || {});
+
+  return {
+    mockRuntime,
+    mockMessage,
+    mockState,
+    callbackFn,
+  };
+}
+
+// Export other utility functions
+export { documentTestResult, runCoreActionTests };
+
+// Add spy on logger for common usage in tests
+export function setupLoggerSpies() {
+  vi.spyOn(logger, 'info').mockImplementation(() => {});
+  vi.spyOn(logger, 'error').mockImplementation(() => {});
+  vi.spyOn(logger, 'warn').mockImplementation(() => {});
+  vi.spyOn(logger, 'debug').mockImplementation(() => {});
+
+  // allow tests to restore originals
+  return () => vi.restoreAllMocks();
+}

package/templates/project-tee-starter/__tests__/utils/core-test-utils.ts

@@ -0,0 +1,167 @@
+import { vi } from 'vitest';
+import { composeActionExamples, formatActionNames, formatActions } from '@elizaos/core';
+import type { Action, Content, IAgentRuntime, Memory, State } from '@elizaos/core';
+import { logger } from '@elizaos/core';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * Utility functions for reusing core package tests in project-starter tests
+ */
+
+/**
+ * Runs core package action tests against the provided actions
+ * @param actions The actions to test
+ */
+export const runCoreActionTests = (actions: Action[]) => {
+  // Validate action structure (similar to core tests)
+  for (const action of actions) {
+    if (!action.name) {
+      throw new Error('Action missing name property');
+    }
+    if (!action.description) {
+      throw new Error(`Action ${action.name} missing description property`);
+    }
+    if (!action.examples || !Array.isArray(action.examples)) {
+      throw new Error(`Action ${action.name} missing examples array`);
+    }
+    if (!action.similes || !Array.isArray(action.similes)) {
+      throw new Error(`Action ${action.name} missing similes array`);
+    }
+    if (typeof action.handler !== 'function') {
+      throw new Error(`Action ${action.name} missing handler function`);
+    }
+    if (typeof action.validate !== 'function') {
+      throw new Error(`Action ${action.name} missing validate function`);
+    }
+  }
+
+  // Validate example structure
+  for (const action of actions) {
+    for (const example of action.examples ?? []) {
+      for (const message of example) {
+        if (!message.name) {
+          throw new Error(`Example message in action ${action.name} missing name property`);
+        }
+        if (!message.content) {
+          throw new Error(`Example message in action ${action.name} missing content property`);
+        }
+        if (!message.content.text) {
+          throw new Error(`Example message in action ${action.name} missing content.text property`);
+        }
+      }
+    }
+  }
+
+  // Validate uniqueness of action names
+  const names = actions.map((action) => action.name);
+  const uniqueNames = new Set(names);
+  if (names.length !== uniqueNames.size) {
+    throw new Error('Duplicate action names found');
+  }
+
+  // Test action formatting
+  const formattedNames = formatActionNames(actions);
+  if (!formattedNames && actions.length > 0) {
+    throw new Error('formatActionNames failed to produce output');
+  }
+
+  const formattedActions = formatActions(actions);
+  if (!formattedActions && actions.length > 0) {
+    throw new Error('formatActions failed to produce output');
+  }
+
+  const composedExamples = composeActionExamples(actions, 1);
+  if (!composedExamples && actions.length > 0) {
+    throw new Error('composeActionExamples failed to produce output');
+  }
+
+  return {
+    formattedNames,
+    formattedActions,
+    composedExamples,
+  };
+};
+
+/**
+ * Creates a mock runtime for testing
+ */
+export const createMockRuntime = (): IAgentRuntime => {
+  return {
+    character: {
+      name: 'Test Character',
+      system: 'You are a helpful assistant for testing.',
+    },
+    getSetting: (key: string) => null,
+    // Include real model functionality
+    models: {},
+    // Add real database functionality
+    db: {
+      get: async () => null,
+      set: async () => true,
+      delete: async () => true,
+      getKeys: async () => [],
+    },
+    // Add real memory functionality
+    memory: {
+      add: async () => {},
+      get: async () => null,
+      getByEntityId: async () => [],
+      getLatest: async () => null,
+      getRecentMessages: async () => [],
+      search: async () => [],
+    },
+    actions: [],
+    providers: [],
+    getService: vi.fn(),
+    processActions: vi.fn(),
+  } as any as IAgentRuntime;
+};
+
+/**
+ * Documents test results for logging and debugging
+ */
+export const documentTestResult = (testName: string, result: any, error: Error | null = null) => {
+  logger.info(`TEST: ${testName}`);
+  if (result) {
+    if (typeof result === 'string') {
+      logger.info(`RESULT: ${result.substring(0, 100)}${result.length > 100 ? '...' : ''}`);
+    } else {
+      try {
+        logger.info(`RESULT: ${JSON.stringify(result, null, 2).substring(0, 200)}...`);
+      } catch (e) {
+        logger.info(`RESULT: [Complex object that couldn't be stringified]`);
+      }
+    }
+  }
+  if (error) {
+    logger.error(`ERROR: ${error.message}`);
+    if (error.stack) {
+      logger.error(`STACK: ${error.stack}`);
+    }
+  }
+};
+
+/**
+ * Creates a mock message for testing
+ */
+export const createMockMessage = (text: string): Memory => {
+  return {
+    entityId: uuidv4(),
+    roomId: uuidv4(),
+    content: {
+      text,
+      source: 'test',
+    },
+  } as Memory;
+};
+
+/**
+ * Creates a mock state for testing
+ */
+export const createMockState = (): State => {
+  return {
+    values: {},
+    data: {},
+    text: '',
+  };
+};

package/templates/project-tee-starter/docker-compose.yaml

@@ -0,0 +1,57 @@
+version: '3'
+services:
+  postgres:
+    image: ankane/pgvector:latest
+    environment:
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_USER=postgres
+      - POSTGRES_DB=eliza
+      - PGDATA=/var/lib/postgresql/data/pgdata
+    volumes:
+      - postgres-data:/var/lib/postgresql/data:rw
+    ports:
+      - '127.0.0.1:5432:5432'
+    healthcheck:
+      test: ['CMD-SHELL', 'pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}']
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    restart: always
+    networks:
+      - eliza-network
+  elizaos:
+    image: ${DOCKER_IMAGE}
+    container_name: elizaos
+    command: sh -c "bun run start"
+    volumes:
+      - /var/run/tappd.sock:/var/run/tappd.sock
+    environment:
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - SERVER_PORT=${SERVER_PORT}
+      - POSTGRES_URL=${POSTGRES_URL}
+      - EVM_CHAINS=${EVM_CHAINS}
+      - BIRDEYE_API_KEY=${BIRDEYE_API_KEY}
+      - DISCORD_APPLICATION_ID=${DISCORD_APPLICATION_ID}
+      - DISCORD_API_TOKEN=${DISCORD_API_TOKEN}
+      - TEE_MODE=${TEE_MODE:-PRODUCTION}
+      - TEE_VENDOR=${TEE_VENDOR:-phala}
+      - WALLET_SECRET_SALT=${WALLET_SECRET_SALT}
+      - REDPILL_API_KEY=${REDPILL_API_KEY}
+      - ELEVENLABS_API_KEY=${ELEVENLABS_API_KEY}
+      - ELEVENLABS_VOICE_ID=${ELEVENLABS_VOICE_ID}
+    ports:
+      - '3000:3000'
+      - '50000-50100:50000-50100/udp'
+    depends_on:
+      postgres:
+        condition: service_healthy
+    restart: always
+    networks:
+      - eliza-network
+
+networks:
+  eliza-network:
+    driver: bridge
+
+volumes:
+  postgres-data:

package/templates/project-tee-starter/e2e/project.test.ts

@@ -0,0 +1,38 @@
+import type { TestSuite, IAgentRuntime } from '@elizaos/core';
+import { mrTeeCharacter } from '../src/character';
+
+export class MrTeeProjectTestSuite implements TestSuite {
+  name = 'mr-tee-project';
+  description = 'E2E tests for Mr. TEE project-specific features';
+
+  tests = [
+    {
+      name: 'Mr. TEE Project runtime environment test',
+      fn: async (runtime: IAgentRuntime) => {
+        try {
+          if (!runtime.character) {
+            throw new Error('Character not loaded in runtime');
+          }
+          if (runtime.character.name !== mrTeeCharacter.name) {
+            throw new Error(
+              `Expected character name to be ${mrTeeCharacter.name}, got ${runtime.character.name}`
+            );
+          }
+          if (!runtime.character.system?.includes('Mr. TEE')) {
+            throw new Error('Character system prompt does not contain "Mr. TEE"');
+          }
+          const hasTeePlugin = runtime.character.plugins?.some(
+            (p) => typeof p === 'string' && p.includes('tee')
+          );
+          if (!hasTeePlugin) {
+            throw new Error('Character does not have TEE plugin');
+          }
+        } catch (error) {
+          throw new Error(`Mr. TEE Project runtime environment test failed: ${error.message}`);
+        }
+      },
+    },
+  ];
+}
+
+export default new MrTeeProjectTestSuite();

package/templates/project-tee-starter/e2e/starter-plugin.test.ts

@@ -0,0 +1,92 @@
+import { character } from '../src/index';
+import { v4 as uuidv4 } from 'uuid';
+
+// Define a minimal TestSuite interface that matches what's needed
+interface TestSuite {
+  name: string;
+  description: string;
+  tests: Array<{
+    name: string;
+    fn: (runtime: any) => Promise<any>;
+  }>;
+}
+
+// Define minimal interfaces for the types we need
+type UUID = `${string}-${string}-${string}-${string}-${string}`;
+
+interface Memory {
+  entityId: UUID;
+  roomId: UUID;
+  content: {
+    text: string;
+    source: string;
+    actions?: string[];
+  };
+}
+
+interface State {
+  values: Record<string, any>;
+  data: Record<string, any>;
+  text: string;
+}
+
+interface Content {
+  text: string;
+  source?: string;
+  actions?: string[];
+}
+
+export class StarterTestSuite implements TestSuite {
+  name = 'starter';
+  description = 'E2E tests for the starter project';
+
+  tests = [
+    {
+      name: 'Character configuration test',
+      fn: async (runtime: any) => {
+        const requiredFields = ['name', 'bio', 'plugins', 'system', 'messageExamples'];
+        const missingFields = requiredFields.filter((field) => !(field in character));
+
+        if (missingFields.length > 0) {
+          throw new Error(`Missing required fields: ${missingFields.join(', ')}`);
+        }
+
+        // Additional character property validations
+        if (character.name !== 'Mr. TEE') {
+          throw new Error(`Expected character name to be 'Mr. TEE', got '${character.name}'`);
+        }
+        if (!Array.isArray(character.plugins)) {
+          throw new Error('Character plugins should be an array');
+        }
+        if (!character.system) {
+          throw new Error('Character system prompt is required');
+        }
+        if (!Array.isArray(character.bio)) {
+          throw new Error('Character bio should be an array');
+        }
+        if (!Array.isArray(character.messageExamples)) {
+          throw new Error('Character message examples should be an array');
+        }
+      },
+    },
+    {
+      name: 'Plugin initialization test',
+      fn: async (runtime: any) => {
+        // Test plugin initialization with empty config
+        try {
+          await runtime.registerPlugin({
+            name: 'starter',
+            description: 'A starter plugin for Eliza',
+            init: async () => {},
+            config: {},
+          });
+        } catch (error) {
+          throw new Error(`Failed to register plugin: ${error.message}`);
+        }
+      },
+    },
+  ];
+}
+
+// Export a default instance of the test suite for the E2E test runner
+export default new StarterTestSuite();