@elizaos/cli 1.3.1 → 1.4.2

package/templates/project-tee-starter/src/plugin.ts

@@ -1,5 +1,5 @@
 import type { Plugin } from '@elizaos/core';
-import { type IAgentRuntime, Service, logger } from '@elizaos/core';
+import { type IAgentRuntime, logger, Service } from '@elizaos/core';
 import { z } from 'zod';
 import { type DeriveKeyResponse, TappdClient } from '@phala/dstack-sdk';
 import { type PrivateKeyAccount, privateKeyToAccount } from 'viem/accounts';
@@ -12,82 +12,201 @@ import crypto from 'node:crypto';
 /**
  * Define the configuration schema for the plugin with the following properties:
  *
- * @param {string} WALLET_SECRET_SALT - The secret salt for the wallet (min length of 1, optional)
+ * @param {string} TEE_MODE - The TEE mode (OFF, LOCAL, DOCKER, PRODUCTION)
+ * @param {string} TEE_VENDOR - The TEE vendor (must be 'phala')
+ * @param {string} WALLET_SECRET_SALT - The secret salt for the wallet (min length of 8)
  * @returns {object} - The configured schema object
  */
 const configSchema = z.object({
+  TEE_MODE: z
+    .string()
+    .optional()
+    .transform((val) => {
+      // Provide test defaults when NODE_ENV is test
+      if (process.env.NODE_ENV === 'test' && !val) {
+        return 'OFF';
+      }
+      return val;
+    })
+    .refine((val) => {
+      if (!val) return true; // Allow undefined in non-test environments
+      return ['OFF', 'LOCAL', 'DOCKER', 'PRODUCTION'].includes(val);
+    }, 'TEE_MODE must be one of: OFF, LOCAL, DOCKER, PRODUCTION'),
+
+  TEE_VENDOR: z
+    .string()
+    .optional()
+    .transform((val) => {
+      // Provide test defaults when NODE_ENV is test
+      if (process.env.NODE_ENV === 'test' && !val) {
+        return 'phala';
+      }
+      return val;
+    })
+    .refine((val) => {
+      if (!val) return true; // Allow undefined in non-test environments
+      return val === 'phala';
+    }, 'TEE_VENDOR must be: phala'),
+
   WALLET_SECRET_SALT: z
     .string()
-    .min(1, 'Wallet secret salt is not provided')
     .optional()
     .transform((val) => {
+      // SECURITY WARNING: Test defaults are ONLY for test environments
+      // NEVER use these defaults in production - always provide a secure salt
+      if (process.env.NODE_ENV === 'test' && !val) {
+        logger.debug('Using test default for WALLET_SECRET_SALT - NEVER use in production');
+        return 'test_default_salt_12345';
+      }
       if (!val) {
         logger.warn('Warning: Wallet secret salt is not provided');
       }
       return val;
-    }),
+    })
+    .refine(
+      (val) => {
+        if (!val) return true; // Allow undefined in non-test environments
+        const trimmedVal = val.trim();
+        return trimmedVal.length >= 8 && trimmedVal.length <= 128;
+      },
+      (val) => {
+        if (!val) return { message: 'Wallet secret salt is required' };
+        const trimmedVal = val.trim();
+        if (trimmedVal.length < 8) {
+          return { message: 'Wallet secret salt must be at least 8 characters long for security' };
+        }
+        if (trimmedVal.length > 128) {
+          return { message: 'Wallet secret salt must not exceed 128 characters' };
+        }
+        return { message: 'Invalid wallet secret salt' };
+      }
+    ),
+});
+
+// Functional TEE service configuration
+type TeeServiceConfig = {
+  teeClient: TappdClient;
+  secretSalt: string;
+  runtime: IAgentRuntime;
+};
+
+/**
+ * Creates a TEE service configuration object
+ */
+const createTeeServiceConfig = (runtime: IAgentRuntime): TeeServiceConfig => ({
+  teeClient: new TappdClient(),
+  secretSalt: process.env.WALLET_SECRET_SALT || 'secret_salt',
+  runtime,
 });
 
