@elizaos/cli 1.3.1 → 1.4.2

package/dist/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/dist/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', () => {
@@ -39,7 +39,8 @@ describe('Environment Setup', () => {
     expect(fs.existsSync(packageJsonPath)).toBe(true);
 
     const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-    expect(packageJson).toHaveProperty('name', '@elizaos/project-tee-starter');
+    expect(packageJson).toHaveProperty('name');
+    expect(typeof packageJson.name).toBe('string');
     expect(packageJson).toHaveProperty('version');
     expect(packageJson).toHaveProperty('type', 'module');
     expect(packageJson).toHaveProperty('main');

package/{templates/project-tee-starter → dist/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/{templates/project-tee-starter → dist/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/{templates/project-tee-starter → dist/templates/project-tee-starter/src}/__tests__/file-structure.test.ts

@@ -1,6 +1,7 @@
-import { describe, expect, it } from 'bun:test';
+import { describe, expect, it, beforeAll } from 'bun:test';
 import fs from 'node:fs';
 import path from 'node:path';
+import { $ } from 'bun';
 import { logger } from '@elizaos/core';
 
 // Helper function to check if a file exists
@@ -14,12 +15,21 @@ 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 () => {
+    // Build the project if dist doesn't exist
+    if (!fs.existsSync(distDir)) {
+      console.log('Building project for tests...');
+      await $`cd ${rootDir} && bun run build`;
+    }
+  });
 
   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', () => {
@@ -59,8 +69,9 @@ describe('Project Structure Validation', () => {
     it('should have the correct package.json configuration', () => {
       const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
 
-      // Check package name
-      expect(packageJson.name).toBe('@elizaos/project-tee-starter');
+      // Check package name - should be valid (not checking exact name since it's dynamic in created projects)
+      expect(packageJson.name).toBeTruthy();
+      expect(typeof packageJson.name).toBe('string');
 
       // Check scripts
       expect(packageJson.scripts).toHaveProperty('build');