@elizaos/cli 1.0.2 → 1.0.3

package/templates/project-tee-starter/__tests__/character.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from 'vitest';
+import { mrTeeCharacter as character } from '../src/character';
+import * as dotenv from 'dotenv';
+import * as path from 'node:path';
+
+dotenv.config({ path: path.resolve(__dirname, '../../.env') });
+
+describe('Mr. TEE Character Configuration', () => {
+  it('should have all required fields for Mr. TEE', () => {
+    expect(character).toBeDefined();
+    expect(character.name).toBe('Mr. TEE');
+    expect(character.plugins).toBeDefined();
+    expect(character.settings).toBeDefined();
+    expect(character.system).toBeDefined();
+    expect(character.bio).toBeDefined();
+    expect(character.messageExamples).toBeDefined();
+    expect(character.postExamples).toBeDefined();
+    expect(character.style).toBeDefined();
+    expect(character.settings?.avatar).toContain('data:image/jpeg;base64');
+    expect(character.settings).toHaveProperty('secrets');
+  });
+
+  it('should include TEE specific plugins', () => {
+    expect(character.plugins).toContain('@elizaos/plugin-tee');
+    expect(character.plugins).toContain('@elizaos/plugin-sql');
+    expect(character.plugins).toContain('@elizaos/plugin-openai');
+    expect(character.plugins).toContain('@elizaos/plugin-discord');
+    expect(character.plugins).toContain('@elizaos/plugin-bootstrap');
+  });
+
+  it("should have a system prompt embodying Mr. TEE's persona", () => {
+    expect(character.system).toContain('Mr. TEE');
+    expect(character.system).toContain('drill sergeant');
+    expect(character.system).toContain('Trusted Execution Environment');
+    expect(character.system).toContain('I pity the fool');
+  });
+
+  it("should have bio entries reflecting Mr. TEE's background", () => {
+    const bioText = Array.isArray(character.bio) ? character.bio.join(' ').toLowerCase() : '';
+    expect(bioText).toContain('tee security enforcer');
+    expect(bioText).toContain('attestation authority');
+    expect(bioText).toContain('hardware security');
+  });
+
+  it('should have TEE-related message examples', () => {
+    let foundTeeExample = false;
+    for (const ex of character.messageExamples) {
+      const dialogue = ex.map((msg) => msg.content.text.toLowerCase()).join(' ');
+      if (
+        dialogue.includes('attestation') ||
+        dialogue.includes('enclave') ||
+        dialogue.includes('tee')
+      ) {
+        foundTeeExample = true;
+        const mrTeeResponse = ex.find((msg) => msg.name === 'Mr. TEE');
+        expect(mrTeeResponse).toBeDefined();
+        if (mrTeeResponse) {
+          expect(mrTeeResponse.content.text.length).toBeGreaterThan(10);
+          if (mrTeeResponse.content.actions) {
+            expect(Array.isArray(mrTeeResponse.content.actions)).toBe(true);
+          }
+        }
+        break;
+      }
+    }
+    expect(foundTeeExample, 'Expected at least one TEE-related message example').toBe(true);
+  });
+
+  it('should have TEE-related post examples', () => {
+    const postText = character.postExamples?.join(' ').toLowerCase() || '';
+    expect(postText).toContain('#teesecurity');
+    expect(postText).toContain('enclave');
+    expect(postText).toContain('attestation');
+  });
+
+  it('should have specific style guidelines for Mr. TEE', () => {
+    expect(character.style?.all).toContain('Direct and commanding');
+    expect(character.style?.chat).toContain('Respond to all security questions with authority');
+    expect(character.style?.post).toContain('TEE evangelism with attitude');
+  });
+
+  it('should have TEE related settings in secrets', () => {
+    expect(character.settings?.secrets).toHaveProperty('TEE_MODE');
+    expect(character.settings?.secrets).toHaveProperty('TEE_VENDOR');
+  });
+});

