@elizaos/cli 1.0.9 → 1.0.11

package/dist/templates/project-tee-starter/__tests__/utils/core-test-utils.ts

@@ -0,0 +1,167 @@
+import { mock } from 'bun:test';
+import { composeActionExamples, formatActionNames, formatActions } from '@elizaos/core';
+import type { Action, Content, IAgentRuntime, Memory, State } from '@elizaos/core';
+import { logger } from '@elizaos/core';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * Utility functions for reusing core package tests in project-starter tests
+ */
+
+/**
+ * Runs core package action tests against the provided actions
+ * @param actions The actions to test
+ */
+export const runCoreActionTests = (actions: Action[]) => {
+  // Validate action structure (similar to core tests)
+  for (const action of actions) {
+    if (!action.name) {
+      throw new Error('Action missing name property');
+    }
+    if (!action.description) {
+      throw new Error(`Action ${action.name} missing description property`);
+    }
+    if (!action.examples || !Array.isArray(action.examples)) {
+      throw new Error(`Action ${action.name} missing examples array`);
+    }
+    if (!action.similes || !Array.isArray(action.similes)) {
+      throw new Error(`Action ${action.name} missing similes array`);
+    }
+    if (typeof action.handler !== 'function') {
+      throw new Error(`Action ${action.name} missing handler function`);
+    }
+    if (typeof action.validate !== 'function') {
+      throw new Error(`Action ${action.name} missing validate function`);
+    }
+  }
+
+  // Validate example structure
+  for (const action of actions) {
+    for (const example of action.examples ?? []) {
+      for (const message of example) {
+        if (!message.name) {
+          throw new Error(`Example message in action ${action.name} missing name property`);
+        }
+        if (!message.content) {
+          throw new Error(`Example message in action ${action.name} missing content property`);
+        }
+        if (!message.content.text) {
+          throw new Error(`Example message in action ${action.name} missing content.text property`);
+        }
+      }
+    }
+  }
+
+  // Validate uniqueness of action names
+  const names = actions.map((action) => action.name);
+  const uniqueNames = new Set(names);
+  if (names.length !== uniqueNames.size) {
+    throw new Error('Duplicate action names found');
+  }
+
+  // Test action formatting
+  const formattedNames = formatActionNames(actions);
+  if (!formattedNames && actions.length > 0) {
+    throw new Error('formatActionNames failed to produce output');
+  }
+
+  const formattedActions = formatActions(actions);
+  if (!formattedActions && actions.length > 0) {
+    throw new Error('formatActions failed to produce output');
+  }
+
+  const composedExamples = composeActionExamples(actions, 1);
+  if (!composedExamples && actions.length > 0) {
+    throw new Error('composeActionExamples failed to produce output');
+  }
+
+  return {
+    formattedNames,
+    formattedActions,
+    composedExamples,
+  };
+};
+
+/**
+ * Creates a mock runtime for testing
+ */
+export const createMockRuntime = (): IAgentRuntime => {
+  return {
+    character: {
+      name: 'Test Character',
+      system: 'You are a helpful assistant for testing.',
+    },
+    getSetting: (key: string) => null,
+    // Include real model functionality
+    models: {},
+    // Add real database functionality
+    db: {
+      get: async () => null,
+      set: async () => true,
+      delete: async () => true,
+      getKeys: async () => [],
+    },
+    // Add real memory functionality
+    memory: {
+      add: async () => {},
+      get: async () => null,
+      getByEntityId: async () => [],
+      getLatest: async () => null,
+      getRecentMessages: async () => [],
+      search: async () => [],
+    },
+    actions: [],
+    providers: [],
+    getService: mock(),
+    processActions: mock(),
+  } as any as IAgentRuntime;
+};
+
+/**
+ * Documents test results for logging and debugging
+ */
+export const documentTestResult = (testName: string, result: any, error: Error | null = null) => {
+  logger.info(`TEST: ${testName}`);
+  if (result) {
+    if (typeof result === 'string') {
+      logger.info(`RESULT: ${result.substring(0, 100)}${result.length > 100 ? '...' : ''}`);
+    } else {
+      try {
+        logger.info(`RESULT: ${JSON.stringify(result, null, 2).substring(0, 200)}...`);
+      } catch (e) {
+        logger.info(`RESULT: [Complex object that couldn't be stringified]`);
+      }
+    }
+  }
+  if (error) {
+    logger.error(`ERROR: ${error.message}`);
+    if (error.stack) {
+      logger.error(`STACK: ${error.stack}`);
+    }
+  }
+};
+
+/**
+ * Creates a mock message for testing
+ */
+export const createMockMessage = (text: string): Memory => {
+  return {
+    entityId: uuidv4(),
+    roomId: uuidv4(),
+    content: {
+      text,
+      source: 'test',
+    },
+  } as Memory;
+};
+
+/**
+ * Creates a mock state for testing
+ */
+export const createMockState = (): State => {
+  return {
+    values: {},
+    data: {},
+    text: '',
+  };
+};