+/**
+ * Derives ECDSA keypair from TEE response
+ */
+const deriveEcdsaKeypair = (deriveKeyResponse: DeriveKeyResponse): PrivateKeyAccount => {
+  const hex = keccak256(deriveKeyResponse.asUint8Array());
+  return privateKeyToAccount(hex);
+};
+
+/**
+ * Derives ED25519 keypair from TEE response
+ */
+const deriveEd25519Keypair = (deriveKeyResponse: DeriveKeyResponse): Keypair => {
+  const uint8ArrayDerivedKey = deriveKeyResponse.asUint8Array();
+  const hash = crypto.createHash('sha256');
+  hash.update(uint8ArrayDerivedKey);
+  const seed = hash.digest();
+  const seedArray = new Uint8Array(seed);
+  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
+ */
+const handleTeeKeyDerivation = async (config: TeeServiceConfig): Promise<void> => {
+  try {
+    const deriveKeyResponse: DeriveKeyResponse = await config.teeClient.deriveKey(
+      config.secretSalt
+    );
+
+    // ECDSA Key
+    const ecdsaKeypair = deriveEcdsaKeypair(deriveKeyResponse);
+
+    // ED25519 Key
+    const ed25519Keypair = deriveEd25519Keypair(deriveKeyResponse);
+
+    logger.log('ECDSA Key Derived Successfully!');
+    logger.log({ address: ecdsaKeypair.address }, 'ECDSA Keypair:');
+    logger.log({ publicKey: ed25519Keypair.publicKey }, 'ED25519 Keypair:');
+
+    const signature = await ecdsaKeypair.signMessage({ message: 'Hello, world!' });
+    logger.log({ signature }, 'Sign message w/ ECDSA keypair: Hello world!, Signature:');
+  } catch (error) {
+    // Handle TEE connection errors gracefully
+    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.warn({ error }, 'TEE daemon connection failed, running in non-TEE mode:');
+    }
+    // Continue without TEE functionality for testing
+  }
+};
+
+/**
+ * Starts the TEE starter service using functional approach
+ */
+const startTeeService = async (runtime: IAgentRuntime): Promise<TeeServiceConfig> => {
+  logger.info("*** Starting Mr. TEE's custom service (Functional) ***");
+
+  const config = createTeeServiceConfig(runtime);
+  await handleTeeKeyDerivation(config);
+
+  return config;
+};
+
+/**
+ * Stops the TEE starter service using functional approach
+ */
+const stopTeeService = async (runtime: IAgentRuntime): Promise<void> => {
+  logger.info("*** Stopping Mr. TEE's custom service (Functional) ***");
+  // In functional approach, cleanup is handled here if needed
+  // No explicit service instance to stop
+};
+
+/**
+ * StarterService class for TEE functionality
+ */
 export class StarterService extends Service {
-  static serviceType = 'starter';
-  capabilityDescription = 'This is a starter service, can be customized for Mr. TEE.';
-  private teeClient: TappdClient;
-  private secretSalt: string;
-  constructor(protected runtime: IAgentRuntime) {
+  public static serviceType = 'starter';
+
+  constructor(runtime: IAgentRuntime) {
     super(runtime);
-    this.teeClient = new TappdClient();
-    this.secretSalt = process.env.WALLET_SECRET_SALT || 'secret_salt';
   }
 
-  static async start(runtime: IAgentRuntime) {
-    logger.info("*** Starting Mr. TEE's custom service (StarterService) ***");
+  static async start(runtime: IAgentRuntime): Promise<StarterService> {
     const service = new StarterService(runtime);
-    try {
-      const deriveKeyResponse: DeriveKeyResponse = await service.teeClient.deriveKey(
-        service.secretSalt
-      );
-
-      // ECDSA Key
-      const hex = keccak256(deriveKeyResponse.asUint8Array());
-      const ecdsaKeypair: PrivateKeyAccount = privateKeyToAccount(hex);
-
-      // ED25519 Key
-      const uint8ArrayDerivedKey = deriveKeyResponse.asUint8Array();
-      const hash = crypto.createHash('sha256');
-      hash.update(uint8ArrayDerivedKey);
-      const seed = hash.digest();
-      const seedArray = new Uint8Array(seed);
-      const ed25519Keypair = Keypair.fromSeed(seedArray.slice(0, 32));
-
-      logger.log('ECDSA Key Derived Successfully!');
-      logger.log('ECDSA Keypair:', ecdsaKeypair.address);
-      logger.log('ED25519 Keypair:', ed25519Keypair.publicKey);
-      const signature = await ecdsaKeypair.signMessage({ message: 'Hello, world!' });
-      logger.log('Sign message w/ ECDSA keypair: Hello world!, Signature: ', signature);
-    } catch (error) {
-      // Handle TEE connection errors gracefully
-      if (error instanceof Error && error.message.includes('ENOENT')) {
-        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);
-      }
-      // Continue without TEE functionality for testing
-    }
+    await startTeeService(runtime);
     return service;
   }
 
-  static async stop(runtime: IAgentRuntime) {
-    logger.info("*** Stopping Mr. TEE's custom service (StarterService) ***");
-    const service = runtime.getService(StarterService.serviceType);
-    if (!service) {
-      throw new Error('Mr. TEE custom service (StarterService) not found');
-    }
-    service.stop();
+  async stop(): Promise<void> {
+    await stopTeeService(this.runtime);
   }
 
-  async stop() {
-    logger.info("*** Stopping Mr. TEE's custom service instance (StarterService) ***");
+  public get capabilityDescription(): string {
+    return 'This is a starter service, can be customized for Mr. TEE.';
   }
 }
 
@@ -96,12 +215,42 @@ const teeStarterPlugin: 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,
   },
-  async init(config: Record<string, string>) {
+  async init(config: Record<string, string>, runtime: IAgentRuntime) {
     logger.info('*** Initializing Mr. TEE plugin ***');
     try {
-      const validatedConfig = await configSchema.parseAsync(config);
+      // Merge process.env values with config, config takes precedence
+      const mergedConfig = {
+        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);
+
+      // Production safety check - ensure test defaults aren't used in production
+      if (
+        process.env.NODE_ENV === 'production' &&
+        validatedConfig.WALLET_SECRET_SALT === 'test_default_salt_12345'
+      ) {
+        throw new Error(
+          'CRITICAL: Test salt detected in production environment. Please provide a secure WALLET_SECRET_SALT.'
+        );
+      }
 
       // Set all environment variables at once
       for (const [key, value] of Object.entries(validatedConfig)) {
@@ -132,13 +281,28 @@ const teeStarterPlugin: Plugin = {
         });
       },
     },
+    {
+      name: 'TEE Status',
+      path: '/public/tee-status',
+      type: 'GET',
+      handler: async (
+        _req: Record<string, unknown>,
+        res: { json: (data: Record<string, unknown>) => void }
+      ) => {
+        res.json({
+          status: 'active',
+          tee_enabled: process.env.TEE_MODE !== 'OFF',
+          vendor: process.env.TEE_VENDOR || 'phala',
+        });
+      },
+    },
   ],
   events: {
     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'
         );
       },
     ],
