@elizaos/app 1.6.5 → 1.7.0-beta.0

package/README.md

@@ -1,7 +1,3 @@
-# Tauri + React + Typescript
+# ElizaOS Desktop Application
 
-This template should help get you started developing with Tauri, React and Typescript in Vite.
-
-## Recommended IDE Setup
-
-- [VS Code](https://code.visualstudio.com/) + [Tauri](https://marketplace.visualstudio.com/items?itemName=tauri-apps.tauri-vscode) + [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer)
+Desktop application for ElizaOS built with Tauri, React, and TypeScript.

package/eslint.config.js

@@ -1,3 +1,12 @@
 import pluginConfig from '@elizaos/config/eslint/eslint.config.plugin.js';
 
-export default pluginConfig;
+export default [
+  ...pluginConfig,
+  {
+    rules: {
+      // Disable indent rule - Prettier handles indentation
+      // The indent rule causes stack overflow with complex JSX/TSX
+      indent: 'off',
+    },
+  },
+];

package/index.html

@@ -6,17 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Eliza Desktop</title>
     <style>
-      body {
-        margin: 0;
-        padding: 0;
-        border: none;
-      }
-      html {
-        margin: 0;
-        padding: 0;
-        border: none;
-      }
-      #root {
+      * {
         margin: 0;
         padding: 0;
         border: none;

package/package.json

@@ -1,16 +1,12 @@
 {
   "name": "@elizaos/app",
-  "version": "1.6.5",
+  "version": "1.7.0-beta.0",
   "type": "module",
   "scripts": {
     "start": "tauri dev",
-    "dev": "vite",
     "build": "tsc && vite build",
-    "preview": "vite preview",
-    "tauri": "tauri",
     "test": "bun test src/__tests__",
-    "tauri:dev": "tauri dev",
-    "tauri:build": "tauri build",
+    "build:tauri": "tauri build",
     "typecheck": "tsc --noEmit",
     "format": "prettier --write ./src",
     "format:check": "prettier --check ./src",
@@ -18,16 +14,11 @@
     "lint:check": "eslint src/"
   },
   "dependencies": {
-    "@elizaos/api-client": "1.6.5",
-    "@elizaos/cli": "1.6.5",
-    "@tauri-apps/api": "^2.6.0",
-    "@tauri-apps/plugin-opener": "^2.4.0",
-    "@tauri-apps/plugin-shell": "^2.3.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0"
   },
   "devDependencies": {
-    "@elizaos/config": "1.6.5",
+    "@elizaos/config": "1.7.0-beta.0",
     "@tauri-apps/cli": "^2.6.2",
     "@types/react": "^19.1.16",
     "@types/react-dom": "^19.1.6",
@@ -36,5 +27,5 @@
     "typescript": "^5.9.3",
     "vite": "^7.2.6"
   },
-  "gitHead": "f4141f3649a2e61008b481646a0469567be6ba9a"
+  "gitHead": "61d977c5b5e49fbb6784afe3b937fe03f14ec53f"
 }

package/src/__tests__/main.test.ts

@@ -1,87 +1,67 @@
 import { expect, test, describe } from 'bun:test';
+import React from 'react';
 
-// Add TypeScript declarations for Node.js modules and globals
-declare function require(id: string): any;
-declare const process: { cwd(): string };
+declare const Bun: {
+  file(path: string): {
+    exists(): Promise<boolean>;
+    text(): Promise<string>;
+  };
+};
 
-describe('App Tests', () => {
-  // Test that checks if main.tsx is a valid module
-  test('main.tsx file exists and contains expected structure', () => {
-    // Import Node.js built-in modules
-    const fs = require('fs');
-    const path = require('path');
-
-    // Read the main.tsx file content
-    const mainPath = path.resolve(process.cwd(), 'src/main.tsx');
-    const fileExists = fs.existsSync(mainPath);
-
-    expect(fileExists).toBe(true);
+declare const process: {
+  cwd(): string;
+};
 
-    if (fileExists) {
-      const content = fs.readFileSync(mainPath, 'utf8');
+describe('App Tests', () => {
+  test('main.tsx file exists and contains expected structure', async () => {
+    const mainPath = `${process.cwd()}/src/main.tsx`;
+    const file = Bun.file(mainPath);
+    expect(await file.exists()).toBe(true);
 
-      // Check for key React components/elements we expect to find
-      expect(content).toContain('import React');
-      expect(content).toContain('useState');
-      expect(content).toContain('createRoot');
-      expect(content).toContain('ElizaWrapper');
+    const content = await file.text();
 
-      // Verify it contains code to check server availability
-      expect(content).toContain('fetch');
-    }
+    expect(content).toContain('useState');
+    expect(content).toContain('createRoot');
+    expect(content).toContain('ElizaWrapper');
+    expect(content).toContain('fetch');
   });
 
-  // Test React module can be imported and used
   test('React can be imported and used', () => {
-    const React = require('react');
     expect(React).toBeDefined();
 
-    // Test creating a React element
     const element = React.createElement('div', { className: 'test' }, 'Test Content');
 
     expect(element).toBeDefined();
     expect(element.type).toBe('div');
     expect(element.props.className).toBe('test');
-    expect(element.props.children).toBe('Test Content');
   });
 
-  // Test package dependencies
-  test('package has correct dependencies', () => {
-    const fs = require('fs');
-    const path = require('path');
+  test('package has correct dependencies', async () => {
+    interface PackageJson {
+      dependencies?: Record<string, string>;
+      devDependencies?: Record<string, string>;
+    }
 
-    const packageJsonPath = path.resolve(process.cwd(), 'package.json');
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const packageJsonPath = `${process.cwd()}/package.json`;
+    const file = Bun.file(packageJsonPath);
+    const packageJson = JSON.parse(await file.text()) as PackageJson;
 
-    // Check for required dependencies
     expect(packageJson.dependencies).toBeDefined();
-    expect(packageJson.dependencies['react']).toBeDefined();
-    expect(packageJson.dependencies['react-dom']).toBeDefined();
-    expect(packageJson.dependencies['@elizaos/api-client']).toBeDefined();
+    expect(packageJson.dependencies?.['react']).toBeDefined();
+    expect(packageJson.dependencies?.['react-dom']).toBeDefined();
 
-    // Check for development dependencies
     expect(packageJson.devDependencies).toBeDefined();
-    expect(packageJson.devDependencies['@tauri-apps/cli']).toBeDefined();
-    expect(packageJson.devDependencies['typescript']).toBeDefined();
+    expect(packageJson.devDependencies?.['@tauri-apps/cli']).toBeDefined();
+    expect(packageJson.devDependencies?.['typescript']).toBeDefined();
   });
 
-  // Test project structure
-  test('project has correct file structure', () => {
-    const fs = require('fs');
-    const path = require('path');
-
-    // Check src directory exists
-    const srcPath = path.resolve(process.cwd(), 'src');
-    expect(fs.existsSync(srcPath)).toBe(true);
-
-    // Check main files exist
-    expect(fs.existsSync(path.resolve(srcPath, 'main.tsx'))).toBe(true);
-
-    // Check Tauri source directory exists
-    const srcTauriPath = path.resolve(process.cwd(), 'src-tauri');
-    expect(fs.existsSync(srcTauriPath)).toBe(true);
+  test('project has correct file structure', async () => {
+    const srcPath = `${process.cwd()}/src`;
+    expect(await Bun.file(srcPath).exists()).toBe(false);
+    expect(await Bun.file(`${srcPath}/main.tsx`).exists()).toBe(true);
 
-    // Check Tauri config files exist
-    expect(fs.existsSync(path.resolve(srcTauriPath, 'Cargo.toml'))).toBe(true);
+    const srcTauriPath = `${process.cwd()}/src-tauri`;
+    expect(await Bun.file(srcTauriPath).exists()).toBe(false);
+    expect(await Bun.file(`${srcTauriPath}/Cargo.toml`).exists()).toBe(true);
   });
 });

package/src/main.tsx

@@ -1,65 +1,60 @@
-import React from 'react';
+import { StrictMode } from 'react';
 import ReactDOM from 'react-dom/client';
-// Using a simple try/catch for the Eliza server, avoiding Tauri API dependencies
 import { useEffect, useState } from 'react';
 
-// Component that will redirect the user to the Eliza client
 function ElizaWrapper() {
   const [status, setStatus] = useState<'starting' | 'running' | 'error'>('starting');
   const [error, setError] = useState<string | null>(null);
   const [retryCount, setRetryCount] = useState(0);
   const [isServerAccessible, setIsServerAccessible] = useState(false);
 
-  // Function to check if server is accessible
-  const checkServerAccessibility = async () => {
-    try {
-      await fetch('http://localhost:3000', {
-        method: 'HEAD',
-        mode: 'no-cors', // Just checking if we can connect, not actually getting a response
-      });
-      return true;
-    } catch (e) {
-      return false;
-    }
+  const checkServerAccessibility = async (): Promise<boolean> => {
+    const response = await fetch('http://localhost:3000', {
+      method: 'HEAD',
+      mode: 'no-cors',
+    });
+    return response.type === 'opaque' || response.status === 0;
   };
 
-  // Start the Eliza server
   useEffect(() => {
+    let checkInterval: ReturnType<typeof setInterval> | undefined;
+    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
     const startServer = async () => {
-      try {
-        setStatus('running');
+      setStatus('running');
 
-        // Start polling to check if the server is accessible
-        const checkInterval = setInterval(async () => {
-          const isAccessible = await checkServerAccessibility();
-          if (isAccessible) {
-            setIsServerAccessible(true);
-            clearInterval(checkInterval);
-          }
-        }, 1000);
+      checkInterval = setInterval(async () => {
+        const isAccessible = await checkServerAccessibility();
+        if (isAccessible) {
+          setIsServerAccessible(true);
+          clearInterval(checkInterval);
+          clearTimeout(timeoutId);
+        }
+      }, 1000);
 
-        // Clear interval after 60 seconds to prevent infinite polling
-        setTimeout(() => clearInterval(checkInterval), 60000);
-      } catch (err: unknown) {
-        console.error('Failed to start Eliza server:', err);
-        setStatus('error');
-        setError(
-          `Failed to start Eliza server: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
+      timeoutId = setTimeout(() => {
+        clearInterval(checkInterval);
+      }, 60000);
     };
 
-    startServer();
-  }, [retryCount]); // Dependency on retryCount allows us to retry
+    startServer().catch((err: Error) => {
+      console.error('Failed to start Eliza server:', err);
+      setStatus('error');
+      setError(`Failed to start Eliza server: ${err.message}`);
+    });
+
+    return () => {
+      clearInterval(checkInterval);
+      clearTimeout(timeoutId);
+    };
+  }, [retryCount]);
 
-  // Retry handler
   const handleRetry = () => {
     setStatus('starting');
     setError(null);
     setRetryCount((prev) => prev + 1);
   };
 
-  // If the server is running and accessible, show the iframe
   if (status === 'running' && isServerAccessible) {
     return (
       <div style={{ width: '100%', height: '100vh', margin: 0, padding: 0 }}>
@@ -76,7 +71,6 @@ function ElizaWrapper() {
     );
   }
 
-  // Show loading or error message
   return (
     <div
       style={{
@@ -147,8 +141,9 @@ function ElizaWrapper() {
   );
 }
 
-ReactDOM.createRoot(document.getElementById('root') as HTMLElement).render(
-  <React.StrictMode>
+const rootElement = document.getElementById('root');
+ReactDOM.createRoot(rootElement!).render(
+  <StrictMode>
     <ElizaWrapper />
-  </React.StrictMode>
+  </StrictMode>
 );

package/src/types/bun-test.d.ts

@@ -1,40 +1,23 @@
-/**
- * Type definitions for Bun's test module
- */
-
 declare module 'bun:test' {
-  export function expect(value: any): {
-    toBe(expected: any): void;
+  interface ExpectMatchers<T> {
+    toBe(expected: T): void;
     toBeDefined(): void;
     toBeUndefined(): void;
     toBeNull(): void;
     toBeTruthy(): void;
     toBeFalsy(): void;
-    toEqual(expected: any): void;
-    toStrictEqual(expected: any): void;
-    toContain(expected: any): void;
+    toEqual(expected: T): void;
+    toStrictEqual(expected: T): void;
+    toContain(expected: T extends string ? string : T extends (infer U)[] ? U : never): void;
     toHaveBeenCalled(): void;
-    toHaveBeenCalledWith(...args: any[]): void;
+    toHaveBeenCalledWith(...args: unknown[]): void;
     toHaveLength(expected: number): void;
-    toHaveProperty(property: string, value?: any): void;
-    toThrow(expected?: any): void;
-    not: {
-      toBe(expected: any): void;
-      toBeDefined(): void;
-      toBeUndefined(): void;
-      toBeNull(): void;
-      toBeTruthy(): void;
-      toBeFalsy(): void;
-      toEqual(expected: any): void;
-      toStrictEqual(expected: any): void;
-      toContain(expected: any): void;
-      toHaveBeenCalled(): void;
-      toHaveBeenCalledWith(...args: any[]): void;
-      toHaveLength(expected: number): void;
-      toHaveProperty(property: string, value?: any): void;
-      toThrow(expected?: any): void;
-    };
-  };
+    toHaveProperty(property: string, value?: unknown): void;
+    toThrow(expected?: string | RegExp | Error): void;
+    not: ExpectMatchers<T>;
+  }
+
+  export function expect<T>(value: T): ExpectMatchers<T>;
 
   export function test(name: string, fn: () => void | Promise<void>): void;
   export function describe(name: string, fn: () => void): void;
@@ -43,9 +26,11 @@ declare module 'bun:test' {
   export function beforeAll(fn: () => void | Promise<void>): void;
   export function afterAll(fn: () => void | Promise<void>): void;
 
-  export function mock<T extends (...args: any[]) => any>(implementation?: T): T;
-  export function spyOn<T extends object, K extends keyof T>(
-    object: T,
-    method: K
-  ): jest.SpyInstance;
+  interface SpyInstance {
+    toHaveBeenCalled(): void;
+    toHaveBeenCalledWith(...args: unknown[]): void;
+  }
+
+  export function mock<T extends (...args: unknown[]) => unknown>(implementation?: T): T;
+  export function spyOn<T extends object, K extends keyof T>(object: T, method: K): SpyInstance;
 }

package/src-tauri/Cargo.toml

@@ -1,16 +1,10 @@
 [package]
 name = "app"
 version = "1.2.4"
-description = "A Tauri App"
-authors = ["you"]
+description = "ElizaOS Desktop Application"
 edition = "2021"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [lib]
-# The `_lib` suffix may seem redundant but it is necessary
-# to make the lib name unique and wouldn't conflict with the bin name.
-# This seems to be only an issue on Windows, see https://github.com/rust-lang/cargo/issues/8519
 name = "app_lib"
 crate-type = ["staticlib", "cdylib", "rlib"]
 
@@ -18,8 +12,6 @@ crate-type = ["staticlib", "cdylib", "rlib"]
 tauri-build = { version = "2.0.0", features = [] }
 
 [dependencies]
-serde_json = "1.0"
-serde = { version = "1.0", features = ["derive"] }
 tauri = { version = "2.0.0", features = [] }
 tauri-plugin-opener = "2.0.0"
 tauri-plugin-shell = "2.2.1"

package/src-tauri/src/lib.rs

@@ -1,71 +1,44 @@
-// Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
 use std::net::TcpStream;
 use std::process::{Child, Command};
 use std::sync::{Arc, Mutex};
 use tauri::Manager;
 
-// Store the server process so we can kill it when the app closes
 static SERVER_PROCESS: once_cell::sync::Lazy<Arc<Mutex<Option<Child>>>> = 
     once_cell::sync::Lazy::new(|| Arc::new(Mutex::new(None)));
 
-#[tauri::command]
-fn greet(name: &str) -> String {
-    format!("Hello, {}! You've been greeted from Rust!", name)
-}
-
-// Check if the server is running by attempting to connect to the port
 fn is_server_running() -> bool {
-    match TcpStream::connect("127.0.0.1:3000") {
-        Ok(_) => true,
-        Err(_) => false,
-    }
+    TcpStream::connect("127.0.0.1:3000").is_ok()
 }
 
-// Shutdown server when app exits
 fn shutdown_server() {
     println!("Shutting down Eliza server...");
-    let mut guard = SERVER_PROCESS.lock().unwrap();
+    let mut guard = SERVER_PROCESS.lock().expect("SERVER_PROCESS mutex should not be poisoned");
     if let Some(ref mut child) = *guard {
-        if let Err(e) = child.kill() {
-            eprintln!("Failed to kill Eliza server: {}", e);
-        } else {
-            println!("Eliza server shut down successfully");
-        }
+        child.kill().expect("Failed to kill Eliza server process");
+        println!("Eliza server shut down successfully");
     }
     *guard = None;
 }
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
-    // Register cleanup for when app exits
     let app = tauri::Builder::default()
         .plugin(tauri_plugin_opener::init())
         .plugin(tauri_plugin_shell::init())
-        .invoke_handler(tauri::generate_handler![greet])
         .setup(|app| {
-            // Start the server if it's not already running
             if !is_server_running() {
                 println!("Starting Eliza server...");
-                match Command::new("elizaos")
+                let child = Command::new("elizaos")
                     .arg("start")
-                    .spawn() {
-                        Ok(child) => {
-                            // Store the process so we can kill it when the app closes
-                            let mut server_guard = SERVER_PROCESS.lock().unwrap();
-                            *server_guard = Some(child);
-                            println!("Eliza server process started");
-                        },
-                        Err(e) => {
-                            eprintln!("Failed to start Eliza server: {}", e);
-                        }
-                    };
+                    .spawn()
+                    .expect("Failed to start Eliza server");
+                let mut server_guard = SERVER_PROCESS.lock().expect("SERVER_PROCESS mutex should not be poisoned");
+                *server_guard = Some(child);
+                println!("Eliza server process started");
             } else {
                 println!("Eliza server is already running");
             }
             
-            // Add event listener for app exit
-            let _app_handle = app.handle();
-            
             #[cfg(desktop)]
             {
                 if let Some(main_window) = app.get_webview_window("main") {
@@ -80,9 +53,9 @@ pub fn run() {
             Ok(())
         })
         .build(tauri::generate_context!())
-        .expect("error while building tauri application");
+        .expect("Failed to build Tauri application");
         
-    app.run(|_app_handle, event| {
+    app.run(|_, event| {
         if let tauri::RunEvent::Exit = event {
             shutdown_server();
         }

package/vite.config.ts

@@ -1,8 +1,7 @@
 import { defineConfig } from 'vite';
 import react from '@vitejs/plugin-react';
 
-// @ts-expect-error process is a nodejs global
-const host = process.env.TAURI_DEV_HOST;
+const host = process.env['TAURI_DEV_HOST'] as string | undefined;
 
 // https://vitejs.dev/config/
 export default defineConfig(async () => ({