@elizaos/cli 1.3.2 → 1.4.2

package/{templates/project-tee-starter → dist/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/dist/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/dist/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/{utils-DBLSDYBF.js → utils-5HPZSIF6.js}

@@ -116,12 +116,12 @@ import {
   updateFile,
   validateGitHubToken,
   writeEnvFile
-} from "./chunk-E6XYTE3A.js";
+} from "./chunk-D3QSET5H.js";
 import {
   runBunCommand
-} from "./chunk-FDEDLANP.js";
+} from "./chunk-FQYWRHLX.js";
 import "./chunk-GXWWPFBO.js";
-import "./chunk-D3Q2UZLZ.js";
+import "./chunk-I4L4T7QX.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   ModuleLoader,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/cli",
-  "version": "1.3.2",
+  "version": "1.4.2",
   "description": "elizaOS CLI - Manage your AI agents and plugins",
   "publishConfig": {
     "access": "public",
@@ -73,15 +73,15 @@
     "typescript": "5.8.3",
     "vite": "^6.3.5"
   },
-  "gitHead": "c4e30a38836ac4bed81c671239377685892ebdf5",
+  "gitHead": "f60dd270910361decc4d4e879e8b2f33c5ddfee2",
   "dependencies": {
     "@anthropic-ai/claude-code": "^1.0.35",
     "@anthropic-ai/sdk": "^0.54.0",
     "@clack/prompts": "^0.11.0",
-    "@elizaos/api-client": "1.3.2",
-    "@elizaos/core": "1.3.2",
-    "@elizaos/plugin-sql": "1.3.2",
-    "@elizaos/server": "1.3.2",
+    "@elizaos/api-client": "1.4.2",
+    "@elizaos/core": "1.4.2",
+    "@elizaos/plugin-sql": "1.4.2",
+    "@elizaos/server": "1.4.2",
     "bun": "^1.2.17",
     "chalk": "^5.3.0",
     "chokidar": "^4.0.3",

package/templates/plugin-quick-starter/README.md

@@ -17,11 +17,13 @@ This quick-starter template is ideal for:
 ```
 plugin-quick-starter/
 ├── src/
-│   ├── __tests__/          # Unit tests
-│   │   ├── plugin.test.ts
-│   │   └── test-utils.ts
-│   ├── plugin.ts           # Main plugin implementation
-│   ├── tests.ts            # Plugin test suite
+│   ├── __tests__/          # Test directory
+│   │   ├── e2e/            # E2E tests
+│   │   │   ├── plugin-quick-starter.e2e.ts
+│   │   │   └── README.md
+│   │   ├── plugin.test.ts  # Component tests
+│   │   └── test-utils.ts   # Test utilities
+│   ├── plugin.ts           # Main plugin implementation (exports tests)
 │   └── index.ts            # Plugin export
 ├── scripts/
 │   └── install-test-deps.js # Test dependency installer
@@ -66,11 +68,11 @@ plugin-quick-starter/
 - No frontend frameworks or build tools
 - Fast installation and builds
 
-### Simple Testing
+### Comprehensive Testing
 
-- Unit tests only with Bun test runner
-- No E2E or component testing overhead
-- Quick test execution
+- Component tests with Bun test runner for unit testing
+- E2E tests with ElizaOS test runner for integration testing
+- Quick test execution with focused test suites
 
 ### Backend Focus
 
@@ -174,7 +176,47 @@ bun run format
 
 ## Testing
 
-Write unit tests in `src/__tests__/`:
+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
+
+### Test Structure
+
+```
+src/
+  __tests__/              # All tests live inside src
+    *.test.ts            # Component tests (use Bun test runner)
+    e2e/                 # E2E tests (use ElizaOS test runner)
+      plugin-quick-starter.e2e.ts  # E2E test suite
+      README.md          # E2E testing documentation
+  plugin.ts              # Export tests here: tests: [QuickStarterPluginTestSuite]
+```
+
+### Running Tests
+
+```bash
+# Run all tests (component + e2e)
+elizaos test
+
+# Component tests only
+elizaos test component
+# or
+bun test
+
+# E2E tests only
+elizaos test e2e
+```
+
+### Writing Component Tests
 
 ```typescript
 import { describe, it, expect } from 'bun:test';

package/templates/plugin-quick-starter/package.json

@@ -41,11 +41,11 @@
     "tsup.config.ts"
   ],
   "dependencies": {
-    "@elizaos/core": "1.3.2",
+    "@elizaos/core": "1.4.2",
     "zod": "^3.24.4"
   },
   "devDependencies": {
-    "@elizaos/cli": "1.3.2",
+    "@elizaos/cli": "1.4.2",
     "dotenv": "16.4.5",
     "prettier": "3.5.3",
     "tsup": "8.5.0",

package/templates/plugin-quick-starter/src/__tests__/e2e/README.md

@@ -0,0 +1,140 @@
+# E2E Tests for Plugin Quick Starter
+
+This directory contains end-to-end tests for the ElizaOS plugin quick 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 plugin's behavior as it would work in production. The quick starter template focuses on minimal, essential functionality to help you get started quickly.
+
+## Test Structure
+
+- **QuickStarterPluginTestSuite** - Main test suite containing all e2e tests
+  - `plugin_should_be_loaded` - Verifies plugin is loaded correctly
+  - `should_have_quick_action_registered` - Checks action registration
+  - `quick_action_should_execute_successfully` - Tests basic action execution
+  - `quick_provider_should_provide_data` - Tests provider functionality
+  - `quick_service_should_be_available` - Tests service availability (optional)
+  - `plugin_should_integrate_with_agent_correctly` - Tests agent integration
+  - `memory_operations_should_work_with_plugin` - Tests memory system integration
+  - `plugin_should_handle_errors_gracefully` - Tests error handling
+
+## Integration with Plugin
+
+E2E tests are integrated directly into your plugin without the need for an intermediate export file:
+
+```typescript
+// src/plugin.ts
+import { QuickStarterPluginTestSuite } from './__tests__/e2e/plugin-quick-starter.e2e';
+
+export const quickPlugin: Plugin = {
+  name: 'plugin-quick-starter',
+  // ... other properties
+  tests: [QuickStarterPluginTestSuite], // 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
+```
+
+## Quick Starter Specifics
+
+The quick starter template is designed for rapid prototyping with minimal boilerplate. Tests focus on:
+
+1. **Basic Functionality**: Core plugin features work correctly
+2. **Simple Integration**: Plugin integrates with the runtime
+3. **Essential Operations**: Memory and message processing work
+4. **Error Resilience**: Plugin handles errors gracefully
+
+## Implementation Details
+
+1. **Direct Import**: Tests are imported directly from the e2e test file
+2. **Plugin Integration**: The test suite is added to the plugin's `tests` array
+3. **Test Discovery**: The ElizaOS test runner automatically finds and executes tests
+4. **Runtime Access**: Each test receives a real runtime instance with full access to:
+   - Plugin actions, providers, and services
+   - Agent character configuration
+   - Database and model access
+
+## Writing New Tests
+
+When extending the quick starter plugin, add corresponding e2e tests:
+
+```typescript
+{
+  name: 'my_new_feature_test',
+  fn: async (runtime) => {
+    // Test your new feature
+    const feature = runtime.getFeature('my-feature');
+    if (!feature) {
+      throw new Error('My feature not loaded');
+    }
+
+    // Test feature behavior
+    const result = await feature.doSomething();
+    if (!result.success) {
+      throw new Error('Feature failed: ' + result.error);
+    }
+
+    console.log('✓ My feature works correctly');
+  }
+}
+```
+
+## Best Practices
+
+1. **Keep It Simple**: Quick starter tests should remain minimal and focused
+2. **Test Essentials**: Focus on core functionality that every plugin needs
+3. **Clear Messages**: Use descriptive error messages for easy debugging
+4. **Fast Feedback**: Tests should run quickly for rapid development
+5. **Incremental Testing**: Add tests as you add features to your plugin
+
+## Troubleshooting
+
+### Tests not running?
+
+- Ensure tests are exported in `plugin.ts`
+- Check that the plugin name matches in tests
+- Verify the ElizaOS test runner is up to date
+
+### Tests failing?
+
+- Check runtime initialization
+- Verify all required services are available
+- Ensure test data doesn't conflict with other tests
+
+## Next Steps
+
+1. Run the existing tests to ensure your setup works
+2. Modify tests as you customize the plugin
+3. Add new tests for your custom functionality
+4. Use TDD: write tests first, then implement features
+5. Keep tests focused and maintainable