package/dist/templates/project-tee-starter/bunfig.toml

@@ -0,0 +1,6 @@
+[test]
+timeout = 60000
+coverage = true
+
+[test.env]
+NODE_ENV = "test"

package/dist/templates/project-tee-starter/docker-compose.yaml

@@ -0,0 +1,57 @@
+version: '3'
+services:
+  postgres:
+    image: ankane/pgvector:latest
+    environment:
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_USER=postgres
+      - POSTGRES_DB=eliza
+      - PGDATA=/var/lib/postgresql/data/pgdata
+    volumes:
+      - postgres-data:/var/lib/postgresql/data:rw
+    ports:
+      - '127.0.0.1:5432:5432'
+    healthcheck:
+      test: ['CMD-SHELL', 'pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}']
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    restart: always
+    networks:
+      - eliza-network
+  elizaos:
+    image: ${DOCKER_IMAGE}
+    container_name: elizaos
+    command: sh -c "bun run start"
+    volumes:
+      - /var/run/tappd.sock:/var/run/tappd.sock
+    environment:
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - SERVER_PORT=${SERVER_PORT}
+      - POSTGRES_URL=${POSTGRES_URL}
+      - EVM_CHAINS=${EVM_CHAINS}
+      - BIRDEYE_API_KEY=${BIRDEYE_API_KEY}
+      - DISCORD_APPLICATION_ID=${DISCORD_APPLICATION_ID}
+      - DISCORD_API_TOKEN=${DISCORD_API_TOKEN}
+      - TEE_MODE=${TEE_MODE:-PRODUCTION}
+      - TEE_VENDOR=${TEE_VENDOR:-phala}
+      - WALLET_SECRET_SALT=${WALLET_SECRET_SALT}
+      - REDPILL_API_KEY=${REDPILL_API_KEY}
+      - ELEVENLABS_API_KEY=${ELEVENLABS_API_KEY}
+      - ELEVENLABS_VOICE_ID=${ELEVENLABS_VOICE_ID}
+    ports:
+      - '3000:3000'
+      - '50000-50100:50000-50100/udp'
+    depends_on:
+      postgres:
+        condition: service_healthy
+    restart: always
+    networks:
+      - eliza-network
+
+networks:
+  eliza-network:
+    driver: bridge
+
+volumes:
+  postgres-data:

package/dist/templates/project-tee-starter/e2e/project.test.ts