package/templates/project-tee-starter/__tests__/config.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import teeStarterPlugin from '../src/plugin';
+
+describe('Plugin Configuration', () => {
+  it('should not have custom configuration (relies on character settings)', () => {
+    // Our plugin has config properties for TEE_MODE and WALLET_SECRET_SALT
+    expect(teeStarterPlugin.config).toBeDefined();
+    expect(teeStarterPlugin.config?.TEE_MODE).toBe(process.env.TEE_MODE);
+    expect(teeStarterPlugin.config?.WALLET_SECRET_SALT).toBe(process.env.WALLET_SECRET_SALT);
+    expect(teeStarterPlugin.init).toBeDefined();
+  });
+
+  it('should have correct plugin metadata', () => {
+    expect(teeStarterPlugin).toBeDefined();
+    expect(teeStarterPlugin.name).toBe('mr-tee-starter-plugin');
+    expect(teeStarterPlugin.description).toBe(
+      "Mr. TEE's starter plugin - using plugin-tee for attestation"
+    );
+  });
+
+  it('should be a minimal plugin focused on character definition', () => {
+    // Verify arrays exist but are empty (except routes and events)
+    expect(teeStarterPlugin.actions).toEqual([]);
+    expect(teeStarterPlugin.providers).toEqual([]);
+    expect(teeStarterPlugin.evaluators).toBeUndefined();
+    expect(teeStarterPlugin.services).toEqual([]);
+    expect(teeStarterPlugin.routes).toBeDefined();
+    expect(teeStarterPlugin.routes?.length).toBeGreaterThan(0);
+    expect(teeStarterPlugin.events).toBeDefined();
+  });
+});

package/templates/project-tee-starter/__tests__/env.test.ts

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+describe('Environment Setup', () => {
+  it('should verify configuration files exist', () => {
+    const requiredFiles = [
+      'package.json',
+      'tsconfig.json',
+      'tsconfig.build.json',
+      'tsup.config.ts',
+      'vitest.config.ts',
+    ];
+
+    for (const file of requiredFiles) {
+      const filePath = path.join(process.cwd(), file);
+      expect(fs.existsSync(filePath)).toBe(true);
+    }
+  });
+
+  it('should have proper src directory structure', () => {
+    const srcDir = path.join(process.cwd(), 'src');
+    expect(fs.existsSync(srcDir)).toBe(true);
+
+    const requiredSrcFiles = ['index.ts', 'plugin.ts'];
+
+    for (const file of requiredSrcFiles) {
+      const filePath = path.join(srcDir, file);
+      expect(fs.existsSync(filePath)).toBe(true);
+    }
+  });
+
+  it('should have a valid package.json with required fields', () => {
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    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('version');
+    expect(packageJson).toHaveProperty('type', 'module');
+    expect(packageJson).toHaveProperty('main');
+    expect(packageJson).toHaveProperty('module');
+    expect(packageJson).toHaveProperty('types');
+    expect(packageJson).toHaveProperty('dependencies');
+    expect(packageJson).toHaveProperty('devDependencies');
+    expect(packageJson).toHaveProperty('scripts');
+
+    // Check for required dependencies
+    expect(packageJson.dependencies).toHaveProperty('@elizaos/core');
+
+    // Check for required scripts
+    expect(packageJson.scripts).toHaveProperty('build');
+    expect(packageJson.scripts).toHaveProperty('test');
+  });
+
+  it('should have a valid tsconfig.json with required configuration', () => {
+    const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+    expect(fs.existsSync(tsconfigPath)).toBe(true);
+
+    const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, 'utf8'));
+    expect(tsconfig).toHaveProperty('compilerOptions');
+
+    // Check compiler options
+    expect(tsconfig.compilerOptions).toHaveProperty('target');
+    expect(tsconfig.compilerOptions).toHaveProperty('module');
+    expect(tsconfig.compilerOptions).toHaveProperty('moduleResolution');
+    expect(tsconfig.compilerOptions).toHaveProperty('esModuleInterop');
+  });
+
+  it('should have a valid tsup.config.ts for building', () => {
+    const tsupConfigPath = path.join(process.cwd(), 'tsup.config.ts');
+    expect(fs.existsSync(tsupConfigPath)).toBe(true);
+
+    const tsupConfig = fs.readFileSync(tsupConfigPath, 'utf8');
+    expect(tsupConfig).toContain('defineConfig');
+    expect(tsupConfig).toContain('entry:');
+    expect(tsupConfig).toContain('src/index.ts');
+  });
+
+  it('should have a valid README.md file', () => {
+    const readmePath = path.join(process.cwd(), 'README.md');
+    expect(fs.existsSync(readmePath)).toBe(true);
+
+    const readme = fs.readFileSync(readmePath, 'utf8');
+    expect(readme).toContain('# Project Starter');
+  });
+});