@@ -159,9 +323,7 @@ const teeStarterPlugin: Plugin = {
     ],
   },
   // Enable this service to run when TEE mode is enabled
-  services: [
-    /* StarterService */
-  ],
+  services: [StarterService],
   actions: [],
   providers: [],
 };

package/templates/project-tee-starter/tailwind.config.js

@@ -0,0 +1,62 @@
+import tailwindcssAnimate from 'tailwindcss-animate';
+
+/** @type {import('tailwindcss').Config} */
+export default {
+  darkMode: ['class'],
+  content: ['./index.html', './src/**/*.{js,ts,jsx,tsx}'],
+  theme: {
+    extend: {
+      container: {
+        center: true,
+      },
+      borderRadius: {
+        lg: 'var(--radius)',
+        md: 'calc(var(--radius) - 2px)',
+        sm: 'calc(var(--radius) - 4px)',
+      },
+      colors: {
+        background: 'hsl(var(--background))',
+        foreground: 'hsl(var(--foreground))',
+        card: {
+          DEFAULT: 'hsl(var(--card))',
+          foreground: 'hsl(var(--card-foreground))',
+        },
+        popover: {
+          DEFAULT: 'hsl(var(--popover))',
+          foreground: 'hsl(var(--popover-foreground))',
+        },
+        primary: {
+          DEFAULT: 'hsl(var(--primary))',
+          foreground: 'hsl(var(--primary-foreground))',
+        },
+        secondary: {
+          DEFAULT: 'hsl(var(--secondary))',
+          foreground: 'hsl(var(--secondary-foreground))',
+        },
+        muted: {
+          DEFAULT: 'hsl(var(--muted))',
+          foreground: 'hsl(var(--muted-foreground))',
+        },
+        accent: {
+          DEFAULT: 'hsl(var(--accent))',
+          foreground: 'hsl(var(--accent-foreground))',
+        },
+        destructive: {
+          DEFAULT: 'hsl(var(--destructive))',
+          foreground: 'hsl(var(--destructive-foreground))',
+        },
+        border: 'hsl(var(--border))',
+        input: 'hsl(var(--input))',
+        ring: 'hsl(var(--ring))',
+        chart: {
+          1: 'hsl(var(--chart-1))',
+          2: 'hsl(var(--chart-2))',
+          3: 'hsl(var(--chart-3))',
+          4: 'hsl(var(--chart-4))',
+          5: 'hsl(var(--chart-5))',
+        },
+      },
+    },
+  },
+  plugins: [tailwindcssAnimate],
+};

