@elizaos/cli 1.0.9 → 1.0.10

package/templates/project-starter/src/__tests__/cypress/support/component.ts

@@ -0,0 +1,33 @@
+// ***********************************************************
+// This file is processed and loaded automatically before your test files.
+// You can change the location of this file or turn off processing using the
+// 'supportFile' config option.
+// ***********************************************************
+
+// Import commands.js using ES2015 syntax:
+import './commands';
+
+// Import Testing Library Cypress commands
+import '@testing-library/cypress/add-commands';
+
+// Import styles
+import '../../../frontend/index.css';
+
+// Add custom TypeScript types
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Custom command to mount React components
+       * @example cy.mount(<Component />)
+       */
+      mount(component: React.ReactElement): Chainable<any>;
+    }
+  }
+}
+
+// Import React mount function
+import { mount } from '@cypress/react';
+
+// Make mount available globally
+Cypress.Commands.add('mount', mount);

package/templates/project-starter/src/__tests__/cypress/support/e2e.ts

@@ -0,0 +1,179 @@
+/**
+ * E2E Support File
+ *
+ * This file is loaded automatically before E2E test files.
+ * Use it to set up global configuration and custom commands.
+ */
+
+// ***********************************************************
+// This file is processed and loaded automatically before your test files.
+// You can change the location of this file or turn off processing using the
+// 'supportFile' config option.
+// ***********************************************************
+
+// Import commands (shared with component tests)
+import './commands';
+
+// Import Testing Library Cypress commands
+import '@testing-library/cypress/add-commands';
+
+// E2E-specific configurations
+Cypress.on('uncaught:exception', (err, runnable) => {
+  // Prevent Cypress from failing the test on uncaught exceptions
+  // This is useful for E2E tests where third-party scripts might throw errors
+  console.error('Uncaught exception:', err);
+  return false;
+});
+
+// Custom E2E commands
+declare global {
+  namespace Cypress {
+    interface Chainable {
+      /**
+       * Login to the application
+       * @param username - Username to login with
+       * @param password - Password to login with
+       */
+      login(username?: string, password?: string): Chainable<void>;
+
+      /**
+       * Wait for the application to be ready
+       */
+      waitForApp(): Chainable<void>;
+
+      /**
+       * Navigate to a specific agent chat
+       * @param agentId - ID of the agent to chat with
+       */
+      navigateToAgent(agentId?: string): Chainable<void>;
+
+      /**
+       * Send a chat message and wait for response
+       * @param message - Message to send
+       */
+      sendChatMessage(message: string): Chainable<void>;
+
+      /**
+       * Clear all application data
+       */
+      clearAppData(): Chainable<void>;
+    }
+  }
+}
+
+// Login command
+Cypress.Commands.add('login', (username = 'testuser', password = 'testpass') => {
+  // Check if login is required
+  cy.get('body').then(($body) => {
+    if ($body.find('[data-testid="login"], form[name="login"], input[name="username"]').length) {
+      cy.get('input[name="username"], input[type="email"]').first().type(username);
+      cy.get('input[name="password"], input[type="password"]').first().type(password);
+      cy.get('button[type="submit"], button:contains("Login")').first().click();
+      cy.wait(1000);
+    }
+  });
+});
+
+// Wait for app to be ready
+Cypress.Commands.add('waitForApp', () => {
+  // Wait for any loading indicators to disappear
+  cy.get('[data-testid="loading"], .loading, .spinner', { timeout: 10000 }).should('not.exist');
+
+  // Ensure the app container is visible
+  cy.get('#root, #app, [data-testid="app"]').should('be.visible');
+
+  // Wait a bit for any animations
+  cy.wait(500);
+});
+
+// Navigate to agent
+Cypress.Commands.add('navigateToAgent', (agentId?: string) => {
+  if (agentId) {
+    cy.visit(`/agent/${agentId}`);
+  } else {
+    cy.get('a[href*="agent"], button:contains("agent")').first().click({ force: true });
+  }
+  cy.waitForApp();
+});
+
+// Send chat message
+Cypress.Commands.add('sendChatMessage', (message: string) => {
+  // Find and type in the input
+  cy.get('input[type="text"], textarea, [contenteditable="true"]')
+    .filter(':visible')
+    .first()
+    .clear()
+    .type(message);
+
+  // Send the message
+  cy.get('button').filter(':contains("Send"), [aria-label*="send"]').first().click();
+
+  // Wait for the message to appear
+  cy.contains(message, { timeout: 5000 }).should('be.visible');
+
+  // Wait for agent response
+  cy.get('[data-testid*="agent"], [class*="agent"], [data-sender="agent"]', {
+    timeout: 15000,
+  }).should('exist');
+});
+
+// Clear app data
+Cypress.Commands.add('clearAppData', () => {
+  cy.window().then((win) => {
+    // Clear local storage
+    (win as any).localStorage.clear();
+
+    // Clear session storage
+    (win as any).sessionStorage.clear();
+
+    // Clear cookies
+    cy.clearCookies();
+
+    // Note: IndexedDB clearing is commented out due to TypeScript compatibility issues
+    // If your app uses IndexedDB, you may need to add custom clearing logic here
+    // Example:
+    // cy.window().its('indexedDB').invoke('deleteDatabase', 'your-db-name');
+  });
+});
+
+// E2E-specific viewport settings
+beforeEach(() => {
+  // Set a consistent viewport for E2E tests
+  cy.viewport(1280, 720);
+});
+
+// Screenshot on failure
+Cypress.on('fail', (error, runnable) => {
+  // Take a screenshot when a test fails
+  cy.screenshot(`failed-${runnable.parent?.title}-${runnable.title}`, {
+    capture: 'runner',
+  });
+  throw error;
+});
+
+/**
+ * E2E TESTING UTILITIES
+ *
+ * These commands help with common E2E testing scenarios:
+ *
+ * 1. LOGIN FLOWS
+ *    - cy.login() - Handle authentication
+ *    - Supports different auth methods
+ *
+ * 2. NAVIGATION
+ *    - cy.navigateToAgent() - Go to agent chat
+ *    - cy.waitForApp() - Wait for app ready
+ *
+ * 3. INTERACTIONS
+ *    - cy.sendChatMessage() - Send and verify messages
+ *    - Handles async responses
+ *
+ * 4. STATE MANAGEMENT
+ *    - cy.clearAppData() - Reset application state
+ *    - Clears all storage types
+ *
+ * BEST PRACTICES:
+ * - Use these commands for consistency
+ * - Add new commands as patterns emerge
+ * - Keep commands focused and reusable
+ */

