@elizaos/cli 1.0.8 → 1.0.10

package/templates/project-starter/src/__tests__/routes.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'bun:test';
+import plugin from '../plugin';
+
+describe('Plugin Routes', () => {
+  it('should have routes defined', () => {
+    expect(plugin.routes).toBeDefined();
+    if (plugin.routes) {
+      expect(Array.isArray(plugin.routes)).toBe(true);
+      expect(plugin.routes.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('should have a route for /helloworld', () => {
+    if (plugin.routes) {
+      const helloWorldRoute = plugin.routes.find((route) => route.path === '/helloworld');
+      expect(helloWorldRoute).toBeDefined();
+
+      if (helloWorldRoute) {
+        expect(helloWorldRoute.type).toBe('GET');
+        expect(typeof helloWorldRoute.handler).toBe('function');
+      }
+    }
+  });
+
+  it('should handle route requests correctly', async () => {
+    if (plugin.routes) {
+      const helloWorldRoute = plugin.routes.find((route) => route.path === '/helloworld');
+
+      if (helloWorldRoute && helloWorldRoute.handler) {
+        // Create mock request and response objects
+        const mockReq = {};
+        const mockRes = {
+          json: spyOnfn(),
+        };
+
+        // Mock runtime object as third parameter
+        const mockRuntime = {} as any;
+
+        // Call the route handler
+        await helloWorldRoute.handler(mockReq, mockRes, mockRuntime);
+
+        // Verify response
+        expect(mockRes.json).toHaveBeenCalledTimes(1);
+        expect(mockRes.json).toHaveBeenCalledWith({
+          message: 'Hello World!',
+        });
+      }
+    }
+  });
+
+  it('should validate route structure', () => {
+    if (plugin.routes) {
+      // Validate each route
+      plugin.routes.forEach((route) => {
+        expect(route).toHaveProperty('path');
+        expect(route).toHaveProperty('type');
+        expect(route).toHaveProperty('handler');
+
+        // Path should be a string starting with /
+        expect(typeof route.path).toBe('string');
+        expect(route.path.startsWith('/')).toBe(true);
+
+        // Type should be a valid HTTP method
+        expect(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).toContain(route.type);
+
+        // Handler should be a function
+        expect(typeof route.handler).toBe('function');
+      });
+    }
+  });
+
+  it('should have unique route paths', () => {
+    if (plugin.routes) {
+      const paths = plugin.routes.map((route) => route.path);
+      const uniquePaths = new Set(paths);
+      expect(paths.length).toBe(uniquePaths.size);
+    }
+  });
+});

package/templates/project-starter/src/__tests__/test-utils.ts

@@ -0,0 +1,121 @@
+import { mock, spyOn } from 'bun:test';
+import { Content, IAgentRuntime, Memory, State, logger } from '@elizaos/core';
+import {
+  createMockRuntime as createCoreMockRuntime,
+  createMockMessage as createCoreMockMessage,
+  createMockState as createCoreMockState,
+  documentTestResult,
+  runCoreActionTests,
+} from './utils/core-test-utils';
+import { character } from '../index';
+import plugin from '../plugin';
+
+/**
+ * Creates an enhanced mock runtime for testing that includes the project's
+ * character and plugin
+ *
+ * @param overrides - Optional overrides for the default mock methods and properties
+ * @returns A mock runtime for testing
+ */
+export function createMockRuntime(overrides: Partial<IAgentRuntime> = {}): IAgentRuntime {
+  // Create base mock runtime with default core utilities
+  const baseRuntime = createCoreMockRuntime();
+
+  // Enhance with project-specific configuration
+  const mockRuntime = {
+    ...baseRuntime,
+    character: character,
+    plugins: [plugin],
+    registerPlugin: mock(),
+    initialize: mock(),
+    getService: mock(),
+    getSetting: mock().mockReturnValue(null),
+    useModel: mock().mockResolvedValue('Test model response'),
+    getProviderResults: mock().mockResolvedValue([]),
+    evaluateProviders: mock().mockResolvedValue([]),
+    evaluate: mock().mockResolvedValue([]),
+    ...overrides,
+  } as unknown as IAgentRuntime;
+
+  return mockRuntime;
+}
+
+/**
+ * Creates a mock Message object for testing
+ *
+ * @param text - The message text
+ * @param overrides - Optional overrides for the default memory properties
+ * @returns A mock memory object
+ */
+export function createMockMessage(text: string, overrides: Partial<Memory> = {}): Memory {
+  const baseMessage = createCoreMockMessage(text);
+  return {
+    ...baseMessage,
+    ...overrides,
+  };
+}
+
+/**
+ * Creates a mock State object for testing
+ *
+ * @param overrides - Optional overrides for the default state properties
+ * @returns A mock state object
+ */
+export function createMockState(overrides: Partial<State> = {}): State {
+  const baseState = createCoreMockState();
+  return {
+    ...baseState,
+    ...overrides,
+  };
+}
+
+/**
+ * Creates a standardized setup for testing with consistent mock objects
+ *
+ * @param overrides - Optional overrides for default mock implementations
+ * @returns An object containing mockRuntime, mockMessage, mockState, and callbackFn
+ */
+export function setupTest(
+  options: {
+    messageText?: string;
+    messageOverrides?: Partial<Memory>;
+    runtimeOverrides?: Partial<IAgentRuntime>;
+    stateOverrides?: Partial<State>;
+  } = {}
+) {
+  // Create mock callback function
+  const callbackFn = mock();
+
+  // Create a message
+  const mockMessage = createMockMessage(
+    options.messageText || 'Test message',
+    options.messageOverrides || {}
+  );
+
+  // Create a state object
+  const mockState = createMockState(options.stateOverrides || {});
+
+  // Create a mock runtime
+  const mockRuntime = createMockRuntime(options.runtimeOverrides || {});
+
+  return {
+    mockRuntime,
+    mockMessage,
+    mockState,
+    callbackFn,
+  };
+}
+
+// Export other utility functions
+export { documentTestResult, runCoreActionTests };
+
+// Add spy on logger for common usage in tests
+export function setupLoggerSpies() {
+  spyOn(logger, 'info').mockImplementation(() => {});
+  spyOn(logger, 'error').mockImplementation(() => {});
+  spyOn(logger, 'warn').mockImplementation(() => {});
+  spyOn(logger, 'debug').mockImplementation(() => {});
+
+  // allow tests to restore originals
+  return () => mock.restore();
+}

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

@@ -0,0 +1,180 @@
+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) => {
+  // Clean, useful test documentation for developers
+  logger.info(`✓ Testing: ${testName}`);
+
+  if (error) {
+    logger.error(`✗ Error: ${error.message}`);
+    if (error.stack) {
+      logger.error(`Stack: ${error.stack}`);
+    }
+    return;
+  }
+
+  if (result) {
+    if (typeof result === 'string') {
+      if (result.trim() && result.length > 0) {
+        const preview = result.length > 60 ? `${result.substring(0, 60)}...` : result;
+        logger.info(`  → ${preview}`);
+      }
+    } else if (typeof result === 'object') {
+      try {
+        // Show key information in a clean format
+        const keys = Object.keys(result);
+        if (keys.length > 0) {
+          const preview = keys.slice(0, 3).join(', ');
+          const more = keys.length > 3 ? ` +${keys.length - 3} more` : '';
+          logger.info(`  → {${preview}${more}}`);
+        }
+      } catch (e) {
+        logger.info(`  → [Complex object]`);
+      }
+    }
+  }
+};
+
+/**
+ * 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/templates/project-starter/src/frontend/index.css

@@ -0,0 +1,77 @@
+@import 'tailwindcss';
+@config "../../tailwind.config.js";
+
+@layer base {
+  :root {
+    --background: 0 0% 97.65%;
+    --foreground: 0 0% 12.55%;
+    --muted: 0 0% 93.73%;
+    --muted-foreground: 0 0% 39.22%;
+    --popover: 0 0% 98.82%;
+    --popover-foreground: 0 0% 12.55%;
+    --card: 0 0% 98.82%;
+    --card-foreground: 0 0% 12.55%;
+    --border: 0 0% 84.71%;
+    --input: 0 0% 94.12%;
+    --primary: 22.93 92.59% 52.35%;
+    --primary-foreground: 44 0% 100%;
+    --secondary: 34.05 100% 85.49%;
+    --secondary-foreground: 16.27 50.43% 22.94%;
+    --accent: 0 0% 90.98%;
+    --accent-foreground: 0 0% 12.55%;
+    --destructive: 10.16 77.87% 53.92%;
+    --destructive-foreground: 0 0% 100%;
+    --ring: 24.8 79.79% 63.14%;
+    --chart-1: 22.93 92.59% 52.35%;
+    --chart-2: 34.05 100% 85.49%;
+    --chart-3: 0 0% 90.98%;
+    --chart-4: 34.05 100% 88.49%;
+    --chart-5: 22.93 95.59% 52.35%;
+    --radius: 0.5rem;
+  }
+
+  .dark {
+    --background: 0 0% 6.67%;
+    --foreground: 0 0% 93.33%;
+    --muted: 0 0% 13.33%;
+    --muted-foreground: 0 0% 70.59%;
+    --popover: 0 0% 9.8%;
+    --popover-foreground: 0 0% 93.33%;
+    --card: 0 0% 9.8%;
+    --card-foreground: 0 0% 93.33%;
+    --border: 44 14% 11%;
+    --input: 0 0% 28.24%;
+    --primary: 22.93 92.59% 52.35%;
+    --primary-foreground: 29.51 0% 100%;
+    --secondary: 28.5 64.52% 12.16%;
+    --secondary-foreground: 29.51 100% 88.04%;
+    --accent: 0 0% 16.47%;
+    --accent-foreground: 0 0% 93.33%;
+    --destructive: 10.16 77.87% 53.92%;
+    --destructive-foreground: 0 0% 100%;
+    --ring: 23.11 59.8% 40%;
+    --chart-1: 22.93 92.59% 52.35%;
+    --chart-2: 28.5 64.52% 12.16%;
+    --chart-3: 0 0% 16.47%;
+    --chart-4: 28.5 64.52% 15.16%;
+    --chart-5: 22.93 95.59% 52.35%;
+  }
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+
+/* Force dark mode */
+:root {
+  color-scheme: dark;
+}
+
+body {
+  @apply font-mono bg-background text-foreground;
+}

package/templates/project-starter/src/frontend/index.html

@@ -0,0 +1,19 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>ElizaOS Frontend</title>
+    <script>
+      // This will be injected by the server in production
+      window.ELIZA_CONFIG = {
+        agentId: 'test-agent-id',
+        apiBase: 'http://localhost:3000',
+      };
+    </script>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/index.tsx"></script>
+  </body>
+</html>

package/templates/project-starter/src/frontend/index.tsx

@@ -0,0 +1,98 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { createRoot } from 'react-dom/client';
+import './index.css';
+import React from 'react';
+import type { UUID } from '@elizaos/core';
+
+const queryClient = new QueryClient();
+
+// Define the interface for the ELIZA_CONFIG
+interface ElizaConfig {
+  agentId: string;
+  apiBase: string;
+}
+
+// Declare global window extension for TypeScript
+declare global {
+  interface Window {
+    ELIZA_CONFIG?: ElizaConfig;
+  }
+}
+
+/**
+ * Main Example route component
+ */
+function ExampleRoute() {
+  const config = window.ELIZA_CONFIG;
+  const agentId = config?.agentId;
+
+  // Apply dark mode to the root element
+  React.useEffect(() => {
+    document.documentElement.classList.add('dark');
+  }, []);
+
+  if (!agentId) {
+    return (
+      <div className="p-4 text-center">
+        <div className="text-red-600 font-medium">Error: Agent ID not found</div>
+        <div className="text-sm text-gray-600 mt-2">
+          The server should inject the agent ID configuration.
+        </div>
+      </div>
+    );
+  }
+
+  return <ExampleProvider agentId={agentId as UUID} />;
+}
+
+/**
+ * Example provider component
+ */
+function ExampleProvider({ agentId }: { agentId: UUID }) {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <div>Hello {agentId}</div>
+    </QueryClientProvider>
+  );
+}
+
+// Initialize the application - no router needed for iframe
+const rootElement = document.getElementById('root');
+if (rootElement) {
+  createRoot(rootElement).render(<ExampleRoute />);
+}
+
+// Define types for integration with agent UI system
+export interface AgentPanel {
+  name: string;
+  path: string;
+  component: React.ComponentType<any>;
+  icon?: string;
+  public?: boolean;
+  shortLabel?: string; // Optional short label for mobile
+}
+
+interface PanelProps {
+  agentId: string;
+}
+
+/**
+ * Example panel component for the plugin system
+ */
+const PanelComponent: React.FC<PanelProps> = ({ agentId }) => {
+  return <div>Helllo {agentId}!</div>;
+};
+
+// Export the panel configuration for integration with the agent UI
+export const panels: AgentPanel[] = [
+  {
+    name: 'Example',
+    path: 'example',
+    component: PanelComponent,
+    icon: 'Book',
+    public: false,
+    shortLabel: 'Example',
+  },
+];
+
+export * from './utils';

package/templates/project-starter/src/frontend/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/templates/project-starter/src/index.ts

@@ -21,7 +21,12 @@ export const character: Character = {
     ...(process.env.OPENAI_API_KEY ? ['@elizaos/plugin-openai'] : []),
     ...(!process.env.OPENAI_API_KEY ? ['@elizaos/plugin-local-ai'] : []),
     ...(process.env.DISCORD_API_TOKEN ? ['@elizaos/plugin-discord'] : []),
-    ...(process.env.TWITTER_USERNAME ? ['@elizaos/plugin-twitter'] : []),
+    ...(process.env.TWITTER_API_KEY &&
+    process.env.TWITTER_API_SECRET_KEY &&
+    process.env.TWITTER_ACCESS_TOKEN &&
+    process.env.TWITTER_ACCESS_TOKEN_SECRET
+      ? ['@elizaos/plugin-twitter']
+      : []),
     ...(process.env.TELEGRAM_BOT_TOKEN ? ['@elizaos/plugin-telegram'] : []),
     ...(!process.env.IGNORE_BOOTSTRAP ? ['@elizaos/plugin-bootstrap'] : []),
   ],
@@ -142,4 +147,7 @@ const project: Project = {
   agents: [projectAgent],
 };
 
+// Export test suites for the test runner
+export { testSuites } from './__tests__/e2e';
+
 export default project;

package/templates/project-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-starter/tsconfig.build.json

@@ -8,6 +8,13 @@
     "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__/**/*",
+    "src/**/cypress/**/*"
+  ]
 }