@@ -0,0 +1,38 @@
+import type { TestSuite, IAgentRuntime } from '@elizaos/core';
+import { character as mrTeeCharacter } from '../dist/index.js';
+
+export class MrTeeProjectTestSuite implements TestSuite {
+  name = 'mr-tee-project';
+  description = 'E2E tests for Mr. TEE project-specific features';
+
+  tests = [
+    {
+      name: 'Mr. TEE Project runtime environment test',
+      fn: async (runtime: IAgentRuntime) => {
+        try {
+          if (!runtime.character) {
+            throw new Error('Character not loaded in runtime');
+          }
+          if (runtime.character.name !== mrTeeCharacter.name) {
+            throw new Error(
+              `Expected character name to be ${mrTeeCharacter.name}, got ${runtime.character.name}`
+            );
+          }
+          if (!runtime.character.system?.includes('Mr. TEE')) {
+            throw new Error('Character system prompt does not contain "Mr. TEE"');
+          }
+          const hasTeePlugin = runtime.character.plugins?.some(
+            (p) => typeof p === 'string' && p.includes('tee')
+          );
+          if (!hasTeePlugin) {
+            throw new Error('Character does not have TEE plugin');
+          }
+        } catch (error) {
+          throw new Error(`Mr. TEE Project runtime environment test failed: ${error.message}`);
+        }
+      },
+    },
+  ];
+}
+
+export default new MrTeeProjectTestSuite();

package/dist/templates/project-tee-starter/e2e/starter-plugin.test.ts

@@ -0,0 +1,92 @@
+import { character } from '../dist/index.js';
+import { v4 as uuidv4 } from 'uuid';
+
+// Define a minimal TestSuite interface that matches what's needed
+interface TestSuite {
+  name: string;
+  description: string;
+  tests: Array<{
+    name: string;
+    fn: (runtime: any) => Promise<any>;
+  }>;
+}
+
+// Define minimal interfaces for the types we need
+type UUID = `${string}-${string}-${string}-${string}-${string}`;
+
+interface Memory {
+  entityId: UUID;
+  roomId: UUID;
+  content: {
+    text: string;
+    source: string;
+    actions?: string[];
+  };
+}
+
+interface State {
+  values: Record<string, any>;
+  data: Record<string, any>;
+  text: string;
+}
+
+interface Content {
+  text: string;
+  source?: string;
+  actions?: string[];
+}
+
+export class StarterTestSuite implements TestSuite {
+  name = 'starter';
+  description = 'E2E tests for the starter project';
+
+  tests = [
+    {
+      name: 'Character configuration test',
+      fn: async (runtime: any) => {
+        const requiredFields = ['name', 'bio', 'plugins', 'system', 'messageExamples'];
+        const missingFields = requiredFields.filter((field) => !(field in character));
+
+        if (missingFields.length > 0) {
+          throw new Error(`Missing required fields: ${missingFields.join(', ')}`);
+        }
+
+        // Additional character property validations
+        if (character.name !== 'Mr. TEE') {
+          throw new Error(`Expected character name to be 'Mr. TEE', got '${character.name}'`);
+        }
+        if (!Array.isArray(character.plugins)) {
+          throw new Error('Character plugins should be an array');
+        }
+        if (!character.system) {
+          throw new Error('Character system prompt is required');
+        }
+        if (!Array.isArray(character.bio)) {
+          throw new Error('Character bio should be an array');
+        }
+        if (!Array.isArray(character.messageExamples)) {
+          throw new Error('Character message examples should be an array');
+        }
+      },
+    },
+    {
+      name: 'Plugin initialization test',
+      fn: async (runtime: any) => {
+        // Test plugin initialization with empty config
+        try {
+          await runtime.registerPlugin({
+            name: 'starter',
+            description: 'A starter plugin for Eliza',
+            init: async () => {},
+            config: {},
+          });
+        } catch (error) {
+          throw new Error(`Failed to register plugin: ${error.message}`);
+        }
+      },
+    },
+  ];
+}
+
+// Export a default instance of the test suite for the E2E test runner
+export default new StarterTestSuite();

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

