@elizaos/cli 1.3.2 → 1.4.3

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

@@ -0,0 +1,280 @@
+import {
+  type Content,
+  type HandlerCallback,
+  type IAgentRuntime,
+  type Memory,
+  type UUID,
+  ChannelType,
+  logger,
+} from '@elizaos/core';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * E2E Test Suite for Project TEE Starter
+ * ======================================
+ *
+ * This test suite validates TEE (Trusted Execution Environment) specific functionality
+ * while gracefully handling non-TEE environments where tests are expected to fail.
+ *
+ * TEST CATEGORIES:
+ * ---------------
+ * 1. ALWAYS PASS: Basic project setup tests that work in any environment
+ * 2. TEE-OPTIONAL: Tests that check for TEE features but pass with warnings if unavailable
+ * 3. TEE-REQUIRED: Tests that only pass in actual TEE environments (skip otherwise)
+ *
+ * ENVIRONMENT DETECTION:
+ * ---------------------
+ * Tests detect TEE availability by checking:
+ * - TEE service registration
+ * - TEE-specific environment variables
+ * - Embedding model availability
+ * - Database schema completeness
+ */
+
+interface TestCase {
+  name: string;
+  category?: 'always-pass' | 'tee-optional' | 'tee-required';
+  fn: (runtime: IAgentRuntime) => Promise<void>;
+}
+
+export class ProjectTeeStarterTestSuite {
+  name = 'Project TEE Starter E2E Tests';
+  description = 'E2E tests for TEE-specific project features with graceful fallbacks';
+
+  // Helper to detect TEE environment
+  private async detectTeeEnvironment(runtime: IAgentRuntime): Promise<{
+    hasService: boolean;
+    hasEndpoint: boolean;
+    hasEmbeddings: boolean;
+    isFullTee: boolean;
+  }> {
+    const teeService = runtime.getService('tee') || runtime.getService('mr-tee-service');
+    const hasEndpoint = !!runtime.getSetting('TEE_ATTESTATION_ENDPOINT');
+
+    // Check for embedding capability
+    let hasEmbeddings = false;
+    try {
+      // Check if embedding model is available via service
+      const embeddingService = runtime.getService('embedding');
+      hasEmbeddings = !!embeddingService;
+    } catch {
+      hasEmbeddings = false;
+    }
+
+    return {
+      hasService: !!teeService,
+      hasEndpoint,
+      hasEmbeddings,
+      isFullTee: !!teeService && hasEndpoint && hasEmbeddings,
+    };
+  }
+
+  tests: TestCase[] = [
+    // ALWAYS PASS: Basic project validation
+    {
+      name: 'tee_project_should_initialize_correctly',
+      category: 'always-pass',
+      fn: async (runtime: IAgentRuntime) => {
+        if (!runtime.agentId) {
+          throw new Error('Agent ID is not set');
+        }
+
+        logger.info(`✓ TEE Project initialized with agent ID: ${runtime.agentId}`);
+      },
+    },
+
+    {
+      name: 'tee_character_should_be_loaded_correctly',
+      category: 'always-pass',
+      fn: async (runtime: IAgentRuntime) => {
+        if (!runtime.character.name) {
+          throw new Error('Character name is not set');
+        }
+
+        if (!runtime.character.bio || runtime.character.bio.length === 0) {
+          throw new Error('Character bio is not set');
+        }
+
+        logger.info(`✓ TEE Character "${runtime.character.name}" loaded successfully`);
+      },
+    },
+
+    // TEE-OPTIONAL: Features that may or may not be available
+    {
+      name: 'tee_service_availability_check',
+      category: 'tee-optional',
+      fn: async (runtime: IAgentRuntime) => {
+        const env = await this.detectTeeEnvironment(runtime);
+
+        if (env.hasService) {
+          logger.info('✓ TEE service is available and registered');
+        } else {
+          logger.info('⚠ TEE service not available (expected in non-TEE environments)');
+        }
+
+        // This test always passes - it's just informational
+      },
+    },
+
+    {
+      name: 'tee_configuration_check',
+      category: 'tee-optional',
+      fn: async (runtime: IAgentRuntime) => {
+        const env = await this.detectTeeEnvironment(runtime);
+        const plugins = runtime.character.plugins || [];
+        const teePlugins = plugins.filter(
+          (p) => p.toLowerCase().includes('tee') || p.toLowerCase().includes('attestation')
+        );
+
+        logger.info(`✓ Found ${teePlugins.length} TEE-related plugins: ${teePlugins.join(', ')}`);
+        logger.info(`✓ TEE mode configured: ${env.isFullTee ? 'FULL' : 'OFF'}`);
+
+        if (!env.hasEndpoint) {
+          logger.info('⚠ TEE_ATTESTATION_ENDPOINT not configured (expected in development)');
+        }
+      },
+    },
+
+    {
+      name: 'tee_plugin_integration_check',
+      category: 'tee-optional',
+      fn: async (runtime: IAgentRuntime) => {
+        const plugins = runtime.character.plugins || [];
+        const hasTeePlugin = plugins.some(
+          (p) => p.toLowerCase().includes('tee') || p === 'mr-tee-starter-plugin'
+        );
+
+        if (hasTeePlugin) {
+          logger.info('✓ TEE plugin is loaded in character configuration');
+        } else {
+          logger.info('⚠ No TEE plugin in character configuration');
+        }
+      },
+    },
+
+    // TEE-REQUIRED: Tests that only work in full TEE environments
+    {
+      name: 'secure_attestation_flow',
+      category: 'tee-required',
+      fn: async (runtime: IAgentRuntime) => {
+        const env = await this.detectTeeEnvironment(runtime);
+
+        if (!env.isFullTee) {
+          logger.info('⚠ Skipping attestation test (requires full TEE environment)');
+          return;
+        }
+
+        // Test attestation action availability
+        const attestationAction = runtime.actions.find((a) =>
+          a.name.toLowerCase().includes('attest')
+        );
+
+        if (!attestationAction) {
+          throw new Error('Attestation action not found in TEE environment');
+        }
+
+        logger.info('✓ Attestation flow validated');
+      },
+    },
+
+    {
+      name: 'secure_memory_operations_with_embeddings',
+      category: 'tee-required',
+      fn: async (runtime: IAgentRuntime) => {
+        const env = await this.detectTeeEnvironment(runtime);
+
+        if (!env.hasEmbeddings) {
+          logger.info('⚠ Skipping embedding test (requires embedding model)');
+          return;
+        }
+
+        try {
+          const testContent = 'Secure TEE test message';
+
+          // Create a test memory with content
+          const testMemory: Memory = {
+            id: uuidv4() as UUID,
+            entityId: uuidv4() as UUID,
+            agentId: runtime.agentId,
+            roomId: uuidv4() as UUID,
+            content: {
+              text: testContent,
+              action: null,
+            } as Content,
+            createdAt: Date.now(),
+            embedding: [], // Would be populated by embedding service
+          };
+
+          await runtime.createMemory(testMemory, 'messages', false);
+          logger.info('✓ Secure memory operations with embeddings working');
+        } catch (error) {
+          logger.info(`⚠ Embedding test failed: ${error.message}`);
+        }
+      },
+    },
+
+    {
+      name: 'tee_agent_message_processing',
+      category: 'tee-required',
+      fn: async (runtime: IAgentRuntime) => {
+        const env = await this.detectTeeEnvironment(runtime);
+
+        if (!env.isFullTee) {
+          logger.info('⚠ Skipping message processing test (requires full TEE environment)');
+          return;
+        }
+
+        try {
+          const testMessage: Memory = {
+            id: uuidv4() as UUID,
+            entityId: uuidv4() as UUID,
+            agentId: runtime.agentId,
+            roomId: uuidv4() as UUID,
+            content: {
+              text: 'Test TEE secure message processing',
+              action: null,
+            } as Content,
+            createdAt: Date.now(),
+            embedding: [],
+          };
+
+          await runtime.createMemory(testMessage, 'messages', false);
+          logger.info('✓ TEE message processing completed');
+        } catch (error) {
+          logger.info(`⚠ Message processing test failed: ${error.message}`);
+        }
+      },
+    },
+
+    // Database connectivity test (handles schema differences)
+    {
+      name: 'database_connectivity_and_schema',
+      category: 'tee-optional',
+      fn: async (runtime: IAgentRuntime) => {
+        try {
+          // Try a simple query that should work regardless of schema
+          const testRoomId = uuidv4() as UUID;
+          const memories = await runtime.getMemories({
+            roomId: testRoomId,
+            count: 1,
+            tableName: 'messages',
+          });
+
+          logger.info('✓ Database connection is working');
+        } catch (error) {
+          // Check if it's a schema issue
+          if (error.message?.includes('embeddings.dim_384')) {
+            logger.info(
+              '⚠ Database schema missing embedding columns (expected without embedding model)'
+            );
+          } else {
+            logger.info(`⚠ Database test failed: ${error.message}`);
+          }
+        }
+      },
+    },
+  ];
+}
+
+// Export the test suite for the test runner
+export default new ProjectTeeStarterTestSuite();

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