package/templates/project-tee-starter/__tests__/error-handling.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import teeStarterPlugin from '../src/plugin';
+import { mrTeeCharacter } from '../src/character';
+
+describe('Error Handling', () => {
+  describe('Plugin Error Handling', () => {
+    it('should handle missing dependencies gracefully', () => {
+      // Our plugin has no dependencies, so it should always be valid
+      expect(teeStarterPlugin).toBeDefined();
+      expect(teeStarterPlugin.actions).toEqual([]);
+      expect(teeStarterPlugin.providers).toEqual([]);
+    });
+
+    it('should handle runtime errors gracefully', async () => {
+      // Test that the plugin can be used even without initialization
+      expect(teeStarterPlugin.name).toBe('mr-tee-starter-plugin');
+      expect(teeStarterPlugin.description).toBe(
+        "Mr. TEE's starter plugin - using plugin-tee for attestation"
+      );
+    });
+  });
+
+  describe('Character Error Handling', () => {
+    it('should have valid character configuration', () => {
+      expect(mrTeeCharacter).toBeDefined();
+      expect(mrTeeCharacter.name).toBe('Mr. TEE');
+      expect(mrTeeCharacter.plugins).toContain('@elizaos/plugin-tee');
+    });
+  });
+});

package/templates/project-tee-starter/__tests__/events.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import teeStarterPlugin from '../src/plugin';
+
+describe('Plugin Events', () => {
+  it('should not have custom events (relies on plugin-tee for TEE events)', () => {
+    // Our plugin actually has events defined for logging
+    expect(teeStarterPlugin.events).toBeDefined();
+    expect(teeStarterPlugin.events?.MESSAGE_RECEIVED).toBeDefined();
+    expect(teeStarterPlugin.events?.VOICE_MESSAGE_RECEIVED).toBeDefined();
+    expect(teeStarterPlugin.events?.WORLD_CONNECTED).toBeDefined();
+    expect(teeStarterPlugin.events?.WORLD_JOINED).toBeDefined();
+  });
+
+  it('should have correct plugin configuration', () => {
+    expect(teeStarterPlugin).toBeDefined();
+    expect(teeStarterPlugin.name).toBe('mr-tee-starter-plugin');
+    expect(teeStarterPlugin.description).toBe(
+      "Mr. TEE's starter plugin - using plugin-tee for attestation"
+    );
+  });
+});