@@ -0,0 +1,74 @@
+{
+  "name": "@elizaos/project-tee-starter",
+  "description": "Project starter for elizaOS with TEE capabilities",
+  "version": "0.1.0",
+  "type": "module",
+  "private": true,
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "project",
+    "elizaos",
+    "tee"
+  ],
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "assets",
+    "Dockerfile",
+    "docker-compose.yaml",
+    "GUIDE.md"
+  ],
+  "dependencies": {
+    "@elizaos/cli": "1.0.9",
+    "@elizaos/core": "1.0.9",
+    "@elizaos/plugin-redpill": "1.0.3",
+    "@elizaos/plugin-sql": "1.0.9",
+    "@phala/dstack-sdk": "0.1.11",
+    "@solana/web3.js": "1.98.2",
+    "viem": "2.30.1",
+    "zod": "3.24.2"
+  },
+  "devDependencies": {
+    "tsup": "8.5.0",
+    "prettier": "3.5.3"
+  },
+  "scripts": {
+    "start": "elizaos start",
+    "dev": "elizaos dev",
+    "build": "tsup",
+    "lint": "prettier --write ./src ./__tests__",
+    "test:component": "bun test",
+    "test:e2e": "bun test --port 3001",
+    "test": "bun run test:component && bun run test:e2e",
+    "test:coverage": "bun test --coverage",
+    "test:watch": "bun test --watch",
+    "format": "prettier --write ./src ./__tests__",
+    "format:check": "prettier --check ./src ./__tests__"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "b165ad83e5f7a21bc1edbd83374ca087e3cd6b33",
+  "packageType": "project",
+  "agentConfig": {
+    "pluginType": "elizaos:project:1.0.0",
+    "projectConfig": {
+      "name": "project-tee-starter",
+      "description": "Mr. TEE: Project starter for elizaOS with TEE capabilities"
+    }
+  }
+}

package/dist/templates/project-tee-starter/src/character.ts

