@elizaos/cli 1.3.2 → 1.4.3

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

@@ -57,7 +57,7 @@ const runCoreModelTests = async (
     expect(typeof basicResponse).toBe('string');
   } catch (e) {
     basicError = e as Error;
-    logger.error(`${modelType} model call failed:`, e);
+    logger.error({ error: e }, `${modelType} model call failed:`);
   }
 
   // Test with empty prompt
@@ -72,7 +72,7 @@ const runCoreModelTests = async (
     emptyResponse = await modelFn(mockRuntime, emptyParams);
   } catch (e) {
     emptyError = e as Error;
-    logger.error(`${modelType} empty prompt test failed:`, e);
+    logger.error({ error: e }, `${modelType} empty prompt test failed:`);
   }
 
   // Test with all parameters
@@ -92,7 +92,7 @@ const runCoreModelTests = async (
     fullResponse = await modelFn(mockRuntime, fullParams);
   } catch (e) {
     fullError = e as Error;
-    logger.error(`${modelType} all parameters test failed:`, e);
+    logger.error({ error: e }, `${modelType} all parameters test failed:`);
   }
 
   return {

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

@@ -137,7 +137,7 @@ describe('Plugin Configuration', () => {
         expect(true).toBe(true); // If we got here, init succeeded
       } catch (e) {
         error = e as Error;
-        logger.error('Plugin initialization error:', e);
+        logger.error({ error: e }, 'Plugin initialization error:');
       }
 
       documentTestResult(
@@ -256,7 +256,7 @@ describe('StarterService', () => {
       expect(typeof startResult.stop).toBe('function');
     } catch (e) {
       error = e as Error;
-      logger.error('Service start error:', e);
+      logger.error({ error: e }, 'Service start error:');
     }
 
     documentTestResult(
@@ -316,7 +316,7 @@ describe('StarterService', () => {
       expect(stopSpy).toHaveBeenCalled();
     } catch (e) {
       error = e as Error;
-      logger.error('Service stop error:', e);
+      logger.error({ error: e }, 'Service stop error:');
     }
 
     documentTestResult(

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

@@ -213,7 +213,7 @@ describe('Provider Tests', () => {
           }
         } catch (e) {
           error = e as Error;
-          logger.error('Error in provider.get:', e);
+          logger.error({ error: e }, 'Error in provider.get:');
         }
 
         documentTestResult('Provider get method', result, error);
@@ -249,7 +249,7 @@ describe('Provider Tests', () => {
           logger.info('Provider handled invalid input without throwing');
         } catch (e) {
           error = e as Error;
-          logger.error('Provider threw an error with invalid input:', e);
+          logger.error({ error: e }, 'Provider threw an error with invalid input:');
         }
 
         documentTestResult('Provider error handling', result, error);

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

@@ -1,23 +1,24 @@
 import { logger, type IAgentRuntime, type Project, type ProjectAgent } from '@elizaos/core';
 import starterPlugin from './plugin.ts';
 import { character } from './character.ts';
+import { ProjectStarterTestSuite } from './__tests__/e2e/project-starter.e2e';
 
 const initCharacter = ({ runtime }: { runtime: IAgentRuntime }) => {
   logger.info('Initializing character');
-  logger.info('Name: ', character.name);
+  logger.info({ name: character.name }, 'Name:');
 };
 
 export const projectAgent: ProjectAgent = {
   character,
   init: async (runtime: IAgentRuntime) => await initCharacter({ runtime }),
   // plugins: [starterPlugin], <-- Import custom plugins here
+  tests: [ProjectStarterTestSuite], // Export tests from ProjectAgent
 };
+
 const project: Project = {
   agents: [projectAgent],
 };
 
-// Export test suites for the test runner
-export { testSuites } from './__tests__/e2e';
 export { character } from './character.ts';
 
 export default project;

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

@@ -95,7 +95,7 @@ const helloWorldAction: Action = {
         success: true,
       };
     } catch (error) {
-      logger.error('Error in HELLO_WORLD action:', error);
+      logger.error({ error }, 'Error in HELLO_WORLD action:');
 
       return {
         text: 'Failed to send hello world greeting',
@@ -248,28 +248,28 @@ const plugin: Plugin = {
       async (params) => {
         logger.info('MESSAGE_RECEIVED event received');
         // print the keys
-        logger.info(Object.keys(params));
+        logger.info({ keys: Object.keys(params) }, 'MESSAGE_RECEIVED param keys');
       },
     ],
     VOICE_MESSAGE_RECEIVED: [
       async (params) => {
         logger.info('VOICE_MESSAGE_RECEIVED event received');
         // print the keys
-        logger.info(Object.keys(params));
+        logger.info({ keys: Object.keys(params) }, 'VOICE_MESSAGE_RECEIVED param keys');
       },
     ],
     WORLD_CONNECTED: [
       async (params) => {
         logger.info('WORLD_CONNECTED event received');
         // print the keys
-        logger.info(Object.keys(params));
+        logger.info({ keys: Object.keys(params) }, 'WORLD_CONNECTED param keys');
       },
     ],
     WORLD_JOINED: [
       async (params) => {
         logger.info('WORLD_JOINED event received');
         // print the keys
-        logger.info(Object.keys(params));
+        logger.info({ keys: Object.keys(params) }, 'WORLD_JOINED param keys');
       },
     ],
   },

package/templates/project-tee-starter/README.md

@@ -104,17 +104,56 @@ project-tee-starter/
 
 ## 🧪 Testing
 
+ElizaOS employs a dual testing strategy:
+
+1. **Component Tests** (`src/__tests__/*.test.ts`)
+
+   - Run with Bun's native test runner
+   - Fast, isolated tests using mocks
+   - Perfect for TDD and component logic
+
+2. **E2E Tests** (`src/__tests__/e2e/*.e2e.ts`)
+   - Run with ElizaOS custom test runner
+   - Real runtime with actual database (PGLite)
+   - Test complete user scenarios including TEE functionality
+
+### Test Structure
+
+```
+src/
+  __tests__/              # All tests live inside src
+    *.test.ts            # Component tests (use Bun test runner)
+    e2e/                 # E2E tests (use ElizaOS test runner)
+      project-tee-starter.e2e.ts  # E2E test suite with TEE-specific tests
+      README.md          # E2E testing documentation
+  index.ts               # Export tests here: tests: [ProjectTeeStarterTestSuite]
+```
+
+### Running Tests
+
 ```bash
-# Run all tests
-bun test
+# Run all tests (component + e2e)
+elizaos test
 
 # Component tests only
-bun test:component
+elizaos test component
+
+# E2E tests only
+elizaos test e2e
 
-# E2E tests
-bun test:e2e
+# With specific port for E2E tests
+elizaos test --port 4000
 ```
 
+### TEE-Specific Testing
+
+The E2E tests include TEE-specific scenarios:
+
+- TEE service availability checks
+- Attestation action registration
+- Secure memory operations
+- Concurrent secure operations handling
+
 ## 🚀 Deployment
 
 ### Local Development

package/templates/project-tee-starter/package.json

@@ -33,11 +33,11 @@
     "GUIDE.md"
   ],
   "dependencies": {
-    "@elizaos/cli": "1.3.2",
-    "@elizaos/core": "1.3.2",
-    "@elizaos/plugin-bootstrap": "1.3.2",
+    "@elizaos/cli": "1.4.3",
+    "@elizaos/core": "1.4.3",
+    "@elizaos/plugin-bootstrap": "1.4.3",
     "@elizaos/plugin-redpill": "1.2.1",
-    "@elizaos/plugin-sql": "1.3.2",
+    "@elizaos/plugin-sql": "1.4.3",
     "@phala/dstack-sdk": "0.1.11",
     "@solana/web3.js": "1.98.2",
     "@tanstack/react-query": "^5.29.0",

package/templates/project-tee-starter/{__tests__ → src/__tests__}/build-order.test.ts

@@ -5,7 +5,7 @@ import { $ } from 'bun';
 import { getViteOutDir } from './vite-config-utils';
 
 describe('Build Order Integration Test', () => {
-  const rootDir = path.resolve(__dirname, '..');
+  const rootDir = path.resolve(__dirname, '..', '..');
   const distDir = path.join(rootDir, 'dist');
   let viteBuildDir: string;
   const tsupBuildMarker = path.join(distDir, 'index.js'); // TSup creates this

package/{dist/templates/project-tee-starter → templates/project-tee-starter/src}/__tests__/character.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test';
-import { mrTeeCharacter as character } from '../src/character';
+import { mrTeeCharacter as character } from '../character';
 import dotenv from 'dotenv';
 import * as path from 'node:path';
 

package/templates/project-tee-starter/{__tests__ → src/__tests__}/config.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'bun:test';
-import teeStarterPlugin from '../src/plugin';
+import teeStarterPlugin from '../plugin';
 
 describe('Plugin Configuration', () => {
   it('should not have custom configuration (relies on character settings)', () => {
@@ -18,6 +18,46 @@ describe('Plugin Configuration', () => {
     );
   });
 
+  it('should parse and validate config during initialization', async () => {
+    // Mock runtime for testing
+    const mockRuntime = {
+      logger: {
+        info: () => {},
+        warn: () => {},
+        debug: () => {},
+        error: () => {},
+      },
+    } as any;
+
+    // Test that config parsing happens during init, not at import time
+    const originalEnv = {
+      NODE_ENV: process.env.NODE_ENV,
+      TEE_MODE: process.env.TEE_MODE,
+      WALLET_SECRET_SALT: process.env.WALLET_SECRET_SALT,
+    };
+
+    try {
+      // Set test environment with valid defaults
+      process.env.NODE_ENV = 'test';
+      process.env.TEE_MODE = 'OFF';
+      process.env.WALLET_SECRET_SALT = 'test_salt_12345';
+
+      // Config should be parsed and validated during init without throwing
+      await expect(teeStarterPlugin.init({}, mockRuntime)).resolves.toBeUndefined();
+
+      // Test with invalid config should fail validation during init
+      const invalidConfig = { TEE_MODE: 'INVALID_MODE' };
+      await expect(teeStarterPlugin.init(invalidConfig, mockRuntime)).rejects.toThrow(
+        'Invalid plugin configuration'
+      );
+    } finally {
+      // Restore original environment
+      process.env.NODE_ENV = originalEnv.NODE_ENV;
+      process.env.TEE_MODE = originalEnv.TEE_MODE;
+      process.env.WALLET_SECRET_SALT = originalEnv.WALLET_SECRET_SALT;
+    }
+  });
+
   it('should be a TEE-focused plugin with appropriate components', () => {
     // Verify plugin has TEE-specific components
     expect(teeStarterPlugin.actions).toEqual([]);

package/templates/project-tee-starter/src/__tests__/e2e/README.md

@@ -0,0 +1,128 @@
+# E2E Tests for Project TEE Starter
+
+This directory contains end-to-end tests for the ElizaOS project TEE (Trusted Execution Environment) starter template.
+
+## ElizaOS Testing Philosophy
+
+ElizaOS employs a dual testing strategy:
+
+1. **Component Tests** (`src/__tests__/*.test.ts`)
+
+   - Run with Bun's native test runner
+   - Fast, isolated tests using mocks
+   - Perfect for TDD and component logic
+   - Command: `bun test`
+
+2. **E2E Tests** (`src/__tests__/e2e/*.e2e.ts`)
+   - Run with ElizaOS custom test runner
+   - Real runtime with actual database (PGLite)
+   - Test complete user scenarios
+   - Command: `elizaos test --type e2e`
+
+## Overview
+
+E2E tests run in a real ElizaOS runtime environment, allowing you to test your TEE-enabled project's behavior as it would work in production. These tests include validation of TEE-specific functionality such as attestation, secure operations, and cryptographic features.
+
+## Test Structure
+
+- **ProjectTeeStarterTestSuite** - Main test suite containing all e2e tests
+  - `tee_project_should_initialize_correctly` - Verifies TEE project and runtime initialization
+  - `tee_character_should_be_loaded_correctly` - Checks character configuration including TEE settings
+  - `tee_service_should_be_available` - Tests TEE service registration and availability
+  - `tee_attestation_action_should_be_registered` - Validates TEE-specific actions
+  - `agent_should_respond_with_tee_awareness` - Tests agent's understanding of TEE capabilities
+  - `secure_memory_operations_should_work` - Validates secure data handling
+  - `tee_plugin_integration_should_work` - Tests TEE plugin integration
+  - `concurrent_secure_operations_should_be_handled` - Tests concurrent secure operations
+  - `tee_configuration_should_be_valid` - Validates TEE-specific configuration
+
+## Integration with Project
+
+E2E tests are integrated directly into your project through the main index.ts file:
+
+```typescript
+// src/index.ts
+import { ProjectTeeStarterTestSuite } from './__tests__/e2e/project-tee-starter.e2e';
+
+export const project: Project = {
+  agents: [projectAgent],
+  tests: [ProjectTeeStarterTestSuite], // Direct import!
+};
+```
+
+## Running Tests
+
+```bash
+# Run all tests (component + e2e)
+elizaos test
+
+# Run only e2e tests (slower, full integration)
+elizaos test --type e2e
+
+# Run only component tests (fast, for TDD)
+bun test
+# or
+elizaos test --type component
+```
+
+## TEE-Specific Testing Considerations
+
+### Development Environment
+
+- TEE hardware features may not be available in development
+- Tests gracefully handle missing TEE services with warnings
+- Mock TEE services can be used for development testing
+
+### Production Environment
+
+- Full TEE capabilities should be available
+- Attestation endpoints should be configured
+- Secure key storage should be operational
+
+### Configuration
+
+TEE-specific environment variables:
+
+- `TEE_MODE`: Enable/disable TEE mode
+- `TEE_ATTESTATION_ENDPOINT`: Attestation service endpoint
+- `TEE_PROVIDER`: TEE provider (e.g., 'phala', 'sgx')
+
+## Implementation Details
+
+1. **Direct Import**: Tests are imported directly from the e2e test file
+2. **Project Integration**: The test suite is added to the project's `tests` array
+3. **TEE Detection**: Tests detect and adapt to TEE availability
+4. **Secure Operations**: Tests validate secure data handling and cryptographic operations
+5. **Runtime Access**: Each test receives a real runtime instance with full access to:
+   - TEE services and attestation
+   - Secure memory operations
+   - Cryptographic functions
+   - All standard ElizaOS features
+
+## Key Differences from Standard Project Tests
+
+- **Export Location**: Tests are exported from the `ProjectAgent` in `src/index.ts` (not directly from `Project`)
+- **TEE Service Testing**: Additional tests for TEE service availability
+- **Attestation Validation**: Tests for attestation generation and verification
+- **Secure Operations**: Validation of secure data handling
+- **Hardware Adaptation**: Tests adapt to TEE hardware availability
+- **Cryptographic Features**: Testing of signing and verification operations
+
+## Writing New Tests
+
+See the comprehensive documentation at the top of `project-tee-starter.e2e.ts` for detailed instructions on adding new tests.
+
+## Best Practices
+
+1. **Hardware Independence**: Write tests that work with or without TEE hardware
+2. **Security Validation**: Test security features without exposing sensitive data
+3. **Attestation Mocking**: Use mock attestation in development environments
+4. **Error Handling**: Test both successful and failed secure operations
+5. **Configuration Testing**: Validate all TEE-specific configuration options
+
+## Known Considerations
+
+- TEE features may require specific hardware or cloud environments
+- Some cryptographic operations may be simulated in development
+- Attestation verification requires connection to attestation services
+- Performance characteristics may differ between TEE and non-TEE environments