package/templates/project-starter/src/__tests__/e2e/index.ts

@@ -0,0 +1,14 @@
+/**
+ * E2E Test Suite Exports
+ *
+ * This file exports all E2E test suites for the ElizaOS test runner.
+ */
+
+import projectTestSuite from './project.test';
+import starterTestSuite from './starter-plugin.test';
+import naturalLanguageTestSuite from './natural-language.test';
+
+// Export test suites for the test runner to discover
+export const testSuites = [projectTestSuite, starterTestSuite, naturalLanguageTestSuite];
+
+export default testSuites;

package/templates/project-starter/src/__tests__/e2e/natural-language.test.ts

@@ -0,0 +1,246 @@
+import { type TestSuite } from '@elizaos/core';
+
+/**
+ * Natural Language E2E Test Suite
+ *
+ * This suite tests the agent's ability to respond to natural language inputs,
+ * including the requested "hello world" test.
+ *
+ * HOW TO ADD NEW NATURAL LANGUAGE TESTS:
+ * 1. Add a new test object to the `tests` array
+ * 2. Create a message with natural language content
+ * 3. Process it through the runtime
+ * 4. Verify the agent's response makes sense
+ *
+ * These tests use the REAL runtime with actual language processing,
+ * so responses may vary based on the model and character configuration.
+ */
+export class NaturalLanguageTestSuite implements TestSuite {
+  name = 'natural-language';
+  description = 'E2E tests for natural language processing and agent responses';
+
+  tests = [
+    {
+      name: 'Agent responds to hello world',
+      fn: async (runtime: any) => {
+        /**
+         * This test verifies that the agent can respond appropriately
+         * to a simple "hello world" greeting.
+         */
+        try {
+          // Create a unique room for this test
+          const roomId = `test-room-hello-${Date.now()}`;
+          const userId = 'test-user-hello';
+
+          // Create a message saying "hello world"
+          const helloMessage = {
+            id: `msg-${Date.now()}`,
+            userId: userId,
+            agentId: runtime.agentId,
+            roomId: roomId,
+            content: {
+              text: 'hello world',
+              type: 'text',
+            },
+            createdAt: Date.now(),
+          };
+
+          console.log('Sending hello world message to agent...');
+
+          // Process the message through the runtime
+          // This will trigger the agent to generate a response
+          await runtime.processMessage(helloMessage);
+
+          // Give the agent a moment to process and respond
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+
+          // Retrieve messages from the conversation
+          const messages = await runtime.messageManager.getMessages({
+            roomId,
+            limit: 10,
+          });
+
+          console.log(`Retrieved ${messages.length} messages from conversation`);
+
+          // Verify we have at least 2 messages (user + agent)
+          if (messages.length < 2) {
+            throw new Error(`Expected at least 2 messages, got ${messages.length}`);
+          }
+
+          // Find the agent's response
+          const agentResponse = messages.find(
+            (m: any) =>
+              m.userId === runtime.agentId && m.roomId === roomId && m.id !== helloMessage.id
+          );
+
+          if (!agentResponse) {
+            throw new Error('Agent did not respond to hello world message');
+          }
+
+          console.log('Agent response:', agentResponse.content.text);
+
+          // Verify the response contains a greeting
+          const responseText = agentResponse.content.text.toLowerCase();
+          const greetingWords = ['hello', 'hi', 'hey', 'greetings', 'welcome'];
+
+          const containsGreeting = greetingWords.some((word) => responseText.includes(word));
+
+          if (!containsGreeting) {
+            throw new Error(
+              `Agent response did not contain a greeting. ` +
+                `Response was: "${agentResponse.content.text}"`
+            );
+          }
+
+          console.log('✓ Agent successfully responded to hello world');
+        } catch (error) {
+          throw new Error(`Hello world test failed: ${(error as Error).message}`);
+        }
+      },
+    },
+
+    {
+      name: 'Agent responds to casual greeting',
+      fn: async (runtime: any) => {
+        /**
+         * Test various casual greetings to ensure the agent
+         * responds appropriately to different forms of hello.
+         */
+        try {
+          const greetings = ['hey there!', 'hi, how are you?', 'good morning!', 'whats up?'];
+
+          for (const greeting of greetings) {
+            const roomId = `test-room-greeting-${Date.now()}-${Math.random()}`;
+            const userId = 'test-user-greeting';
+
+            const message = {
+              id: `msg-${Date.now()}-${Math.random()}`,
+              userId: userId,
+              agentId: runtime.agentId,
+              roomId: roomId,
+              content: {
+                text: greeting,
+                type: 'text',
+              },
+              createdAt: Date.now(),
+            };
+
+            console.log(`Testing greeting: "${greeting}"`);
+
+            await runtime.processMessage(message);
+            await new Promise((resolve) => setTimeout(resolve, 500));
+
+            const messages = await runtime.messageManager.getMessages({
+              roomId,
+              limit: 10,
+            });
+
+            const agentResponse = messages.find(
+              (m: any) => m.userId === runtime.agentId && m.id !== message.id
+            );
+
+            if (!agentResponse) {
+              throw new Error(`Agent did not respond to greeting: "${greeting}"`);
+            }
+
+            // Just verify we got a response - content may vary
+            if (!agentResponse.content.text || agentResponse.content.text.length < 2) {
+              throw new Error(`Agent gave empty response to: "${greeting}"`);
+            }
+
+            console.log(`✓ Agent responded to: "${greeting}"`);
+          }
+        } catch (error) {
+          throw new Error(`Casual greeting test failed: ${(error as Error).message}`);
+        }
+      },
+    },
+
+    {
+      name: 'Agent maintains conversation context',
+      fn: async (runtime: any) => {
+        /**
+         * Test that the agent remembers context from previous messages
+         * in the same conversation.
+         */
+        try {
+          const roomId = `test-room-context-${Date.now()}`;
+          const userId = 'test-user-context';
+
+          // First message - introduce a topic
+          const firstMessage = {
+            id: `msg-1-${Date.now()}`,
+            userId: userId,
+            agentId: runtime.agentId,
+            roomId: roomId,
+            content: {
+              text: "My favorite color is blue. What's yours?",
+              type: 'text',
+            },
+            createdAt: Date.now(),
+          };
+
+          console.log('Sending first message about favorite color...');
+          await runtime.processMessage(firstMessage);
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+
+          // Second message - reference the topic
+          const secondMessage = {
+            id: `msg-2-${Date.now()}`,
+            userId: userId,
+            agentId: runtime.agentId,
+            roomId: roomId,
+            content: {
+              text: 'Why did you choose that color?',
+              type: 'text',
+            },
+            createdAt: Date.now() + 1000,
+          };
+
+          console.log('Sending follow-up question...');
+          await runtime.processMessage(secondMessage);
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+
+          // Get all messages
+          const messages = await runtime.messageManager.getMessages({
+            roomId,
+            limit: 10,
+          });
+
+          // Should have at least 4 messages (2 user + 2 agent)
+          if (messages.length < 4) {
+            throw new Error(`Expected at least 4 messages, got ${messages.length}`);
+          }
+
+          // Find the agent's second response
+          const agentResponses = messages.filter((m: any) => m.userId === runtime.agentId);
+          if (agentResponses.length < 2) {
+            throw new Error('Agent did not respond to both messages');
+          }
+
+          // The second response should reference colors or the previous conversation
+          const secondResponse = agentResponses[agentResponses.length - 1];
+          const responseText = secondResponse.content.text.toLowerCase();
+
+          // Check if the response shows context awareness
+          const contextWords = ['color', 'blue', 'favorite', 'chose', 'choice', 'because'];
+          const hasContext = contextWords.some((word) => responseText.includes(word));
+
+          if (!hasContext) {
+            console.warn(
+              'Agent response may not show context awareness. ' +
+                `Response: "${secondResponse.content.text}"`
+            );
+          }
+
+          console.log('✓ Agent maintained conversation context');
+        } catch (error) {
+          throw new Error(`Context test failed: ${(error as Error).message}`);
+        }
+      },
+    },
+  ];
+}
+
+// Export a default instance for the test runner
+export default new NaturalLanguageTestSuite();