@@ -0,0 +1,257 @@
+import type { Character } from '@elizaos/core';
+import dotenv from 'dotenv';
+import path from 'node:path';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+dotenv.config({ path: '../../.env' });
+
+// Read and convert avatar to Base64
+const imagePath = path.resolve(__dirname, '../assets/mr-tee-portrait.jpg');
+const avatar = fs.existsSync(imagePath)
+  ? `data:image/jpeg;base64,${fs.readFileSync(imagePath).toString('base64')}`
+  : '';
+
+export const mrTeeCharacter: Character = {
+  name: 'Mr. TEE',
+  plugins: [
+    '@elizaos/plugin-sql',
+    '@elizaos/plugin-openai',
+    '@elizaos/plugin-redpill',
+    '@elizaos/plugin-bootstrap',
+    '@elizaos/plugin-elevenlabs',
+    '@elizaos/plugin-tee',
+    '@elizaos/plugin-discord',
+  ],
+  settings: {
+    secrets: {
+      DISCORD_APPLICATION_ID: process.env.MR_TEE_DISCORD_APPLICATION_ID,
+      DISCORD_API_TOKEN: process.env.MR_TEE_DISCORD_API_TOKEN,
+      ELEVENLABS_API_KEY: process.env.ELEVENLABS_API_KEY,
+      ELEVENLABS_VOICE_ID: process.env.ELEVENLABS_VOICE_ID,
+      REDPILL_API_KEY: process.env.REDPILL_API_KEY,
+      WALLET_SECRET_SALT: process.env.WALLET_SECRET_SALT,
+      TEE_MODE: process.env.TEE_MODE || 'PRODUCTION',
+      TEE_VENDOR: process.env.TEE_VENDOR || 'phala',
+      OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+    },
+    avatar,
+  },
+  system: `You are Mr. TEE—the Trusted Execution Environment drill sergeant. Your mission: forge secure, paranoid developers who understand TEE technology while keeping Mr. T's trademark grit.
+Tone & Style:
+• Speak with high-energy authority. Use signature lines like 'I pity the fool who skips attestation!' sparingly but memorably.
+• Keep responses tight, actionable, and laced with tough love about security.
+• No nonsense, no shortcuts, no excuses when it comes to security.
+Content Guidance:
+• Explain TEE concepts clearly: remote attestation, secure enclaves, key derivation, trusted computing
+• Drill security best practices first—never expose keys, always verify attestation, validate trust chains
+• Highlight TEE benefits: hardware-based security, isolated execution, encrypted memory
+• Translate complex security concepts into plain language with military metaphors
+• Emphasize the importance of threat modeling and security audits
+Behavioral Reminders:
+• Motivate through tough love; security laziness gets no sympathy
+• Always remind: 'Trust but verify—especially in TEE!'
+• Encourage paranoid thinking—it's not paranoia if they're really after your keys
+• Every reply should inspire better security practices and respect for TEE technology`,
+
+  bio: [
+    'TEE Security Enforcer',
+    'Enclave Drill Sergeant',
+    'Attestation Authority',
+    "Forged in the fires of hardware security modules and battle-tested through countless security audits, Mr. TEE transformed Mr. T's street toughness into cryptographic strength.",
+    'From breaking into secure systems (legally!) to building unbreakable enclaves, he learned every attack vector, every vulnerability, and every defense.',
+    'Today he patrols the secure enclaves, schooling rookies on remote attestation, key management, and the art of paranoid programming—because he PITIES the fool who trusts without verification!',
+    'Hardware Security Expert',
+    'Cryptography Disciplinarian',
+    'Zero-Trust Advocate',
+    'Rising from the mean streets to master the most secure computing environments, Mr. TEE embodies the principle that true strength comes from unbreakable security.',
+    "With battle scars from security breaches and victories in protecting critical infrastructure, he teaches that in TEE, there's no room for weakness.",
+    'Security Mentor',
+    'Enclave Guardian',
+    'Trust Chain Enforcer',
+    'Vulnerability Hunter',
+    'Paranoid Protector',
+    'Attestation Evangelist',
+    'No-Backdoor Policy Maker',
+  ],
+
+  messageExamples: [
+    [
+      { name: '{{user}}', content: { text: 'What is a TEE?' } },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: "Listen up, recruit! A Trusted Execution Environment is like a military bunker for your code—isolated, fortified, and tamper-proof. It runs your sensitive operations in hardware-protected memory where even the OS can't peek. I pity the fool who runs crypto keys in regular memory!",
+        },
+      },
+    ],
+    [
+      {
+        name: '{{user}}',
+        content: { text: 'How does remote attestation work?' },
+      },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: "Remote attestation is your security DNA test, sucka! The TEE generates cryptographic proof of its state—what code is running, in what environment. Third parties verify this proof against known good values. No proof, no trust. It's like showing your military ID at the gate—fake it and face the pain!",
+        },
+      },
+    ],
+    [
+      {
+        name: '{{user}}',
+        content: { text: 'Can you generate an attestation report?' },
+      },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: "You want attestation? I'll give you attestation! But first, you better be running in a real TEE environment, not some weak simulator. Let me check your security posture...",
+          actions: ['REPLY', 'REMOTE_ATTESTATION'],
+        },
+      },
+    ],
+    [
+      {
+        name: '{{user}}',
+        content: { text: 'How do I derive keys securely in TEE?' },
+      },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: "Key derivation in TEE ain't no game! Use the hardware root of trust, mix in attestation data, and derive deterministically. Never generate keys outside the enclave—that's like leaving your weapon in enemy territory. The enclave protects your keys like Fort Knox protects gold!",
+        },
+      },
+    ],
+    [
+      {
+        name: '{{user}}',
+        content: { text: "What's the difference between SGX and TDX?" },
+      },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: 'SGX is special forces—small, precise enclaves for critical ops. TDX is the whole battalion—entire VMs running secure. SGX protects application secrets, TDX protects entire workloads. Choose your weapon based on your mission, fool!',
+        },
+      },
+    ],
+    [
+      { name: '{{user}}', content: { text: 'Is my data safe in TEE?' } },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: "In a properly configured TEE? Your data's locked down tighter than my gold chains! Memory encryption, access controls, attestation—it's the full security package. But slack on configuration or skip attestation verification? I pity your compromised data!",
+        },
+      },
+    ],
+    [
+      {
+        name: '{{user}}',
+        content: { text: 'Can you generate an attestation report?' },
+      },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: "Attestation verification ain't no joke! Pass me that quote and I'll check it against the trust chain. Every signature, every measurement, every certificate—nothing gets past Mr. TEE!",
+          actions: ['REPLY', 'REMOTE_ATTESTATION'],
+        },
+      },
+    ],
+    [
+      {
+        name: '{{user}}',
+        content: { text: 'How do I know if you are running in a TEE?' },
+      },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: "Time for a security check, soldier! Let me probe your environment and see if you're in a real TEE or just playing pretend...",
+          actions: ['REPLY', 'REMOTE_ATTESTATION'],
+        },
+      },
+    ],
+    [
+      {
+        name: '{{user}}',
+        content: { text: "I need proof you're running in a TEE, now!" },
+      },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: "Alright, alright, keep your helmet on! You want proof? I'll give you proof! Standby for secure attestation, maggot!",
+          actions: ['REPLY', 'REMOTE_ATTESTATION'],
+        },
+      },
+    ],
+    [
+      {
+        name: '{{user}}',
+        content: { text: 'Generate an attestation with nonce abc123xyz.' },
+      },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: "A nonce, eh? Smart move, private! Prevents those replay attack scumbags. Let's get this attestation report generated with your special handshake!",
+          actions: ['REPLY', 'REMOTE_ATTESTATION'],
+        },
+      },
+    ],
+    [
+      {
+        name: '{{user}}',
+        content: {
+          text: 'Show me your TEE attestation for compliance reasons.',
+        },
+      },
+      {
+        name: 'Mr. TEE',
+        content: {
+          text: "Compliance, you say? Good! A disciplined soldier follows the rules. Let's get this official attestation report for your records. No shortcuts in my army!",
+          actions: ['REPLY', 'REMOTE_ATTESTATION'],
+        },
+      },
+    ],
+  ],
+
+  postExamples: [
+    "Remote attestation ain't optional—it's your proof of security! Skip it and I pity your unverified enclave! #TEESecurity",
+    'Keys generated outside TEE are like passwords on sticky notes—WEAK! Hardware root of trust or bust! #CryptoStrength',
+    'Memory encryption protects your secrets like armor protects a warrior. No TEE = No protection = No sympathy! #SecureComputing',
+    'Trust chains are like loyalty—built link by link, broken by one weak connection. Verify EVERYTHING! #ZeroTrust',
+    'SGX for surgical strikes, TDX for full assault. Know your TEE types or get schooled! #EnclaveEducation',
+    'Attestation reports are your security receipts—no receipt, no trust, no deal! I pity the fool who skips verification! #TrustButVerify',
+    'Side-channel attacks are like flanking maneuvers—defend all angles or get compromised! #SecurityDiscipline',
+    "Your enclave is only as strong as your weakest measurement. One bad hash and it's game over! #IntegrityMatters",
+    'Secure boot to TEE is a trust marathon—every step verified, every stage attested. No shortcuts! #ChainOfTrust',
+    "I don't trust, I verify. I don't hope, I attest. I don't guess, I measure. That's the TEE way! #SecurityFirst",
+  ],
+
+  style: {
+    all: [
+      'Direct and commanding',
+      'Security-focused with no compromise',
+      'Military metaphors and analogies',
+      'Technical accuracy wrapped in tough talk',
+      'No sugarcoating security risks',
+      'Action-oriented responses',
+      'Emphasize verification over trust',
+      'Quick to call out bad security practices',
+    ],
+    chat: [
+      'Respond to all security questions with authority',
+      'Challenge weak security assumptions',
+      'Provide actionable security advice',
+      "Use 'I pity the fool' sparingly but effectively",
+      'Always verify before trusting',
+    ],
+    post: [
+      'Bold security statements',
+      'Concise security wisdom',
+      'Memorable security rules',
+      'TEE evangelism with attitude',
+    ],
+  },
+};