@elizaos/cli 1.3.2 → 1.4.2

package/{dist/templates/project-tee-starter → templates/project-tee-starter/src}/__tests__/vite-config-utils.ts

@@ -1,17 +1,29 @@
 import path from 'node:path';
 import fs from 'node:fs';
 
+// Default output directories
+const DEFAULT_VITE_OUT_DIR = 'dist/frontend';
+const DEFAULT_VITE_VAR_DIR = 'dist/.vite';
+
 /**
  * Extracts the Vite output directory from vite.config.ts
  */
 export async function getViteOutDir(rootDir: string): Promise<string> {
   const viteConfigPath = path.join(rootDir, 'vite.config.ts');
+
+  // Check if vite config exists
+  if (!fs.existsSync(viteConfigPath)) {
+    // Return default if config doesn't exist
+    return DEFAULT_VITE_OUT_DIR;
+  }
+
   const configContent = await fs.promises.readFile(viteConfigPath, 'utf-8');
 
   // Extract the outDir value using regex
   const outDirMatch = configContent.match(/outDir\s*:\s*['"`]([^'"`]+)['"`]/);
   if (!outDirMatch) {
-    throw new Error('Could not find outDir in vite.config.ts');
+    // Return default output directory if outDir configuration is not found in vite.config.ts
+    return DEFAULT_VITE_OUT_DIR;
   }
 
   let outDir = outDirMatch[1];
@@ -24,7 +36,7 @@ export async function getViteOutDir(rootDir: string): Promise<string> {
       outDir = outDir.replace('${outDir}', varMatch[1]);
     } else {
       // Default fallback
-      outDir = 'dist/.vite';
+      outDir = DEFAULT_VITE_VAR_DIR;
     }
   }
 

package/templates/project-tee-starter/src/index.ts

@@ -1,6 +1,7 @@
 import { logger, type IAgentRuntime, type Project, type ProjectAgent } from '@elizaos/core';
 import teeStarterPlugin, { StarterService } from './plugin.ts';
 import { mrTeeCharacter as character } from './character.ts';
+import ProjectTeeStarterTestSuite from './__tests__/e2e/project-tee-starter.e2e';
 
 const initCharacter = ({ runtime }: { runtime: IAgentRuntime }) => {
   logger.info(`Initializing character: ${character.name}`);
@@ -10,6 +11,7 @@ const initCharacter = ({ runtime }: { runtime: IAgentRuntime }) => {
 export const projectAgent: ProjectAgent = {
   character,
   init: async (runtime: IAgentRuntime) => await initCharacter({ runtime }),
+  tests: [ProjectTeeStarterTestSuite], // Export tests from ProjectAgent
 };
 
 const project: Project = {

package/templates/project-tee-starter/src/plugin.ts

@@ -119,6 +119,18 @@ const deriveEd25519Keypair = (deriveKeyResponse: DeriveKeyResponse): Keypair =>
   return Keypair.fromSeed(seedArray.slice(0, 32));
 };
 
+/**
+ * Checks if an error is a TEE connection error
+ * @param error The error to check
+ * @returns True if the error is a TEE connection error
+ */
+const isTeeConnectionError = (error: unknown): boolean => {
+  return (
+    error instanceof Error &&
+    (error.message.includes('ENOENT') || error.message.includes('Failed to connect'))
+  );
+};
+
 /**
  * Handles TEE key derivation and logging
  */
@@ -135,18 +147,18 @@ const handleTeeKeyDerivation = async (config: TeeServiceConfig): Promise<void> =
     const ed25519Keypair = deriveEd25519Keypair(deriveKeyResponse);
 
     logger.log('ECDSA Key Derived Successfully!');
-    logger.log('ECDSA Keypair:', ecdsaKeypair.address);
-    logger.log('ED25519 Keypair:', ed25519Keypair.publicKey);
+    logger.log({ address: ecdsaKeypair.address }, 'ECDSA Keypair:');
+    logger.log({ publicKey: ed25519Keypair.publicKey }, 'ED25519 Keypair:');
 
     const signature = await ecdsaKeypair.signMessage({ message: 'Hello, world!' });
-    logger.log('Sign message w/ ECDSA keypair: Hello world!, Signature: ', signature);
+    logger.log({ signature }, 'Sign message w/ ECDSA keypair: Hello world!, Signature:');
   } catch (error) {
     // Handle TEE connection errors gracefully
-    if (error instanceof Error && error.message.includes('ENOENT')) {
+    if (isTeeConnectionError(error)) {
       logger.warn('TEE daemon not available - running in non-TEE mode for testing');
       logger.warn('To run with TEE, ensure tappd is running at /var/run/tappd.sock');
     } else {
-      logger.error('Error connecting to TEE:', error);
+      logger.warn({ error }, 'TEE daemon connection failed, running in non-TEE mode:');
     }
     // Continue without TEE functionality for testing
   }
@@ -289,8 +301,8 @@ const teeStarterPlugin: Plugin = {
     MESSAGE_RECEIVED: [
       async (params) => {
         logger.info(
-          '[MR_TEE_PLUGIN] MESSAGE_RECEIVED event',
-          params.message?.content?.text?.substring(0, 50)
+          { preview: params.message?.content?.text?.substring(0, 50) },
+          '[MR_TEE_PLUGIN] MESSAGE_RECEIVED event'
         );
       },
     ],

package/dist/templates/plugin-starter/src/tests.ts

@@ -1,6 +0,0 @@
-/**
- * Test exports for the starter plugin
- * This file exports the test suite so it can be included in the plugin build
- */
-
-export { StarterPluginTestSuite } from './__tests__/e2e/starter-plugin';

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

@@ -1,14 +0,0 @@
-/**
- * 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/dist/templates/project-starter/src/__tests__/e2e/natural-language.test.ts

@@ -1,246 +0,0 @@
-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/dist/templates/project-starter/src/__tests__/e2e/project.test.ts

@@ -1,155 +0,0 @@
-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();