@@ -4,7 +4,7 @@ import { describe, expect, it } from 'bun:test';
 import { fileURLToPath } from 'node:url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const projectRoot = path.resolve(__dirname, '..');
+const projectRoot = path.resolve(__dirname, '..', '..');
 
 describe('Environment Setup', () => {
   it('should verify configuration files exist', () => {

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'bun:test';
-import teeStarterPlugin from '../src/plugin';
-import { mrTeeCharacter } from '../src/character';
+import teeStarterPlugin from '../plugin';
+import { mrTeeCharacter } from '../character';
 
 describe('Error Handling', () => {
   describe('Plugin Error Handling', () => {

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'bun:test';
-import teeStarterPlugin from '../src/plugin';
+import teeStarterPlugin from '../plugin';
 
 describe('Plugin Events', () => {
   it('should not have custom events (relies on plugin-tee for TEE events)', () => {

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

@@ -15,7 +15,7 @@ function directoryExists(dirPath: string): boolean {
 }
 
 describe('Project Structure Validation', () => {
-  const rootDir = path.resolve(__dirname, '..');
+  const rootDir = path.resolve(__dirname, '..', '..');
   const distDir = path.join(rootDir, 'dist');
 
   beforeAll(async () => {
@@ -29,7 +29,7 @@ describe('Project Structure Validation', () => {
   describe('Directory Structure', () => {
     it('should have the expected directory structure', () => {
       expect(directoryExists(path.join(rootDir, 'src'))).toBe(true);
-      expect(directoryExists(path.join(rootDir, '__tests__'))).toBe(true);
+      expect(directoryExists(path.join(rootDir, 'src', '__tests__'))).toBe(true);
     });
 
     it('should have a dist directory after building', () => {

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

@@ -2,8 +2,8 @@ import { describe, expect, it, spyOn, beforeAll, afterAll } from 'bun:test';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { logger, IAgentRuntime, Plugin } from '@elizaos/core';
-import { character } from '../src/index';
-import plugin from '../src/plugin';
+import { character } from '../index';
+import plugin from '../plugin';
 import { createMockRuntime } from './test-utils';
 import * as os from 'node:os';
 

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'bun:test';
-import teeStarterPlugin from '../src/plugin';
+import teeStarterPlugin from '../plugin';
 
 describe('Plugin Models', () => {
   it('should not have custom models (using plugin-tee and other plugins for model handling)', () => {

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, spyOn, mock } from 'bun:test';
-import teeStarterPlugin from '../src/plugin';
+import teeStarterPlugin from '../plugin';
 import { logger } from '@elizaos/core';
 
 // Spy on logger to capture logs

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

@@ -1,10 +1,10 @@
 import { describe, expect, it, spyOn, beforeAll, afterAll } from 'bun:test';
-import plugin from '../src/plugin';
+import plugin from '../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';
+import teeStarterPlugin from '../plugin';
 
 // Setup environment variables
 dotenv.config();

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'bun:test';
-import teeStarterPlugin from '../src/plugin';
+import teeStarterPlugin from '../plugin';
 
 describe('Plugin Routes', () => {
   it('should have TEE-specific routes for status and frontend', () => {

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

@@ -10,7 +10,7 @@ const mockLogger = {
 };
 
 // We'll test the validation logic by importing the plugin and testing its init method
-import teeStarterPlugin from '../src/plugin';
+import teeStarterPlugin from '../plugin';
 
 // Mock runtime for testing
 const mockRuntime = {} as IAgentRuntime;

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

@@ -7,8 +7,8 @@ import {
   documentTestResult,
   runCoreActionTests,
 } from './utils/core-test-utils';
-import { mrTeeCharacter } from '../src/character';
-import plugin from '../src/plugin';
+import { mrTeeCharacter } from '../character';
+import plugin from '../plugin';
 
 /**
  * Creates an enhanced mock runtime for testing that includes the project's

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
   }
@@ -201,34 +213,36 @@ export class StarterService extends Service {
 const teeStarterPlugin: Plugin = {
   name: 'mr-tee-starter-plugin',
   description: "Mr. TEE's starter plugin - using plugin-tee for attestation",
-  config: {
-    TEE_MODE: process.env.TEE_MODE,
-    TEE_VENDOR: process.env.TEE_VENDOR,
-    WALLET_SECRET_SALT: process.env.WALLET_SECRET_SALT,
-  },
+  // Use dynamic getters so tests/CI always see current env values
+  config: Object.defineProperties(
+    {},
+    {
+      TEE_MODE: {
+        get: () => process.env.TEE_MODE,
+        enumerable: true,
+      },
+      TEE_VENDOR: {
+        get: () => process.env.TEE_VENDOR,
+        enumerable: true,
+      },
+      WALLET_SECRET_SALT: {
+        get: () => process.env.WALLET_SECRET_SALT,
+        enumerable: true,
+      },
+    }
+  ) as Record<string, string>,
   async init(config: Record<string, string>, runtime: IAgentRuntime) {
     logger.info('*** Initializing Mr. TEE plugin ***');
     try {
       // Merge process.env values with config, config takes precedence
-      const mergedConfig = {
+      const rawConfig = {
         TEE_MODE: config.TEE_MODE ?? process.env.TEE_MODE,
         TEE_VENDOR: config.TEE_VENDOR ?? process.env.TEE_VENDOR,
         WALLET_SECRET_SALT: config.WALLET_SECRET_SALT ?? process.env.WALLET_SECRET_SALT,
       };
 
-      // Apply test defaults if in test environment
-      const isTestEnvironment = process.env.NODE_ENV === 'test' || process.argv.includes('test');
-
-      if (isTestEnvironment) {
-        // Apply test-only defaults - NEVER use these in production
-        mergedConfig.TEE_MODE = mergedConfig.TEE_MODE || 'OFF';
-        mergedConfig.TEE_VENDOR = mergedConfig.TEE_VENDOR || 'phala';
-        // Test salt - this is ONLY for test environments and should NEVER be used in production
-        mergedConfig.WALLET_SECRET_SALT =
-          mergedConfig.WALLET_SECRET_SALT || 'test_default_salt_12345';
-      }
-
-      const validatedConfig = await configSchema.parseAsync(mergedConfig);
+      // Parse and validate configuration with schema (includes test defaults)
+      const validatedConfig = configSchema.parse(rawConfig);
 
       // Production safety check - ensure test defaults aren't used in production
       if (
@@ -289,8 +303,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;