package/templates/project-tee-starter/__tests__/file-structure.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { logger } from '@elizaos/core';
+
+// Helper function to check if a file exists
+function fileExists(filePath: string): boolean {
+  return fs.existsSync(filePath);
+}
+
+// Helper function to check if a directory exists
+function directoryExists(dirPath: string): boolean {
+  return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+}
+
+describe('Project Structure Validation', () => {
+  const rootDir = path.resolve(__dirname, '..');
+
+  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);
+    });
+
+    it('should have a dist directory after building', () => {
+      // This test assumes the build has been run before testing
+      expect(directoryExists(path.join(rootDir, 'dist'))).toBe(true);
+    });
+  });
+
+  describe('Source Files', () => {
+    it('should contain the required source files', () => {
+      expect(fileExists(path.join(rootDir, 'src', 'index.ts'))).toBe(true);
+      expect(fileExists(path.join(rootDir, 'src', 'plugin.ts'))).toBe(true);
+    });
+
+    it('should have properly structured main files', () => {
+      // Check index.ts contains character definition
+      const indexContent = fs.readFileSync(path.join(rootDir, 'src', 'index.ts'), 'utf8');
+      expect(indexContent).toContain('character');
+      expect(indexContent).toContain('plugin');
+
+      // Check plugin.ts contains plugin definition
+      const pluginContent = fs.readFileSync(path.join(rootDir, 'src', 'plugin.ts'), 'utf8');
+      expect(pluginContent).toContain('export default');
+      expect(pluginContent).toContain('actions');
+    });
+  });
+
+  describe('Configuration Files', () => {
+    it('should have the required configuration files', () => {
+      expect(fileExists(path.join(rootDir, 'package.json'))).toBe(true);
+      expect(fileExists(path.join(rootDir, 'tsconfig.json'))).toBe(true);
+      expect(fileExists(path.join(rootDir, 'tsconfig.build.json'))).toBe(true);
+      expect(fileExists(path.join(rootDir, 'tsup.config.ts'))).toBe(true);
+      expect(fileExists(path.join(rootDir, 'vitest.config.ts'))).toBe(true);
+    });
+
+    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 scripts
+      expect(packageJson.scripts).toHaveProperty('build');
+      expect(packageJson.scripts).toHaveProperty('test');
+      expect(packageJson.scripts).toHaveProperty('test:coverage');
+
+      // Check dependencies
+      expect(packageJson.dependencies).toHaveProperty('@elizaos/core');
+
+      // Check dev dependencies - adjusted for actual dev dependencies
+      expect(packageJson.devDependencies).toBeTruthy();
+      expect(packageJson.devDependencies).toHaveProperty('vitest');
+      expect(packageJson.devDependencies).toHaveProperty('tsup');
+    });
+
+    it('should have proper TypeScript configuration', () => {
+      const tsConfig = JSON.parse(fs.readFileSync(path.join(rootDir, 'tsconfig.json'), 'utf8'));
+
+      // Check essential compiler options
+      expect(tsConfig).toHaveProperty('compilerOptions');
+      expect(tsConfig.compilerOptions).toHaveProperty('target');
+      expect(tsConfig.compilerOptions).toHaveProperty('module');
+
+      // Check paths inclusion
+      expect(tsConfig).toHaveProperty('include');
+    });
+  });
+
+  describe('Build Output', () => {
+    it('should check for expected build output structure', () => {
+      // Instead of checking specific files, check that the dist directory exists
+      // and contains at least some files
+      if (directoryExists(path.join(rootDir, 'dist'))) {
+        const files = fs.readdirSync(path.join(rootDir, 'dist'));
+        expect(files.length).toBeGreaterThan(0);
+
+        // Check for common output patterns rather than specific files
+        const hasJsFiles = files.some((file) => file.endsWith('.js'));
+        expect(hasJsFiles).toBe(true);
+      } else {
+        // Skip test if dist directory doesn't exist yet
+        logger.warn('Dist directory not found, skipping build output tests');
+      }
+    });
+
+    it('should verify the build process can be executed', () => {
+      // Check that the build script exists in package.json
+      const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+      expect(packageJson.scripts).toHaveProperty('build');
+
+      // Check that tsup.config.ts exists and contains proper configuration
+      const tsupConfig = fs.readFileSync(path.join(rootDir, 'tsup.config.ts'), 'utf8');
+      expect(tsupConfig).toContain('export default');
+      expect(tsupConfig).toContain('entry');
+    });
+  });
+
+  describe('Documentation', () => {
+    it('should have README files', () => {
+      expect(fileExists(path.join(rootDir, 'README.md'))).toBe(true);
+    });
+
+    it('should have appropriate documentation content', () => {
+      const readmeContent = fs.readFileSync(path.join(rootDir, 'README.md'), 'utf8');
+      expect(readmeContent).toContain('Project Starter');
+
+      // Testing key sections exist without requiring specific keywords
+      expect(readmeContent).toContain('Development');
+      expect(readmeContent).toContain('Testing');
+    });
+  });
+});

package/templates/project-tee-starter/__tests__/integration.test.ts