package/templates/project-tee-starter/tsconfig.build.json

@@ -8,6 +8,6 @@
     "declaration": true,
     "emitDeclarationOnly": true
   },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+  "include": ["src/index.ts", "src/plugin.ts", "src/frontend/**/*.ts", "src/frontend/**/*.tsx"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts", "src/__tests__/**/*"]
 }

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

@@ -1,30 +1,33 @@
 {
   "compilerOptions": {
-    "outDir": "dist",
+    "outDir": "./dist",
     "rootDir": "src",
-    "lib": ["ESNext"],
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
     "target": "ESNext",
     "module": "Preserve",
     "moduleResolution": "Bundler",
     "strict": false,
     "esModuleInterop": true,
     "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": false,
+    "forceConsistentCasingInFileNames": true,
+    "strictFunctionTypes": false,
+    "useUnknownInCatchVariables": false,
     "allowImportingTsExtensions": true,
     "declaration": true,
     "emitDeclarationOnly": true,
     "resolveJsonModule": true,
-    "noImplicitAny": false,
     "allowJs": true,
     "checkJs": false,
     "noEmitOnError": false,
     "moduleDetection": "force",
     "allowArbitraryExtensions": true,
+    "jsx": "react-jsx",
     "baseUrl": ".",
     "paths": {
       "@elizaos/core": ["../../core/src"],
       "@elizaos/core/*": ["../../core/src/*"]
     }
   },
-  "include": ["src/**/*.ts"]
+  "include": ["src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["dist", "node_modules", "src/__tests__/**/*", "**/*.test.ts", "**/*.spec.ts"]
 }

package/templates/project-tee-starter/tsup.config.ts

@@ -5,15 +5,16 @@ export default defineConfig({
   outDir: 'dist',
   tsconfig: './tsconfig.build.json', // Use build-specific tsconfig
   sourcemap: true,
-  clean: true,
+  clean: false,
   format: ['esm'], // Ensure you're targeting CommonJS
-  dts: false, // Skip DTS generation to avoid external import issues // Ensure you're targeting CommonJS
+  dts: true, // require DTS so we get d.ts in the dist folder on npm
   external: [
     'dotenv', // Externalize dotenv to prevent bundling
     'fs', // Externalize fs to use Node.js built-in module
     'path', // Externalize other built-ins if necessary
     'https',
     'http',
+    '@elizaos/core',
     'zod',
   ],
 });

package/templates/project-tee-starter/vite.config.ts

@@ -0,0 +1,39 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+  root: 'src/frontend',
+  build: {
+    outDir: '../../dist/frontend',
+    emptyOutDir: true,
+    rollupOptions: {
+      input: {
+        main: path.resolve(__dirname, 'src/frontend/index.html'),
+      },
+    },
+  },
+  optimizeDeps: {
+    include: ['react', 'react-dom', '@tanstack/react-query'],
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+      '@elizaos/core': path.resolve(__dirname, '../../core/src'),
+    },
+  },
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:3000',
+        changeOrigin: true,
+      },
+    },
+  },
+});

package/dist/chunk-4O6EZU37.js

@@ -1,14 +0,0 @@
-// src/commands/shared/url-utils.ts
-function getAgentRuntimeUrl(opts) {
-  return opts.remoteUrl?.replace(/\/$/, "") || // Use the flag if provided
-  process.env.AGENT_RUNTIME_URL?.replace(/\/$/, "") || // Fallback to env var
-  `http://localhost:${opts.port || process.env.SERVER_PORT || "3000"}`;
-}
-function getAgentsBaseUrl(opts) {
-  return `${getAgentRuntimeUrl(opts)}/api/agents`;
-}
-
-export {
-  getAgentRuntimeUrl,
-  getAgentsBaseUrl
-};