package/templates/project-starter/src/__tests__/e2e/project.test.ts

@@ -0,0 +1,155 @@
+import { type TestSuite } from '@elizaos/core';
+
+/**
+ * Project E2E Test Suite
+ *
+ * This file demonstrates how to write end-to-end (E2E) tests for ElizaOS projects.
+ * E2E tests are run using the `elizaos test` command, which provides a REAL runtime
+ * environment with actual database, services, and plugin initialization.
+ *
+ * Key differences from unit tests:
+ * - E2E tests receive a fully initialized IAgentRuntime instance
+ * - The runtime has a real database (in-memory PGLite for testing)
+ * - All plugins and services are actually initialized and running
+ * - You can test real agent interactions and behaviors
+ *
+ * HOW TO ADD NEW E2E TESTS:
+ * 1. Add a new test object to the `tests` array below
+ * 2. Each test should have a descriptive `name` and async `fn` function
+ * 3. The test function receives a real runtime instance as its parameter
+ * 4. Use the runtime to simulate real agent interactions
+ * 5. Throw an error if the test fails (assertions that fail should throw)
+ *
+ * IMPORTANT: These tests run in a real environment, so:
+ * - Don't use mocks or stubs - everything is real
+ * - Tests may be slower than unit tests due to real operations
+ * - Each test should be independent and not rely on previous test state
+ */
+export class ProjectTestSuite implements TestSuite {
+  name = 'project';
+  description = 'E2E tests for project-specific features';
+
+  tests = [
+    {
+      name: 'Project runtime environment test',
+      fn: async (runtime: any) => {
+        /**
+         * This test verifies that the project's runtime environment is set up correctly.
+         * It's a basic smoke test to ensure the character and core systems are loaded.
+         */
+        try {
+          // Verify character is loaded
+          if (!runtime.character) {
+            throw new Error('Character not loaded in runtime');
+          }
+
+          // Verify expected character properties
+          const character = runtime.character;
+          if (!character.name) {
+            throw new Error('Character name is missing');
+          }
+
+          // Verify the character has the expected name
+          if (character.name !== 'Eliza') {
+            throw new Error(`Expected character name 'Eliza', got '${character.name}'`);
+          }
+
+          // Verify character has required configuration
+          if (!character.system) {
+            throw new Error('Character system prompt is missing');
+          }
+
+          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');
+          }
+
+          // Verify plugins are loaded (if specified in character)
+          if (character.plugins && !Array.isArray(character.plugins)) {
+            throw new Error('Character plugins should be an array');
+          }
+
+          // Test passed - no need to return anything
+          // The test framework considers it successful if no error is thrown
+        } catch (error) {
+          // Re-throw with more context for debugging
+          throw new Error(`Project runtime environment test failed: ${(error as Error).message}`);
+        }
+      },
+    },
+
+    /**
+     * Example: How to add a new test that checks if services are initialized
+     * Uncomment and modify this template for your own tests
+     */
+    /*
+    {
+      name: 'Services initialization test',
+      fn: async (runtime: any) => {
+        // Example: Check if a specific service is available
+        const myService = runtime.getService('my-service-name');
+        if (!myService) {
+          throw new Error('Expected service not found');
+        }
+        
+        // Example: Test service functionality
+        const result = await myService.doSomething();
+        if (!result) {
+          throw new Error('Service did not return expected result');
+        }
+      },
+    },
+    */
+
+    /**
+     * Example: How to test agent message processing
+     * This shows how to simulate a conversation with the agent
+     */
+    /*
+    {
+      name: 'Agent conversation test',
+      fn: async (runtime: any) => {
+        // Create a test room/conversation
+        const roomId = `test-room-${Date.now()}`;
+        
+        // Simulate sending a message to the agent
+        const userMessage = {
+          userId: 'test-user',
+          roomId: roomId,
+          content: { text: 'Hello agent!' },
+          // Add other required message properties
+        };
+        
+        // Process the message through the runtime
+        await runtime.processMessage(userMessage);
+        
+        // Retrieve messages from the conversation
+        const messages = await runtime.messageManager.getMessages({ roomId });
+        
+        // Verify the agent responded
+        if (messages.length < 2) {
+          throw new Error('Agent did not respond to message');
+        }
+        
+        // Check the agent's response
+        const agentResponse = messages.find(m => m.userId === runtime.agentId);
+        if (!agentResponse) {
+          throw new Error('Could not find agent response');
+        }
+        
+        // Verify response content
+        if (!agentResponse.content.text.toLowerCase().includes('hello')) {
+          throw new Error('Agent response did not contain expected greeting');
+        }
+      },
+    },
+    */
+  ];
+}
+
+// Export a default instance of the test suite for the E2E test runner
+// The test runner will automatically discover and run this suite
+export default new ProjectTestSuite();