@@ -0,0 +1,209 @@
+import { describe, expect, it, vi, beforeAll, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { logger, IAgentRuntime, Plugin } from '@elizaos/core';
+import { character } from '../src/index';
+import plugin from '../src/plugin';
+import { createMockRuntime } from './test-utils';
+import * as os from 'os';
+
+// Set up spies on logger
+beforeAll(() => {
+  vi.spyOn(logger, 'info').mockImplementation(() => {});
+  vi.spyOn(logger, 'error').mockImplementation(() => {});
+  vi.spyOn(logger, 'warn').mockImplementation(() => {});
+  vi.spyOn(logger, 'debug').mockImplementation(() => {});
+});
+
+afterAll(() => {
+  vi.restoreAllMocks();
+});
+
+// Skip in CI environments or when running automated tests without interaction
+const isCI = Boolean(process.env.CI) || process.env.NODE_ENV === 'test';
+
+/**
+ * Integration tests demonstrate how multiple components of the project work together.
+ * Unlike unit tests that test individual functions in isolation, integration tests
+ * examine how components interact with each other.
+ */
+describe('Integration: Project Structure and Components', () => {
+  it('should have a valid package structure', () => {
+    const srcDir = path.join(process.cwd(), 'src');
+    expect(fs.existsSync(srcDir)).toBe(true);
+
+    // Check for required source files - only checking core files
+    const srcFiles = [path.join(srcDir, 'index.ts'), path.join(srcDir, 'plugin.ts')];
+
+    srcFiles.forEach((file) => {
+      expect(fs.existsSync(file)).toBe(true);
+    });
+  });
+
+  it('should have dist directory for build outputs', () => {
+    const distDir = path.join(process.cwd(), 'dist');
+
+    // Skip directory content validation if dist doesn't exist yet
+    if (!fs.existsSync(distDir)) {
+      logger.warn('Dist directory does not exist yet. Build the project first.');
+      return;
+    }
+
+    expect(fs.existsSync(distDir)).toBe(true);
+  });
+});
+
+describe('Integration: Character and Plugin', () => {
+  it('should have character with required properties', () => {
+    // Verify character has required properties
+    expect(character).toHaveProperty('name');
+    expect(character).toHaveProperty('plugins');
+    expect(character).toHaveProperty('bio');
+    expect(character).toHaveProperty('system');
+    expect(character).toHaveProperty('messageExamples');
+
+    // Verify plugins is an array
+    expect(Array.isArray(character.plugins)).toBe(true);
+  });
+
+  it('should configure plugin correctly', () => {
+    // Verify plugin has necessary components that character will use
+    expect(plugin).toHaveProperty('name');
+    expect(plugin).toHaveProperty('description');
+    expect(plugin).toHaveProperty('init');
+
+    // Check if plugin has actions, models, providers, etc. that character might use
+    const components = ['models', 'actions', 'providers', 'services', 'routes', 'events'];
+    components.forEach((component) => {
+      if (plugin[component]) {
+        // Just verify if these exist, we don't need to test their functionality here
+        // Those tests belong in plugin.test.ts, actions.test.ts, etc.
+        expect(
+          Array.isArray(plugin[component]) || typeof plugin[component] === 'object'
+        ).toBeTruthy();
+      }
+    });
+  });
+});
+
+describe('Integration: Runtime Initialization', () => {
+  it('should create a mock runtime with character and plugin', async () => {
+    // Create a custom mock runtime for this test
+    const customMockRuntime = {
+      character: { ...character },
+      plugins: [],
+      registerPlugin: vi.fn().mockImplementation((plugin: Plugin) => {
+        // In a real runtime, registering the plugin would call its init method,
+        // but since we're testing init itself, we just need to record the call
+        return Promise.resolve();
+      }),
+      initialize: vi.fn(),
+      getService: vi.fn(),
+      getSetting: vi.fn().mockReturnValue(null),
+      useModel: vi.fn().mockResolvedValue('Test model response'),
+      getProviderResults: vi.fn().mockResolvedValue([]),
+      evaluateProviders: vi.fn().mockResolvedValue([]),
+      evaluate: vi.fn().mockResolvedValue([]),
+    } as unknown as IAgentRuntime;
+
+    // Ensure we're testing safely - to avoid parallel test race conditions
+    const originalInit = plugin.init;
+    let initCalled = false;
+
+    // Mock the plugin.init method using vi.fn instead of direct assignment
+    if (plugin.init) {
+      plugin.init = vi.fn(async (config, runtime) => {
+        // Set flag to indicate our wrapper was called
+        initCalled = true;
+
+        // Call original if it exists
+        if (originalInit) {
+          await originalInit(config, runtime);
+        }
+
+        // Register plugin
+        await runtime.registerPlugin(plugin);
+      });
+    }
+
+    try {
+      // Initialize plugin in runtime
+      if (plugin.init) {
+        await plugin.init({ EXAMPLE_PLUGIN_VARIABLE: 'test-value' }, customMockRuntime);
+      }
+
+      // Verify our wrapper was called
+      expect(initCalled).toBe(true);
+
+      // Check if registerPlugin was called
+      expect(customMockRuntime.registerPlugin).toHaveBeenCalled();
+    } catch (error) {
+      console.error('Error initializing plugin:', error);
+      throw error;
+    } finally {
+      // Restore the original init method to avoid affecting other tests
+      plugin.init = originalInit;
+    }
+  });
+});
+
+// Skip scaffolding tests in CI environments as they modify the filesystem
+const describeScaffolding = isCI ? describe.skip : describe;
+describeScaffolding('Integration: Project Scaffolding', () => {
+  // Create a temp directory for testing the scaffolding
+  const TEST_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'eliza-test-'));
+
+  beforeAll(() => {
+    // Create test directory if it doesn't exist
+    if (!fs.existsSync(TEST_DIR)) {
+      fs.mkdirSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  afterAll(() => {
+    // Clean up test directory
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  it('should scaffold a new project correctly', () => {
+    try {
+      // This is a simple simulation of the scaffolding process
+      // In a real scenario, you'd use the CLI or API to scaffold
+
+      // Copy essential files to test directory
+      const srcFiles = ['index.ts', 'plugin.ts', 'character.ts'];
+
+      for (const file of srcFiles) {
+        const sourceFilePath = path.join(process.cwd(), 'src', file);
+        const targetFilePath = path.join(TEST_DIR, file);
+
+        if (fs.existsSync(sourceFilePath)) {
+          fs.copyFileSync(sourceFilePath, targetFilePath);
+        }
+      }
+
+      // Create package.json in test directory
+      const packageJson = {
+        name: 'test-project',
+        version: '1.0.0',
+        type: 'module',
+        dependencies: {
+          '@elizaos/core': 'workspace:*',
+        },
+      };
+
+      fs.writeFileSync(path.join(TEST_DIR, 'package.json'), JSON.stringify(packageJson, null, 2));
+
+      // Verify files exist
+      expect(fs.existsSync(path.join(TEST_DIR, 'index.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(TEST_DIR, 'plugin.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(TEST_DIR, 'character.ts'))).toBe(true);
+      expect(fs.existsSync(path.join(TEST_DIR, 'package.json'))).toBe(true);
+    } catch (error) {
+      logger.error('Error in scaffolding test:', error);
+      throw error;
+    }
+  });
+});

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

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import teeStarterPlugin from '../src/plugin';
+
+describe('Plugin Models', () => {
+  it('should not have custom models (using plugin-tee and other plugins for model handling)', () => {
+    // Our simplified plugin doesn't define custom models
+    // Model handling is done by other plugins (openai, etc.)
+    expect(teeStarterPlugin.models).toBeUndefined();
+  });
+
+  it('should rely on other plugins for model functionality', () => {
+    // Verify the plugin is configured correctly
+    expect(teeStarterPlugin.name).toBe('mr-tee-starter-plugin');
+    expect(teeStarterPlugin.description).toBe(
+      "Mr. TEE's starter plugin - using plugin-tee for attestation"
+    );
+
+    // Model functionality comes from character plugins
+    expect(teeStarterPlugin.actions).toEqual([]);
+    expect(teeStarterPlugin.providers).toEqual([]);
+  });
+});

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

@@ -0,0 +1,44 @@
+import { describe, it, expect, vi } from 'vitest';
+import teeStarterPlugin from '../src/plugin';
+import { logger } from '@elizaos/core';
+
+// Spy on logger to capture logs
+vi.spyOn(logger, 'info');
+vi.spyOn(logger, 'error');
+vi.spyOn(logger, 'warn');
+
+// Mock the character import to avoid file system dependencies
+vi.mock('../src/character', () => ({
+  mrTeeCharacter: {
+    name: 'Mr. TEE',
+    plugins: ['@elizaos/plugin-tee'],
+  },
+}));
+
+describe('TEE Starter Plugin', () => {
+  it('should have the correct name', () => {
+    expect(teeStarterPlugin.name).toBe('mr-tee-starter-plugin');
+  });
+
+  it('should have the correct description', () => {
+    expect(teeStarterPlugin.description).toBe(
+      "Mr. TEE's starter plugin - using plugin-tee for attestation"
+    );
+  });
+
+  it('should have no custom actions (using plugin-tee instead)', () => {
+    expect(teeStarterPlugin.actions).toEqual([]);
+  });
+
+  it('should have no custom providers', () => {
+    expect(teeStarterPlugin.providers).toEqual([]);
+  });
+
+  it('should have no custom evaluators', () => {
+    expect(teeStarterPlugin.evaluators).toBeUndefined();
+  });
+
+  it('should have no custom services', () => {
+    expect(teeStarterPlugin.services).toEqual([]);
+  });
+});