diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..5e3fedd
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,64 @@
+# Git files
+.git
+.gitignore
+.gitattributes
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Workspace and cache (will be mounted as volumes)
+workspace/
+cache/
+
+# Documentation and examples
+README.md
+LICENSE
+asset/
+examples/
+evaluation/
+
+# Docker files themselves
+Dockerfile
+docker-compose.yaml
+.dockerignore
+
+# Logs
+*.log
+logs/
+
+# Test files
+tests/
+*.test
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Temporary files
+tmp/
+temp/
+*.tmp
diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..d97248c
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,61 @@
+# InfantAgent Environment Configuration
+# Copy this file to .env and fill in your values
+
+# Required: Anthropic API Key
+# Get your key from: https://console.anthropic.com/
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Optional: Hugging Face Token (for downloading UI-TARS model)
+# Get your token from: https://huggingface.co/settings/tokens
+# Required if the model is gated or for faster downloads
+HF_API_KEY=your_huggingface_token_here
+
+# Optional: Hugging Face cache directory
+# HF_HOME=~/.cache/huggingface
+
+# Optional: GPU Configuration
+# Specify which CUDA devices to use (comma-separated list)
+# Default GPU allocation:
+#   - GPU 0: Computer container (display rendering)
+#   - GPU 2,3: vLLM server (UI-TARS model with tensor parallelism)
+#   - InfantAgent server: Runs on CPU (no GPU needed)
+# Note: Adjust based on your available GPUs
+# CUDA_VISIBLE_DEVICES=0,2,3
+
+# Optional: Computer Container Configuration
+# NVIDIA driver type: Tesla, GeForce, or other
+# NVIDIA_DRIVER=Tesla
+# GPU device(s) visible to the computer container
+# NVIDIA_VISIBLE_DEVICES=0
+# Specific GPU device ID(s) for docker deploy (e.g., '0' or '0,1')
+# NVIDIA_DEVICE_ID=0
+# Render type: gpu or software
+# RENDER_TYPE=gpu
+# User account to create in the container: infant or root
+# CREATE_USER_ACCOUNT=infant
+# Workspace mount path on host (default: ./workspace)
+# WORKSPACE_MOUNT_PATH=./workspace
+# Cache directory on host (default: ./cache)
+# CACHE_DIR=./cache
+
+# Optional: Other API Keys (if using different models)
+# OPENAI_API_KEY=your_openai_key_here
+# GOOGLE_API_KEY=your_google_key_here
+
+# Optional: Custom Model Configuration
+# Uncomment and modify if you want to use different models
+# MODEL=claude-sonnet-4-6
+# MODEL_OSS=ByteDance-Seed/UI-TARS-1.5-7B
+
+# Optional: Agent Configuration
+# MAX_ITERATIONS=100
+# MAX_BUDGET_PER_TASK=20
+# DEBUG=false
+
+# Optional: Network Configuration
+# AGENT_PORT=8000
+# GUI_PORT=4443  # Guacamole web interface port (maps to container's 8080)
+# SSH_PORT=58673  # SSH port for computer container (maps to container's 22)
+
+# Optional: Timezone
+# TZ=America/New_York
diff --git a/DOCKER_SETUP.md b/DOCKER_SETUP.md
new file mode 100644
index 0000000..b16b457
--- /dev/null
+++ b/DOCKER_SETUP.md
@@ -0,0 +1,444 @@
+# Docker Setup Guide for InfantAgent
+
+This guide explains how to run InfantAgent using Docker and Docker Compose.
+
+## Prerequisites
+
+- Docker Engine 20.10+ with Docker Compose V2
+- NVIDIA Docker runtime (nvidia-docker2) - only required for GPU-accelerated components
+- NVIDIA GPU with CUDA support (minimum 3 GPUs recommended for full setup)
+  - 2 GPUs for vLLM server (UI-TARS model with tensor parallelism)
+  - 1 GPU for computer container (display rendering)
+  - InfantAgent server runs on CPU (no GPU needed)
+  - Can work with fewer GPUs by adjusting configuration
+- At least 32GB RAM (64GB recommended)
+- 100GB free disk space (for model downloads and workspace)
+
+## Quick Start
+
+### 1. Clone the Repository
+
+```bash
+git clone https://github.com/bin123apple/InfantAgent.git
+cd InfantAgent
+```
+
+### 2. Set Environment Variables
+
+Create a `.env` file in the project root:
+
+```bash
+# Copy the example file
+cp .env.example .env
+
+# Edit with your values
+nano .env
+```
+
+Required variables:
+```bash
+# Required: Your Anthropic API key
+ANTHROPIC_API_KEY=your_api_key_here
+
+# Optional but recommended: Hugging Face token for UI-TARS model
+HUGGING_FACE_HUB_TOKEN=your_huggingface_token_here
+
+# Optional: Specify which GPUs to use (default: 0,1,2,3)
+CUDA_VISIBLE_DEVICES=0,1,2,3
+```
+
+### 3. Build and Start Services
+
+```bash
+# Build both containers
+docker-compose build
+
+# Start all services
+docker-compose up -d
+
+# View logs
+docker-compose logs -f
+```
+
+### 4. Access the Services
+
+- **InfantAgent API**: http://localhost:8000
+- **vLLM Server API**: http://localhost:8001/v1 (OpenAI-compatible API)
+- **Guacamole Desktop**: http://localhost:4443/guacamole/#/client/GNOME
+  - Username: `web`
+  - Password: `web`
+  - Desktop credentials: `infant` / `123`
+
+## Architecture
+
+The Docker Compose setup includes three main services:
+
+### 1. vllm-server (OSS Model Server)
+- Hosts the UI-TARS-1.5-7B model using vLLM
+- OpenAI-compatible API endpoint
+- Tensor parallelism across 2 GPUs for faster inference
+- Exposed on port 8001
+- Automatic model download from Hugging Face
+
+### 2. infant-agent (Main Server)
+- Runs the FastAPI backend server
+- Handles agent logic and orchestration
+- Connects to vLLM server for OSS model inference
+- Runs on CPU (no GPU required)
+- Exposed on port 8000
+
+### 3. computer-container (Desktop Environment)
+- Ubuntu 22.04 with GNOME desktop
+- Accessible via Guacamole web interface
+- SSH access on port 22222
+- Shared workspace with agent server
+
+## Configuration
+
+### GPU Configuration
+
+By default, the setup uses 3 GPUs:
+- **GPU 2,3**: vLLM server (UI-TARS-1.5-7B model with tensor parallelism)
+- **GPU 0**: Computer container (display rendering)
+- **InfantAgent server**: Runs on CPU (no GPU needed)
+
+**For systems with fewer GPUs:**
+
+If you only have 2 GPUs, modify `docker-compose.yaml`:
+
+```yaml
+# vLLM server - use single GPU
+vllm-server:
+  environment:
+    - CUDA_VISIBLE_DEVICES=1
+  command: >
+    --model ByteDance-Seed/UI-TARS-1.5-7B
+    --tensor-parallel-size 1  # Changed from 2
+  deploy:
+    resources:
+      reservations:
+        devices:
+          - driver: nvidia
+            device_ids: ['1']  # Single GPU
+
+# Computer - use first GPU
+computer-container:
+  deploy:
+    resources:
+      reservations:
+        devices:
+          - driver: nvidia
+            device_ids: ['0']
+
+# InfantAgent - no GPU needed (runs on CPU)
+```
+
+If you only have 1 GPU (vLLM only, no desktop GUI):
+```yaml
+# vLLM server - use the only GPU
+vllm-server:
+  environment:
+    - CUDA_VISIBLE_DEVICES=0
+  deploy:
+    resources:
+      reservations:
+        devices:
+          - driver: nvidia
+            device_ids: ['0']
+
+# Computer container - disable or run without GPU
+computer-container:
+  # Comment out the deploy.resources section to run without GPU
+  # Or don't start it: docker-compose up -d vllm-server infant-agent
+```
+
+### Workspace Volumes
+
+The `./workspace` directory is shared between:
+- Host machine: `./workspace`
+- Agent server: `/app/workspace`
+- Computer container: `/workspace`
+
+Files created in any location are accessible from all others.
+
+### Config Updates
+
+To update the configuration without rebuilding:
+
+1. Edit `config.toml`
+2. Restart the agent service:
+   ```bash
+   docker-compose restart infant-agent
+   ```
+
+## Common Commands
+
+```bash
+# Start services
+docker-compose up -d
+
+# Stop services
+docker-compose down
+
+# View logs
+docker-compose logs -f infant-agent
+docker-compose logs -f vllm-server
+docker-compose logs -f computer-container
+
+# Restart a specific service
+docker-compose restart infant-agent
+
+# Check vLLM server status and model loading progress
+docker-compose logs -f vllm-server | grep -i "model\|loading\|ready"
+
+# Rebuild after code changes
+docker-compose build --no-cache infant-agent
+docker-compose up -d
+
+# Access agent container shell
+docker exec -it infant-agent-server bash
+
+# Access computer container shell
+docker exec -it infant-computer bash
+
+# Monitor resource usage
+docker stats
+```
+
+## Troubleshooting
+
+### GPU Not Detected
+
+Verify NVIDIA Docker runtime is installed:
+
+```bash
+docker run --rm --gpus all nvidia/cuda:12.1.0-base-ubuntu22.04 nvidia-smi
+```
+
+If this fails, install nvidia-docker2:
+
+```bash
+# Ubuntu/Debian
+distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
+curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
+curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
+sudo apt-get update && sudo apt-get install -y nvidia-docker2
+sudo systemctl restart docker
+```
+
+### Container Won't Start
+
+Check logs for errors:
+
+```bash
+docker-compose logs computer-container
+```
+
+Common issues:
+- Port conflicts: Change ports in `docker-compose.yaml`
+- Insufficient memory: Increase Docker memory limit
+- Missing GPU: Check `nvidia-smi` output
+
+### Connection Refused to Guacamole
+
+The computer container takes 1-2 minutes to fully initialize:
+
+1. Check container status: `docker-compose ps`
+2. Wait for health check to pass
+3. Try accessing: http://localhost:4443/guacamole/
+
+### vLLM Server Issues
+
+**Model fails to download:**
+- Check Hugging Face token is set: `echo $HUGGING_FACE_HUB_TOKEN`
+- Verify internet connection
+- Check disk space: `df -h`
+- View download progress: `docker-compose logs -f vllm-server`
+
+**Out of memory errors:**
+- Reduce `--gpu-memory-utilization` from 0.9 to 0.7
+- Use single GPU instead of tensor parallelism
+- Reduce `--max-model-len` from 8192 to 4096
+
+**vLLM server not responding:**
+```bash
+# Check if model is loaded
+curl http://localhost:8001/v1/models
+
+# Test inference
+curl http://localhost:8001/v1/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "ByteDance-Seed/UI-TARS-1.5-7B",
+    "prompt": "Hello, how are you?",
+    "max_tokens": 50
+  }'
+```
+
+The vLLM server takes 2-5 minutes to download and load the model on first startup.
+
+### Build Failures
+
+Clear Docker cache and rebuild:
+
+```bash
+docker-compose down -v
+docker system prune -a
+docker-compose build --no-cache
+docker-compose up -d
+```
+
+## Production Deployment
+
+For production use, consider:
+
+1. **Use docker-compose.prod.yaml** with:
+   - Resource limits
+   - Logging configuration
+   - Secrets management
+   - Network security
+
+2. **Enable HTTPS** for Guacamole:
+   - Use a reverse proxy (nginx/traefik)
+   - Configure SSL certificates
+
+3. **Persistent Storage**:
+   - Use named volumes instead of bind mounts
+   - Regular backup of workspace data
+
+4. **Monitoring**:
+   - Add Prometheus exporters
+   - Configure health check endpoints
+   - Set up alerting
+
+## Advanced Configuration
+
+### Custom Build Args
+
+Build with custom Python version:
+
+```bash
+docker-compose build --build-arg PYTHON_VERSION=3.11 infant-agent
+```
+
+### Multi-GPU Setup
+
+For systems with 4+ GPUs, distribute workload:
+
+```yaml
+infant-agent:
+  environment:
+    - CUDA_VISIBLE_DEVICES=0,1,2,3
+  deploy:
+    resources:
+      reservations:
+        devices:
+          - driver: nvidia
+            count: 4
+            capabilities: [gpu]
+```
+
+### Using Different OSS Models
+
+To use a different model with vLLM, modify the `docker-compose.yaml`:
+
+```yaml
+vllm-server:
+  command: >
+    --model meta-llama/Llama-3-8B  # Change model here
+    --host 0.0.0.0
+    --port 8000
+    --tensor-parallel-size 1  # Adjust based on model size
+    --max-model-len 4096
+    --gpu-memory-utilization 0.9
+    --trust-remote-code
+```
+
+Popular models:
+- `meta-llama/Llama-3-8B`
+- `mistralai/Mistral-7B-v0.1`
+- `Qwen/Qwen2-7B`
+- `ByteDance-Seed/UI-TARS-1.5-7B` (default, optimized for UI tasks)
+
+### vLLM Performance Tuning
+
+**For faster inference:**
+```yaml
+command: >
+  --model ByteDance-Seed/UI-TARS-1.5-7B
+  --enable-prefix-caching  # Cache common prefixes
+  --enable-chunked-prefill  # Process long prompts efficiently
+  --max-num-seqs 16  # Increase batch size
+```
+
+**For lower memory usage:**
+```yaml
+command: >
+  --model ByteDance-Seed/UI-TARS-1.5-7B
+  --gpu-memory-utilization 0.7  # Reduce from 0.9
+  --max-model-len 4096  # Reduce from 8192
+  --quantization awq  # Use quantization (if model supports)
+```
+
+### Development Mode
+
+Mount source code for live reloading:
+
+```yaml
+infant-agent:
+  volumes:
+    - ./infant:/app/infant
+    - ./backend.py:/app/backend.py
+  command: uvicorn backend:app --reload --host 0.0.0.0 --port 8000
+```
+
+### Running Without vLLM (API-only mode)
+
+If you want to use only commercial APIs (no OSS models):
+
+```bash
+# Start without vLLM server
+docker-compose up -d computer-container infant-agent
+
+# Or comment out vllm-server in docker-compose.yaml
+```
+
+Update `config.toml`:
+```toml
+use_oss_llm = false
+```
+
+## Maintenance
+
+### Update to Latest Version
+
+```bash
+cd InfantAgent
+git pull origin main
+docker-compose build --no-cache
+docker-compose up -d
+```
+
+### Clean Up Resources
+
+```bash
+# Remove stopped containers
+docker-compose down
+
+# Remove all data (including volumes)
+docker-compose down -v
+
+# Clean up unused Docker resources
+docker system prune -a --volumes
+```
+
+## Support
+
+For issues and questions:
+- GitHub Issues: https://github.com/bin123apple/InfantAgent/issues
+- Discord: https://discord.gg/urxApEGcwV
+- Documentation: https://github.com/bin123apple/InfantAgent
+
+## License
+
+This project is licensed under the MIT License. See LICENSE file for details.
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..e32a82d
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,58 @@
+# Dockerfile for InfantAgent Server
+# Build from project root: docker build -t infant-agent:latest -f Dockerfile .
+FROM python:3.11-slim-bookworm
+
+# Prevent interactive prompts during installation
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+
+# Install system dependencies including OpenCV requirements
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    ca-certificates \
+    build-essential \
+    git \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    openssh-client \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Download and install uv
+ADD https://astral.sh/uv/install.sh /uv-installer.sh
+RUN sh /uv-installer.sh && rm /uv-installer.sh
+ENV PATH="/root/.local/bin/:$PATH"
+
+# Create working directory
+WORKDIR /app
+
+# Copy dependency files first for better layer caching
+COPY pyproject.toml ./
+
+# Create virtual environment and install dependencies
+RUN uv venv && \
+    uv pip install -e .
+
+# Copy application code
+COPY infant ./infant
+COPY config.toml ./
+COPY backend.py ./
+COPY frontend ./frontend
+
+# Activate virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+ENV VIRTUAL_ENV="/app/.venv"
+
+# Create necessary directories
+RUN mkdir -p /tmp/cache /tmp/file_store /app/workspace && \
+    chmod 777 /tmp/cache /tmp/file_store /app/workspace
+
+# Expose the backend port
+EXPOSE 8008
+
+# Run the web server
+CMD ["python", "backend.py"]
+    
\ No newline at end of file
diff --git a/Dockerfile_vllm b/Dockerfile_vllm
new file mode 100644
index 0000000..fa74679
--- /dev/null
+++ b/Dockerfile_vllm
@@ -0,0 +1,11 @@
+FROM nvidia/cuda:12.2.2-devel-ubuntu22.04
+
+RUN apt-get update && apt-get install -y \
+    curl \
+    python3 python3-pip \
+    && rm -rf /var/lib/apt/lists/*
+    
+RUN pip3 install vllm
+
+
+CMD ["vllm", "serve", "ByteDance-Seed/UI-TARS-1.5-7B", "--host", "0.0.0.0", "--port", "8005", "--max-model-len", "8192", "--gpu-memory-utilization", "0.8", "--dtype", "float16", "--api-key", "infant"]
diff --git a/README.md b/README.md
index 1afc00e..5fedd24 100644
--- a/README.md
+++ b/README.md
@@ -41,7 +41,134 @@ We’ve switched from NoMachine to the open-source Guacamole for desktop sharing
 
 Now, it is only tested on `linux` server with `Nvidia Tesla GPU (A100, H200 ...)`. The GPU is for open-spurce model inference. There may be some bugs for Mac/Windows.
 
-## Setup 
+## Setup
+
+### Option 1: Docker Compose Setup (Recommended)
+
+This is the recommended approach for running InfantAgent as a complete containerized system with all services.
+
+1. **Prerequisites**
+   - Docker and Docker Compose installed
+   - NVIDIA GPU with drivers installed (for vLLM inference)
+   - NVIDIA Container Toolkit installed
+
+2. **Configure Environment Variables**
+
+   Create a `.env` file in the project root:
+   ```bash
+   cd InfantAgent
+   cp .env.example .env
+   ```
+
+   Edit `.env` and add your API keys:
+   ```bash
+   # Required: Claude API key for the agent
+   ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+   # Optional: Hugging Face token for downloading models
+   HF_API_KEY=your_huggingface_token_here
+
+   # Optional: Custom port configuration
+   SSH_PORT=63710
+   GUI_PORT=4443
+   ```
+
+3. **Build and Start All Services**
+   ```bash
+   # Build all containers (first time only)
+   docker compose build
+
+   # Start all services in background
+   docker compose up -d
+
+   # View logs
+   docker compose logs -f
+
+   # View agent logs specifically
+   docker compose logs -f infant-agent-cli
+   ```
+
+4. **Access the Services**
+   - **Guacamole Web Desktop**: http://localhost:4443/guacamole/
+     - Login: `web` / `web`
+     - Connection: Click "GNOME Desktop (RDP)"
+   - **SSH to Computer Container**: `ssh infant@localhost -p 63710` (password: `123`)
+   - **RDP Direct Access**: `localhost:3389` (username: `infant`, password: `123`)
+   - **vLLM Server**: http://localhost:8005 (for OSS model inference)
+
+5. **Managing Containers**
+   ```bash
+   # Stop all services
+   docker compose down
+
+   # Restart specific service
+   docker compose restart infant-agent-cli
+
+   # Rebuild after code changes
+   docker compose down
+   docker compose build infant-agent
+   docker compose up -d
+
+   # View running containers
+   docker compose ps
+
+   # Execute commands in agent container
+   docker exec -it infant-agent-cli bash
+   ```
+
+6. **Interacting with the Agent**
+
+   The agent is ready to receive prompts once you see the log:
+   ```
+   INFO: Current working directory: /workspace
+   Input your request or use type exit to refresh the agent:
+   ```
+
+   **Recommended Method - Direct Attach:**
+   ```bash
+   # Attach to the running container
+   docker attach infant-agent-cli
+
+   # Type your prompt and press Enter
+   # Example: "Create a Python script to analyze data.csv"
+
+   # To detach without stopping, press: Ctrl+P then Ctrl+Q
+   ```
+
+   **Alternative Methods:**
+   ```bash
+   # Send prompt via pipe
+   echo "Your task here" | docker attach --no-stdin --sig-proxy=false infant-agent-cli
+
+   # View logs in real-time
+   docker logs -f infant-agent-cli
+
+   # Using provided scripts (may have limitations)
+   python3 send_prompt.py "Create a Python script"
+   ./agent_cli.sh logs -f
+   ```
+
+   **📖 For detailed usage instructions, see [USAGE.md](USAGE.md)**
+
+7. **Troubleshooting**
+   ```bash
+   # Check service health
+   docker compose ps
+
+   # View detailed logs
+   docker compose logs infant-computer
+   docker compose logs vllm-server
+
+   # Restart unhealthy services
+   docker compose restart
+
+   # Clean up and rebuild
+   docker compose down -v  # Remove volumes
+   docker compose build --no-cache
+   docker compose up -d
+   ```
+
+### Option 2: Manual Setup (Advanced)
 
 1. Setup environment
 ```
diff --git a/VLLM_SETUP.md b/VLLM_SETUP.md
new file mode 100644
index 0000000..4d98865
--- /dev/null
+++ b/VLLM_SETUP.md
@@ -0,0 +1,411 @@
+# vLLM Server Setup Guide
+
+This guide focuses on the vLLM server component for hosting the UI-TARS-1.5-7B model.
+
+## Quick Start
+
+The vLLM server is automatically started when you run `docker-compose up -d`. It serves the UI-TARS-1.5-7B model via an OpenAI-compatible API.
+
+## Configuration
+
+### Default Settings
+
+The vLLM server is configured in [docker-compose.yaml](docker-compose.yaml):
+
+```yaml
+vllm-server:
+  image: vllm/vllm-openai:latest
+  ports:
+    - "8001:8000"
+  environment:
+    - CUDA_VISIBLE_DEVICES=2,3
+  command: >
+    --model ByteDance-Seed/UI-TARS-1.5-7B
+    --tensor-parallel-size 2
+    --max-model-len 8192
+    --gpu-memory-utilization 0.9
+```
+
+### GPU Requirements
+
+- **Minimum**: 1x GPU with 16GB VRAM
+- **Recommended**: 2x GPUs with 24GB VRAM each (for tensor parallelism)
+- **Model Size**: ~14GB (7B parameters)
+
+### Environment Variables
+
+Set in your `.env` file:
+
+```bash
+# Optional but recommended for faster downloads
+HUGGING_FACE_HUB_TOKEN=your_token_here
+
+# GPU allocation (adjust based on your system)
+CUDA_VISIBLE_DEVICES=0,1,2,3
+```
+
+## Accessing the API
+
+### Health Check
+
+```bash
+curl http://localhost:8001/health
+```
+
+### List Models
+
+```bash
+curl http://localhost:8001/v1/models
+```
+
+### Test Inference
+
+```bash
+curl http://localhost:8001/v1/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "ByteDance-Seed/UI-TARS-1.5-7B",
+    "prompt": "Click on the login button",
+    "max_tokens": 100,
+    "temperature": 0.7
+  }'
+```
+
+### Chat Completions
+
+```bash
+curl http://localhost:8001/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "ByteDance-Seed/UI-TARS-1.5-7B",
+    "messages": [
+      {"role": "user", "content": "What should I click to login?"}
+    ],
+    "max_tokens": 100
+  }'
+```
+
+## Integration with InfantAgent
+
+The InfantAgent server automatically connects to vLLM via the environment variable:
+
+```yaml
+infant-agent:
+  environment:
+    - VLLM_BASE_URL=http://vllm-server:8000/v1
+```
+
+In your `config.toml`, set:
+
+```toml
+use_oss_llm = true
+base_url_oss = "http://vllm-server:8000/v1"
+model_oss = "ByteDance-Seed/UI-TARS-1.5-7B"
+```
+
+## Performance Tuning
+
+### For 2 GPUs (Recommended)
+
+```yaml
+vllm-server:
+  environment:
+    - CUDA_VISIBLE_DEVICES=2,3
+  command: >
+    --model ByteDance-Seed/UI-TARS-1.5-7B
+    --tensor-parallel-size 2
+    --max-model-len 8192
+    --gpu-memory-utilization 0.9
+    --disable-custom-all-reduce
+```
+
+### For 1 GPU (Minimum)
+
+```yaml
+vllm-server:
+  environment:
+    - CUDA_VISIBLE_DEVICES=1
+  command: >
+    --model ByteDance-Seed/UI-TARS-1.5-7B
+    --tensor-parallel-size 1
+    --max-model-len 4096
+    --gpu-memory-utilization 0.85
+```
+
+### High Throughput Mode
+
+```yaml
+command: >
+  --model ByteDance-Seed/UI-TARS-1.5-7B
+  --tensor-parallel-size 2
+  --max-model-len 8192
+  --max-num-seqs 32
+  --enable-prefix-caching
+  --enable-chunked-prefill
+```
+
+### Low Memory Mode
+
+```yaml
+command: >
+  --model ByteDance-Seed/UI-TARS-1.5-7B
+  --tensor-parallel-size 1
+  --max-model-len 2048
+  --gpu-memory-utilization 0.7
+  --max-num-seqs 8
+```
+
+## Using Alternative Models
+
+### Llama 3 8B
+
+```yaml
+vllm-server:
+  command: >
+    --model meta-llama/Llama-3-8B
+    --tensor-parallel-size 1
+    --max-model-len 8192
+```
+
+### Mistral 7B
+
+```yaml
+vllm-server:
+  command: >
+    --model mistralai/Mistral-7B-v0.1
+    --tensor-parallel-size 1
+    --max-model-len 8192
+```
+
+### Qwen 2 7B
+
+```yaml
+vllm-server:
+  command: >
+    --model Qwen/Qwen2-7B
+    --tensor-parallel-size 1
+    --max-model-len 8192
+    --trust-remote-code
+```
+
+## Monitoring
+
+### View Logs
+
+```bash
+# All logs
+docker-compose logs -f vllm-server
+
+# Model loading progress
+docker-compose logs -f vllm-server | grep -i "loading\|model\|ready"
+
+# Errors only
+docker-compose logs vllm-server | grep -i "error\|fail"
+```
+
+### Check GPU Usage
+
+```bash
+# From host
+nvidia-smi
+
+# From container
+docker exec vllm-server nvidia-smi
+```
+
+### Monitor Performance
+
+```bash
+# Container stats
+docker stats vllm-server
+
+# Request latency
+time curl http://localhost:8001/v1/completions \
+  -H "Content-Type: application/json" \
+  -d '{"model": "ByteDance-Seed/UI-TARS-1.5-7B", "prompt": "test", "max_tokens": 10}'
+```
+
+## Troubleshooting
+
+### Model Download Fails
+
+**Issue**: Cannot download model from Hugging Face
+
+**Solutions**:
+1. Set Hugging Face token:
+   ```bash
+   export HUGGING_FACE_HUB_TOKEN=your_token_here
+   docker-compose up -d vllm-server
+   ```
+
+2. Pre-download model:
+   ```bash
+   # On host machine
+   huggingface-cli download ByteDance-Seed/UI-TARS-1.5-7B
+
+   # Mount in docker-compose.yaml
+   volumes:
+     - ~/.cache/huggingface:/root/.cache/huggingface
+   ```
+
+### Out of Memory (OOM)
+
+**Issue**: CUDA out of memory errors
+
+**Solutions**:
+1. Reduce memory utilization:
+   ```yaml
+   --gpu-memory-utilization 0.7  # Down from 0.9
+   ```
+
+2. Reduce context length:
+   ```yaml
+   --max-model-len 4096  # Down from 8192
+   ```
+
+3. Use single GPU:
+   ```yaml
+   --tensor-parallel-size 1  # Down from 2
+   ```
+
+4. Reduce batch size:
+   ```yaml
+   --max-num-seqs 4  # Smaller batch
+   ```
+
+### Slow Inference
+
+**Issue**: Requests taking too long
+
+**Solutions**:
+1. Enable caching:
+   ```yaml
+   --enable-prefix-caching
+   ```
+
+2. Increase batch size:
+   ```yaml
+   --max-num-seqs 16
+   ```
+
+3. Use tensor parallelism (if you have 2+ GPUs):
+   ```yaml
+   --tensor-parallel-size 2
+   ```
+
+### Server Not Responding
+
+**Issue**: Cannot connect to http://localhost:8001
+
+**Check**:
+```bash
+# Container status
+docker-compose ps vllm-server
+
+# Port binding
+docker port vllm-server
+
+# Logs
+docker-compose logs vllm-server
+
+# Health
+curl http://localhost:8001/health
+```
+
+**Wait Time**: First startup takes 2-5 minutes to download and load the model.
+
+### Model Not Found
+
+**Issue**: "Model not found" errors
+
+**Solution**:
+Ensure the model name matches exactly:
+```yaml
+# Correct
+--model ByteDance-Seed/UI-TARS-1.5-7B
+
+# Wrong
+--model UI-TARS-1.5-7B
+--model ByteDance/UI-TARS-1.5-7B
+```
+
+## Advanced Configuration
+
+### Custom Sampling Parameters
+
+```yaml
+command: >
+  --model ByteDance-Seed/UI-TARS-1.5-7B
+  --tensor-parallel-size 2
+  --max-model-len 8192
+  --temperature 0.8
+  --top-p 0.95
+  --top-k 50
+```
+
+### Quantization (Lower Memory)
+
+```yaml
+command: >
+  --model ByteDance-Seed/UI-TARS-1.5-7B
+  --quantization awq
+  --tensor-parallel-size 1
+```
+
+Note: Model must support quantization format.
+
+### Distributed Inference (4+ GPUs)
+
+```yaml
+vllm-server:
+  environment:
+    - CUDA_VISIBLE_DEVICES=0,1,2,3
+  command: >
+    --model ByteDance-Seed/UI-TARS-1.5-7B
+    --tensor-parallel-size 4
+    --pipeline-parallel-size 1
+```
+
+## API Documentation
+
+The vLLM server implements the OpenAI API specification:
+
+- **Completions**: `POST /v1/completions`
+- **Chat Completions**: `POST /v1/chat/completions`
+- **Models**: `GET /v1/models`
+- **Health**: `GET /health`
+
+Full API docs: https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html
+
+## Performance Benchmarks
+
+On 2x A100 40GB GPUs:
+- **Cold Start**: 2-3 minutes (model download + loading)
+- **Warm Start**: 30-60 seconds (model loading only)
+- **Inference**: 20-50 tokens/second (depends on batch size)
+- **Latency**: 100-300ms for first token
+
+## Best Practices
+
+1. **Pre-download models** before production deployment
+2. **Use tensor parallelism** for models > 13B parameters
+3. **Enable prefix caching** for repeated prompts
+4. **Monitor GPU memory** and adjust utilization
+5. **Set appropriate max-model-len** based on use case
+6. **Use health checks** to ensure server readiness
+
+## Resources
+
+- vLLM Documentation: https://docs.vllm.ai/
+- UI-TARS Model: https://huggingface.co/ByteDance-Seed/UI-TARS-1.5-7B
+- OpenAI API Spec: https://platform.openai.com/docs/api-reference
+- InfantAgent Issues: https://github.com/bin123apple/InfantAgent/issues
+
+## Support
+
+For vLLM-specific issues:
+- vLLM GitHub: https://github.com/vllm-project/vllm
+- vLLM Discord: https://discord.gg/vllm
+
+For InfantAgent integration:
+- GitHub Issues: https://github.com/bin123apple/InfantAgent/issues
diff --git a/agent_cli.sh b/agent_cli.sh
new file mode 100755
index 0000000..ddaad7b
--- /dev/null
+++ b/agent_cli.sh
@@ -0,0 +1,127 @@
+#!/bin/bash
+# Simple CLI wrapper to interact with InfantAgent via Docker
+
+CONTAINER_NAME="infant-agent-cli"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Function to check if container is running
+check_container() {
+    if ! docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
+        echo -e "${RED}❌ Error: Container '${CONTAINER_NAME}' is not running.${NC}"
+        echo -e "${YELLOW}Please start the containers with: docker compose up -d${NC}"
+        exit 1
+    fi
+}
+
+# Function to send prompt via stdin
+send_prompt() {
+    local prompt="$1"
+    echo -e "${BLUE}📤 Sending prompt to agent:${NC} $prompt"
+    echo -e "${YELLOW}⏳ Agent is processing...${NC}"
+    echo ""
+
+    # Send the prompt to the container's stdin
+    echo "$prompt" | docker attach --no-stdin "$CONTAINER_NAME" 2>/dev/null || \
+    echo "$prompt" | docker exec -i "$CONTAINER_NAME" /bin/bash -c "cat" || \
+    echo -e "${RED}Failed to send prompt. Try: docker exec -it $CONTAINER_NAME python -m infant${NC}"
+}
+
+# Function to view logs
+view_logs() {
+    echo -e "${BLUE}📋 Viewing agent logs...${NC}"
+    if [ "$1" = "-f" ]; then
+        docker logs -f "$CONTAINER_NAME"
+    else
+        docker logs --tail 100 "$CONTAINER_NAME"
+    fi
+}
+
+# Function to show status
+show_status() {
+    echo -e "${BLUE}📊 Container Status:${NC}"
+    docker ps --filter "name=$CONTAINER_NAME" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
+}
+
+# Function to enter interactive mode
+interactive_mode() {
+    echo -e "${GREEN}🤖 Entering interactive mode with agent...${NC}"
+    docker exec -it "$CONTAINER_NAME" /bin/bash
+}
+
+# Function to show help
+show_help() {
+    cat << EOF
+${GREEN}InfantAgent CLI - Docker Container Interface${NC}
+
+Usage: $0 [COMMAND] [OPTIONS]
+
+${YELLOW}Commands:${NC}
+  send "prompt"     Send a prompt to the agent
+  logs              View agent logs (last 100 lines)
+  logs -f           Follow agent logs in real-time
+  status            Show container status
+  shell             Open interactive shell in container
+  restart           Restart the agent container
+  help              Show this help message
+
+${YELLOW}Examples:${NC}
+  $0 send "Create a Python script to analyze data.csv"
+  $0 logs -f
+  $0 status
+  $0 shell
+
+${YELLOW}Direct interaction:${NC}
+  For direct interaction with the agent, use:
+    docker exec -it ${CONTAINER_NAME} /bin/bash
+    # Then inside container:
+    # The agent is already running with input prompt
+
+${YELLOW}View logs while agent is running:${NC}
+  docker logs -f ${CONTAINER_NAME}
+EOF
+}
+
+# Main script logic
+case "$1" in
+    send)
+        check_container
+        if [ -z "$2" ]; then
+            echo -e "${RED}❌ Error: Please provide a prompt${NC}"
+            echo "Usage: $0 send \"your prompt here\""
+            exit 1
+        fi
+        send_prompt "$2"
+        ;;
+    logs)
+        check_container
+        view_logs "$2"
+        ;;
+    status)
+        check_container
+        show_status
+        ;;
+    shell)
+        check_container
+        interactive_mode
+        ;;
+    restart)
+        echo -e "${YELLOW}⏳ Restarting agent container...${NC}"
+        docker restart "$CONTAINER_NAME"
+        echo -e "${GREEN}✅ Container restarted${NC}"
+        ;;
+    help|--help|-h|"")
+        show_help
+        ;;
+    *)
+        echo -e "${RED}❌ Unknown command: $1${NC}"
+        echo ""
+        show_help
+        exit 1
+        ;;
+esac
diff --git a/backend.py b/backend.py
index b4e5d37..d1a0fa3 100644
--- a/backend.py
+++ b/backend.py
@@ -28,7 +28,7 @@
 app = FastAPI()
 
 upstream_http = httpx.AsyncClient(verify=False, follow_redirects=True)
-upstream_aiohttp = ClientSession(connector=TCPConnector(ssl=False))
+upstream_aiohttp = None
 
 # Enable CORS
 app.add_middleware(
@@ -41,6 +41,8 @@
 
 @app.on_event("startup")
 async def startup_event():
+    global upstream_aiohttp
+    upstream_aiohttp = ClientSession(connector=TCPConnector(ssl=False))
     logger.info("[WS] connecting to {url}")
 
 
@@ -73,14 +75,30 @@ async def shutdown_event():
             logger.error(f"Error during cleanup: {str(e)}")
 
 # Redirect to frontend
-@app.get("/")
-async def root():
+@app.get("/", name="root_frontend")
+async def root_frontend():
     return RedirectResponse(url="/frontend/index.html")
 
 # Static files
 app.mount("/frontend", StaticFiles(directory="frontend"), name="frontend")
 
 # Status API
+@app.get("/api/guacamole-token")
+async def guacamole_token():
+    """Get a fresh Guacamole auth token for the iframe."""
+    try:
+        resp = await upstream_http.post(
+            "http://infant-computer:8080/guacamole/api/tokens",
+            data={"username": "web", "password": "web"},
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+        )
+        if resp.status_code == 200:
+            data = resp.json()
+            return {"success": True, "token": data["authToken"]}
+        return {"success": False, "error": f"Guacamole returned {resp.status_code}"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
 @app.get("/api/status")
 async def status():
     if agent:
@@ -88,7 +106,7 @@ async def status():
             "success": True,
             "status": "ready",
             "currentTask": "none",
-            "model": agent._planning_llm.model,
+            "model": agent.planning_llm.model_name,
             "sessionActive": True,
         }
     return {"success": True, "status": "ready", "currentTask": "none", "model": "demo", "sessionActive": False}
@@ -100,8 +118,12 @@ async def chat(data: dict):
     if not user_message:
         return {"success": False, "error": "No message provided"}
     if agent and run_single_step:
-        response = await run_single_step(agent, user_message)
-        return {"success": True, "response": response, "status": "completed"}
+        try:
+            response = await run_single_step(agent, user_message)
+            return {"success": True, "response": response, "status": "completed"}
+        except Exception as e:
+            logger.error(f"Error in chat: {e}")
+            return {"success": False, "error": str(e)}
     await asyncio.sleep(1)
     return {"success": True, "response": f"Demo mode: Received '{user_message}'", "status": "completed"}
 
@@ -121,16 +143,26 @@ async def reset():
 @app.post("/api/settings")
 async def settings(data: dict):
     global config, agent, computer
-    config.model = data.get('model')
-    config.api_key = data.get('apiKey')
-    config.temperature = float(data.get('temperature'))
-    config.max_tokens = int(data.get('maxTokens'))
-    print(agent)
+    # Load base config from config.toml first
+    try:
+        user_config = config._load()
+        config.__dict__.update(user_config)
+    except FileNotFoundError:
+        logger.warning("config.toml not found, using defaults")
+    # Apply frontend settings
+    if data.get('model'):
+        config.model = data.get('model')
+    if data.get('apiKey'):
+        config.api_key = data.get('apiKey')
+    if data.get('temperature') is not None:
+        config.temperature = float(data.get('temperature'))
+    if data.get('maxTokens') is not None:
+        config.max_output_tokens = int(data.get('maxTokens'))
+    # Finalize config (resolves paths, SSH settings, etc.)
+    config.finalize_config()
     if agent:
-        # 实际实现中应该更新 agent 配置
         await agent.update_agent_config(config)
         return {"success": True, "message": "Agent updated", "appliedSettings": data}
-    await asyncio.sleep(0.5)
     return {"success": True, "message": "Agent initialized", "appliedSettings": data}
 
 @app.get("/api/initialize")
@@ -433,26 +465,8 @@ def get_forward_params(request: Request):
     return params
 
 # ——————————————
-# root: capture sid & redirect
+# root: handled by root_frontend above
 # ——————————————
-@app.get("/")
-async def root(request: Request):
-    logger.debug(f"[ROOT] incoming path={request.url.path} query={request.url.query!r}")
-    qs = request.url.query
-    target = "/gui/" + (f"?{qs}" if qs else "")
-    logger.debug(f"[ROOT] redirecting to {target}")
-    resp = RedirectResponse(target)
-    if "sid" in request.query_params:
-        sid_val = request.query_params["sid"]
-        logger.debug(f"[ROOT] setting cookie sid={sid_val!r}")
-        resp.set_cookie(
-            key="sid",
-            value=sid_val,
-            httponly=True,
-            secure=False,   # allow HTTP
-        )
-    logger.debug("[ROOT] response prepared")
-    return resp
 
 # ——————————————
 # SSE proxy
@@ -462,7 +476,7 @@ async def sse(request: Request):
     params = get_forward_params(request)
     logger.debug(f"[SSE] path={request.url.path} params={params} cookies={dict(request.cookies)}")
     upstream = await upstream_aiohttp.get(
-        f"https://localhost:4443{request.url.path}",
+        f"https://infant-computer:8080{request.url.path}",
         params=params,
         ssl=False
     )
@@ -481,7 +495,7 @@ async def gen():
 async def ws_proxy(ws: WebSocket):
     await ws.accept()
     sid = ws.query_params.get("sid") or ws.cookies.get("sid")
-    url = f"wss://localhost:4443{ws.url.path}" + (f"?sid={sid}" if sid else "")
+    url = f"wss://infant-computer:8080{ws.url.path}" + (f"?sid={sid}" if sid else "")
     logger.debug(f"[WS] connecting to {url}")
     upstream = await upstream_aiohttp.ws_connect(url, ssl=False)
     logger.debug("[WS upstream] connected")
@@ -515,7 +529,7 @@ async def to_client():
 @app.api_route("/gui/{full_path:path}", methods=["GET","POST","HEAD","OPTIONS"])
 async def gui_proxy(request: Request, full_path: str):
     params = get_forward_params(request)
-    upstream_url = f"https://localhost:4443/gui/{full_path}"
+    upstream_url = f"https://infant-computer:8080/gui/{full_path}"
     logger.debug(f"[HTTP] {request.method} {upstream_url} params={params} headers={dict(request.headers)}")
 
     resp_up = await upstream_http.request(
@@ -555,12 +569,160 @@ async def gui_proxy(request: Request, full_path: str):
         media_type=resp_up.headers.get("content-type"),
     )
 
+# ——————————————
+# Guacamole HTTP proxy
+# ——————————————
+@app.api_route("/guacamole/{full_path:path}", methods=["GET","POST","PUT","DELETE","HEAD","OPTIONS"])
+async def guacamole_proxy(request: Request, full_path: str):
+    params = get_forward_params(request)
+    upstream_url = f"http://infant-computer:8080/guacamole/{full_path}"
+    logger.debug(f"[guacamole] {request.method} {upstream_url} params={params}")
+
+    body = await request.body()
+    fwd_headers = {
+        k: v for k, v in request.headers.items()
+        if k.lower() not in ("host", "content-length", "transfer-encoding")
+    }
+    resp_up = await upstream_http.request(
+        method=request.method,
+        url=upstream_url,
+        params=params,
+        content=body,
+        headers=fwd_headers,
+    )
+    logger.debug(f"[guacamole upstream] status={resp_up.status_code}")
+
+    headers = {
+        k: v for k, v in resp_up.headers.multi_items()
+        if k.lower() not in ("x-frame-options", "content-security-policy", "set-cookie")
+    }
+
+    # Rewrite Set-Cookie: drop the upstream Domain (so the cookie attaches to our
+    # proxy host), but preserve SameSite/Secure/HttpOnly/Path as set by Guacamole.
+    cookies = resp_up.headers.get_list("set-cookie")
+    rewritten = []
+    for raw in cookies:
+        c = SimpleCookie()
+        try:
+            c.load(raw)
+        except Exception:
+            rewritten.append(raw)
+            continue
+        for morsel in c.values():
+            parts = [f"{morsel.key}={morsel.value}"]
+            parts.append(f"Path={morsel['path'] or '/'}")
+            if morsel["expires"]:
+                parts.append(f"Expires={morsel['expires']}")
+            if morsel["max-age"]:
+                parts.append(f"Max-Age={morsel['max-age']}")
+            if morsel["samesite"]:
+                parts.append(f"SameSite={morsel['samesite']}")
+            if morsel["secure"]:
+                parts.append("Secure")
+            if morsel["httponly"]:
+                parts.append("HttpOnly")
+            rewritten.append("; ".join(parts))
+    if rewritten:
+        # Starlette's Response needs a MutableHeaders to send multiple Set-Cookie lines.
+        resp = Response(
+            content=resp_up.content,
+            status_code=resp_up.status_code,
+            headers=headers,
+            media_type=resp_up.headers.get("content-type"),
+        )
+        for ck in rewritten:
+            resp.raw_headers.append((b"set-cookie", ck.encode("latin-1")))
+        return resp
+
+    return Response(
+        content=resp_up.content,
+        status_code=resp_up.status_code,
+        headers=headers,
+        media_type=resp_up.headers.get("content-type"),
+    )
+
+# ——————————————
+# Guacamole WebSocket proxy
+# ——————————————
+@app.websocket("/guacamole/websocket-tunnel")
+async def guacamole_ws_proxy(ws: WebSocket):
+    # Guacamole's guacamole-common-js WebSocketTunnel connects with subprotocol
+    # "guacamole". The server MUST echo it back or the browser fails the handshake.
+    requested_protocols = ws.headers.get("sec-websocket-protocol", "")
+    client_protocols = [p.strip() for p in requested_protocols.split(",") if p.strip()]
+    selected = "guacamole" if "guacamole" in client_protocols else (client_protocols[0] if client_protocols else None)
+
+    params = dict(ws.query_params)
+    qs = "&".join(f"{k}={v}" for k, v in params.items())
+    url = f"ws://infant-computer:8080/guacamole/websocket-tunnel" + (f"?{qs}" if qs else "")
+    logger.debug(f"[guacamole WS] connecting to {url} protocols={client_protocols}")
+
+    # Forward the browser's Cookie header so upstream session state stays consistent.
+    upstream_headers = {}
+    cookie = ws.headers.get("cookie")
+    if cookie:
+        upstream_headers["Cookie"] = cookie
+
+    upstream = await upstream_aiohttp.ws_connect(
+        url,
+        ssl=False,
+        protocols=client_protocols or (),
+        headers=upstream_headers or None,
+    )
+    logger.debug(f"[guacamole WS] connected upstream protocol={upstream.protocol}")
+
+    # Prefer the subprotocol the upstream actually selected; fall back to our guess.
+    accept_protocol = upstream.protocol or selected
+    await ws.accept(subprotocol=accept_protocol)
+
+    closed = asyncio.Event()
+
+    async def up_to_client():
+        try:
+            async for msg in upstream:
+                if closed.is_set():
+                    break
+                if msg.type == WSMsgType.TEXT:
+                    await ws.send_text(msg.data)
+                elif msg.type == WSMsgType.BINARY:
+                    await ws.send_bytes(msg.data)
+                elif msg.type in (WSMsgType.CLOSE, WSMsgType.CLOSING, WSMsgType.CLOSED):
+                    break
+        except Exception:
+            pass
+        finally:
+            closed.set()
+
+    async def client_to_up():
+        try:
+            while not closed.is_set():
+                m = await ws.receive()
+                if m["type"] == "websocket.receive":
+                    if "text" in m:
+                        await upstream.send_str(m["text"])
+                    else:
+                        await upstream.send_bytes(m["bytes"])
+                else:
+                    break
+        except (WebSocketDisconnect, Exception):
+            pass
+        finally:
+            closed.set()
+
+    try:
+        await asyncio.gather(up_to_client(), client_to_up())
+    except Exception:
+        pass
+    finally:
+        if not upstream.closed:
+            await upstream.close()
+
 # ——————————————
 # proxy for /nxplayer/* (Web Player assets)
 # ——————————————
 @app.api_route("/nxplayer/{full_path:path}", methods=["GET","HEAD","OPTIONS"])
 async def nxplayer_proxy(request: Request, full_path: str):
-    upstream_url = f"https://localhost:4443/nxplayer/{full_path}"
+    upstream_url = f"https://infant-computer:8080/nxplayer/{full_path}"
     logger.debug(f"[nxplayer] {request.method} {upstream_url}")
     resp_up = await upstream_http.request(
         method=request.method,
@@ -582,5 +744,6 @@ async def nxplayer_proxy(request: Request, full_path: str):
     )
 if __name__ == "__main__":
     import uvicorn
-    print("Starting server on http://localhost:8001")
-    uvicorn.run("backend:app", host="0.0.0.0", port=8001, reload=True)
+    port = int(os.getenv("BACKEND_PORT", "8008"))
+    print(f"Starting server on http://localhost:{port}")
+    uvicorn.run("backend:app", host="0.0.0.0", port=port, reload=True)
diff --git a/config.toml b/config.toml
index dc62505..48801f4 100644
--- a/config.toml
+++ b/config.toml
@@ -1,31 +1,31 @@
 # Optional, if not provided, the Global LLM will be used
+# api_key is inherited from ANTHROPIC_API_KEY env var — do NOT set empty api_key here
 [planning_llm]
-model = "claude-sonnet-4-20250514"
-api_key = "" # YOUR API KEY
+model = "claude-sonnet-4-6"
 
 # Optional, if not provided, the Global LLM will be used
 [classification_llm]
-model = "claude-sonnet-4-20250514"
-api_key = "" # YOUR API KEY
+model = "claude-sonnet-4-6"
 
 # Optional, if not provided, the Global LLM will be used
 [execution_llm]
-model = "claude-sonnet-4-20250514"
-api_key = "" # YOUR API KEY
+model = "claude-sonnet-4-6"
 
-# Optional, Visual Grounding model, if not provided, the default VG model will be used
+# Visual Grounding model served by the vLLM container (OpenAI-compatible API).
+# The "openai/" prefix tells litellm to use the OpenAI provider with our custom base_url.
 [vg_llm]
-model_oss = "ByteDance-Seed/UI-TARS-1.5-7B"
+model_oss = "openai/ByteDance-Seed/UI-TARS-1.5-7B"
+base_url_oss = "http://vllm-server:8005/v1"
+api_key_oss = "infant"
 
 # Optional, File Editing model, if not provided, the default model will be used
 [fe_llm]
-model = "claude-sonnet-4-20250514"
+model = "claude-sonnet-4-6"
 
 # Optional, Toolmaker model, if not provided, the default model will be used
 [tm_llm]
-model = "claude-sonnet-4-20250514"
+model = "claude-sonnet-4-6"
 
 # Audio parsing model, if not provided, the default model will be used
 [ap_llm]
 model = "gpt-4o-audio-preview"
-api_key = "" # YOUR API KEY
\ No newline at end of file
diff --git a/docker-compose.yaml b/docker-compose.yaml
new file mode 100644
index 0000000..76938b7
--- /dev/null
+++ b/docker-compose.yaml
@@ -0,0 +1,163 @@
+version: '3.8'
+
+services:
+  # vLLM server for OSS model inference
+  
+  vllm-server:
+    build:
+      context: .
+      dockerfile: Dockerfile_vllm
+    container_name: vllm-server
+    restart: unless-stopped
+    ports:
+      - "8005:8005"
+    environment:
+      - HUGGING_FACE_HUB_TOKEN=${HF_API_KEY:-}
+    volumes:
+      # Cache Hugging Face models
+      - ${HF_HOME:-huggingface-cache}:/root/.cache/huggingface
+    networks:
+      - infant-network
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              device_ids: ['4']
+              capabilities: [gpu, utility, compute, graphics]
+    
+    healthcheck:
+      test: ["CMD-SHELL", "curl -f http://localhost:8005/health || exit 1"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+      start_period: 90s
+
+  # InfantAgent main CLI application
+  infant-agent:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: infant-agent:latest
+    container_name: infant-agent-cli
+    restart: unless-stopped
+    stdin_open: true  # Enable interactive mode (docker run -i)
+    tty: true         # Allocate a pseudo-TTY (docker run -t)
+    ports:
+      - "${BACKEND_PORT:-8008}:8008"
+    environment:
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
+      - PYTHONUNBUFFERED=1
+      - PYTHONIOENCODING=utf-8
+      # vLLM server configuration
+      - base_url_oss=http://vllm-server:8005/v1
+      - api_key_oss=infant
+      - SSH_HOSTNAME=${SSH_HOSTNAME:-computer-container}
+      - SSH_PORT=${SSH_PORT:-63710}
+      - SSH_USERNAME=${SSH_USERNAME:-infant}
+      - SSH_PASSWORD=${SSH_PASSWORD:-123}
+    volumes:
+      # Mount workspace for persistent data
+      - ./workspace:/app/workspace
+      # Mount cache directory
+      - ./cache:/tmp/cache
+      # Mount config for easy updates
+      - ./config.toml:/app/config.toml:ro
+      # Mount Docker socket for container management
+      - /var/run/docker.sock:/var/run/docker.sock
+    networks:
+      - infant-network
+    depends_on:
+      - infant-computer
+      - vllm-server
+
+  # Computer container with desktop environment
+  infant-computer:
+    build:
+      context: .
+      dockerfile: infant/computer/Dockerfile
+    image: ubuntu-gnome-guacamole:22.04
+    container_name: infant-computer
+    restart: unless-stopped
+    ports:
+      # SSH port - maps container port 22 to host (computer.py line 1126)
+      - "${SSH_PORT:-63710}:22"
+      # Guacamole web interface - maps container port 8080 to host (computer.py line 1125)
+      - "${GUI_PORT:-4443}:8080"
+      # RDP port for remote desktop - maps container port 3389 (computer.py line 1127)
+      - "3389:3389"
+    environment:
+      # Display configuration (computer.py line 1135)
+      - DISPLAY=:0
+      # User account creation - "infant" if run_as_infant, "root" otherwise (computer.py line 1131)
+      - CreateUserAccount=${CREATE_USER_ACCOUNT:-infant}
+      # Render type for graphics (computer.py line 1132)
+      - RenderType=${RENDER_TYPE:-gpu}
+      # NVIDIA driver type: Tesla, GeForce, etc. (computer.py line 1133)
+      - NvidiaDriver=${NVIDIA_DRIVER:-Tesla}
+      # GPU device visibility (computer.py line 1134)
+      - NVIDIA_VISIBLE_DEVICES=${NVIDIA_VISIBLE_DEVICES:-0}
+      # Timezone
+      - TZ=America/New_York
+    volumes:
+      # Shared workspace between agent and computer (computer.py line 1169)
+      - ${WORKSPACE_MOUNT_PATH:-./workspace}:/workspace
+      # Cache directory for infant user (computer.py line 1170)
+      - ${CACHE_DIR:-./cache}:/home/infant/.cache
+    networks:
+      - infant-network
+    # Shared memory size (computer.py line 1114)
+    shm_size: '2gb'
+    stdin_open: true
+    tty: true
+    # Privileged mode required for systemd and desktop (computer.py line 1111)
+    privileged: true
+    # User namespace mode (computer.py line 1112)
+    userns_mode: host
+    # IPC mode (computer.py line 1113)
+    ipc: host
+    # Capabilities required for systemd (computer.py line 1115)
+    cap_add:
+      - SYS_ADMIN
+      - SYS_BOOT
+    # TTY device access (computer.py line 1116)
+    devices:
+      - /dev/tty0
+    # deploy:
+    #   resources:
+    #     reservations:
+    #       devices:
+    #         - driver: nvidia
+    #           device_ids: ['${NVIDIA_DEVICE_ID:-0}']
+    #           capabilities: [gpu, utility, compute, graphics]
+    # systemd init command (computer.py line 1137)
+    command: ["/sbin/init", "-D", "-o", "PermitRootLogin=yes"]
+    healthcheck:
+      # Check Guacamole is responding on port 8080 (internal port)
+      test: ["CMD", "curl", "-f", "http://localhost:8080/guacamole/"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 120s
+
+networks:
+  infant-network:
+    driver: bridge
+
+volumes:
+  workspace:
+    driver: local
+  cache:
+    driver: local
+  huggingface-cache:
+    driver: local
+
+
+
+# docker run -it --gpus all \
+#     -v HF_HOME:/root/.cache/huggingface \
+#     -p 8005:8005 \
+#     vllm/vllm-openai:latest \
+#     --model ByteDance-Seed/UI-TARS-1.5-7B \
+#     --dtype bfloat16 \
+#     --gpu-memory-utilization 0.9
diff --git a/evaluation/gaia/run_inference.py b/evaluation/gaia/run_inference.py
index aef3677..e2421f0 100644
--- a/evaluation/gaia/run_inference.py
+++ b/evaluation/gaia/run_inference.py
@@ -8,7 +8,7 @@
 import concurrent.futures
 from infant.config import config, ComputerParams
 from infant.agent.agent import Agent
-from infant.computer.computer import Computer
+from infant.computer.computer import create_computer_from_params
 from infant.llm.llm_api_base import LLM_API_BASED
 from infant.llm.llm_oss_base import LLM_OSS_BASED
 from infant.agent.memory.memory import Userrequest, Finish, IPythonRun
@@ -63,7 +63,7 @@ async def initialize_docker_agent(instance: dict, config=config)-> Agent:
 
     sid = str(uuid.uuid4())
     try:
-        computer = Computer(computer_parameter, sid = sid)
+        computer = create_computer_from_params(computer_parameter, sid = sid)
     except:
         logger.error({traceback.format_exc()})
 
diff --git a/evaluation/swe_bench/run_inference.py b/evaluation/swe_bench/run_inference.py
index 608b961..3aed5a1 100644
--- a/evaluation/swe_bench/run_inference.py
+++ b/evaluation/swe_bench/run_inference.py
@@ -14,7 +14,7 @@
 from infant.config import config, ComputerParams
 from datasets import load_dataset
 from infant.agent.agent import Agent
-from infant.computer.computer import Computer
+from infant.computer.computer import create_computer_from_params
 from infant.llm.llm_api_base import LLM_API_BASED
 from infant.llm.llm_oss_base import LLM_OSS_BASED
 from infant.agent.memory.restore_memory import truncate_output
@@ -153,7 +153,7 @@ async def initialize_docker_agent(instance: dict, config=config)-> Agent:
 
     sid = str(uuid.uuid4())
     try:
-        computer = Computer(computer_parameter, sid = sid)
+        computer = create_computer_from_params(computer_parameter, sid = sid)
     except:
         logger.error({traceback.format_exc()})
         
diff --git a/frontend/.gitignore b/frontend/.gitignore
new file mode 100644
index 0000000..a547bf3
--- /dev/null
+++ b/frontend/.gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/frontend/README.md b/frontend/README.md
new file mode 100644
index 0000000..7059a96
--- /dev/null
+++ b/frontend/README.md
@@ -0,0 +1,12 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.
diff --git a/frontend/css/styles.css b/frontend/css/styles.css
index 6d568bf..9b6dc2b 100644
--- a/frontend/css/styles.css
+++ b/frontend/css/styles.css
@@ -1,564 +1,920 @@
-/* Global Styles */
-:root {
-    --primary-color: #4a6fa5;
-    --secondary-color: #6c757d;
-    --accent-color: #28a745;
-    --background-color: #f8f9fa;
-    --text-color: #333;
-    --border-color: #dee2e6;
-    --message-bg-user: #e9f5ff;
-    --message-bg-system: #f0f0f0;
-    --shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-}
-
-* {
-    margin: 0;
-    padding: 0;
-    box-sizing: border-box;
-}
-
-body {
-    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-    line-height: 1.6;
-    color: var(--text-color);
-    background-color: var(--background-color);
-}
-
-.container {
-    max-width: 1200px;
-    margin: 0 auto;
-    padding: 20px;
-    display: flex;
-    flex-direction: column;
-    min-height: 100vh;
-}
-
-/* Header Styles */
-header {
-    background-color: var(--primary-color);
-    color: white;
-    padding: 15px 20px;
-    border-radius: 8px 8px 0 0;
-    box-shadow: var(--shadow);
-}
-
-header h1 {
-    font-size: 1.8rem;
-    display: flex;
-    align-items: center;
-    gap: 10px;
-}
-
-/* Main Content Styles */
-main {
-    display: grid;
-    grid-template-columns: 1fr 300px;
-    gap: 20px;
-    flex: 1;
-    margin: 20px 0;
-}
-
-/* Chat Container Styles */
-.chat-container {
-    background-color: white;
-    border-radius: 8px;
-    box-shadow: var(--shadow);
-    display: flex;
-    flex-direction: column;
-    height: 70vh;
-}
+/* ==========================================================================
+   InfantAgent Dashboard — Modern Design System
+   Inspired by shadcn/ui (neutral palette, clean borders, subtle shadows)
+   ========================================================================== */
 
+/* --- Design Tokens --- */
+:root {
+  --background: #fafafa;
+  --foreground: #09090b;
+  --card: #ffffff;
+  --card-foreground: #09090b;
+  --muted: #f4f4f5;
+  --muted-foreground: #71717a;
+  --border: #e4e4e7;
+  --input: #e4e4e7;
+  --primary: #18181b;
+  --primary-foreground: #fafafa;
+  --secondary: #f4f4f5;
+  --secondary-foreground: #18181b;
+  --accent: #f4f4f5;
+  --accent-foreground: #18181b;
+  --destructive: #ef4444;
+  --success: #22c55e;
+  --warning: #eab308;
+  --ring: #a1a1aa;
+  --radius: 0.5rem;
+  --font-sans: -apple-system, BlinkMacSystemFont, "Segoe UI", "Noto Sans",
+    Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji";
+  --font-mono: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas,
+    "Liberation Mono", monospace;
+}
+
+/* --- Reset --- */
+*,
+*::before,
+*::after {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body,
+html {
+  height: 100%;
+  font-family: var(--font-sans);
+  font-size: 14px;
+  line-height: 1.5;
+  color: var(--foreground);
+  background-color: var(--background);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+/* ==========================================================================
+   Layout
+   ========================================================================== */
+.dashboard {
+  display: flex;
+  height: 100vh;
+  overflow: hidden;
+}
+
+/* ==========================================================================
+   Chat Sidebar (left panel)
+   ========================================================================== */
+.chat-area {
+  flex: 0 0 25%;
+  display: flex;
+  flex-direction: column;
+  min-width: 300px;
+  max-width: 520px;
+  background: var(--card);
+  border-right: 1px solid var(--border);
+}
+
+/* --- Header --- */
+.chat-area header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  height: 56px;
+  padding: 0 16px;
+  border-bottom: 1px solid var(--border);
+  flex-shrink: 0;
+}
+
+.chat-header-left {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.chat-header-left img {
+  width: 32px;
+  height: 32px;
+  border-radius: 8px;
+  object-fit: cover;
+}
+
+.chat-area header h1 {
+  margin: 0;
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: var(--foreground);
+  letter-spacing: -0.01em;
+}
+
+.setting-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  border-radius: 6px;
+  background: transparent;
+  border: none;
+  color: var(--muted-foreground);
+  cursor: pointer;
+  font-size: 0.875rem;
+  transition: background-color 0.15s, color 0.15s;
+}
+
+.setting-btn:hover {
+  background: var(--accent);
+  color: var(--accent-foreground);
+}
+
+/* --- Chat Messages --- */
 .chat-messages {
-    display: flex;
-    flex-direction: column;
-    padding: 0;           /* 去掉多余内边距 */
-    margin: 5px 0;
-  }
+  flex: 1;
+  overflow-y: auto;
+  padding: 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  border: none;
+  border-radius: 0;
+  margin: 0;
+}
 
 .chat-messages .message {
-    display: flex;        /* 变成 flex 容器 */
-    width: 100%;
-    box-sizing: border-box;
-    margin-bottom: 8px;
-  }
-/* 然后让内容区域跑满剩余空间 */
-.chat-messages .message .message-content {
-    flex: 1 1 auto;       /* 拉伸填满父容器 */
-    max-width: 100%;
-    box-sizing: border-box;
-  }
-
-.message.user {
-    align-items: flex-end;
+  display: flex;
+  width: 100%;
+  margin-bottom: 0;
 }
 
-/* 灰色内容块铺满 parent */
-.chat-messages .message-content {
-    display: block;
-    width: 100%;
-    box-sizing: border-box; /* padding 不会撑破宽度 */
-    background-color: #f0f0f0;  /* 灰色背景 */
-    padding: 8px 12px;      /* 根据喜好调整内边距 */
-    border-radius: 4px;
-    word-break: break-word; /* 内容太长可以换行 */
-  }
+.chat-messages .message .message-content {
+  flex: 1;
+  max-width: 100%;
+  border-radius: 12px;
+  padding: 10px 14px;
+  font-size: 0.8125rem;
+  line-height: 1.65;
+  word-break: break-word;
+  overflow-wrap: break-word;
+}
 
 .message.system .message-content {
-    background-color: var(--message-bg-system);
-    border-radius: 12px 12px 12px 0;
+  background: var(--muted);
+  color: var(--foreground);
+  border-radius: 12px 12px 12px 4px;
 }
 
 .message.user .message-content {
-    background-color: var(--message-bg-user);
-    border-radius: 12px 12px 0 12px;
-    color: #333;
+  background: var(--primary);
+  color: var(--primary-foreground);
+  border-radius: 12px 12px 4px 12px;
 }
 
 .message-content p {
-    margin-bottom: 8px;
+  margin-bottom: 6px;
 }
 
 .message-content p:last-child {
-    margin-bottom: 0;
+  margin-bottom: 0;
 }
 
-.user-input {
-    display: flex;
-    padding: 15px;
-    border-top: 1px solid var(--border-color);
-    background-color: #f8f9fa;
-    border-radius: 0 0 8px 8px;
+.message-content pre {
+  background: #1e1e2e;
+  color: #cdd6f4;
+  padding: 10px 12px;
+  border-radius: 6px;
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  overflow-x: auto;
+  margin: 6px 0;
+  line-height: 1.5;
 }
 
-.user-input textarea {
-    flex: 1;
-    padding: 12px 15px;
-    border: 1px solid var(--border-color);
-    border-radius: 20px;
-    resize: none;
-    height: 50px;
-    font-family: inherit;
-    font-size: 0.95rem;
-}
-
-.user-input button {
-    background-color: var(--primary-color);
-    color: white;
-    border: none;
-    border-radius: 50%;
-    width: 50px;
-    height: 50px;
-    margin-left: 10px;
-    cursor: pointer;
-    transition: background-color 0.2s;
-    display: flex;
-    align-items: center;
-    justify-content: center;
+.message-content code {
+  font-family: var(--font-mono);
+  font-size: 0.8em;
+  background: rgba(0, 0, 0, 0.06);
+  padding: 1px 5px;
+  border-radius: 4px;
 }
 
-.user-input button:hover {
-    background-color: #3a5a8a;
+.message-content pre code {
+  background: none;
+  padding: 0;
 }
 
-#resetButton {
-    background-color: var(--secondary-color);
+.message-content ol,
+.message-content ul {
+  padding-left: 1.5em;
+  margin: 4px 0;
 }
 
-#resetButton:hover {
-    background-color: #5a6268;
+.message-content li {
+  margin-bottom: 2px;
+  list-style-position: outside;
 }
 
-/* Status Panel Styles */
+/* --- Status Panel --- */
 .status-panel {
-    background-color: white;
-    border-radius: 8px;
-    box-shadow: var(--shadow);
-    overflow: hidden;
-}
-
-.status-header {
-    background-color: var(--primary-color);
-    color: white;
-    padding: 15px;
-}
-
-.status-header h3 {
-    font-size: 1.2rem;
-    font-weight: 500;
-}
-
-.status-content {
-    padding: 15px;
+  padding: 8px 16px;
+  border-top: 1px solid var(--border);
+  background: var(--muted);
+  flex-shrink: 0;
 }
 
 .status-item {
-    margin-bottom: 15px;
-    padding-bottom: 15px;
-    border-bottom: 1px solid var(--border-color);
+  display: flex;
+  gap: 6px;
+  align-items: center;
+  margin-bottom: 2px;
+  font-size: 0.6875rem;
+  line-height: 1.6;
 }
 
 .status-item:last-child {
-    margin-bottom: 0;
-    padding-bottom: 0;
-    border-bottom: none;
+  margin-bottom: 0;
+  padding-bottom: 0;
+  border-bottom: none;
 }
 
 .status-label {
-    font-weight: 600;
-    display: block;
-    margin-bottom: 5px;
-    color: var(--secondary-color);
+  font-weight: 500;
+  color: var(--muted-foreground);
+  display: inline;
 }
 
 .status-value {
-    font-size: 0.95rem;
+  font-size: 0.6875rem;
+  font-weight: 500;
 }
 
-/* Footer Styles */
-footer {
-    text-align: center;
-    padding: 15px 0;
-    color: var(--secondary-color);
-    border-top: 1px solid var(--border-color);
-    margin-top: auto;
+/* --- User Input --- */
+.user-input {
+  display: flex;
+  align-items: flex-end;
+  gap: 6px;
+  padding: 12px 16px;
+  border-top: 1px solid var(--border);
+  background: var(--card);
+  flex-shrink: 0;
 }
 
-footer a {
-    color: var(--primary-color);
-    text-decoration: none;
+.user-input textarea {
+  flex: 1;
+  resize: none;
+  padding: 8px 12px;
+  border: 1px solid var(--input);
+  border-radius: 12px;
+  font-family: var(--font-sans);
+  font-size: 0.8125rem;
+  line-height: 1.5;
+  color: var(--foreground);
+  background: var(--muted);
+  min-height: 38px;
+  max-height: 120px;
+  outline: none;
+  transition: border-color 0.15s, box-shadow 0.15s;
 }
 
-footer a:hover {
-    text-decoration: underline;
+.user-input textarea:focus {
+  border-color: var(--ring);
+  box-shadow: 0 0 0 2px rgba(161, 161, 170, 0.15);
 }
 
-/* Modal Styles */
-.modal {
-    display: none;
-    position: fixed;
-    z-index: 1000;
-    left: 0;
-    top: 0;
-    width: 100%;
-    height: 100%;
-    background-color: rgba(0, 0, 0, 0.5);
-    align-items: center;
-    justify-content: center;
+.user-input textarea::placeholder {
+  color: var(--muted-foreground);
 }
 
-.modal-content {
-    background-color: white;
-    padding: 25px;
-    border-radius: 8px;
-    width: 90%;
-    max-width: 500px;
-    box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
-    position: relative;
+.user-input button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  border-radius: 6px;
+  border: 1px solid var(--border);
+  background: var(--card);
+  color: var(--muted-foreground);
+  cursor: pointer;
+  transition: all 0.15s;
+  flex-shrink: 0;
+  font-size: 0.8125rem;
 }
 
-.close-button {
-    position: absolute;
-    top: 15px;
-    right: 20px;
-    font-size: 24px;
-    cursor: pointer;
-    color: var(--secondary-color);
+.user-input button:hover {
+  background: var(--accent);
+  color: var(--accent-foreground);
 }
 
-.modal h2 {
-    margin-bottom: 20px;
-    color: var(--primary-color);
+#sendButton {
+  background: var(--primary);
+  color: var(--primary-foreground);
+  border-color: var(--primary);
 }
 
-.form-group {
-    margin-bottom: 20px;
+#sendButton:hover {
+  opacity: 0.9;
 }
 
-.form-group label {
-    display: block;
-    margin-bottom: 8px;
-    font-weight: 500;
+#resetButton {
+  background: var(--card);
 }
 
-.form-group input,
-.form-group select {
-    width: 100%;
-    padding: 10px;
-    border: 1px solid var(--border-color);
-    border-radius: 4px;
-    font-size: 0.95rem;
+.hidden-input {
+  display: none;
 }
 
-.form-group input[type="range"] {
-    width: calc(100% - 40px);
-    vertical-align: middle;
+/* ==========================================================================
+   Resizer
+   ========================================================================== */
+.resizer {
+  width: 1px;
+  background-color: var(--border);
+  cursor: col-resize;
+  position: relative;
+  transition: background-color 0.15s;
+  flex-shrink: 0;
 }
 
-#temperatureValue {
-    display: inline-block;
-    width: 30px;
-    text-align: right;
-    margin-left: 5px;
+/* Wider invisible grab target */
+.resizer::before {
+  content: "";
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: -4px;
+  right: -4px;
+  z-index: 10;
 }
 
-.submit-button {
-    background-color: var(--accent-color);
-    color: white;
-    border: none;
-    padding: 10px 20px;
-    border-radius: 4px;
-    cursor: pointer;
-    font-size: 1rem;
-    margin-top: 10px;
+.resizer:hover {
+  background-color: var(--ring);
 }
 
-.submit-button:hover {
-    background-color: #218838;
+.resizer:active {
+  background-color: var(--primary);
 }
 
-/* Responsive Styles */
-@media (max-width: 768px) {
-    main {
-        grid-template-columns: 1fr;
-    }
+/* Small drag indicator in the center */
+.resizer::after {
+  content: "";
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  width: 3px;
+  height: 28px;
+  background: var(--border);
+  border-radius: 2px;
+  opacity: 0;
+  transition: opacity 0.15s;
+}
 
-    .chat-container {
-        height: 60vh;
-    }
+.resizer:hover::after {
+  opacity: 1;
 }
 
-/* 在你的style.css中添加以下样式 */
+/* ==========================================================================
+   Right Dashboard
+   ========================================================================== */
+.dashboard-right {
+  flex: 1;
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  grid-template-rows: 1fr 1fr;
+  gap: 8px;
+  padding: 8px;
+  position: relative;
+  min-width: 400px;
+  height: 100vh;
+  box-sizing: border-box;
+  background: var(--background);
+  pointer-events: auto;
+}
+
+/* ==========================================================================
+   Panels
+   ========================================================================== */
+.panel {
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  position: relative;
+  z-index: 1;
+  min-height: 0;
+  min-width: 0;
+  width: 100%;
+  height: 100%;
+  box-sizing: border-box;
+  background: var(--card);
+}
 
-/* Task items styling */
+.panel.fullspan {
+  grid-column: 1 / -1;
+  grid-row: 1 / -1;
+  z-index: 10;
+}
+
+.panel.hidden {
+  display: none;
+}
+
+/* --- Panel Header --- */
+.panel-header {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 0 12px;
+  height: 36px;
+  background: var(--card);
+  border-bottom: 1px solid var(--border);
+  font-size: 0.75rem;
+  font-weight: 500;
+  color: var(--foreground);
+  position: relative;
+  z-index: 100;
+  flex-shrink: 0;
+}
+
+.panel-header i:first-child {
+  color: var(--muted-foreground);
+  font-size: 0.6875rem;
+}
+
+.panel.fullspan .panel-header {
+  height: 44px;
+  font-size: 0.875rem;
+  padding: 0 16px;
+}
+
+/* --- Panel Content --- */
+.panel-content {
+  flex: 1;
+  overflow: hidden;
+  padding: 0;
+  min-height: 0;
+  display: flex;
+  flex-direction: column;
+  word-wrap: break-word;
+  word-break: break-all;
+  overflow-wrap: break-word;
+  hyphens: auto;
+  max-width: 100%;
+}
+
+/* --- Fullscreen Button --- */
+.fs-btn {
+  position: absolute;
+  top: 50%;
+  right: 8px;
+  transform: translateY(-50%);
+  width: 26px;
+  height: 26px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: transparent;
+  border: none;
+  border-radius: 6px;
+  font-size: 0.6875rem;
+  color: var(--muted-foreground);
+  cursor: pointer;
+  z-index: 101;
+  pointer-events: auto;
+  transition: background-color 0.15s, color 0.15s;
+  line-height: 1;
+}
+
+.fs-btn:hover {
+  background: var(--accent);
+  color: var(--accent-foreground);
+}
+
+.fs-btn:focus-visible {
+  outline: 2px solid var(--ring);
+  outline-offset: 2px;
+}
+
+.panel.fullspan .fs-btn {
+  right: 12px;
+}
+
+/* ==========================================================================
+   Terminal & Notebook
+   ========================================================================== */
+.terminal-output {
+  background: #0c0c0c;
+  color: #4ade80;
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  padding: 12px;
+  flex: 1;
+  overflow-x: auto;
+  overflow-y: auto;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+  word-break: normal;
+  overflow-wrap: break-word;
+  margin: 0;
+  min-height: 0;
+  max-width: 100%;
+  line-height: 1.6;
+}
+
+.notebook-output {
+  background: var(--muted);
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  padding: 12px;
+  flex: 1;
+  overflow-x: auto;
+  overflow-y: auto;
+  white-space: pre-wrap;
+  word-wrap: break-word;
+  word-break: normal;
+  overflow-wrap: break-word;
+  margin: 0;
+  min-height: 0;
+  max-width: 100%;
+  line-height: 1.6;
+}
+
+/* --- Desktop iframe --- */
+.iframe-container {
+  flex: 1;
+  min-height: 0;
+  overflow: hidden;
+}
+
+#desktopFrame {
+  width: 100%;
+  height: 100%;
+  border: none;
+}
+
+/* ==========================================================================
+   Subtask List
+   ========================================================================== */
+#subtaskList {
+  flex: 1;
+  min-height: 0;
+  overflow-y: auto;
+  overflow-x: hidden;
+  margin: 0;
+  padding: 8px;
+  list-style: none;
+  max-width: 100%;
+}
+
+#subtaskList li {
+  word-wrap: break-word;
+  overflow-wrap: break-word;
+  hyphens: auto;
+  white-space: normal;
+  max-width: 100%;
+}
+
+/* --- Task Items --- */
 .task-item {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    padding: 8px 12px;
-    margin: 4px 0;
-    background: #f8f9fa;
-    border-radius: 6px;
-    border-left: 3px solid #007bff;
-    transition: all 0.2s ease;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 8px 12px;
+  margin-bottom: 4px;
+  background: var(--muted);
+  border-radius: 6px;
+  border-left: 3px solid var(--ring);
+  transition: background-color 0.15s;
 }
 
 .task-item:hover {
-    background: #e9ecef;
-    transform: translateX(2px);
+  background: var(--accent);
 }
 
 .task-item.completed {
-    border-left-color: #28a745;
-    background: #d4edda;
-    opacity: 0.8;
-    color: #6c757d;
+  border-left-color: var(--success);
+  background: #f0fdf4;
+  opacity: 0.75;
 }
 
 .task-item.running {
-    border-left-color: #ffc107;
-    background: #fff3cd;
+  border-left-color: var(--warning);
+  background: #fefce8;
 }
 
 .task-content {
-    flex: 1;
+  flex: 1;
 }
 
 .task-name {
-    display: block;
-    font-weight: 500;
-    color: #333;
-    margin-bottom: 2px;
+  display: block;
+  font-weight: 500;
+  font-size: 0.8125rem;
+  color: var(--foreground);
+  margin-bottom: 2px;
 }
 
 .task-description {
-    font-size: 0.85em;
-    color: #666;
-    margin-top: 4px;
+  font-size: 0.75rem;
+  color: var(--muted-foreground);
+  margin-top: 2px;
 }
 
 .task-status {
-    display: inline-block;
-    padding: 2px 6px;
-    border-radius: 12px;
-    font-size: 0.75em;
-    font-weight: 500;
-    text-transform: uppercase;
-    margin-left: 8px;
+  display: inline-flex;
+  align-items: center;
+  padding: 1px 8px;
+  border-radius: 9999px;
+  font-size: 0.625rem;
+  font-weight: 500;
+  text-transform: uppercase;
+  letter-spacing: 0.025em;
+  margin-left: 8px;
 }
 
 .status-pending {
-    background: #6c757d;
-    color: white;
+  background: var(--secondary);
+  color: var(--secondary-foreground);
 }
 
 .status-running {
-    background: #ffc107;
-    color: #212529;
+  background: #fef9c3;
+  color: #854d0e;
 }
 
 .status-completed {
-    background: #28a745;
-    color: white;
+  background: #dcfce7;
+  color: #166534;
 }
 
 .task-actions {
-    display: flex;
-    gap: 4px;
-    opacity: 0;
-    transition: opacity 0.2s ease;
+  display: flex;
+  gap: 4px;
+  opacity: 0;
+  transition: opacity 0.15s;
 }
 
 .task-item:hover .task-actions {
-    opacity: 1;
+  opacity: 1;
 }
 
 .task-btn {
-    width: 24px;
-    height: 24px;
-    border: none;
-    border-radius: 50%;
-    cursor: pointer;
-    font-size: 12px;
-    font-weight: bold;
-    transition: all 0.2s ease;
+  width: 22px;
+  height: 22px;
+  border: none;
+  border-radius: 6px;
+  cursor: pointer;
+  font-size: 0.6875rem;
+  font-weight: 600;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  transition: opacity 0.15s;
 }
 
 .complete-btn {
-    background: #28a745;
-    color: white;
+  background: var(--success);
+  color: white;
 }
 
 .complete-btn:hover {
-    background: #218838;
-    transform: scale(1.1);
+  opacity: 0.85;
 }
 
 .delete-btn {
-    background: #dc3545;
-    color: white;
+  background: var(--destructive);
+  color: white;
 }
 
 .delete-btn:hover {
-    background: #c82333;
-    transform: scale(1.1);
+  opacity: 0.85;
+}
+
+/* --- Empty state for subtasks --- */
+#subtaskList li[style*="italic"] {
+  text-align: center;
+  padding: 24px 16px;
+  border: 1px dashed var(--border);
+  border-radius: var(--radius);
+  margin: 8px;
+  font-size: 0.8125rem;
+  color: var(--muted-foreground);
+}
+
+/* ==========================================================================
+   Settings Modal
+   ========================================================================== */
+.modal {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background: rgba(0, 0, 0, 0.5);
+  backdrop-filter: blur(4px);
+  -webkit-backdrop-filter: blur(4px);
+  display: none;
+  justify-content: center;
+  align-items: center;
+  z-index: 1000;
 }
 
-/* Notification styling */
+.modal-content {
+  background: var(--card);
+  padding: 24px;
+  border-radius: 12px;
+  width: 90%;
+  max-width: 420px;
+  border: 1px solid var(--border);
+  box-shadow: 0 16px 48px rgba(0, 0, 0, 0.12);
+  position: relative;
+}
+
+.modal-content h2 {
+  font-size: 1.125rem;
+  font-weight: 600;
+  color: var(--foreground);
+  margin-bottom: 20px;
+  letter-spacing: -0.01em;
+}
+
+.close-btn {
+  position: absolute;
+  top: 16px;
+  right: 16px;
+  width: 28px;
+  height: 28px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: transparent;
+  border: none;
+  border-radius: 6px;
+  color: var(--muted-foreground);
+  cursor: pointer;
+  transition: background-color 0.15s, color 0.15s;
+  font-size: 0.875rem;
+}
+
+.close-btn:hover {
+  background: var(--accent);
+  color: var(--accent-foreground);
+}
+
+.form-group {
+  margin-bottom: 16px;
+}
+
+.form-group label {
+  display: block;
+  margin-bottom: 6px;
+  font-weight: 500;
+  font-size: 0.8125rem;
+  color: var(--foreground);
+}
+
+.form-group input,
+.form-group select {
+  width: 100%;
+  padding: 8px 12px;
+  border: 1px solid var(--input);
+  border-radius: 6px;
+  font-size: 0.8125rem;
+  font-family: var(--font-sans);
+  color: var(--foreground);
+  background: var(--card);
+  outline: none;
+  transition: border-color 0.15s, box-shadow 0.15s;
+}
+
+.form-group input:focus,
+.form-group select:focus {
+  border-color: var(--ring);
+  box-shadow: 0 0 0 2px rgba(161, 161, 170, 0.15);
+}
+
+.form-group input[type="range"] {
+  width: calc(100% - 44px);
+  vertical-align: middle;
+  padding: 0;
+  accent-color: var(--primary);
+}
+
+#temperatureValue {
+  display: inline-block;
+  width: 30px;
+  text-align: right;
+  margin-left: 8px;
+  font-size: 0.8125rem;
+  font-weight: 500;
+  font-family: var(--font-mono);
+  color: var(--muted-foreground);
+}
+
+.submit-button {
+  width: 100%;
+  padding: 8px 16px;
+  background: var(--primary);
+  color: var(--primary-foreground);
+  border: none;
+  border-radius: 6px;
+  font-size: 0.8125rem;
+  font-weight: 500;
+  font-family: var(--font-sans);
+  cursor: pointer;
+  transition: opacity 0.15s;
+  margin-top: 8px;
+}
+
+.submit-button:hover {
+  opacity: 0.9;
+}
+
+/* ==========================================================================
+   Notifications
+   ========================================================================== */
 .notification {
-    position: fixed;
-    top: 20px;
-    right: 20px;
-    padding: 12px 20px;
-    border-radius: 6px;
-    color: white;
-    font-weight: 500;
-    z-index: 1000;
-    transform: translateX(100%);
-    animation: slideIn 0.3s ease forwards;
+  position: fixed;
+  top: 16px;
+  right: 16px;
+  padding: 10px 16px;
+  border-radius: var(--radius);
+  font-size: 0.8125rem;
+  font-weight: 500;
+  z-index: 1001;
+  border: 1px solid;
+  transform: translateX(calc(100% + 20px));
+  animation: slideIn 0.2s ease forwards;
 }
 
 .notification-success {
-    background: #28a745;
+  background: #f0fdf4;
+  border-color: #bbf7d0;
+  color: #166534;
 }
 
 .notification-error {
-    background: #dc3545;
+  background: #fef2f2;
+  border-color: #fecaca;
+  color: #991b1b;
 }
 
 .notification-info {
-    background: #17a2b8;
+  background: #eff6ff;
+  border-color: #bfdbfe;
+  color: #1e40af;
 }
 
 .notification.fade-out {
-    animation: slideOut 0.3s ease forwards;
+  animation: slideOut 0.2s ease forwards;
 }
 
 @keyframes slideIn {
-    to {
-        transform: translateX(0);
-    }
+  to {
+    transform: translateX(0);
+  }
 }
 
 @keyframes slideOut {
-    to {
-        transform: translateX(100%);
-    }
+  to {
+    transform: translateX(calc(100% + 20px));
+  }
 }
 
-/* Empty state */
-#subtaskList li[style*="italic"] {
-    text-align: center;
-    padding: 20px;
-    border: 2px dashed #ddd;
-    border-radius: 6px;
-    margin: 10px 0;
+/* ==========================================================================
+   Scrollbars
+   ========================================================================== */
+::-webkit-scrollbar {
+  width: 6px;
+  height: 6px;
 }
 
-#terminalOutput {
-    white-space: pre-wrap;
-  }
+::-webkit-scrollbar-track {
+  background: transparent;
+}
 
-/* 让 fullspan 时横跨所有格子，并置顶 */
-.panel.fullspan {
-    grid-column: 1 / -1;
-    grid-row: 1 / -1;
-    z-index: 10;
-  }
-  
-  /* 隐藏非目标 panel */
-  .panel.hidden {
-    display: none;
-  }
+::-webkit-scrollbar-thumb {
+  background: var(--border);
+  border-radius: 3px;
+}
 
-/* 保证 dashboard-right 区域本身可以接收事件 */
-.dashboard-right {
-    position: relative;
-    pointer-events: auto;
-  }
-  
-/* 1. Panel 不裁剪其子元素（包括 header 溢出） */
-.panel {
-    position: relative;
-    overflow: visible !important;
-    z-index: 1;
-  }
-  
-  /* 2. Header 保证在最上层并使用 Flex 布局 */
-  .panel-header {
-    position: relative;      /* 参照系，供绝对定位的按钮使用 */
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    padding: 4px 8px;
-    background: #fafafa;
-    z-index: 100;            /* 压过 iframe 等内容 */
+::-webkit-scrollbar-thumb:hover {
+  background: var(--ring);
+}
+
+/* ==========================================================================
+   Responsive
+   ========================================================================== */
+@media (max-width: 900px) {
+  .chat-area {
+    min-width: 240px;
+    flex-basis: 30%;
   }
-  
-  /* ----------------------------
-     全屏按钮样式
-     ---------------------------- */
-  
-  /* 3. 按钮绝对定位到 header 右上角 */
-  .fs-btn {
-    position: absolute;
-    top: 4px;
-    right: 4px;
-    width: 24px;
-    height: 24px;
-    line-height: 24px;
-    text-align: center;
-  
-    background: transparent;
-    border: none;
-    font-size: 1rem;
-    cursor: pointer;
-  
-    z-index: 101;            /* 高于 header 本身 */
-    pointer-events: auto;
+
+  .dashboard-right {
+    min-width: 300px;
   }
-  
-  /* 4. Hover 反馈 */
-  .fs-btn:hover {
-    background: rgba(0, 0, 0, 0.05);
-    border-radius: 4px;
-  }
\ No newline at end of file
+}
+
+#terminalOutput {
+  white-space: pre-wrap;
+}
diff --git a/frontend/eslint.config.js b/frontend/eslint.config.js
new file mode 100644
index 0000000..ec2b712
--- /dev/null
+++ b/frontend/eslint.config.js
@@ -0,0 +1,33 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+
+export default [
+  { ignores: ['dist'] },
+  {
+    files: ['**/*.{js,jsx}'],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    plugins: {
+      'react-hooks': reactHooks,
+      'react-refresh': reactRefresh,
+    },
+    rules: {
+      ...js.configs.recommended.rules,
+      ...reactHooks.configs.recommended.rules,
+      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
+      'react-refresh/only-export-components': [
+        'warn',
+        { allowConstantExport: true },
+      ],
+    },
+  },
+]
diff --git a/frontend/index.html b/frontend/index.html
index d04d1c3..fb06c09 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -3,328 +3,38 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Infant AI Assistant Dashboard</title>
+  <title>InfantAgent</title>
   <link rel="icon" type="image/png" href="asset/Logo.png">
   <link rel="stylesheet" href="css/styles.css">
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
-  <style>
-    /* Layout */
-    body, html { height: 100%; margin: 0; padding: 0; font-family: Arial, sans-serif; }
-    .dashboard { display: flex; height: 100vh; }
-    .chat-area { 
-      flex: 0 0 25%;
-      padding: 5px 0;
-      padding-left: 5px;
-      display: flex; 
-      flex-direction: column;
-      min-width: 300px;
-    }
-    
-    /* Added styles for the resizer */
-    .resizer {
-      width: 6px;
-      background-color: #e0e0e0;
-      cursor: col-resize;
-      position: relative;
-      transition: background-color 0.2s ease;
-    }
-    
-    .resizer:hover {
-      background-color: #4a6fa5;
-    }
-    
-    .resizer:active {
-      background-color: #3a5a8a;
-    }
-    
-    /* Indicator in the middle of the resizer */
-    .resizer::after {
-      content: '';
-      position: absolute;
-      top: 50%;
-      left: 50%;
-      transform: translate(-50%, -50%);
-      width: 2px;
-      height: 40px;
-      background-color: #999;
-      border-radius: 1px;
-    }
-    .chat-messages { flex: 1; overflow-y: auto; border: 1px solid #ccc; border-radius: 4px; padding: 8px; margin: 5px 0; }
-    .user-input { display: flex; align-items: center; margin: 5px 0; }
-    .user-input textarea { flex: 1; resize: none; padding: 6px; }
-    .user-input button { margin-left: 4px; }
-
-    /* Status panel */
-    .status-panel { margin: 5px 0; font-size: 0.9em; }
-    .status-item { display: flex; gap: 4px; margin-bottom: 2px; }
-    .status-label { font-weight: bold; }
-
-    /* Right dashboard grid */
-    .dashboard-right {
-      flex: 0 0 75%;
-      display: grid;
-      grid-template-columns: 1fr 1fr;
-      grid-template-rows: 1fr 1fr;
-      gap: 5px;
-      padding: 10px;
-      position: relative;
-      pointer-events: auto;
-      min-width: 400px;
-      height: 100vh;
-      box-sizing: border-box;
-    }
-    
-    .panel { 
-      border: 1px solid #ccc; 
-      border-radius: 4px; 
-      padding: 0;
-      display: flex; 
-      flex-direction: column; 
-      overflow: hidden;
-      position: relative;
-      z-index: 1;
-      min-height: 0;
-      min-width: 0;
-      width: 100%;
-      height: 100%;
-      box-sizing: border-box;
-    }
-    
-    /* Fullscreen state: span all grid cells and be on top */
-    .panel.fullspan {
-      grid-column: 1 / -1;
-      grid-row: 1 / -1;
-      z-index: 10;
-    }
-    
-    /* Hide non-target panels */
-    .panel.hidden {
-      display: none;
-    }
-    
-    .panel-header { 
-      font-weight: bold; 
-      margin: 0;
-      padding: 8px;
-      position: relative;
-      display: flex;
-      align-items: center;
-      justify-content: start; 
-      background: #fafafa;
-      border-bottom: 0.5px solid #e0e0e0;
-      z-index: 100;
-    }
-    
-    /* Content area styles - key fixes */
-    .panel-content {
-      flex: 1;
-      overflow: hidden;
-      padding: 0px;
-      min-height: 0;
-      display: flex;
-      flex-direction: column;
-      word-wrap: break-word;
-      word-break: break-all;
-      overflow-wrap: break-word;
-      hyphens: auto;
-      max-width: 100%;
-    }
-    
-    .terminal-output { 
-      background: #000; 
-      color: #0f0; 
-      font-family: monospace; 
-      font-size: 12px;
-      padding: 6px; 
-      flex: 1; 
-      overflow-x: auto;
-      overflow-y: auto; 
-      word-wrap: break-word; 
-      word-break: normal;
-      overflow-wrap: break-word;
-      white-space: pre-wrap;
-      margin: 0;
-      min-height: 0;
-      max-width: 100%;
-      line-height: 1.4;
-    }
-    
-    .notebook-output { 
-      background: #f5f5f5; 
-      font-family: monospace; 
-      font-size: 12px;
-      padding: 6px; 
-      flex: 1; 
-      overflow-x: auto;
-      overflow-y: auto; 
-      word-wrap: break-word; 
-      word-break: normal;
-      overflow-wrap: break-word;
-      white-space: pre-wrap;
-      margin: 0;
-      min-height: 0;
-      max-width: 100%;
-      line-height: 1.4;
-    }
-    
-    /* Subtask list styles */
-    #subtaskList {
-      word-wrap: break-word;
-      word-break: break-all;
-      hyphens: auto;
-      white-space: normal;
-      flex: 1;
-      min-height: 0;
-      overflow-y: auto;
-      overflow-x: hidden;
-      margin: 0;
-      padding: 0;
-      list-style-type: disc;
-      padding-left: 20px;
-      max-width: 100%;
-    }
-    
-    #subtaskList li {
-      word-wrap: break-word;
-      word-break: break-all;
-      hyphens: auto;
-      white-space: normal;
-      margin-bottom: 4px;
-      line-height: 1.4;
-      max-width: 100%;
-      overflow-wrap: break-word;
-    }
-    
-    /* iframe styles to ensure it fills the panel content */
-    .iframe-container {
-      flex: 1;
-      min-height: 0;
-      overflow: hidden;
-    }
-    
-    #desktopFrame {
-      width: 100%;
-      height: 100%;
-      border: none;
-    }
-
-    /*Fullscreen Button*/
-    .fs-btn {
-      position: absolute;
-      top: 4px;
-      right: 4px;
-      width: 24px;
-      height: 24px;
-      line-height: 24px;
-      text-align: center;
-      background: transparent;
-      border: none;
-      font-size: 1rem;
-      cursor: pointer;
-      z-index: 101;
-      pointer-events: auto;
-    }
-    
-    .fs-btn:hover {
-      background: rgba(0, 0, 0, 0.05);
-      border-radius: 4px;
-    }
-
-    /* Modal */
-    .modal {
-      position: fixed; top: 0; left: 0;
-      width: 100%; height: 100%;
-      background: rgba(0,0,0,0.5);
-      display: none; justify-content: center; align-items: center;
-    }
-    .modal-content {
-      background: #fff; padding: 20px;
-      border-radius: 4px; width: 90%; max-width: 400px;
-      position: relative;
-    }
-    .close-btn {
-      position: absolute; top: 10px; right: 15px;
-      font-size: 1em; cursor: pointer;
-      background: transparent; border: none; 
-    }
-    .close-btn:hover {
-      background: rgba(0, 0, 0, 0.05);
-      border-radius: 4px;
-    }
-    .form-group { margin-bottom: 10px; }
-    .submit-button { margin-top: 10px; }
-
-    .setting-btn {
-      background: transparent; 
-      border: none; 
-      font-size: 1.2em; 
-      padding-right: 5px;
-      color:#f5f5f5}
-
-    .setting-btn:hover {
-      background: rgba(0, 0, 0, 0.05); 
-      border-radius: 4px;}
-
-    ol, li { /* Or ol li */
-      list-style-position: inside;
-    }
-  </style>
-  <style>
-    :root{ --dpr:1; --px: calc(1px / var(--dpr)); }
-    .panel .panel-header{ padding: calc(0.5 * var(--px)) 8px; }
-    .panel.fullspan .panel-header{ padding: 8px 12px; }
-    .panel .panel-header .fs-btn { top: calc(0.5 * var(--px)); right: 2px; }
-    .panel.fullspan .panel-header .fs-btn { top: 4px; right: 4px; }
-    .panel .panel-header { font-size: 10px; padding: 0.05em 0.6em; }  /* Not full screen */
-    .panel.fullspan .panel-header { font-size: 16px; padding: 0.5em 0.75em; } /* full screen */
-    .panel .panel-header { position: relative; }
-
-    .panel .panel-header .fs-btn{
-      position: absolute;
-      top: 50%;
-      right: 6px;
-      transform: translateY(-50%);
-      width: 28px; height: 28px;
-      line-height: 28px;
-      z-index: 101;
-    }
-    
-    .panel.fullspan .panel-header .fs-btn{ right: 10px; }
-    
-    .panel .panel-header .fs-btn:focus-visible{
-      outline: 2px solid #4a90e2;
-      outline-offset: 2px;
-    }
-  </style>
 </head>
 <body>
   <div class="dashboard">
     <!-- Left: Chat area -->
     <div class="chat-area">
-      <header style="display: flex; justify-content: space-between; align-items: center; margin: 5px 0; padding: 0 5px;">
-        <div style="display: flex; align-items: center; gap: 10px;">
-          <img src="asset/Logo.png" alt="Logo" style="width: 50px; height: 50px;">
-          <h1 style="margin: 0; font-size: 1.2em;">Infant AI Assistant</h1>
+      <header>
+        <div class="chat-header-left">
+          <img src="asset/Logo.png" alt="Logo">
+          <h1>InfantAgent</h1>
         </div>
         <button type="button" id="settingsLink" class="setting-btn"><i class="fa-solid fa-gear"></i></button>
-        <!-- <a href="#" id="settingsLink" style="font-size: 0.9em;"><i class="fa-solid fa-gear"></i></a> -->
       </header>
 
       <div id="chatMessages" class="chat-messages">
         <div class="message system">
           <div class="message-content">
-            <p>Welcome to Infant AI Assistant! How can I help you today?</p>
+            <p>Welcome to InfantAgent! How can I help you today?</p>
           </div>
         </div>
-      </div>  
+      </div>
 
       <div class="status-panel">
         <div class="status-item">
-          <span class="status-label">Agent Status:</span>
+          <span class="status-label">Status:</span>
           <span id="agentStatus" class="status-value">Ready</span>
         </div>
         <div class="status-item">
-          <span class="status-label">Current Task:</span>
+          <span class="status-label">Task:</span>
           <span id="currentTask" class="status-value">None</span>
         </div>
         <div class="status-item">
@@ -334,24 +44,24 @@ <h1 style="margin: 0; font-size: 1.2em;">Infant AI Assistant</h1>
       </div>
 
       <div class="user-input">
-        <textarea id="userInput" placeholder="Type your request here..."></textarea>
+        <textarea id="userInput" placeholder="Type your message..."></textarea>
         <button id="sendButton" title="Send"><i class="fas fa-paper-plane"></i></button>
         <button id="resetButton" title="Reset"><i class="fas fa-sync-alt"></i></button>
         <button id="uploadFilesBtn" title="Upload files"><i class="fas fa-file-upload"></i></button>
-        <input type="file" id="fileUploadFiles" style="display:none" multiple>
+        <input type="file" id="fileUploadFiles" class="hidden-input" multiple>
         <button id="uploadFolderBtn" title="Upload folder"><i class="fas fa-folder-open"></i></button>
-        <input type="file" id="fileUploadFolder" style="display:none" webkitdirectory directory>
+        <input type="file" id="fileUploadFolder" class="hidden-input" webkitdirectory directory>
       </div>
     </div>
 
-    <!-- The resizer div between chat area and dashboard panels -->
+    <!-- Resizer -->
     <div class="resizer" id="resizer"></div>
-    
+
     <!-- Right: Dashboard panels -->
     <div class="dashboard-right">
       <div id="subtasksPanel" class="panel">
         <div class="panel-header">
-          <i class="fa-solid fa-list-check" style="padding-right: 5px;"></i>
+          <i class="fa-solid fa-list-check"></i>
           Subtasks
           <button type="button" class="fs-btn" data-panel="subtasksPanel" title="Full Screen"><i class="fa-solid fa-expand"></i></button>
         </div>
@@ -359,10 +69,10 @@ <h1 style="margin: 0; font-size: 1.2em;">Infant AI Assistant</h1>
           <ul id="subtaskList"></ul>
         </div>
       </div>
-      
+
       <div id="desktopPanel" class="panel">
         <div class="panel-header">
-          <i class="fa-solid fa-tv" style="padding-right: 2px;"></i>
+          <i class="fa-solid fa-tv"></i>
           System Desktop
           <button type="button" class="fs-btn" data-panel="desktopPanel" title="Full Screen"><i class="fa-solid fa-expand"></i></button>
         </div>
@@ -370,16 +80,16 @@ <h1 style="margin: 0; font-size: 1.2em;">Infant AI Assistant</h1>
           <div class="iframe-container">
             <iframe
               id="desktopFrame"
-              src="http://localhost:4443/guacamole/#/client/R05PTUUgRGVza3RvcCAoUkRQKQBjAGRlZmF1bHQ"
+              src=""
               allow="fullscreen">
             </iframe>
           </div>
         </div>
       </div>
-      
+
       <div id="terminalPanel" class="panel">
         <div class="panel-header">
-          <i class="fa-solid fa-terminal" style="padding-right: 5px;"></i>
+          <i class="fa-solid fa-terminal"></i>
           Terminal
           <button type="button" class="fs-btn" data-panel="terminalPanel" title="Full Screen"><i class="fa-solid fa-expand"></i></button>
         </div>
@@ -387,10 +97,10 @@ <h1 style="margin: 0; font-size: 1.2em;">Infant AI Assistant</h1>
           <div class="terminal-output" id="terminalOutput"></div>
         </div>
       </div>
-      
+
       <div id="notebookPanel" class="panel">
         <div class="panel-header">
-          <i class="fa-solid fa-file-code" style="padding-right: 5px;"></i>
+          <i class="fa-solid fa-file-code"></i>
           Jupyter Code
           <button type="button" class="fs-btn" data-panel="notebookPanel" title="Full Screen"><i class="fa-solid fa-expand"></i></button>
         </div>
@@ -408,24 +118,24 @@ <h1 style="margin: 0; font-size: 1.2em;">Infant AI Assistant</h1>
       <h2>Settings</h2>
       <form id="settingsForm">
         <div class="form-group">
-          <label for="modelSelect">LLM Model:</label>
+          <label for="modelSelect">LLM Model</label>
           <select id="modelSelect">
-            <option value="claude-sonnet-4-20250514">Claude 4 Sonnet</option>
+            <option value="claude-sonnet-4-6">Claude Sonnet 4.6</option>
             <option value="gpt-4o">GPT-4o</option>
             <option value="gpt-4-turbo">GPT-4 Turbo</option>
           </select>
         </div>
-        <div class="form-group"> 
-          <label for="modelApiKey">API Key:</label>
-          <input type="password" id="modelApiKey" required>
+        <div class="form-group">
+          <label for="modelApiKey">API Key</label>
+          <input type="password" id="modelApiKey" placeholder="sk-..." required>
         </div>
         <div class="form-group">
-          <label for="temperatureSlider">Temperature:</label>
+          <label for="temperatureSlider">Temperature</label>
           <input type="range" id="temperatureSlider" min="0" max="1" step="0.1" value="0.9">
           <span id="temperatureValue">0.9</span>
         </div>
         <div class="form-group">
-          <label for="maxTokensInput">Max Output Tokens:</label>
+          <label for="maxTokensInput">Max Output Tokens</label>
           <input type="number" id="maxTokensInput" min="100" max="10000" value="8191">
         </div>
         <button type="submit" class="submit-button">Save Settings</button>
@@ -437,47 +147,39 @@ <h2>Settings</h2>
   <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
   <script src="js/backend-connector.js"></script>
   <script src="js/script.js"></script>
-  
+
   <script>
     // Adjustable divider functionality
     document.addEventListener('DOMContentLoaded', function() {
       const resizer = document.getElementById('resizer');
       const chatArea = document.querySelector('.chat-area');
       const dashboardRight = document.querySelector('.dashboard-right');
-      
+
       let isResizing = false;
-      
+
       resizer.addEventListener('mousedown', function(e) {
         isResizing = true;
         document.body.style.cursor = 'col-resize';
         document.body.style.userSelect = 'none';
-        
-        // Prevent text selection
         e.preventDefault();
       });
-      
+
       document.addEventListener('mousemove', function(e) {
         if (!isResizing) return;
-        
         const dashboardRect = document.querySelector('.dashboard').getBoundingClientRect();
         const mouseX = e.clientX - dashboardRect.left;
         const dashboardWidth = dashboardRect.width;
-        
         const leftPercentage = (mouseX / dashboardWidth) * 100;
-        
-        const minLeft = 20;
-        const maxLeft = 80;
-        const clampedPercentage = Math.max(minLeft, Math.min(maxLeft, leftPercentage));
-        
+        const clampedPercentage = Math.max(20, Math.min(80, leftPercentage));
+
         chatArea.style.flexBasis = clampedPercentage + '%';
         dashboardRight.style.flexBasis = (100 - clampedPercentage) + '%';
-        
         chatArea.style.flexGrow = '0';
         chatArea.style.flexShrink = '0';
         dashboardRight.style.flexGrow = '0';
         dashboardRight.style.flexShrink = '0';
       });
-      
+
       document.addEventListener('mouseup', function() {
         if (isResizing) {
           isResizing = false;
@@ -485,39 +187,36 @@ <h2>Settings</h2>
           document.body.style.userSelect = '';
         }
       });
-      
+
       document.addEventListener('selectstart', function(e) {
-        if (isResizing) {
-          e.preventDefault();
-        }
+        if (isResizing) e.preventDefault();
       });
     });
-    
+
+    // Fullscreen panel toggle
     document.addEventListener('DOMContentLoaded', function() {
       const fullscreenButtons = document.querySelectorAll('.fs-btn');
-      
+
       fullscreenButtons.forEach(button => {
         button.addEventListener('click', function(e) {
           e.preventDefault();
           e.stopPropagation();
-          
+
           const panelId = this.getAttribute('data-panel');
           const targetPanel = document.getElementById(panelId);
           const allPanels = document.querySelectorAll('.panel');
-          
+
           if (!targetPanel) return;
-          
+
           const isFullscreen = targetPanel.classList.contains('fullspan');
-          
+
           if (isFullscreen) {
-            // quit fullscreen mode
             allPanels.forEach(panel => {
               panel.classList.remove('fullspan', 'hidden');
             });
             this.innerHTML = '<i class="fa-solid fa-expand"></i>';
             this.title = 'Full Screen';
           } else {
-            // enter fullscreen mode
             allPanels.forEach(panel => {
               if (panel.id === panelId) {
                 panel.classList.add('fullspan');
@@ -534,14 +233,5 @@ <h2>Settings</h2>
       });
     });
   </script>
-  <script>
-    (function setDPR(){
-      const apply = () =>
-        document.documentElement.style.setProperty('--dpr', (window.devicePixelRatio || 1));
-      window.addEventListener('load', apply);
-      window.addEventListener('resize', apply);
-      apply();
-    })();
-  </script>
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/frontend/js/script.js b/frontend/js/script.js
index a79978d..24e4524 100644
--- a/frontend/js/script.js
+++ b/frontend/js/script.js
@@ -517,12 +517,32 @@ document.addEventListener('DOMContentLoaded', () => {
   uploadFolderBtn.addEventListener('click',      () => fileUploadFolder.click());
   fileUploadFolder.addEventListener('change', handleFileUpload);
 
+  // Initialize Guacamole desktop iframe with auth token
+  loadGuacamoleDesktop();
+
   // 初始化连接
   console.log('[Debug] connectToBackend() 开始执行');
   connectToBackend();
 });
 
-// 在你的script.js中添加以下代码
+// Load Guacamole desktop with auto-login
+async function loadGuacamoleDesktop() {
+  const frame = document.getElementById('desktopFrame');
+  try {
+    const res = await fetch('/api/guacamole-token');
+    const data = await res.json();
+    if (data.success) {
+      // Connection ID: base64("GNOME Desktop (RDP)\0c\0default")
+      frame.src = `/guacamole/#/client/R05PTUUgRGVza3RvcCAoUkRQKQBjAGRlZmF1bHQ?token=${data.token}`;
+    } else {
+      console.error('Failed to get Guacamole token:', data.error);
+      frame.src = '/guacamole/';
+    }
+  } catch (e) {
+    console.error('Failed to load Guacamole desktop:', e);
+    frame.src = '/guacamole/';
+  }
+}
 
 // 全局变量存储EventSource
 let tasksEventSource = null;
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
new file mode 100644
index 0000000..4797836
--- /dev/null
+++ b/frontend/package-lock.json
@@ -0,0 +1,3699 @@
+{
+  "name": "frontend",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "frontend",
+      "version": "0.0.0",
+      "dependencies": {
+        "@fontsource/roboto": "^5.2.5",
+        "@mui/icons-material": "^7.1.0",
+        "@mui/material": "^7.1.0",
+        "@mui/styled-engine-sc": "^7.1.0",
+        "@tailwindcss/vite": "^4.1.7",
+        "lucide-react": "^0.511.0",
+        "react": "^19.1.0",
+        "react-dom": "^19.1.0",
+        "styled-components": "^6.1.18",
+        "tailwindcss": "^4.1.7"
+      },
+      "devDependencies": {
+        "@eslint/js": "^9.25.0",
+        "@types/react": "^19.1.2",
+        "@types/react-dom": "^19.1.2",
+        "@vitejs/plugin-react": "^4.4.1",
+        "eslint": "^9.25.0",
+        "eslint-plugin-react-hooks": "^5.2.0",
+        "eslint-plugin-react-refresh": "^0.4.19",
+        "globals": "^16.0.0",
+        "vite": "^6.3.5"
+      }
+    },
+    "node_modules/@ampproject/remapping": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
+      "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+      "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+      "dev": true,
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.27.2.tgz",
+      "integrity": "sha512-TUtMJYRPyUb/9aU8f3K0mjmjf6M9N5Woshn2CS6nqJSeJtTtQcpLUXjGt9vbF8ZGff0El99sWkLgzwW3VXnxZQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.27.1.tgz",
+      "integrity": "sha512-IaaGWsQqfsQWVLqMn9OB92MNN7zukfVA4s7KKAI0KfrrDsZ0yhi5uV4baBuLuN7n3vsZpwP8asPPcVwApxvjBQ==",
+      "dev": true,
+      "dependencies": {
+        "@ampproject/remapping": "^2.2.0",
+        "@babel/code-frame": "^7.27.1",
+        "@babel/generator": "^7.27.1",
+        "@babel/helper-compilation-targets": "^7.27.1",
+        "@babel/helper-module-transforms": "^7.27.1",
+        "@babel/helpers": "^7.27.1",
+        "@babel/parser": "^7.27.1",
+        "@babel/template": "^7.27.1",
+        "@babel/traverse": "^7.27.1",
+        "@babel/types": "^7.27.1",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.27.1.tgz",
+      "integrity": "sha512-UnJfnIpc/+JO0/+KRVQNGU+y5taA5vCbwN8+azkX6beii/ZF+enZJSOKo11ZSzGJjlNfJHfQtmQT8H+9TXPG2w==",
+      "dev": true,
+      "dependencies": {
+        "@babel/parser": "^7.27.1",
+        "@babel/types": "^7.27.1",
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.25",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz",
+      "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==",
+      "dev": true,
+      "dependencies": {
+        "@babel/compat-data": "^7.27.2",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz",
+      "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==",
+      "dev": true,
+      "dependencies": {
+        "@babel/traverse": "^7.27.1",
+        "@babel/types": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.27.1.tgz",
+      "integrity": "sha512-9yHn519/8KvTU5BjTVEEeIM3w9/2yXNKoD82JifINImhpKkARMJKPP59kLo+BafpdN5zgNeIcS4jsGDmd3l58g==",
+      "dev": true,
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.27.1",
+        "@babel/traverse": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz",
+      "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz",
+      "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.27.1.tgz",
+      "integrity": "sha512-FCvFTm0sWV8Fxhpp2McP5/W53GPllQ9QeQ7SiqGWjMf/LVG07lFa5+pgK05IRhVwtvafT22KF+ZSnM9I545CvQ==",
+      "dev": true,
+      "dependencies": {
+        "@babel/template": "^7.27.1",
+        "@babel/types": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.2.tgz",
+      "integrity": "sha512-QYLs8299NA7WM/bZAdp+CviYYkVoYXlDW2rzliy3chxd1PQjej7JORuMJDJXJUb9g0TT+B99EwaVLKmX+sPXWw==",
+      "dev": true,
+      "dependencies": {
+        "@babel/types": "^7.27.1"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "dev": true,
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "dev": true,
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/runtime": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.1.tgz",
+      "integrity": "sha512-1x3D2xEk2fRo3PAhwQwu5UubzgiVWSXTBfWpVd2Mx2AzRqJuDJCsgaDVZ7HB5iGzDW1Hl1sWN2mFyKjmR9uAog==",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.27.2",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
+      "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
+      "dev": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.27.1",
+        "@babel/parser": "^7.27.2",
+        "@babel/types": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.27.1.tgz",
+      "integrity": "sha512-ZCYtZciz1IWJB4U61UPu4KEaqyfj+r5T1Q5mqPo+IBpcG9kHv30Z0aD8LXPgC1trYa6rK0orRyAhqUgk4MjmEg==",
+      "dev": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.27.1",
+        "@babel/generator": "^7.27.1",
+        "@babel/parser": "^7.27.1",
+        "@babel/template": "^7.27.1",
+        "@babel/types": "^7.27.1",
+        "debug": "^4.3.1",
+        "globals": "^11.1.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse/node_modules/globals": {
+      "version": "11.12.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+      "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
+      "dev": true,
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.1.tgz",
+      "integrity": "sha512-+EzkxvLNfiUeKMgy/3luqfsCWFRXLb7U6wNQTk60tovuckwB15B191tJWvpp4HjiQWdJkCxO3Wbvc6jlk3Xb2Q==",
+      "dev": true,
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@emotion/cache": {
+      "version": "11.14.0",
+      "resolved": "https://registry.npmjs.org/@emotion/cache/-/cache-11.14.0.tgz",
+      "integrity": "sha512-L/B1lc/TViYk4DcpGxtAVbx0ZyiKM5ktoIyafGkH6zg/tj+mA+NE//aPYKG0k8kCHSHVJrpLpcAlOBEXQ3SavA==",
+      "dependencies": {
+        "@emotion/memoize": "^0.9.0",
+        "@emotion/sheet": "^1.4.0",
+        "@emotion/utils": "^1.4.2",
+        "@emotion/weak-memoize": "^0.4.0",
+        "stylis": "4.2.0"
+      }
+    },
+    "node_modules/@emotion/hash": {
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/@emotion/hash/-/hash-0.9.2.tgz",
+      "integrity": "sha512-MyqliTZGuOm3+5ZRSaaBGP3USLw6+EGykkwZns2EPC5g8jJ4z9OrdZY9apkl3+UP9+sdz76YYkwCKP5gh8iY3g=="
+    },
+    "node_modules/@emotion/is-prop-valid": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/@emotion/is-prop-valid/-/is-prop-valid-1.2.2.tgz",
+      "integrity": "sha512-uNsoYd37AFmaCdXlg6EYD1KaPOaRWRByMCYzbKUX4+hhMfrxdVSelShywL4JVaAeM/eHUOSprYBQls+/neX3pw==",
+      "dependencies": {
+        "@emotion/memoize": "^0.8.1"
+      }
+    },
+    "node_modules/@emotion/is-prop-valid/node_modules/@emotion/memoize": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/@emotion/memoize/-/memoize-0.8.1.tgz",
+      "integrity": "sha512-W2P2c/VRW1/1tLox0mVUalvnWXxavmv/Oum2aPsRcoDJuob75FC3Y8FbpfLwUegRcxINtGUMPq0tFCvYNTBXNA=="
+    },
+    "node_modules/@emotion/memoize": {
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/@emotion/memoize/-/memoize-0.9.0.tgz",
+      "integrity": "sha512-30FAj7/EoJ5mwVPOWhAyCX+FPfMDrVecJAM+Iw9NRoSl4BBAQeqj4cApHHUXOVvIPgLVDsCFoz/hGD+5QQD1GQ=="
+    },
+    "node_modules/@emotion/serialize": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@emotion/serialize/-/serialize-1.3.3.tgz",
+      "integrity": "sha512-EISGqt7sSNWHGI76hC7x1CksiXPahbxEOrC5RjmFRJTqLyEK9/9hZvBbiYn70dw4wuwMKiEMCUlR6ZXTSWQqxA==",
+      "dependencies": {
+        "@emotion/hash": "^0.9.2",
+        "@emotion/memoize": "^0.9.0",
+        "@emotion/unitless": "^0.10.0",
+        "@emotion/utils": "^1.4.2",
+        "csstype": "^3.0.2"
+      }
+    },
+    "node_modules/@emotion/sheet": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/@emotion/sheet/-/sheet-1.4.0.tgz",
+      "integrity": "sha512-fTBW9/8r2w3dXWYM4HCB1Rdp8NLibOw2+XELH5m5+AkWiL/KqYX6dc0kKYlaYyKjrQ6ds33MCdMPEwgs2z1rqg=="
+    },
+    "node_modules/@emotion/unitless": {
+      "version": "0.10.0",
+      "resolved": "https://registry.npmjs.org/@emotion/unitless/-/unitless-0.10.0.tgz",
+      "integrity": "sha512-dFoMUuQA20zvtVTuxZww6OHoJYgrzfKM1t52mVySDJnMSEa08ruEvdYQbhvyu6soU+NeLVd3yKfTfT0NeV6qGg=="
+    },
+    "node_modules/@emotion/utils": {
+      "version": "1.4.2",
+      "resolved": "https://registry.npmjs.org/@emotion/utils/-/utils-1.4.2.tgz",
+      "integrity": "sha512-3vLclRofFziIa3J2wDh9jjbkUz9qk5Vi3IZ/FSTKViB0k+ef0fPV7dYrUIugbgupYDx7v9ud/SjrtEP8Y4xLoA=="
+    },
+    "node_modules/@emotion/weak-memoize": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/@emotion/weak-memoize/-/weak-memoize-0.4.0.tgz",
+      "integrity": "sha512-snKqtPW01tN0ui7yu9rGv69aJXr/a/Ywvl11sUjNtEcRc+ng/mQriFL0wLXMef74iHa/EkftbDzU9F8iFbH+zg=="
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.4.tgz",
+      "integrity": "sha512-1VCICWypeQKhVbE9oW/sJaAmjLxhVqacdkvPLEjwlttjfwENRSClS8EjBz0KzRyFSCPDIkuXW34Je/vk7zdB7Q==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.4.tgz",
+      "integrity": "sha512-QNdQEps7DfFwE3hXiU4BZeOV68HHzYwGd0Nthhd3uCkkEKK7/R6MTgM0P7H7FAs5pU/DIWsviMmEGxEoxIZ+ZQ==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.4.tgz",
+      "integrity": "sha512-bBy69pgfhMGtCnwpC/x5QhfxAz/cBgQ9enbtwjf6V9lnPI/hMyT9iWpR1arm0l3kttTr4L0KSLpKmLp/ilKS9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.4.tgz",
+      "integrity": "sha512-TVhdVtQIFuVpIIR282btcGC2oGQoSfZfmBdTip2anCaVYcqWlZXGcdcKIUklfX2wj0JklNYgz39OBqh2cqXvcQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.4.tgz",
+      "integrity": "sha512-Y1giCfM4nlHDWEfSckMzeWNdQS31BQGs9/rouw6Ub91tkK79aIMTH3q9xHvzH8d0wDru5Ci0kWB8b3up/nl16g==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.4.tgz",
+      "integrity": "sha512-CJsry8ZGM5VFVeyUYB3cdKpd/H69PYez4eJh1W/t38vzutdjEjtP7hB6eLKBoOdxcAlCtEYHzQ/PJ/oU9I4u0A==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-yYq+39NlTRzU2XmoPW4l5Ifpl9fqSk0nAJYM/V/WUGPEFfek1epLHJIkTQM6bBs1swApjO5nWgvr843g6TjxuQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.4.tgz",
+      "integrity": "sha512-0FgvOJ6UUMflsHSPLzdfDnnBBVoCDtBTVyn/MrWloUNvq/5SFmh13l3dvgRPkDihRxb77Y17MbqbCAa2strMQQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.4.tgz",
+      "integrity": "sha512-kro4c0P85GMfFYqW4TWOpvmF8rFShbWGnrLqlzp4X1TNWjRY3JMYUfDCtOxPKOIY8B0WC8HN51hGP4I4hz4AaQ==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.4.tgz",
+      "integrity": "sha512-+89UsQTfXdmjIvZS6nUnOOLoXnkUTB9hR5QAeLrQdzOSWZvNSAXAtcRDHWtqAUtAmv7ZM1WPOOeSxDzzzMogiQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.4.tgz",
+      "integrity": "sha512-yTEjoapy8UP3rv8dB0ip3AfMpRbyhSN3+hY8mo/i4QXFeDxmiYbEKp3ZRjBKcOP862Ua4b1PDfwlvbuwY7hIGQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.4.tgz",
+      "integrity": "sha512-NeqqYkrcGzFwi6CGRGNMOjWGGSYOpqwCjS9fvaUlX5s3zwOtn1qwg1s2iE2svBe4Q/YOG1q6875lcAoQK/F4VA==",
+      "cpu": [
+        "loong64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.4.tgz",
+      "integrity": "sha512-IcvTlF9dtLrfL/M8WgNI/qJYBENP3ekgsHbYUIzEzq5XJzzVEV/fXY9WFPfEEXmu3ck2qJP8LG/p3Q8f7Zc2Xg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.4.tgz",
+      "integrity": "sha512-HOy0aLTJTVtoTeGZh4HSXaO6M95qu4k5lJcH4gxv56iaycfz1S8GO/5Jh6X4Y1YiI0h7cRyLi+HixMR+88swag==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.4.tgz",
+      "integrity": "sha512-i8JUDAufpz9jOzo4yIShCTcXzS07vEgWzyX3NH2G7LEFVgrLEhjwL3ajFE4fZI3I4ZgiM7JH3GQ7ReObROvSUA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.4.tgz",
+      "integrity": "sha512-jFnu+6UbLlzIjPQpWCNh5QtrcNfMLjgIavnwPQAfoGx4q17ocOU9MsQ2QVvFxwQoWpZT8DvTLooTvmOQXkO51g==",
+      "cpu": [
+        "s390x"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.4.tgz",
+      "integrity": "sha512-6e0cvXwzOnVWJHq+mskP8DNSrKBr1bULBvnFLpc1KY+d+irZSgZ02TGse5FsafKS5jg2e4pbvK6TPXaF/A6+CA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-vUnkBYxZW4hL/ie91hSqaSNjulOnYXE1VSLusnvHg2u3jewJBz3YzB9+oCw8DABeVqZGg94t9tyZFoHma8gWZQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.4.tgz",
+      "integrity": "sha512-XAg8pIQn5CzhOB8odIcAm42QsOfa98SBeKUdo4xa8OvX8LbMZqEtgeWE9P/Wxt7MlG2QqvjGths+nq48TrUiKw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.4.tgz",
+      "integrity": "sha512-Ct2WcFEANlFDtp1nVAXSNBPDxyU+j7+tId//iHXU2f/lN5AmO4zLyhDcpR5Cz1r08mVxzt3Jpyt4PmXQ1O6+7A==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.4.tgz",
+      "integrity": "sha512-xAGGhyOQ9Otm1Xu8NT1ifGLnA6M3sJxZ6ixylb+vIUVzvvd6GOALpwQrYrtlPouMqd/vSbgehz6HaVk4+7Afhw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.4.tgz",
+      "integrity": "sha512-Mw+tzy4pp6wZEK0+Lwr76pWLjrtjmJyUB23tHKqEDP74R3q95luY/bXqXZeYl4NYlvwOqoRKlInQialgCKy67Q==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.4.tgz",
+      "integrity": "sha512-AVUP428VQTSddguz9dO9ngb+E5aScyg7nOeJDrF1HPYu555gmza3bDGMPhmVXL8svDSoqPCsCPjb265yG/kLKQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.4.tgz",
+      "integrity": "sha512-i1sW+1i+oWvQzSgfRcxxG2k4I9n3O9NRqy8U+uugaT2Dy7kLO9Y7wI72haOahxceMX8hZAzgGou1FhndRldxRg==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.4.tgz",
+      "integrity": "sha512-nOT2vZNw6hJ+z43oP1SPea/G/6AbN6X+bGNhNuq8NtRHy4wsMhw765IKLNmnjek7GvjWBYQ8Q5VBoYTFg9y1UQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz",
+      "integrity": "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==",
+      "dev": true,
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
+      "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
+      "dev": true,
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/config-array": {
+      "version": "0.20.0",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.20.0.tgz",
+      "integrity": "sha512-fxlS1kkIjx8+vy2SjuCB94q3htSNrufYTXubwiBFeaQHbH6Ipi43gFJq2zCMt6PHhImH3Xmr0NksKDvchWlpQQ==",
+      "dev": true,
+      "dependencies": {
+        "@eslint/object-schema": "^2.1.6",
+        "debug": "^4.3.1",
+        "minimatch": "^3.1.2"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/config-helpers": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.2.2.tgz",
+      "integrity": "sha512-+GPzk8PlG0sPpzdU5ZvIRMPidzAnZDl/s9L+y13iodqvb8leL53bTannOrQ/Im7UkpsmFU5Ily5U60LWixnmLg==",
+      "dev": true,
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/core": {
+      "version": "0.14.0",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.14.0.tgz",
+      "integrity": "sha512-qIbV0/JZr7iSDjqAc60IqbLdsj9GDt16xQtWD+B78d/HAlvysGdZZ6rpJHGAc2T0FQx1X6thsSPdnoiGKdNtdg==",
+      "dev": true,
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.1.tgz",
+      "integrity": "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==",
+      "dev": true,
+      "dependencies": {
+        "ajv": "^6.12.4",
+        "debug": "^4.3.2",
+        "espree": "^10.0.1",
+        "globals": "^14.0.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.0",
+        "minimatch": "^3.1.2",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "9.27.0",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.27.0.tgz",
+      "integrity": "sha512-G5JD9Tu5HJEu4z2Uo4aHY2sLV64B7CDMXxFzqzjl3NKd6RVzSXNoE80jk7Y0lJkTTkjiIhBAqmlYwjuBY3tvpA==",
+      "dev": true,
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      }
+    },
+    "node_modules/@eslint/object-schema": {
+      "version": "2.1.6",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.6.tgz",
+      "integrity": "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==",
+      "dev": true,
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.3.1.tgz",
+      "integrity": "sha512-0J+zgWxHN+xXONWIyPWKFMgVuJoZuGiIFu8yxk7RJjxkzpGmyja5wRFqZIVtjDVOQpV+Rw0iOAjYPE2eQyjr0w==",
+      "dev": true,
+      "dependencies": {
+        "@eslint/core": "^0.14.0",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@fontsource/roboto": {
+      "version": "5.2.5",
+      "resolved": "https://registry.npmjs.org/@fontsource/roboto/-/roboto-5.2.5.tgz",
+      "integrity": "sha512-70r2UZ0raqLn5W+sPeKhqlf8wGvUXFWlofaDlcbt/S3d06+17gXKr3VNqDODB0I1ASme3dGT5OJj9NABt7OTZQ==",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
+    "node_modules/@humanfs/core": {
+      "version": "0.19.1",
+      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz",
+      "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==",
+      "dev": true,
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.6",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.6.tgz",
+      "integrity": "sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==",
+      "dev": true,
+      "dependencies": {
+        "@humanfs/core": "^0.19.1",
+        "@humanwhocodes/retry": "^0.3.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node/node_modules/@humanwhocodes/retry": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.3.1.tgz",
+      "integrity": "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==",
+      "dev": true,
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+      "dev": true,
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/retry": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@isaacs/fs-minipass": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
+      "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",
+      "dependencies": {
+        "minipass": "^7.0.4"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.8",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz",
+      "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==",
+      "dependencies": {
+        "@jridgewell/set-array": "^1.2.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/set-array": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
+      "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ=="
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.25",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
+      "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@mui/core-downloads-tracker": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/@mui/core-downloads-tracker/-/core-downloads-tracker-7.1.0.tgz",
+      "integrity": "sha512-E0OqhZv548Qdc0PwWhLVA2zmjJZSTvaL4ZhoswmI8NJEC1tpW2js6LLP827jrW9MEiXYdz3QS6+hask83w74yQ==",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/mui-org"
+      }
+    },
+    "node_modules/@mui/icons-material": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/@mui/icons-material/-/icons-material-7.1.0.tgz",
+      "integrity": "sha512-1mUPMAZ+Qk3jfgL5ftRR06ATH/Esi0izHl1z56H+df6cwIlCWG66RXciUqeJCttbOXOQ5y2DCjLZI/4t3Yg3LA==",
+      "dependencies": {
+        "@babel/runtime": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/mui-org"
+      },
+      "peerDependencies": {
+        "@mui/material": "^7.1.0",
+        "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@mui/material": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/@mui/material/-/material-7.1.0.tgz",
+      "integrity": "sha512-ahUJdrhEv+mCp4XHW+tHIEYzZMSRLg8z4AjUOsj44QpD1ZaMxQoVOG2xiHvLFdcsIPbgSRx1bg1eQSheHBgvtg==",
+      "dependencies": {
+        "@babel/runtime": "^7.27.1",
+        "@mui/core-downloads-tracker": "^7.1.0",
+        "@mui/system": "^7.1.0",
+        "@mui/types": "^7.4.2",
+        "@mui/utils": "^7.1.0",
+        "@popperjs/core": "^2.11.8",
+        "@types/react-transition-group": "^4.4.12",
+        "clsx": "^2.1.1",
+        "csstype": "^3.1.3",
+        "prop-types": "^15.8.1",
+        "react-is": "^19.1.0",
+        "react-transition-group": "^4.4.5"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/mui-org"
+      },
+      "peerDependencies": {
+        "@emotion/react": "^11.5.0",
+        "@emotion/styled": "^11.3.0",
+        "@mui/material-pigment-css": "^7.1.0",
+        "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@emotion/react": {
+          "optional": true
+        },
+        "@emotion/styled": {
+          "optional": true
+        },
+        "@mui/material-pigment-css": {
+          "optional": true
+        },
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@mui/private-theming": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/@mui/private-theming/-/private-theming-7.1.0.tgz",
+      "integrity": "sha512-4Kck4jxhqF6YxNwJdSae1WgDfXVg0lIH6JVJ7gtuFfuKcQCgomJxPvUEOySTFRPz1IZzwz5OAcToskRdffElDA==",
+      "dependencies": {
+        "@babel/runtime": "^7.27.1",
+        "@mui/utils": "^7.1.0",
+        "prop-types": "^15.8.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/mui-org"
+      },
+      "peerDependencies": {
+        "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@mui/styled-engine": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/@mui/styled-engine/-/styled-engine-7.1.0.tgz",
+      "integrity": "sha512-m0mJ0c6iRC+f9hMeRe0W7zZX1wme3oUX0+XTVHjPG7DJz6OdQ6K/ggEOq7ZdwilcpdsDUwwMfOmvO71qDkYd2w==",
+      "dependencies": {
+        "@babel/runtime": "^7.27.1",
+        "@emotion/cache": "^11.13.5",
+        "@emotion/serialize": "^1.3.3",
+        "@emotion/sheet": "^1.4.0",
+        "csstype": "^3.1.3",
+        "prop-types": "^15.8.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/mui-org"
+      },
+      "peerDependencies": {
+        "@emotion/react": "^11.4.1",
+        "@emotion/styled": "^11.3.0",
+        "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@emotion/react": {
+          "optional": true
+        },
+        "@emotion/styled": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@mui/styled-engine-sc": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/@mui/styled-engine-sc/-/styled-engine-sc-7.1.0.tgz",
+      "integrity": "sha512-6ZIB0uwLN1MtJAmAZgtwDJMMNhSpHQL6K+hWaikPnPjyTe8qyS14fhvoelD16qOp/c2abE2ZSqMQKlDiyApDig==",
+      "dependencies": {
+        "@babel/runtime": "^7.27.1",
+        "@types/hoist-non-react-statics": "^3.3.6",
+        "csstype": "^3.1.3",
+        "hoist-non-react-statics": "^3.3.2",
+        "prop-types": "^15.8.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/mui-org"
+      },
+      "peerDependencies": {
+        "styled-components": "^6.0.0"
+      }
+    },
+    "node_modules/@mui/system": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/@mui/system/-/system-7.1.0.tgz",
+      "integrity": "sha512-iedAWgRJMCxeMHvkEhsDlbvkK+qKf9me6ofsf7twk/jfT4P1ImVf7Rwb5VubEA0sikrVL+1SkoZM41M4+LNAVA==",
+      "dependencies": {
+        "@babel/runtime": "^7.27.1",
+        "@mui/private-theming": "^7.1.0",
+        "@mui/styled-engine": "^7.1.0",
+        "@mui/types": "^7.4.2",
+        "@mui/utils": "^7.1.0",
+        "clsx": "^2.1.1",
+        "csstype": "^3.1.3",
+        "prop-types": "^15.8.1"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/mui-org"
+      },
+      "peerDependencies": {
+        "@emotion/react": "^11.5.0",
+        "@emotion/styled": "^11.3.0",
+        "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@emotion/react": {
+          "optional": true
+        },
+        "@emotion/styled": {
+          "optional": true
+        },
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@mui/types": {
+      "version": "7.4.2",
+      "resolved": "https://registry.npmjs.org/@mui/types/-/types-7.4.2.tgz",
+      "integrity": "sha512-edRc5JcLPsrlNFYyTPxds+d5oUovuUxnnDtpJUbP6WMeV4+6eaX/mqai1ZIWT62lCOe0nlrON0s9HDiv5en5bA==",
+      "dependencies": {
+        "@babel/runtime": "^7.27.1"
+      },
+      "peerDependencies": {
+        "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@mui/utils": {
+      "version": "7.1.0",
+      "resolved": "https://registry.npmjs.org/@mui/utils/-/utils-7.1.0.tgz",
+      "integrity": "sha512-/OM3S8kSHHmWNOP+NH9xEtpYSG10upXeQ0wLZnfDgmgadTAk5F4MQfFLyZ5FCRJENB3eRzltMmaNl6UtDnPovw==",
+      "dependencies": {
+        "@babel/runtime": "^7.27.1",
+        "@mui/types": "^7.4.2",
+        "@types/prop-types": "^15.7.14",
+        "clsx": "^2.1.1",
+        "prop-types": "^15.8.1",
+        "react-is": "^19.1.0"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/mui-org"
+      },
+      "peerDependencies": {
+        "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@popperjs/core": {
+      "version": "2.11.8",
+      "resolved": "https://registry.npmjs.org/@popperjs/core/-/core-2.11.8.tgz",
+      "integrity": "sha512-P1st0aksCrn9sGZhp8GMYwBnQsbvAWsZAX44oXNNvLHGqAOcoVxmjZiohstwQ7SqKnbR47akdNi+uleWD8+g6A==",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/popperjs"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.9",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.9.tgz",
+      "integrity": "sha512-e9MeMtVWo186sgvFFJOPGy7/d2j2mZhLJIdVW0C/xDluuOvymEATqz6zKsP0ZmXGzQtqlyjz5sC1sYQUoJG98w==",
+      "dev": true
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.41.1.tgz",
+      "integrity": "sha512-NELNvyEWZ6R9QMkiytB4/L4zSEaBC03KIXEghptLGLZWJ6VPrL63ooZQCOnlx36aQPGhzuOMwDerC1Eb2VmrLw==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.41.1.tgz",
+      "integrity": "sha512-DXdQe1BJ6TK47ukAoZLehRHhfKnKg9BjnQYUu9gzhI8Mwa1d2fzxA1aw2JixHVl403bwp1+/o/NhhHtxWJBgEA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.41.1.tgz",
+      "integrity": "sha512-5afxvwszzdulsU2w8JKWwY8/sJOLPzf0e1bFuvcW5h9zsEg+RQAojdW0ux2zyYAz7R8HvvzKCjLNJhVq965U7w==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.41.1.tgz",
+      "integrity": "sha512-egpJACny8QOdHNNMZKf8xY0Is6gIMz+tuqXlusxquWu3F833DcMwmGM7WlvCO9sB3OsPjdC4U0wHw5FabzCGZg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.41.1.tgz",
+      "integrity": "sha512-DBVMZH5vbjgRk3r0OzgjS38z+atlupJ7xfKIDJdZZL6sM6wjfDNo64aowcLPKIx7LMQi8vybB56uh1Ftck/Atg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.41.1.tgz",
+      "integrity": "sha512-3FkydeohozEskBxNWEIbPfOE0aqQgB6ttTkJ159uWOFn42VLyfAiyD9UK5mhu+ItWzft60DycIN1Xdgiy8o/SA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.41.1.tgz",
+      "integrity": "sha512-wC53ZNDgt0pqx5xCAgNunkTzFE8GTgdZ9EwYGVcg+jEjJdZGtq9xPjDnFgfFozQI/Xm1mh+D9YlYtl+ueswNEg==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.41.1.tgz",
+      "integrity": "sha512-jwKCca1gbZkZLhLRtsrka5N8sFAaxrGz/7wRJ8Wwvq3jug7toO21vWlViihG85ei7uJTpzbXZRcORotE+xyrLA==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.41.1.tgz",
+      "integrity": "sha512-g0UBcNknsmmNQ8V2d/zD2P7WWfJKU0F1nu0k5pW4rvdb+BIqMm8ToluW/eeRmxCared5dD76lS04uL4UaNgpNA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.41.1.tgz",
+      "integrity": "sha512-XZpeGB5TKEZWzIrj7sXr+BEaSgo/ma/kCgrZgL0oo5qdB1JlTzIYQKel/RmhT6vMAvOdM2teYlAaOGJpJ9lahg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.41.1.tgz",
+      "integrity": "sha512-bkCfDJ4qzWfFRCNt5RVV4DOw6KEgFTUZi2r2RuYhGWC8WhCA8lCAJhDeAmrM/fdiAH54m0mA0Vk2FGRPyzI+tw==",
+      "cpu": [
+        "loong64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.41.1.tgz",
+      "integrity": "sha512-3mr3Xm+gvMX+/8EKogIZSIEF0WUu0HL9di+YWlJpO8CQBnoLAEL/roTCxuLncEdgcfJcvA4UMOf+2dnjl4Ut1A==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.41.1.tgz",
+      "integrity": "sha512-3rwCIh6MQ1LGrvKJitQjZFuQnT2wxfU+ivhNBzmxXTXPllewOF7JR1s2vMX/tWtUYFgphygxjqMl76q4aMotGw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.41.1.tgz",
+      "integrity": "sha512-LdIUOb3gvfmpkgFZuccNa2uYiqtgZAz3PTzjuM5bH3nvuy9ty6RGc/Q0+HDFrHrizJGVpjnTZ1yS5TNNjFlklw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.41.1.tgz",
+      "integrity": "sha512-oIE6M8WC9ma6xYqjvPhzZYk6NbobIURvP/lEbh7FWplcMO6gn7MM2yHKA1eC/GvYwzNKK/1LYgqzdkZ8YFxR8g==",
+      "cpu": [
+        "s390x"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.41.1.tgz",
+      "integrity": "sha512-cWBOvayNvA+SyeQMp79BHPK8ws6sHSsYnK5zDcsC3Hsxr1dgTABKjMnMslPq1DvZIp6uO7kIWhiGwaTdR4Og9A==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.41.1.tgz",
+      "integrity": "sha512-y5CbN44M+pUCdGDlZFzGGBSKCA4A/J2ZH4edTYSSxFg7ce1Xt3GtydbVKWLlzL+INfFIZAEg1ZV6hh9+QQf9YQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.41.1.tgz",
+      "integrity": "sha512-lZkCxIrjlJlMt1dLO/FbpZbzt6J/A8p4DnqzSa4PWqPEUUUnzXLeki/iyPLfV0BmHItlYgHUqJe+3KiyydmiNQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.41.1.tgz",
+      "integrity": "sha512-+psFT9+pIh2iuGsxFYYa/LhS5MFKmuivRsx9iPJWNSGbh2XVEjk90fmpUEjCnILPEPJnikAU6SFDiEUyOv90Pg==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.41.1.tgz",
+      "integrity": "sha512-Wq2zpapRYLfi4aKxf2Xff0tN+7slj2d4R87WEzqw7ZLsVvO5zwYCIuEGSZYiK41+GlwUo1HiR+GdkLEJnCKTCw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@tailwindcss/node": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.1.7.tgz",
+      "integrity": "sha512-9rsOpdY9idRI2NH6CL4wORFY0+Q6fnx9XP9Ju+iq/0wJwGD5IByIgFmwVbyy4ymuyprj8Qh4ErxMKTUL4uNh3g==",
+      "dependencies": {
+        "@ampproject/remapping": "^2.3.0",
+        "enhanced-resolve": "^5.18.1",
+        "jiti": "^2.4.2",
+        "lightningcss": "1.30.1",
+        "magic-string": "^0.30.17",
+        "source-map-js": "^1.2.1",
+        "tailwindcss": "4.1.7"
+      }
+    },
+    "node_modules/@tailwindcss/oxide": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide/-/oxide-4.1.7.tgz",
+      "integrity": "sha512-5SF95Ctm9DFiUyjUPnDGkoKItPX/k+xifcQhcqX5RA85m50jw1pT/KzjdvlqxRja45Y52nR4MR9fD1JYd7f8NQ==",
+      "hasInstallScript": true,
+      "dependencies": {
+        "detect-libc": "^2.0.4",
+        "tar": "^7.4.3"
+      },
+      "engines": {
+        "node": ">= 10"
+      },
+      "optionalDependencies": {
+        "@tailwindcss/oxide-android-arm64": "4.1.7",
+        "@tailwindcss/oxide-darwin-arm64": "4.1.7",
+        "@tailwindcss/oxide-darwin-x64": "4.1.7",
+        "@tailwindcss/oxide-freebsd-x64": "4.1.7",
+        "@tailwindcss/oxide-linux-arm-gnueabihf": "4.1.7",
+        "@tailwindcss/oxide-linux-arm64-gnu": "4.1.7",
+        "@tailwindcss/oxide-linux-arm64-musl": "4.1.7",
+        "@tailwindcss/oxide-linux-x64-gnu": "4.1.7",
+        "@tailwindcss/oxide-linux-x64-musl": "4.1.7",
+        "@tailwindcss/oxide-wasm32-wasi": "4.1.7",
+        "@tailwindcss/oxide-win32-arm64-msvc": "4.1.7",
+        "@tailwindcss/oxide-win32-x64-msvc": "4.1.7"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-android-arm64": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-android-arm64/-/oxide-android-arm64-4.1.7.tgz",
+      "integrity": "sha512-IWA410JZ8fF7kACus6BrUwY2Z1t1hm0+ZWNEzykKmMNM09wQooOcN/VXr0p/WJdtHZ90PvJf2AIBS/Ceqx1emg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-arm64": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-arm64/-/oxide-darwin-arm64-4.1.7.tgz",
+      "integrity": "sha512-81jUw9To7fimGGkuJ2W5h3/oGonTOZKZ8C2ghm/TTxbwvfSiFSDPd6/A/KE2N7Jp4mv3Ps9OFqg2fEKgZFfsvg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-darwin-x64": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-darwin-x64/-/oxide-darwin-x64-4.1.7.tgz",
+      "integrity": "sha512-q77rWjEyGHV4PdDBtrzO0tgBBPlQWKY7wZK0cUok/HaGgbNKecegNxCGikuPJn5wFAlIywC3v+WMBt0PEBtwGw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-freebsd-x64": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-freebsd-x64/-/oxide-freebsd-x64-4.1.7.tgz",
+      "integrity": "sha512-RfmdbbK6G6ptgF4qqbzoxmH+PKfP4KSVs7SRlTwcbRgBwezJkAO3Qta/7gDy10Q2DcUVkKxFLXUQO6J3CRvBGw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm-gnueabihf": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm-gnueabihf/-/oxide-linux-arm-gnueabihf-4.1.7.tgz",
+      "integrity": "sha512-OZqsGvpwOa13lVd1z6JVwQXadEobmesxQ4AxhrwRiPuE04quvZHWn/LnihMg7/XkN+dTioXp/VMu/p6A5eZP3g==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-gnu": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-gnu/-/oxide-linux-arm64-gnu-4.1.7.tgz",
+      "integrity": "sha512-voMvBTnJSfKecJxGkoeAyW/2XRToLZ227LxswLAwKY7YslG/Xkw9/tJNH+3IVh5bdYzYE7DfiaPbRkSHFxY1xA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-arm64-musl": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-arm64-musl/-/oxide-linux-arm64-musl-4.1.7.tgz",
+      "integrity": "sha512-PjGuNNmJeKHnP58M7XyjJyla8LPo+RmwHQpBI+W/OxqrwojyuCQ+GUtygu7jUqTEexejZHr/z3nBc/gTiXBj4A==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-gnu": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-gnu/-/oxide-linux-x64-gnu-4.1.7.tgz",
+      "integrity": "sha512-HMs+Va+ZR3gC3mLZE00gXxtBo3JoSQxtu9lobbZd+DmfkIxR54NO7Z+UQNPsa0P/ITn1TevtFxXTpsRU7qEvWg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-linux-x64-musl": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-linux-x64-musl/-/oxide-linux-x64-musl-4.1.7.tgz",
+      "integrity": "sha512-MHZ6jyNlutdHH8rd+YTdr3QbXrHXqwIhHw9e7yXEBcQdluGwhpQY2Eku8UZK6ReLaWtQ4gijIv5QoM5eE+qlsA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-wasm32-wasi": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-wasm32-wasi/-/oxide-wasm32-wasi-4.1.7.tgz",
+      "integrity": "sha512-ANaSKt74ZRzE2TvJmUcbFQ8zS201cIPxUDm5qez5rLEwWkie2SkGtA4P+GPTj+u8N6JbPrC8MtY8RmJA35Oo+A==",
+      "bundleDependencies": [
+        "@napi-rs/wasm-runtime",
+        "@emnapi/core",
+        "@emnapi/runtime",
+        "@tybys/wasm-util",
+        "@emnapi/wasi-threads",
+        "tslib"
+      ],
+      "cpu": [
+        "wasm32"
+      ],
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.4.3",
+        "@emnapi/runtime": "^1.4.3",
+        "@emnapi/wasi-threads": "^1.0.2",
+        "@napi-rs/wasm-runtime": "^0.2.9",
+        "@tybys/wasm-util": "^0.9.0",
+        "tslib": "^2.8.0"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-win32-arm64-msvc": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-arm64-msvc/-/oxide-win32-arm64-msvc-4.1.7.tgz",
+      "integrity": "sha512-HUiSiXQ9gLJBAPCMVRk2RT1ZrBjto7WvqsPBwUrNK2BcdSxMnk19h4pjZjI7zgPhDxlAbJSumTC4ljeA9y0tEw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/oxide-win32-x64-msvc": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/oxide-win32-x64-msvc/-/oxide-win32-x64-msvc-4.1.7.tgz",
+      "integrity": "sha512-rYHGmvoHiLJ8hWucSfSOEmdCBIGZIq7SpkPRSqLsH2Ab2YUNgKeAPT1Fi2cx3+hnYOrAb0jp9cRyode3bBW4mQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tailwindcss/vite": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@tailwindcss/vite/-/vite-4.1.7.tgz",
+      "integrity": "sha512-tYa2fO3zDe41I7WqijyVbRd8oWT0aEID1Eokz5hMT6wShLIHj3yvwj9XbfuloHP9glZ6H+aG2AN/+ZrxJ1Y5RQ==",
+      "dependencies": {
+        "@tailwindcss/node": "4.1.7",
+        "@tailwindcss/oxide": "4.1.7",
+        "tailwindcss": "4.1.7"
+      },
+      "peerDependencies": {
+        "vite": "^5.2.0 || ^6"
+      }
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.20.7",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.7.tgz",
+      "integrity": "sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng==",
+      "dev": true,
+      "dependencies": {
+        "@babel/types": "^7.20.7"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.7.tgz",
+      "integrity": "sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ=="
+    },
+    "node_modules/@types/hoist-non-react-statics": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/@types/hoist-non-react-statics/-/hoist-non-react-statics-3.3.6.tgz",
+      "integrity": "sha512-lPByRJUer/iN/xa4qpyL0qmL11DqNW81iU/IG1S3uvRUq4oKagz8VCxZjiWkumgt66YT3vOdDgZ0o32sGKtCEw==",
+      "dependencies": {
+        "@types/react": "*",
+        "hoist-non-react-statics": "^3.3.0"
+      }
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true
+    },
+    "node_modules/@types/prop-types": {
+      "version": "15.7.14",
+      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.14.tgz",
+      "integrity": "sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ=="
+    },
+    "node_modules/@types/react": {
+      "version": "19.1.5",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.5.tgz",
+      "integrity": "sha512-piErsCVVbpMMT2r7wbawdZsq4xMvIAhQuac2gedQHysu1TZYEigE6pnFfgZT+/jQnrRuF5r+SHzuehFjfRjr4g==",
+      "dependencies": {
+        "csstype": "^3.0.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "19.1.5",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.1.5.tgz",
+      "integrity": "sha512-CMCjrWucUBZvohgZxkjd6S9h0nZxXjzus6yDfUb+xLxYM7VvjKNH1tQrE9GWLql1XoOP4/Ds3bwFqShHUYraGg==",
+      "dev": true,
+      "peerDependencies": {
+        "@types/react": "^19.0.0"
+      }
+    },
+    "node_modules/@types/react-transition-group": {
+      "version": "4.4.12",
+      "resolved": "https://registry.npmjs.org/@types/react-transition-group/-/react-transition-group-4.4.12.tgz",
+      "integrity": "sha512-8TV6R3h2j7a91c+1DXdJi3Syo69zzIZbz7Lg5tORM5LEJG7X/E6a1V3drRyBRZq7/utz7A+c4OgYLiLcYGHG6w==",
+      "peerDependencies": {
+        "@types/react": "*"
+      }
+    },
+    "node_modules/@types/stylis": {
+      "version": "4.2.5",
+      "resolved": "https://registry.npmjs.org/@types/stylis/-/stylis-4.2.5.tgz",
+      "integrity": "sha512-1Xve+NMN7FWjY14vLoY5tL3BVEQ/n42YLwaqJIPYhotZ9uBHt87VceMwWQpzmdEt2TNXIorIFG+YeCUUW7RInw=="
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.5.0.tgz",
+      "integrity": "sha512-JuLWaEqypaJmOJPLWwO335Ig6jSgC1FTONCWAxnqcQthLTK/Yc9aH6hr9z/87xciejbQcnP3GnA1FWUSWeXaeg==",
+      "dev": true,
+      "dependencies": {
+        "@babel/core": "^7.26.10",
+        "@babel/plugin-transform-react-jsx-self": "^7.25.9",
+        "@babel/plugin-transform-react-jsx-source": "^7.25.9",
+        "@rolldown/pluginutils": "1.0.0-beta.9",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.14.1",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz",
+      "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==",
+      "dev": true,
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "dev": true,
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.24.5",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.5.tgz",
+      "integrity": "sha512-FDToo4Wo82hIdgc1CQ+NQD0hEhmpPjrZ3hiUgwgOG6IuTdlpr8jdjyG24P6cNP1yJpTLzS5OcGgSw0xmDU1/Tw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "caniuse-lite": "^1.0.30001716",
+        "electron-to-chromium": "^1.5.149",
+        "node-releases": "^2.0.19",
+        "update-browserslist-db": "^1.1.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/camelize": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/camelize/-/camelize-1.0.1.tgz",
+      "integrity": "sha512-dU+Tx2fsypxTgtLoE36npi3UqcjSSMNYfkqgmoEhtZrraP5VWq0K7FkWVTYa8eMPtnU/G2txVsfdCJTn9uzpuQ==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001718",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001718.tgz",
+      "integrity": "sha512-AflseV1ahcSunK53NfEs9gFWgOEmzr0f+kaMFA4xiLZlr9Hzt7HxcSpIFcnNCUkz6R6dWKa54rUz3HUmI3nVcw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ]
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/chownr": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
+      "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/css-color-keywords": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/css-color-keywords/-/css-color-keywords-1.0.0.tgz",
+      "integrity": "sha512-FyyrDHZKEjXDpNJYvVsV960FiqQyXc/LlYmsxl2BcdMb2WPx0OGRVgTg55rPSyLSNMqP52R9r8geSp7apN3Ofg==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/css-to-react-native": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/css-to-react-native/-/css-to-react-native-3.2.0.tgz",
+      "integrity": "sha512-e8RKaLXMOFii+02mOlqwjbD00KSEKqblnpO9e++1aXS1fPQOpS1YoqdVHBqPjHNoxeF2mimzVqawm2KCbEdtHQ==",
+      "dependencies": {
+        "camelize": "^1.0.0",
+        "css-color-keywords": "^1.0.0",
+        "postcss-value-parser": "^4.0.2"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
+      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "dev": true,
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true
+    },
+    "node_modules/detect-libc": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.4.tgz",
+      "integrity": "sha512-3UDv+G9CsCKO1WKMGw9fwq/SWJYbI0c5Y7LU1AXYoDdbhE2AHQ6N6Nb34sG8Fj7T5APy8qXDCKuuIHd1BR0tVA==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/dom-helpers": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz",
+      "integrity": "sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==",
+      "dependencies": {
+        "@babel/runtime": "^7.8.7",
+        "csstype": "^3.0.2"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.157",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.157.tgz",
+      "integrity": "sha512-/0ybgsQd1muo8QlnuTpKwtl0oX5YMlUGbm8xyqgDU00motRkKFFbUJySAQBWcY79rVqNLWIWa87BGVGClwAB2w==",
+      "dev": true
+    },
+    "node_modules/enhanced-resolve": {
+      "version": "5.18.1",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.18.1.tgz",
+      "integrity": "sha512-ZSW3ma5GkcQBIpwZTSRAI8N71Uuwgs93IezB7mf7R60tC8ZbJideoDNKjHn2O9KIlx6rkGTTEk1xUCK2E1Y2Yg==",
+      "dependencies": {
+        "graceful-fs": "^4.2.4",
+        "tapable": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.4",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.4.tgz",
+      "integrity": "sha512-8pgjLUcUjcgDg+2Q4NYXnPbo/vncAY4UmyaCm0jZevERqCHZIaWwdJHkf8XQtu4AxSKCdvrUbT0XUr1IdZzI8Q==",
+      "hasInstallScript": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.4",
+        "@esbuild/android-arm": "0.25.4",
+        "@esbuild/android-arm64": "0.25.4",
+        "@esbuild/android-x64": "0.25.4",
+        "@esbuild/darwin-arm64": "0.25.4",
+        "@esbuild/darwin-x64": "0.25.4",
+        "@esbuild/freebsd-arm64": "0.25.4",
+        "@esbuild/freebsd-x64": "0.25.4",
+        "@esbuild/linux-arm": "0.25.4",
+        "@esbuild/linux-arm64": "0.25.4",
+        "@esbuild/linux-ia32": "0.25.4",
+        "@esbuild/linux-loong64": "0.25.4",
+        "@esbuild/linux-mips64el": "0.25.4",
+        "@esbuild/linux-ppc64": "0.25.4",
+        "@esbuild/linux-riscv64": "0.25.4",
+        "@esbuild/linux-s390x": "0.25.4",
+        "@esbuild/linux-x64": "0.25.4",
+        "@esbuild/netbsd-arm64": "0.25.4",
+        "@esbuild/netbsd-x64": "0.25.4",
+        "@esbuild/openbsd-arm64": "0.25.4",
+        "@esbuild/openbsd-x64": "0.25.4",
+        "@esbuild/sunos-x64": "0.25.4",
+        "@esbuild/win32-arm64": "0.25.4",
+        "@esbuild/win32-ia32": "0.25.4",
+        "@esbuild/win32-x64": "0.25.4"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "9.27.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.27.0.tgz",
+      "integrity": "sha512-ixRawFQuMB9DZ7fjU3iGGganFDp3+45bPOdaRurcFHSXO1e/sYwUX/FtQZpLZJR6SjMoJH8hR2pPEAfDyCoU2Q==",
+      "dev": true,
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.2.0",
+        "@eslint-community/regexpp": "^4.12.1",
+        "@eslint/config-array": "^0.20.0",
+        "@eslint/config-helpers": "^0.2.1",
+        "@eslint/core": "^0.14.0",
+        "@eslint/eslintrc": "^3.3.1",
+        "@eslint/js": "9.27.0",
+        "@eslint/plugin-kit": "^0.3.1",
+        "@humanfs/node": "^0.16.6",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.4.2",
+        "@types/estree": "^1.0.6",
+        "@types/json-schema": "^7.0.15",
+        "ajv": "^6.12.4",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^8.3.0",
+        "eslint-visitor-keys": "^4.2.0",
+        "espree": "^10.3.0",
+        "esquery": "^1.5.0",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.2",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "jiti": "*"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-plugin-react-hooks": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-5.2.0.tgz",
+      "integrity": "sha512-+f15FfK64YQwZdJNELETdn5ibXEUQmW1DZL6KXhNnc2heoy/sg9VJJeT7n8TlMWouzWqSWavFkIhHyIbIAEapg==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "peerDependencies": {
+        "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0"
+      }
+    },
+    "node_modules/eslint-plugin-react-refresh": {
+      "version": "0.4.20",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.4.20.tgz",
+      "integrity": "sha512-XpbHQ2q5gUF8BGOX4dHe+71qoirYMhApEPZ7sfhF/dNnOF1UXnCMGZf79SFTBO7Bz5YEIT4TMieSlJBWhP9WBA==",
+      "dev": true,
+      "peerDependencies": {
+        "eslint": ">=8.40"
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "8.3.0",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.3.0.tgz",
+      "integrity": "sha512-pUNxi75F8MJ/GdeKtVLSbYg4ZI34J6C0C7sbL4YOp2exGwen7ZsuBqKzUhXd0qMQ362yET3z+uPwKeg/0C2XCQ==",
+      "dev": true,
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz",
+      "integrity": "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==",
+      "dev": true,
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/espree": {
+      "version": "10.3.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.3.0.tgz",
+      "integrity": "sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==",
+      "dev": true,
+      "dependencies": {
+        "acorn": "^8.14.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz",
+      "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==",
+      "dev": true,
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "dev": true,
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true
+    },
+    "node_modules/fdir": {
+      "version": "6.4.4",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.4.tgz",
+      "integrity": "sha512-1NZP+GK4GfuAv3PqKvxQRDMjdSRZjnkq7KfhlNrCNNlZ0ygQFpebfrnfnq/W7fpUnAv9aGWmY1zKx7FYL3gwhg==",
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+      "dev": true,
+      "dependencies": {
+        "flat-cache": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+      "dev": true,
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/flatted": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz",
+      "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==",
+      "dev": true
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/globals": {
+      "version": "16.2.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-16.2.0.tgz",
+      "integrity": "sha512-O+7l9tPdHCU320IigZZPj5zmRCFG9xHmx9cU8FqU2Rp+JN714seHV+2S9+JslCpY4gJwU2vOGox0wzgae/MCEg==",
+      "dev": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/hoist-non-react-statics": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz",
+      "integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==",
+      "dependencies": {
+        "react-is": "^16.7.0"
+      }
+    },
+    "node_modules/hoist-non-react-statics/node_modules/react-is": {
+      "version": "16.13.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ=="
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "dev": true,
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true
+    },
+    "node_modules/jiti": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.4.2.tgz",
+      "integrity": "sha512-rg9zJN+G4n2nfJl5MW3BMygZX56zKPNVEYYqq7adpmMh4Jn2QNEwhvQlFy6jPVdcod7txZtKHWnyZiA3a0zP7A==",
+      "bin": {
+        "jiti": "lib/jiti-cli.mjs"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "dev": true,
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "dev": true
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+      "dev": true
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "dev": true,
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+      "dev": true,
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.30.1.tgz",
+      "integrity": "sha512-xi6IyHML+c9+Q3W0S4fCQJOym42pyurFiJUHEcEyHS0CeKzia4yZDEsLlqOFykxOdHpNy0NmvVO31vcSqAxJCg==",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-darwin-arm64": "1.30.1",
+        "lightningcss-darwin-x64": "1.30.1",
+        "lightningcss-freebsd-x64": "1.30.1",
+        "lightningcss-linux-arm-gnueabihf": "1.30.1",
+        "lightningcss-linux-arm64-gnu": "1.30.1",
+        "lightningcss-linux-arm64-musl": "1.30.1",
+        "lightningcss-linux-x64-gnu": "1.30.1",
+        "lightningcss-linux-x64-musl": "1.30.1",
+        "lightningcss-win32-arm64-msvc": "1.30.1",
+        "lightningcss-win32-x64-msvc": "1.30.1"
+      }
+    },
+    "node_modules/lightningcss-darwin-arm64": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.30.1.tgz",
+      "integrity": "sha512-c8JK7hyE65X1MHMN+Viq9n11RRC7hgin3HhYKhrMyaXflk5GVplZ60IxyoVtzILeKr+xAJwg6zK6sjTBJ0FKYQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-darwin-x64": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.30.1.tgz",
+      "integrity": "sha512-k1EvjakfumAQoTfcXUcHQZhSpLlkAuEkdMBsI/ivWw9hL+7FtilQc0Cy3hrx0AAQrVtQAbMI7YjCgYgvn37PzA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-freebsd-x64": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.30.1.tgz",
+      "integrity": "sha512-kmW6UGCGg2PcyUE59K5r0kWfKPAVy4SltVeut+umLCFoJ53RdCUWxcRDzO1eTaxf/7Q2H7LTquFHPL5R+Gjyig==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm-gnueabihf": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.30.1.tgz",
+      "integrity": "sha512-MjxUShl1v8pit+6D/zSPq9S9dQ2NPFSQwGvxBCYaBYLPlCWuPh9/t1MRS8iUaR8i+a6w7aps+B4N0S1TYP/R+Q==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-gnu": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.30.1.tgz",
+      "integrity": "sha512-gB72maP8rmrKsnKYy8XUuXi/4OctJiuQjcuqWNlJQ6jZiWqtPvqFziskH3hnajfvKB27ynbVCucKSm2rkQp4Bw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-arm64-musl": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.30.1.tgz",
+      "integrity": "sha512-jmUQVx4331m6LIX+0wUhBbmMX7TCfjF5FoOH6SD1CttzuYlGNVpA7QnrmLxrsub43ClTINfGSYyHe2HWeLl5CQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.30.1.tgz",
+      "integrity": "sha512-piWx3z4wN8J8z3+O5kO74+yr6ze/dKmPnI7vLqfSqI8bccaTGY5xiSGVIJBDd5K5BHlvVLpUB3S2YCfelyJ1bw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.30.1.tgz",
+      "integrity": "sha512-rRomAK7eIkL+tHY0YPxbc5Dra2gXlI63HL+v1Pdi1a3sC+tJTcFrHX+E86sulgAXeI7rSzDYhPSeHHjqFhqfeQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-arm64-msvc": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.30.1.tgz",
+      "integrity": "sha512-mSL4rqPi4iXq5YVqzSsJgMVFENoa4nGTT/GjO2c0Yl9OuQfPsIfncvLrEW6RbbB24WtZ3xP/2CCmI3tNkNV4oA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-win32-x64-msvc": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.30.1.tgz",
+      "integrity": "sha512-PVqXh48wh4T53F/1CCu8PIPCxLzWyCnn/9T5W1Jpmdy5h9Cwd+0YQS6/LwhHXSafuc61/xg9Lv5OrCby6a++jg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+      "dev": true
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/lucide-react": {
+      "version": "0.511.0",
+      "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.511.0.tgz",
+      "integrity": "sha512-VK5a2ydJ7xm8GvBeKLS9mu1pVK6ucef9780JVUjw6bAjJL/QXnd4Y0p7SPeOUMC27YhzNCZvm5d/QX0Tp3rc0w==",
+      "peerDependencies": {
+        "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.17",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
+      "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "7.1.2",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
+      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.0.2.tgz",
+      "integrity": "sha512-oG62iEk+CYt5Xj2YqI5Xi9xWUeZhDI8jjQmC5oThVH5JGCTgIjr7ciJDzC7MBzYd//WvR1OTmP5Q38Q8ShQtVA==",
+      "dependencies": {
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/mkdirp": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-3.0.1.tgz",
+      "integrity": "sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==",
+      "bin": {
+        "mkdirp": "dist/cjs/src/bin.js"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "dev": true
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.19",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz",
+      "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==",
+      "dev": true
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+      "dev": true,
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dev": true,
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
+      "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.4.49",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.49.tgz",
+      "integrity": "sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "nanoid": "^3.3.7",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/postcss-value-parser": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+      "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ=="
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "dev": true,
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/prop-types": {
+      "version": "15.8.1",
+      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
+      "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
+      "dependencies": {
+        "loose-envify": "^1.4.0",
+        "object-assign": "^4.1.1",
+        "react-is": "^16.13.1"
+      }
+    },
+    "node_modules/prop-types/node_modules/react-is": {
+      "version": "16.13.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ=="
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.1.0",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.1.0.tgz",
+      "integrity": "sha512-FS+XFBNvn3GTAWq26joslQgWNoFu08F4kl0J4CgdNKADkdSGXQyTCnKteIAJy96Br6YbpEU1LSzV5dYtjMkMDg==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.1.0",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.1.0.tgz",
+      "integrity": "sha512-Xs1hdnE+DyKgeHJeJznQmYMIBG3TKIHJJT95Q58nHLSrElKlGQqDTR2HQ9fx5CN/Gk6Vh/kupBTDLU11/nDk/g==",
+      "dependencies": {
+        "scheduler": "^0.26.0"
+      },
+      "peerDependencies": {
+        "react": "^19.1.0"
+      }
+    },
+    "node_modules/react-is": {
+      "version": "19.1.0",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-19.1.0.tgz",
+      "integrity": "sha512-Oe56aUPnkHyyDxxkvqtd7KkdQP5uIUfHxd5XTb3wE9d/kRnZLmKbDB0GWk919tdQ+mxxPtG6EAs6RMT6i1qtHg=="
+    },
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-transition-group": {
+      "version": "4.4.5",
+      "resolved": "https://registry.npmjs.org/react-transition-group/-/react-transition-group-4.4.5.tgz",
+      "integrity": "sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g==",
+      "dependencies": {
+        "@babel/runtime": "^7.5.5",
+        "dom-helpers": "^5.0.1",
+        "loose-envify": "^1.4.0",
+        "prop-types": "^15.6.2"
+      },
+      "peerDependencies": {
+        "react": ">=16.6.0",
+        "react-dom": ">=16.6.0"
+      }
+    },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "dev": true,
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.41.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.41.1.tgz",
+      "integrity": "sha512-cPmwD3FnFv8rKMBc1MxWCwVQFxwf1JEmSX3iQXrRVVG15zerAIXRjMFVWnd5Q5QvgKF7Aj+5ykXFhUl+QGnyOw==",
+      "dependencies": {
+        "@types/estree": "1.0.7"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.41.1",
+        "@rollup/rollup-android-arm64": "4.41.1",
+        "@rollup/rollup-darwin-arm64": "4.41.1",
+        "@rollup/rollup-darwin-x64": "4.41.1",
+        "@rollup/rollup-freebsd-arm64": "4.41.1",
+        "@rollup/rollup-freebsd-x64": "4.41.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.41.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.41.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.41.1",
+        "@rollup/rollup-linux-arm64-musl": "4.41.1",
+        "@rollup/rollup-linux-loongarch64-gnu": "4.41.1",
+        "@rollup/rollup-linux-powerpc64le-gnu": "4.41.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.41.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.41.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.41.1",
+        "@rollup/rollup-linux-x64-gnu": "4.41.1",
+        "@rollup/rollup-linux-x64-musl": "4.41.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.41.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.41.1",
+        "@rollup/rollup-win32-x64-msvc": "4.41.1",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.26.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.26.0.tgz",
+      "integrity": "sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA=="
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/shallowequal": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/shallowequal/-/shallowequal-1.1.0.tgz",
+      "integrity": "sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ=="
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/styled-components": {
+      "version": "6.1.18",
+      "resolved": "https://registry.npmjs.org/styled-components/-/styled-components-6.1.18.tgz",
+      "integrity": "sha512-Mvf3gJFzZCkhjY2Y/Fx9z1m3dxbza0uI9H1CbNZm/jSHCojzJhQ0R7bByrlFJINnMzz/gPulpoFFGymNwrsMcw==",
+      "dependencies": {
+        "@emotion/is-prop-valid": "1.2.2",
+        "@emotion/unitless": "0.8.1",
+        "@types/stylis": "4.2.5",
+        "css-to-react-native": "3.2.0",
+        "csstype": "3.1.3",
+        "postcss": "8.4.49",
+        "shallowequal": "1.1.0",
+        "stylis": "4.3.2",
+        "tslib": "2.6.2"
+      },
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/styled-components"
+      },
+      "peerDependencies": {
+        "react": ">= 16.8.0",
+        "react-dom": ">= 16.8.0"
+      }
+    },
+    "node_modules/styled-components/node_modules/@emotion/unitless": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/@emotion/unitless/-/unitless-0.8.1.tgz",
+      "integrity": "sha512-KOEGMu6dmJZtpadb476IsZBclKvILjopjUii3V+7MnXIQCYh8W3NgNcgwo21n9LXZX6EDIKvqfjYxXebDwxKmQ=="
+    },
+    "node_modules/styled-components/node_modules/stylis": {
+      "version": "4.3.2",
+      "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.3.2.tgz",
+      "integrity": "sha512-bhtUjWd/z6ltJiQwg0dUfxEJ+W+jdqQd8TbWLWyeIJHlnsqmGLRFFd8e5mA0AZi/zx90smXRlN66YMTcaSFifg=="
+    },
+    "node_modules/stylis": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.2.0.tgz",
+      "integrity": "sha512-Orov6g6BB1sDfYgzWfTHDOxamtX1bE/zo104Dh9e6fqJ3PooipYyfJ0pUmrZO2wAvO8YbEyeFrkV91XTsGMSrw=="
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tailwindcss": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.7.tgz",
+      "integrity": "sha512-kr1o/ErIdNhTz8uzAYL7TpaUuzKIE6QPQ4qmSdxnoX/lo+5wmUHQA6h3L5yIqEImSRnAAURDirLu/BgiXGPAhg=="
+    },
+    "node_modules/tapable": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.2.tgz",
+      "integrity": "sha512-Re10+NauLTMCudc7T5WLFLAwDhQ0JWdrMK+9B2M8zR5hRExKmsRDCBA7/aV/pNJFltmBFO5BAMlQFi/vq3nKOg==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/tar": {
+      "version": "7.4.3",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-7.4.3.tgz",
+      "integrity": "sha512-5S7Va8hKfV7W5U6g3aYxXmlPoZVAwUMy9AOKyF2fVuZa2UD3qZjg578OrLRt8PcNN1PleVaL/5/yYATNL0ICUw==",
+      "dependencies": {
+        "@isaacs/fs-minipass": "^4.0.0",
+        "chownr": "^3.0.0",
+        "minipass": "^7.1.2",
+        "minizlib": "^3.0.1",
+        "mkdirp": "^3.0.1",
+        "yallist": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/tar/node_modules/yallist": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
+      "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.14",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.14.tgz",
+      "integrity": "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ==",
+      "dependencies": {
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.6.2",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz",
+      "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q=="
+    },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+      "dev": true,
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz",
+      "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "dev": true,
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "6.3.5",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.3.5.tgz",
+      "integrity": "sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ==",
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "fdir": "^6.4.4",
+        "picomatch": "^4.0.2",
+        "postcss": "^8.5.3",
+        "rollup": "^4.34.9",
+        "tinyglobby": "^0.2.13"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/postcss": {
+      "version": "8.5.3",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz",
+      "integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "nanoid": "^3.3.8",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    }
+  }
+}
diff --git a/frontend/package.json b/frontend/package.json
new file mode 100644
index 0000000..b008c4b
--- /dev/null
+++ b/frontend/package.json
@@ -0,0 +1,35 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@fontsource/roboto": "^5.2.5",
+    "@mui/icons-material": "^7.1.0",
+    "@mui/material": "^7.1.0",
+    "@mui/styled-engine-sc": "^7.1.0",
+    "@tailwindcss/vite": "^4.1.7",
+    "lucide-react": "^0.511.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "styled-components": "^6.1.18",
+    "tailwindcss": "^4.1.7"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.25.0",
+    "@types/react": "^19.1.2",
+    "@types/react-dom": "^19.1.2",
+    "@vitejs/plugin-react": "^4.4.1",
+    "eslint": "^9.25.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.19",
+    "globals": "^16.0.0",
+    "vite": "^6.3.5"
+  }
+}
diff --git a/frontend/public/vite.svg b/frontend/public/vite.svg
new file mode 100644
index 0000000..e7b8dfb
--- /dev/null
+++ b/frontend/public/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>
\ No newline at end of file
diff --git a/frontend/src/App.css b/frontend/src/App.css
new file mode 100644
index 0000000..f1d8c73
--- /dev/null
+++ b/frontend/src/App.css
@@ -0,0 +1 @@
+@import "tailwindcss";
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
new file mode 100644
index 0000000..4e2844c
--- /dev/null
+++ b/frontend/src/App.jsx
@@ -0,0 +1,20 @@
+// src/App.jsx
+import { useState } from 'react';
+import './App.css';
+import Chat from './components/Chat';
+import InfantBackendConnector from './services/BackendService';
+
+function App() {
+  const backendConnector = new InfantBackendConnector({ apiUrl: '/api' });
+
+
+  return (
+    <div className="App">
+      <Chat backendConnector={backendConnector}/>
+
+
+    </div>
+  );
+}
+
+export default App;
\ No newline at end of file
diff --git a/frontend/src/assets/react.svg b/frontend/src/assets/react.svg
new file mode 100644
index 0000000..6c87de9
--- /dev/null
+++ b/frontend/src/assets/react.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>
\ No newline at end of file
diff --git a/frontend/src/components/Chat.jsx b/frontend/src/components/Chat.jsx
new file mode 100644
index 0000000..1e2dd78
--- /dev/null
+++ b/frontend/src/components/Chat.jsx
@@ -0,0 +1,308 @@
+import React, { useState, useRef, useEffect } from 'react';
+import { Send, Bot, User, Paperclip, X, FileText, Image, File } from 'lucide-react';
+
+const Chat = ({ backendConnector }) => {
+  const [messages, setMessages] = useState([
+    { id: 1, text: "Hello! I'm here to help. What would you like to chat about?", sender: 'bot', timestamp: new Date() }
+  ]);
+  const [input, setInput] = useState('');
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [streamingMessage, setStreamingMessage] = useState('');
+  const [attachedFiles, setAttachedFiles] = useState([]);
+  const messagesEndRef = useRef(null);
+  const inputRef = useRef(null);
+  const fileInputRef = useRef(null);
+
+  const scrollToBottom = () => {
+    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
+  };
+
+  useEffect(() => {
+    scrollToBottom();
+  }, [messages, streamingMessage]);
+
+  const getFileIcon = (fileType) => {
+    if (fileType.startsWith('image/')) return Image;
+    if (fileType.includes('text') || fileType.includes('document')) return FileText;
+    return File;
+  };
+
+  const formatFileSize = (bytes) => {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+  };
+
+  const handleFileSelect = (event) => {
+    const files = Array.from(event.target.files);
+    const newFiles = files.map(file => ({
+      id: Date.now() + Math.random(),
+      file: file,
+      name: file.name,
+      size: file.size,
+      type: file.type
+    }));
+    
+    setAttachedFiles(prev => [...prev, ...newFiles]);
+    // Reset file input
+    if (fileInputRef.current) {
+      fileInputRef.current.value = '';
+    }
+  };
+
+  const removeFile = (fileId) => {
+    setAttachedFiles(prev => prev.filter(f => f.id !== fileId));
+  };
+
+  const handleFileUpload = () => {
+    fileInputRef.current?.click();
+  };
+
+  const simulateStreamingResponse = async (userMessage, files) => {
+    // Simulate different responses based on user input and files
+    let responses = [
+      "That's an interesting question! Let me think about this carefully. Streaming responses are great for creating more engaging user experiences because they provide immediate feedback and make the interaction feel more natural and conversational.",
+      "I understand what you're asking about. Real-time streaming in chat applications works by sending data in chunks rather than waiting for the complete response. This creates a more dynamic and responsive feel for users.",
+      "Great point! When implementing streaming functionality, you'll want to consider factors like error handling, connection stability, and user experience. The key is to balance responsiveness with reliability.",
+      "Thanks for that question! Streaming chat interfaces have become increasingly popular because they reduce perceived latency and keep users engaged throughout longer responses. The technical implementation can vary depending on your backend architecture."
+    ];
+
+    if (files && files.length > 0) {
+      const fileTypes = files.map(f => f.type);
+      if (fileTypes.some(type => type.startsWith('image/'))) {
+        responses = [
+          "I can see you've uploaded some images! While I can't actually process images in this demo, in a real implementation I would analyze the visual content and provide relevant insights or descriptions.",
+          "Thanks for sharing those images! In a production chat system, I would be able to examine the visual content, identify objects, read text, and answer questions about what I see in the images.",
+          "Great! You've attached some image files. Image analysis capabilities would allow me to describe scenes, identify objects, read text from images, and help with visual questions."
+        ];
+      } else if (fileTypes.some(type => type.includes('text') || type.includes('document'))) {
+        responses = [
+          "I notice you've uploaded some documents! In a real implementation, I would read through the content and help you analyze, summarize, or answer questions about the text.",
+          "Thanks for the document upload! With proper file processing, I could extract the text content, provide summaries, answer questions about the material, or help with analysis.",
+          "Excellent! You've shared some text documents. Document processing would allow me to read the content and assist with comprehension, analysis, or specific questions about the material."
+        ];
+      } else {
+        responses = [
+          "I see you've uploaded some files! While this is a demo interface, a production system would process these files appropriately based on their type and provide relevant assistance.",
+          "Thanks for the file upload! Different file types would be handled accordingly - images analyzed, documents read, data files processed, etc.",
+          "Great! You've attached some files. In a real implementation, I would process these based on their format and help you work with the content."
+        ];
+      }
+    }
+    
+    const response = responses[Math.floor(Math.random() * responses.length)];
+    const words = response.split(' ');
+    
+    setIsStreaming(true);
+    setStreamingMessage('');
+    
+    for (let i = 0; i < words.length; i++) {
+      await new Promise(resolve => setTimeout(resolve, 50 + Math.random() * 100));
+      setStreamingMessage(prev => prev + (i === 0 ? words[i] : ' ' + words[i]));
+    }
+    
+    // Complete the streaming and add to messages
+    const newMessage = {
+      id: Date.now(),
+      text: response,
+      sender: 'bot',
+      timestamp: new Date()
+    };
+    
+    setMessages(prev => [...prev, newMessage]);
+    setStreamingMessage('');
+    setIsStreaming(false);
+  };
+
+  const handleSend = async () => {
+    if ((!input.trim() && attachedFiles.length === 0) || isStreaming) return;
+    
+    const userMessage = {
+      id: Date.now(),
+      text: input.trim(),
+      sender: 'user',
+      timestamp: new Date(),
+      files: attachedFiles.length > 0 ? [...attachedFiles] : undefined
+    };
+    
+    setMessages(prev => [...prev, userMessage]);
+    setInput('');
+    setAttachedFiles([]);
+    
+    // Start streaming response
+    await simulateStreamingResponse(userMessage.text, userMessage.files);
+  };
+
+  const handleKeyPress = (e) => {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault();
+      handleSend();
+    }
+  };
+
+  const formatTime = (timestamp) => {
+    return timestamp.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+  };
+
+  return (
+    <div className="flex flex-col h-screen w-full bg-gray-50">
+      {/* Header */}
+      <div className="bg-white border-b border-gray-200 p-3 sm:p-4 shadow-sm flex-shrink-0">
+        <h1 className="text-lg sm:text-xl font-semibold text-gray-800 flex items-center gap-2">
+          <Bot className="w-5 h-5 sm:w-6 sm:h-6 text-blue-600" />
+          <span className="hidden sm:inline">Streaming Chat</span>
+          <span className="sm:hidden">Chat</span>
+        </h1>
+      </div>
+
+      {/* Messages Container */}
+      <div className="flex-1 overflow-y-auto p-2 sm:p-4 space-y-3 sm:space-y-4 min-h-0">
+        {messages.map((message) => (
+          <div key={message.id} className={`flex ${message.sender === 'user' ? 'justify-end' : 'justify-start'}`}>
+            <div className={`flex w-full max-w-[85%] sm:max-w-sm md:max-w-md lg:max-w-lg xl:max-w-xl ${message.sender === 'user' ? 'flex-row-reverse' : 'flex-row'} items-start gap-2 sm:gap-3`}>
+              <div className={`flex-shrink-0 w-6 h-6 sm:w-8 sm:h-8 rounded-full flex items-center justify-center ${
+                message.sender === 'user' ? 'bg-blue-600' : 'bg-gray-600'
+              }`}>
+                {message.sender === 'user' ? (
+                  <User className="w-3 h-3 sm:w-4 sm:h-4 text-white" />
+                ) : (
+                  <Bot className="w-3 h-3 sm:w-4 sm:h-4 text-white" />
+                )}
+              </div>
+              <div className={`rounded-lg px-3 py-2 sm:px-4 sm:py-2 flex-1 min-w-0 ${
+                message.sender === 'user' 
+                  ? 'bg-blue-600 text-white' 
+                  : 'bg-white text-gray-800 border border-gray-200'
+              }`}>
+                <p className="text-sm sm:text-base break-words">{message.text}</p>
+                
+                {/* File attachments */}
+                {message.files && message.files.length > 0 && (
+                  <div className="mt-2 space-y-1">
+                    {message.files.map((file) => {
+                      const IconComponent = getFileIcon(file.type);
+                      return (
+                        <div key={file.id} className={`flex items-center gap-2 p-2 rounded text-xs ${
+                          message.sender === 'user' 
+                            ? 'bg-blue-500 bg-opacity-50' 
+                            : 'bg-gray-50'
+                        }`}>
+                          <IconComponent className="w-3 h-3 flex-shrink-0" />
+                          <span className="flex-1 truncate">{file.name}</span>
+                          <span className="text-xs opacity-75">{formatFileSize(file.size)}</span>
+                        </div>
+                      );
+                    })}
+                  </div>
+                )}
+                
+                <p className={`text-xs mt-1 ${
+                  message.sender === 'user' ? 'text-blue-100' : 'text-gray-500'
+                }`}>
+                  {formatTime(message.timestamp)}
+                </p>
+              </div>
+            </div>
+          </div>
+        ))}
+
+        {/* Streaming Message */}
+        {isStreaming && (
+          <div className="flex justify-start">
+            <div className="flex w-full max-w-[85%] sm:max-w-sm md:max-w-md lg:max-w-lg xl:max-w-xl items-start gap-2 sm:gap-3">
+              <div className="flex-shrink-0 w-6 h-6 sm:w-8 sm:h-8 rounded-full bg-gray-600 flex items-center justify-center">
+                <Bot className="w-3 h-3 sm:w-4 sm:h-4 text-white" />
+              </div>
+              <div className="rounded-lg px-3 py-2 sm:px-4 sm:py-2 bg-white text-gray-800 border border-gray-200 flex-1 min-w-0">
+                <p className="text-sm sm:text-base break-words">
+                  {streamingMessage}
+                  <span className="inline-block w-0.5 h-4 sm:h-5 bg-gray-400 ml-1 animate-pulse"></span>
+                </p>
+              </div>
+            </div>
+          </div>
+        )}
+
+        <div ref={messagesEndRef} />
+      </div>
+
+      {/* Input Area */}
+      <div className="bg-white border-t border-gray-200 flex-shrink-0">
+        {/* File Preview */}
+        {attachedFiles.length > 0 && (
+          <div className="p-3 border-b border-gray-200">
+            <div className="flex flex-wrap gap-2">
+              {attachedFiles.map((file) => {
+                const IconComponent = getFileIcon(file.type);
+                return (
+                  <div key={file.id} className="flex items-center gap-2 bg-gray-100 rounded-lg p-2 text-sm">
+                    <IconComponent className="w-4 h-4 text-gray-600 flex-shrink-0" />
+                    <span className="flex-1 truncate max-w-32">{file.name}</span>
+                    <span className="text-xs text-gray-500">{formatFileSize(file.size)}</span>
+                    <button
+                      onClick={() => removeFile(file.id)}
+                      className="text-gray-400 hover:text-red-500 transition-colors"
+                    >
+                      <X className="w-3 h-3" />
+                    </button>
+                  </div>
+                );
+              })}
+            </div>
+          </div>
+        )}
+        
+        <div className="p-3 sm:p-4">
+          <div className="flex gap-2 sm:gap-3">
+            <button
+              onClick={handleFileUpload}
+              disabled={isStreaming}
+              className="flex-shrink-0 p-2 text-gray-500 hover:text-blue-600 hover:bg-blue-50 rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+              title="Attach file"
+            >
+              <Paperclip className="w-4 h-4 sm:w-5 sm:h-5" />
+            </button>
+            <textarea
+              ref={inputRef}
+              value={input}
+              onChange={(e) => setInput(e.target.value)}
+              onKeyPress={handleKeyPress}
+              placeholder={isStreaming ? "Please wait for response..." : "Type your message..."}
+              disabled={isStreaming}
+              className="flex-1 resize-none border border-gray-300 rounded-lg px-3 py-2 sm:px-4 sm:py-2 text-sm sm:text-base focus:outline-none focus:border-blue-500 focus:ring-1 focus:ring-blue-500 disabled:bg-gray-100 disabled:cursor-not-allowed transition-colors"
+              rows="1"
+              style={{ minHeight: '36px', maxHeight: '120px' }}
+            />
+            <button
+              onClick={handleSend}
+              disabled={(!input.trim() && attachedFiles.length === 0) || isStreaming}
+              className="px-3 py-2 sm:px-4 sm:py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 disabled:bg-gray-400 disabled:cursor-not-allowed transition-colors flex-shrink-0"
+            >
+              <Send className="w-4 h-4 sm:w-5 sm:h-5" />
+            </button>
+          </div>
+          <p className="text-xs text-gray-500 mt-2 hidden sm:block">
+            Press Enter to send, Shift+Enter for new line
+          </p>
+          <p className="text-xs text-gray-500 mt-2 sm:hidden">
+            Tap send or press Enter
+          </p>
+        </div>
+        
+        {/* Hidden file input */}
+        <input
+          ref={fileInputRef}
+          type="file"
+          multiple
+          onChange={handleFileSelect}
+          className="hidden"
+          accept="*/*"
+        />
+      </div>
+    </div>
+  );
+};
+
+export default StreamingChat;
\ No newline at end of file
diff --git a/frontend/src/index.css b/frontend/src/index.css
new file mode 100644
index 0000000..f1d8c73
--- /dev/null
+++ b/frontend/src/index.css
@@ -0,0 +1 @@
+@import "tailwindcss";
diff --git a/frontend/src/main.jsx b/frontend/src/main.jsx
new file mode 100644
index 0000000..b9a1a6d
--- /dev/null
+++ b/frontend/src/main.jsx
@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
diff --git a/frontend/src/services/BackendService.js b/frontend/src/services/BackendService.js
new file mode 100644
index 0000000..714517c
--- /dev/null
+++ b/frontend/src/services/BackendService.js
@@ -0,0 +1,158 @@
+// Backend Connector for Infant AI Assistant
+// This file provides the interface between the frontend and the Infant backend
+
+class InfantBackendConnector {
+  constructor(config = {}) {
+      this.apiUrl = config.apiUrl || '/api';
+      this.connected = false;
+      this.sessionId = null;
+  }
+
+  // Initialize connection to the backend
+  async connect() {
+      try {
+          // In a real implementation, this would establish a connection to the backend
+          // For now, we'll simulate a successful connection
+          this.connected = true;
+          this.sessionId = 'session-' + Math.random().toString(36).substring(2, 15);
+          console.log('Connected to Infant backend with session ID:', this.sessionId);
+          return true;
+      } catch (error) {
+          console.error('Failed to connect to Infant backend:', error);
+          this.connected = false;
+          return false;
+      }
+  }
+
+  // Send a user request to the backend
+  async sendRequest(message, options = {}) {
+      if (!this.connected) {
+          await this.connect();
+      }
+
+      try {
+          console.log('Sending request to backend:', message);
+
+          // Make an actual API call to the backend
+          const response = await fetch(`${this.apiUrl}/chat`, {
+              method: 'POST',
+              headers: {
+                  'Content-Type': 'application/json'
+              },
+              body: JSON.stringify({
+                  message: message,
+                  session_id: this.sessionId,
+                  options: options
+              })
+          });
+
+          if (!response.ok) {
+              throw new Error(`API request failed with status ${response.status}`);
+          }
+
+          return await response.json();
+      } catch (error) {
+          console.error('Error sending request to backend:', error);
+          return {
+              success: false,
+              error: error.message || 'Unknown error occurred'
+          };
+      }
+  }
+
+  // Reset the conversation
+  async resetConversation() {
+      try {
+          // In a real implementation, this would reset the conversation state in the backend
+          console.log('Resetting conversation in backend');
+
+          // Simulate network delay
+          return new Promise((resolve) => {
+              setTimeout(() => {
+                  // Generate a new session ID
+                  this.sessionId = 'session-' + Math.random().toString(36).substring(2, 15);
+                  resolve({
+                      success: true,
+                      message: "Conversation reset successfully",
+                      newSessionId: this.sessionId
+                  });
+              }, 1000);
+          });
+      } catch (error) {
+          console.error('Error resetting conversation:', error);
+          return {
+              success: false,
+              error: error.message || 'Unknown error occurred'
+          };
+      }
+  }
+
+  // Update settings in the backend
+  async updateSettings(settings) {
+      try {
+          // In a real implementation, this would update settings in the backend
+          console.log('Updating settings in backend:', settings);
+
+          // Simulate network delay
+          return new Promise((resolve) => {
+              setTimeout(() => {
+                  resolve({
+                      success: true,
+                      message: "Settings updated successfully",
+                      appliedSettings: settings
+                  });
+              }, 1000);
+          });
+      } catch (error) {
+          console.error('Error updating settings:', error);
+          return {
+              success: false,
+              error: error.message || 'Unknown error occurred'
+          };
+      }
+  }
+
+  // Get current status from the backend
+  async getStatus() {
+      try {
+          // In a real implementation, this would fetch the current status from the backend
+          console.log('Fetching status from backend');
+
+          // Simulate network delay
+          return new Promise((resolve) => {
+              setTimeout(() => {
+                  resolve({
+                      success: true,
+                      status: "ready",
+                      currentTask: "none",
+                      model: "claude-3-7-sonnet-latest",
+                      sessionActive: this.connected
+                  });
+              }, 500);
+          });
+      } catch (error) {
+          console.error('Error fetching status:', error);
+          return {
+              success: false,
+              error: error.message || 'Unknown error occurred'
+          };
+      }
+  }
+
+  // Disconnect from the backend
+  async disconnect() {
+      try {
+          // In a real implementation, this would properly close the connection to the backend
+          console.log('Disconnecting from Infant backend');
+          this.connected = false;
+          this.sessionId = null;
+          return true;
+      } catch (error) {
+          console.error('Error disconnecting from backend:', error);
+          return false;
+      }
+  }
+}
+
+// Export the connector
+window.InfantBackendConnector = InfantBackendConnector;
\ No newline at end of file
diff --git a/frontend/vite.config.js b/frontend/vite.config.js
new file mode 100644
index 0000000..c4069b7
--- /dev/null
+++ b/frontend/vite.config.js
@@ -0,0 +1,8 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+})
diff --git a/infant/__main__.py b/infant/__main__.py
new file mode 100644
index 0000000..994ae2b
--- /dev/null
+++ b/infant/__main__.py
@@ -0,0 +1,9 @@
+"""
+Entry point for running the infant module as a CLI application.
+Usage: python -m infant
+"""
+import asyncio
+from infant.main import main
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/infant/agent/agent.py b/infant/agent/agent.py
index 979bd01..e00cb63 100644
--- a/infant/agent/agent.py
+++ b/infant/agent/agent.py
@@ -3,7 +3,7 @@
 from infant.config import AgentParams
 from infant.llm.llm_api_base import LLM_API_BASED
 from infant.llm.llm_oss_base import LLM_OSS_BASED
-from infant.computer.computer import Computer
+from infant.computer.computer import Computer as Computer
 from infant.util.debug import print_messages # For debugging
 from infant.agent.state.state import State, AgentState
 from infant.agent.memory.memory import ( 
@@ -338,8 +338,8 @@ def flatten(nested):
 
         if case == "planning":
             memory_block = await process_memory_block(memory_block, planning_memory_rtve)
-            messages = planning_memory_to_diag(memory_block, end_prompt=self.planning_task_end_prompt, 
-                                                mount_path = self.computer.workspace_mount_path)
+            messages = planning_memory_to_diag(memory_block, end_prompt=self.planning_task_end_prompt,
+                                                mount_path = constant.MOUNT_PATH)
 
         elif case == "classification":
             memory_block = await process_memory_block(memory_block, classification_memory_rtve)
@@ -350,7 +350,7 @@ def flatten(nested):
             # print(f'cmd_set in memory_to_input: {cmd_set}')
             memory_block = await process_memory_block(memory_block, execution_memory_rtve)
             messages = execution_memory_to_diag(memory_block, cmd_set, end_prompt=self.execution_task_end_prompt,
-                                                mount_path = self.computer.workspace_mount_path)
+                                                mount_path = constant.MOUNT_PATH)
         return messages
 
     def extract_image_from_response(self, response: str) -> bytes:
diff --git a/infant/agent/memory/file_related_memory.py b/infant/agent/memory/file_related_memory.py
index 132d34f..7bae08c 100644
--- a/infant/agent/memory/file_related_memory.py
+++ b/infant/agent/memory/file_related_memory.py
@@ -1,5 +1,5 @@
 import re
-from infant.computer.computer import Computer
+from infant.computer.computer import Computer as Computer
 from infant.util.logger import infant_logger as logger
 
 def get_diff_patch(computer: Computer):
diff --git a/infant/computer/Dockerfile b/infant/computer/Dockerfile
index 561be2d..9e72518 100644
--- a/infant/computer/Dockerfile
+++ b/infant/computer/Dockerfile
@@ -18,18 +18,18 @@ RUN rm -f /etc/update-motd.d/60-unminimize /etc/update-motd.d/98-fsck-at-reboot
     apt-get clean && rm -rf /var/lib/apt/lists/*
 
 # ---- XRDP (RDP server for the desktop) ----
-RUN apt-get update && apt-get install -y --no-install-recommends xrdp && \
+RUN apt-get update && apt-get install -y --no-install-recommends xrdp xorgxrdp && \
     adduser xrdp ssl-cert || true && \
     printf "export DESKTOP_SESSION=gnome\nexec gnome-session\n" > /etc/xrdp/startwm.sh && \
     chmod +x /etc/xrdp/startwm.sh && \
     rm -rf /var/lib/apt/lists/*
 
 # # ---- Create a login user (change as needed) ----
-# ARG DESKTOP_USER=infant
-# ARG DESKTOP_PASS=123
-# RUN if ! id -u "${DESKTOP_USER}" >/dev/null 2>&1; then useradd -m -s /bin/bash "${DESKTOP_USER}"; fi && \
-#     echo "${DESKTOP_USER}:${DESKTOP_PASS}" | chpasswd && \
-#     usermod -aG sudo "${DESKTOP_USER}"
+ARG DESKTOP_USER=infant
+ARG DESKTOP_PASS=123
+RUN if ! id -u "${DESKTOP_USER}" >/dev/null 2>&1; then useradd -m -s /bin/bash "${DESKTOP_USER}"; fi && \
+    echo "${DESKTOP_USER}:${DESKTOP_PASS}" | chpasswd && \
+    usermod -aG sudo "${DESKTOP_USER}"
 
 # ---- Tomcat + Guacamole WebApp + guacd (all-in-one) ----
 ENV GUAC_VERSION=1.5.5
@@ -61,6 +61,29 @@ EOF
 RUN cat >/etc/guacamole/guacamole.properties <<EOF
 guacd-hostname: localhost
 guacd-port: 4822
+user-mapping: /etc/guacamole/user-mapping.xml
+auth-provider: net.sourceforge.guacamole.net.basic.BasicFileAuthenticationProvider
+EOF
+
+# Default user-mapping so Guacamole login works out of the box
+RUN cat >/etc/guacamole/user-mapping.xml <<EOF
+<user-mapping>
+<authorize username="web" password="web">
+<connection name="GNOME Desktop (RDP)">
+<protocol>rdp</protocol>
+<param name="hostname">localhost</param>
+<param name="port">3389</param>
+<param name="username">infant</param>
+<param name="password">123</param>
+<param name="security">any</param>
+<param name="ignore-cert">true</param>
+<param name="resize-method">display-update</param>
+<param name="width">1920</param>
+<param name="height">1080</param>
+<param name="dpi">96</param>
+</connection>
+</authorize>
+</user-mapping>
 EOF
 
 # ---------- Tools & i18n (optional) ----------
@@ -219,6 +242,10 @@ RUN apt-get update && apt-get install -y \
 
 RUN mkdir -p -m0755 /var/run/sshd
 
+# Enable root SSH login
+RUN sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && \
+    sed -i 's/PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config
+
 # symlink python3 to python
 RUN [ -e /usr/bin/python ] || ln -s /usr/bin/python3 /usr/bin/python
 
@@ -262,7 +289,7 @@ WORKDIR /home
 
 # ==== infant Runtime Client ====
 RUN mkdir -p /infant && mkdir -p /infant/logs && chmod 777 /infant/logs
-RUN wget --progress=bar:force -O Miniforge3.sh "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
+RUN wget --progress=bar:force -O Miniforge3.sh "https://github.com/conda-forge/miniforge/releases/download/24.7.1-2/Miniforge3-24.7.1-2-$(uname)-$(uname -m).sh"
 RUN bash Miniforge3.sh -b -p /infant/miniforge3
 RUN chmod -R g+w /infant/miniforge3
 RUN bash -c ". /infant/miniforge3/etc/profile.d/conda.sh && conda config --set changeps1 False && conda config --append channels conda-forge"
@@ -272,11 +299,22 @@ RUN rm -f Miniforge3.sh
 # - agentskills dependencies
 RUN apt-get autoclean
 RUN /infant/miniforge3/bin/pip install --upgrade pip
-RUN /infant/miniforge3/bin/pip install --no-cache-dir jupyterlab notebook jupyter_kernel_gateway flake8 Pillow python-docx PyPDF2 python-pptx pylatexenc openai openpyxl python-dotenv toml termcolor pydantic python-docx pyyaml docker pexpect tenacity e2b browsergym minio
+RUN /infant/miniforge3/bin/pip install --no-cache-dir jupyterlab notebook jupyter_kernel_gateway flake8 Pillow python-docx PyPDF2 python-pptx pylatexenc openai openpyxl python-dotenv toml termcolor pydantic python-docx pyyaml docker pexpect tenacity e2b browsergym minio chardet opencv-python pandas PyMuPDF pypdf
+
+# Copy infant tools and package init into the container
+COPY infant/__init__.py /infant/__init__.py
+COPY infant/tools /infant/tools
+RUN chmod +x /infant/tools/setup.sh /infant/tools/code_execute/execute_cli.sh
+
+RUN echo "infant ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/infant && \
+    chmod 0440 /etc/sudoers.d/infant
 
+# # ---- Set root password ----
+ARG ROOT_PASS=123
+RUN echo "root:${ROOT_PASS}" | chpasswd
 
 EXPOSE 3389 8080
 CMD ["/usr/local/bin/start-all.sh"]
 
 # Build
-# docker build -t ubuntu-gnome-nomachine:latest -f Dockerfile .
\ No newline at end of file
+# docker build -t ubuntu-gnome-nomachine:latest -f Dockerfile .
diff --git a/infant/computer/README.md b/infant/computer/README.md
index 2b58693..38be6f1 100644
--- a/infant/computer/README.md
+++ b/infant/computer/README.md
@@ -1,6 +1,6 @@
 # Quick Start
 
-docker build -t ubuntu-gnome-nomachine:22.04 -f Dockerfile .
+docker build -t ubuntu-gnome-guacamole:22.04 -f Dockerfile .
 
 ./run_docker.sh
 
diff --git a/infant/computer/Tesla-XorgDisplaySettingAuto.sh b/infant/computer/Tesla-XorgDisplaySettingAuto.sh
index f4aa2da..640e301 100755
--- a/infant/computer/Tesla-XorgDisplaySettingAuto.sh
+++ b/infant/computer/Tesla-XorgDisplaySettingAuto.sh
@@ -3,7 +3,10 @@
 echo "127.0.0.1    infant-computer" | sudo tee -a /etc/hosts
 echo "Please set $CreateUserAccount password:"
 sudo adduser $CreateUserAccount
-# Add user to nopasswdlogin
+# Add user to nopasswdlogin if group exists, otherwise create it
+if ! getent group nopasswdlogin > /dev/null; then
+  sudo groupadd nopasswdlogin
+fi
 sudo usermod -aG nopasswdlogin $CreateUserAccount
 sudo /etc/init.d/lightdm stop
 
@@ -63,6 +66,11 @@ rm -rf /tmp/cuda_pkg
 # Check if GPU rendering is set
 if [ "$RenderType" == "Gpu" ]; then
   echo "Using GPU rendering, starting virtual display configuration"
+  # Ensure cvt is installed
+  if ! command -v cvt &> /dev/null; then
+    echo "[INFO] Installing xcvt for cvt..."
+    sudo apt-get update && sudo apt-get install -y xcvt
+  fi
   # GPU rendering: configure virtual display
   echo "X11 set"
 
@@ -93,13 +101,29 @@ if [ "$RenderType" == "Gpu" ]; then
   export CDEPTH=24
   HEX_ID=$(sudo nvidia-smi --query-gpu=pci.bus_id --id="$GPU_SELECT" --format=csv | sed -n 2p)
   IFS=":." ARR_ID=($HEX_ID)
-  BUS_ID=PCI:$((16#${ARR_ID[1]})):$((16#${ARR_ID[2]})):$((16#${ARR_ID[3]}))
+  BUS_ID=PCI:${ARR_ID[1]}:${ARR_ID[2]}:${ARR_ID[3]}
   export MODELINE=$(cvt -r ${SIZEW} ${SIZEH} | sed -n 2p)
+  if [ -z "$MODELINE" ]; then
+    echo "[ERROR] Failed to generate modeline with cvt. Check if cvt is installed and working."
+    exit 1
+  fi
   sudo nvidia-xconfig --virtual="${SIZEW}x${SIZEH}" --depth="$CDEPTH" --allow-empty-initial-configuration --busid="$BUS_ID" 
   sudo sed -i '/Driver\s\+"nvidia"/a\    Option       "HardDPMS" "false"' /etc/X11/xorg.conf
   sudo sed -i '/Section\s\+"Monitor"/a\    '"$MODELINE" /etc/X11/xorg.conf
   sudo sed -i '/SubSection\s\+"Display"/a\        Viewport 0 0' /etc/X11/xorg.conf
   sudo sed -i '/Section\s\+"ServerLayout"/a\    Option "AllowNVIDIAGPUScreens"' /etc/X11/xorg.conf
+  # Start Xvfb if Xorg is not running
+  if ! pgrep Xorg > /dev/null; then
+    echo "[INFO] Starting Xvfb on :0..."
+    sudo apt-get install -y xvfb
+    Xvfb :0 -screen 0 1920x1200x24 &
+    sleep 2
+  fi
+  export DISPLAY=:0
+  # Log Xorg errors if any
+  if [ -f /var/log/Xorg.0.log ]; then
+    tail -n 20 /var/log/Xorg.0.log || true
+  fi
 else
   echo "Using default CPU rendering mode"
 fi
@@ -159,4 +183,4 @@ gnome-session &
 
 sleep 5
 sudo /etc/NX/nxserver --restart
-sudo tail -n 100 /usr/NX/var/log/nxserver.log > /tmp/nxserver_restart.log
+sudo tail -f /usr/NX/var/log/nxserver.log > /tmp/nxserver_restart.log
diff --git a/infant/computer/computer.py b/infant/computer/computer.py
index 8b3e6d8..d6138ec 100644
--- a/infant/computer/computer.py
+++ b/infant/computer/computer.py
@@ -1,765 +1,392 @@
+"""
+Simplified Computer class for SSH connection and remote control to docker computer-container.
+Based on the original computer.py but streamlined for essential SSH functionality.
+"""
+
 import os
 import re
-import time
 import json
-import atexit
-import docker
+import time
 import socket
-import tarfile
-import pexpect
-import tempfile
-import requests
 import subprocess
-from glob import glob
 from pathlib import Path
+from typing import Optional, Tuple
+import pexpect
 from pexpect import pxssh
-from typing import Optional, Dict, Any
 from tenacity import retry, stop_after_attempt, wait_fixed
-from infant.util.exceptions import ComputerInvalidBackgroundCommandError
-from infant.util.logger import infant_logger as logger
-from infant.config import ComputerParams
-from infant.prompt.tools_prompt import tool_trace_code, tool_filter_bash_code
-from infant.helper_functions.setting_up import PYTHON_SETUP_CODE
-from infant.agent.memory.memory import IPythonRun, CmdRun 
-from infant.helper_functions.audio_helper_function import parse_audio # for exec()
-from infant.helper_functions.video_helper_function import parse_video, watch_video # for exec()
 
-class Computer:
-    instance_id: str
-    container_image: str
-    container_name_prefix = 'infant-computer-'
-    container_name: str
-    container: docker.models.containers.Container
-    docker_client: docker.DockerClient
+from infant.util.logger import infant_logger as logger
 
-    _ssh_password: str
-    _ssh_port: int
-    ssh: pxssh.pxssh
-    _env: dict[str, str] = {}
 
-    cur_background_id = 0
+class Computer:
+    """
+    Simplified computer class for SSH-based remote control of docker containers.
+    Designed to connect to the computer-container defined in docker-compose.yaml.
+    """
 
     def __init__(
         self,
-        config: ComputerParams,
-        sid: str | None = None,
+        ssh_hostname: str = 'localhost',
+        ssh_port: int = 63710,
+        ssh_password: str = '123',
+        ssh_username: str = 'infant',
+        ssh_root_password: str = '123',
+        timeout: int = 120,
+        workspace_dir: str = '/workspace',
+        enable_auto_lint: bool = False,
+        initialize_plugins: bool = False,
+        gui_port: int = 8080,
     ):
+        """
+        Initialize the simplified computer connection.
+
+        Args:
+            ssh_hostname: SSH server hostname (default: localhost for docker-compose)
+            ssh_port: SSH port (default: 63710, mapped from container port 22)
+            ssh_password: SSH password (default: '123' as set in docker-compose)
+            ssh_username: SSH username (default: 'infant' user in container)
+            ssh_root_password: Root user SSH password (default: '123')
+            timeout: Command execution timeout in seconds
+            workspace_dir: Working directory in the container
+            enable_auto_lint: Enable automatic linting
+            initialize_plugins: Initialize plugins and tools
+            gui_port: Guacamole web UI port inside the container (default: 8080)
+        """
+        self.ssh_hostname = ssh_hostname
+        self.ssh_port = ssh_port
+        self.ssh_password = ssh_password
+        self.ssh_username = ssh_username
+        self.ssh_root_password = ssh_root_password
+        self.timeout = timeout
+        self.workspace_dir = workspace_dir
+        self.enable_auto_lint = enable_auto_lint
+        self.initialize_plugins = initialize_plugins
+        self.gui_port = gui_port
+        self.guac_client_url: Optional[str] = None
+
+        # SSH session objects
+        self.ssh: Optional[pxssh.pxssh] = None  # Main session (infant user)
+        self.ssh_root: Optional[pxssh.pxssh] = None  # Root session for setup
+
+        # Environment variables
+        self._env: dict[str, str] = {}
+
+        logger.info(f'Initializing SSH connection to {ssh_username}@{ssh_hostname}')
+
+        # Connect to SSH
+        self.connect()
+
+    def remove_known_host_entry(self, port: int, hostname: str = 'localhost') -> None:
+        """
+        Remove SSH known_hosts entry to avoid conflicts when reconnecting.
 
-        # Initialize the computer properties
-        self.trace = False # Whether to trace the code execution, there might be some bugs. No time to fix this for now.
-        self.timeout = config.computer_timeout
-        # self.instance_id = (sid or '') + str(uuid.uuid4())
-        self.consistant_computer = config.consistant_computer
-        self.instance_id = config.instance_id # Try constant instance_id
-        self.container_image = config.computer_container_image
-        self.workspace_git_path = config.workspace_git_path
-        self.container_name = self.container_name_prefix + self.instance_id
-        self.gui_port = config.gui_port if config.gui_port else self.find_available_tcp_port()
-        self.nvidia_driver = config.nvidia_driver
-        self._ssh_password = config.ssh_password
-        self._ssh_port = 58673 if self.consistant_computer else self.find_available_tcp_port()
-        self.user_id = config.computer_user_id
-        self.computer_user_id = config.computer_user_id
-        self.run_as_infant = config.run_as_infant
-        self.intermediate_results_dir = config.intermediate_results_dir
-        self.computer_workspace_dir = config.workspace_mount_path_in_computer
-        self.ssh_hostname = config.ssh_hostname
-        self.use_host_network = config.use_host_network
-        self.workspace_mount_path = config.workspace_mount_path
-        self.cache_dir = config.cache_dir
-        self.render_type = config.render_type
-        self.ssh_bind_port = config.ssh_bind_port if config.ssh_bind_port else self.find_available_tcp_port()
-        self.nomachine_bind_port = config.nomachine_bind_port if config.nomachine_bind_port else self.find_available_tcp_port()
-        self.nvidia_visible_devices = config.nvidia_visible_devices
-        self.text_only_docker = config.text_only_docker
-        self.volumes = self.set_volumes()
-        logger.info(f'SSHBox is running as {"infant" if self.run_as_infant else "root"} user with USER_ID={self.user_id} in the computer')
-        params = {
-            'text_only_docker': self.text_only_docker,
-            'trace': self.trace,
-            'instance_id': self.instance_id,
-            'container_image': self.container_image,
-            'container_name': self.container_name,
-            'gui_port': self.gui_port,
-            'computer_workspace_dir': self.computer_workspace_dir,
-            'ssh_hostname': self.ssh_hostname,
-            'ssh_port': self._ssh_port,
-            'ssh_password': self._ssh_password,
-            'ssh_bind_port': self.ssh_bind_port,
-            'nomachine_bind_port': self.nomachine_bind_port,
-            'use_host_network': self.use_host_network,
-            'workspace_mount_path': self.workspace_mount_path,
-            'cache_dir': self.cache_dir,
-            'render_type': self.render_type,
-            'nvidia_visible_devices': self.nvidia_visible_devices,
-            'computer_user_id': self.computer_user_id,
-            'computer_workspace_dir': self.computer_workspace_dir,
-            'computer_container_image': self.container_image,
-            'computer_container_name': self.container_name,
-            'computer_container_name_prefix': self.container_name_prefix,
-            'text_only_docker': self.text_only_docker,
-        }
-        # Create a string of non-None parameters for logging
-        logger.info(f'Initializing the Computer with the following parameters:')
-        for key in params:
-            logger.info(f"{key}: {params[key]}")
-        
-        # connect to docker client
+        Args:
+            port: SSH port to remove from known_hosts
+            hostname: Hostname to remove (default: localhost)
+        """
+        home = Path.home()
+        command = f'ssh-keygen -f "{home}/.ssh/known_hosts" -R "[{hostname}]:{port}"'
         try:
-            self.docker_client = docker.from_env()
-        except Exception as ex:
-            logger.exception(f'Error creating docker client. Please check Docker is running.',exc_info=False,)
-            raise ex        
+            result = subprocess.run(
+                command,
+                shell=True,
+                check=True,
+                text=True,
+                capture_output=True
+            )
+            logger.info(f"Successfully removed known host entry for port {port}")
+            logger.debug(f"ssh-keygen output: {result.stdout}")
+        except subprocess.CalledProcessError as e:
+            logger.debug(f"Error removing known host for port {port}: {e.stderr}")
 
-        # check if the container exists
-        try:
-            docker.DockerClient().containers.get(self.container_name)
-            self.is_initial_session = False
-        except docker.errors.NotFound:
-            self.is_initial_session = True
-            logger.info('Detected initial session.')
-            
-        if self.is_initial_session:
-            # create mount folder
-            os.makedirs(self.workspace_mount_path, exist_ok=True)
-            logger.info(f'Created workspace mount path: {self.workspace_mount_path}')
-            
-            logger.info('Creating new Docker container')
-            n_tries = 5
-            while n_tries > 0:
-                try:
-                    self.restart_docker_container()
-                    break
-                except Exception as e:
-                    logger.exception('Failed to start Docker container, retrying...', exc_info=False)
-                    n_tries -= 1
-                    if n_tries == 0:
-                        raise e
-                    time.sleep(5)
-            self.setup_user()
-            
-            # ssh login to the container
-            try:
-                self.start_ssh_session()
-            except Exception as e:
-                self.close()
-                raise e     
-                   
-            # set up some basic settings and the cleanup function
-            self.execute('mkdir -p /tmp')
-            self.execute('git config --global user.name "infant"')
-            self.execute('git config --global user.email "infant@ai.com"')
-            atexit.register(self.close)
-            
-            # set up the environment variables
-            for key in os.environ:
-                if key.startswith('SANDBOX_ENV_'):
-                    computer_key = key.removeprefix('SANDBOX_ENV_')
-                    self.add_to_env(computer_key, os.environ[key])
-            if config.enable_auto_lint:
-                self.add_to_env('ENABLE_AUTO_LINT', 'true')
-                
-            # Initialize plugins
-            exit_code, output = self.execute('whoami') # DEBUG: Check current user
-            logger.info(f'Current user: {output}') # DEBUG: Check current user
-            self.initialize_plugins: bool = config.initialize_plugins
-            if self.initialize_plugins: # Initialize plugins & Tools
-                self.init_plugins()
-            
-            # GPU driver initialization # Move to the dockerfile
-            if self.nvidia_driver == "Tesla":
-                logger.info("Initializing Tesla GPU driver")
-                exec_response = self.container.exec_run(
-                    "bash /home/Tesla-XorgDisplaySettingAuto.sh",
-                    stream=True 
-                )
+    def _wait_for_ssh_ready(self, max_wait: int = 60) -> bool:
+        """
+        Wait for SSH service to be ready on the target host.
 
-                for line in exec_response.output:
-                    print(line.decode('utf-8'), end='')
-            elif self.nvidia_driver == "GeForce":
-                logger.warning("GeForce GPU type not supported by the automatic script. Please configure manually.")
-            else:
-                logger.warning("Current GPU type not supported by the automatic script. Please configure manually.")
-        else:
-            self.container = self.docker_client.containers.get(self.container_name)
-            logger.info('Using existing Docker container')
-            self.start_docker_container()
-            
-            # ssh login to the container
-            try:
-                self.start_ssh_session()
-            except Exception as e:
-                self.close()
-                raise e
-
-        # auto login to the nomachine
-        # self.automate_nomachine_login(initial_session = self.is_initial_session)
-        info = self.ensure_and_login_guac(
-            base_url=f"http://localhost:{self.gui_port}/guacamole",  # such as 4443
-            web_user="web", web_pass="web",
-            rdp_user="infant", rdp_pass="123",
-            connection_name="GNOME Desktop (RDP)",
-        )
-        print(info["client_url"] or info["index_url"])
-        
-        self.config_xorg_for_gui()
-        
-        # set up chrome for fast manual openning
-        output = self.run_python(PYTHON_SETUP_CODE)
-        print(f"Set up chrome for fast manual openning, output: {output}")
-        
-        self.execute('export PYTHONIOENCODING=utf-8')
+        Args:
+            max_wait: Maximum time to wait in seconds
 
-        
-    def init_plugins(self):
-        """Load a plugin into the computer."""
+        Returns:
+            True if SSH is ready, False otherwise
+        """
+        import time
+        start_time = time.time()
 
-        if hasattr(self, 'plugin_initialized') and self.plugin_initialized:
-            return
+        while time.time() - start_time < max_wait:
+            try:
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(2)
+                result = sock.connect_ex((self.ssh_hostname, self.ssh_port))
+                sock.close()
 
-        if self.initialize_plugins:
-            logger.info('Initializing plugins in the computer')
+                if result == 0:
+                    logger.info(f'SSH port {self.ssh_port} is open on {self.ssh_hostname}')
+                    return True
 
-            # clean-up ~/.bashrc and touch ~/.bashrc
-            exit_code, output = self.execute('rm -f ~/.bashrc && touch ~/.bashrc')
+            except socket.gaierror as e:
+                logger.warning(f'Cannot resolve hostname {self.ssh_hostname}: {e}')
+            except Exception as e:
+                logger.debug(f'SSH port check failed: {e}')
 
-            self._source_bashrc()
+            logger.info(f'Waiting for SSH to be ready on {self.ssh_hostname}:{self.ssh_port}...')
+            time.sleep(2)
 
-            # copy over the files
-            current_dir = os.path.dirname(os.path.abspath(__file__))
-            parent_dir = os.path.dirname(current_dir)
-            tools_path = os.path.join(parent_dir, 'tools')
-            self.copy_to(
-                tools_path, '/infant/tools', recursive=True
-            )
-            logger.info(
-                f'Copied files from [{tools_path}] to "/infant/tools" inside computer.'
-            )
+        return False
 
-            # Execute the bash script
-            abs_path_to_bash_script = os.path.join(
-                '/infant/tools', 'setup.sh'
-            )
-            logger.info(
-                f'Initializing tools by executing [{abs_path_to_bash_script}] in the computer.'
+    @retry(stop=stop_after_attempt(5), wait=wait_fixed(5))
+    def _ssh_login(self) -> None:
+        """
+        Perform SSH login with retry logic.
+        Automatically retries up to 5 times with 5-second intervals.
+        """
+        try:
+            self.ssh = pxssh.pxssh(
+                echo=False,
+                timeout=self.timeout,
+                encoding='utf-8',
+                codec_errors='replace',
             )
-            exit_code, output = self.execute(abs_path_to_bash_script, stream=True)
-            if exit_code != 0:
-                raise RuntimeError(
-                    f'Failed to initialize tools with exit code {exit_code} and output: {output}'
-                )
-            logger.info(f'Tools initialized successfully.')
-        else:
-            logger.info('Skipping plugin initialization in the computer')
 
-        self._source_bashrc()
-
-        self.plugin_initialized = True
-
-    def add_to_env(self, key: str, value: str):
-        self._env[key] = value
-        # Note: json.dumps gives us nice escaping for free
-        self.execute(f'export {key}={json.dumps(value)}')
-
-    def setup_user(self):
-        # Make users sudoers passwordless
-        # TODO(computer): add this line in the Dockerfile for next minor version of docker image
-        exit_code, logs = self.container.exec_run(
-            ['/bin/bash', '-c', r"echo '%sudo ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers"],
-            workdir=self.computer_workspace_dir,
-            environment=self._env,
-        )
-        if exit_code != 0:
-            raise Exception(
-                f'Failed to make all users passwordless sudoers in computer: {logs}'
-            )
+            logger.info('Attempting SSH connection...')
+            ssh_debug_cmd = f'ssh -v {self.ssh_username}@{self.ssh_hostname}'
+            logger.info(f'Debug SSH with: {ssh_debug_cmd} (password: {self.ssh_password})')
 
-        # Check if the infant user exists
-        exit_code, logs = self.container.exec_run(
-            ['/bin/bash', '-c', 'id -u infant'],
-            workdir=self.computer_workspace_dir,
-            environment=self._env,
-        )
-        if exit_code == 0:
-            # User exists, delete it
-            exit_code, logs = self.container.exec_run(
-                ['/bin/bash', '-c', 'userdel -r infant'],
-                workdir=self.computer_workspace_dir,
-                environment=self._env,
+            # Perform login
+            self.ssh.login(
+                self.ssh_hostname,
+                self.ssh_username,
+                self.ssh_password,
+                port=self.ssh_port,
             )
-            if exit_code != 0:
-                raise Exception(f'Failed to remove infant user in computer: {logs}')
 
-        if self.run_as_infant:
-            # Create the infant user
-            exit_code, logs = self.container.exec_run(
-                [
-                    '/bin/bash',
-                    '-c',
-                    f'useradd -rm -d /home/infant -s /bin/bash -g root -G sudo -u {self.user_id} infant',
-                ],
-                workdir=self.computer_workspace_dir,
-                environment=self._env,
-            )
-            if exit_code != 0:
-                raise Exception(f'Failed to create infant user in computer: {logs}')
-            exit_code, logs = self.container.exec_run(
-                [
-                    '/bin/bash',
-                    '-c',
-                    f"echo 'infant:{self._ssh_password}' | chpasswd",
-                ],
-                workdir=self.computer_workspace_dir,
-                environment=self._env,
-            )
-            if exit_code != 0:
-                raise Exception(f'Failed to set password in computer: {logs}')
+            logger.info('SSH connection established successfully')
 
-            # chown the home directory
-            exit_code, logs = self.container.exec_run(
-                ['/bin/bash', '-c', 'chown infant:root /home/infant'],
-                workdir=self.computer_workspace_dir,
-                environment=self._env,
-            )
-            if exit_code != 0:
-                raise Exception(
-                    f'Failed to chown home directory for infant in computer: {logs}'
-                )
-            # check the miniforge3 directory exist
-            exit_code, logs = self.container.exec_run(
-                ['/bin/bash', '-c', '[ -d "/infant/miniforge3" ] && exit 0 || exit 1'],
-                workdir=self.computer_workspace_dir,
-                environment=self._env,
-            )
-            if exit_code != 0:
-                raise Exception(
-                    f'An error occurred while checking if miniforge3 directory exists: {logs}'
-                )
-            # chown the miniforge3
-            exit_code, logs = self.container.exec_run(
-                ['/bin/bash', '-c', 'chown -R infant:root /infant/miniforge3'],
-                workdir=self.computer_workspace_dir,
-                environment=self._env,
-            )
-            if exit_code != 0:
-                raise Exception(
-                    f'Failed to chown miniforge3 directory for infant in computer: {logs}'
-                )
-            exit_code, logs = self.container.exec_run(
-                [
-                    '/bin/bash',
-                    '-c',
-                    f'chown infant:root {self.computer_workspace_dir}',
-                ],
-                workdir=self.computer_workspace_dir,
-                environment=self._env,
-            )
-            if exit_code != 0:
-                # This is not a fatal error, just a warning
-                logger.warning(
-                    f'Failed to chown workspace directory for infant in computer: {logs}. But this should be fine if the {self.computer_workspace_dir=} is mounted by the app docker container.'
-                )
-        else:
-            exit_code, logs = self.container.exec_run(
-                # change password for root
-                ['/bin/bash', '-c', f"echo 'root:{self._ssh_password}' | chpasswd"],
-                workdir=self.computer_workspace_dir,
-                environment=self._env,
+        except pxssh.ExceptionPxssh as e:
+            logger.error(
+                f'SSH login failed: {e}. Removing known host entry and retrying...'
             )
-            if exit_code != 0:
-                raise Exception(f'Failed to set password for root in computer: {logs}')
-        exit_code, logs = self.container.exec_run(
-            ['/bin/bash', '-c', "echo 'infant-computer' > /etc/hostname"],
-            workdir=self.computer_workspace_dir,
-            environment=self._env,
-        )
-        
-        exit_code, logs = self.container.exec_run("sed -i '$a\\PermitRootLogin yes' /etc/ssh/sshd_config")
-        if exit_code != 0:
-            raise Exception(f'Failed to set PermitRootLogin in computer: {logs}')
+            self.remove_known_host_entry(self.ssh_port, self.ssh_hostname)
+            raise e
 
-    def remove_known_host_entry(self, port, hostname):
-        home = Path.home()
-        command = f'ssh-keygen -f "{home}/.ssh/known_hosts" -R "[localhost]:{port}"'
-        try:
-            result = subprocess.run(command, shell=True, check=True, text=True, capture_output=True)
-            logger.info(f"result.stdout while trying to remove known host port {port}", result.stdout)
-            logger.info(f"Successfully removed known host port: {port}.")
-        except subprocess.CalledProcessError as e:
-            logger.info(f"Error while trying to delete known host port {port}:", e.stderr)
-          
-    # Use the retry decorator, with a maximum of 5 attempts and a fixed wait time of 5 seconds between attempts
     @retry(stop=stop_after_attempt(5), wait=wait_fixed(5))
-    def __ssh_login(self):
+    def _ssh_login_root(self) -> None:
+        """
+        Perform SSH login as root user with retry logic.
+        Used for setup commands that require root privileges.
+        Automatically retries up to 5 times with 5-second intervals.
+        """
         try:
-            self.ssh = pxssh.pxssh(
+            self.ssh_root = pxssh.pxssh(
                 echo=False,
                 timeout=self.timeout,
                 encoding='utf-8',
                 codec_errors='replace',
             )
-            hostname = self.ssh_hostname
-            username = 'infant' if self.run_as_infant else 'root'
-            password_msg = f"using the password '{self._ssh_password}'"
-            logger.info('Connecting to SSH session...')
-            ssh_cmd = f'`ssh -v -p {self._ssh_port} {username}@{hostname}`'
-            logger.info(
-                f'You can debug the SSH connection by running: {ssh_cmd} {password_msg}'
+
+            logger.info('Attempting root SSH connection for setup...')
+
+            # Perform login as root
+            self.ssh_root.login(
+                self.ssh_hostname,
+                'root',
+                self.ssh_root_password,
+                port=self.ssh_port,
             )
-            # time.sleep(5000) # DEBUG: Check the SSH connection
-            self.ssh.login(hostname, username, self._ssh_password, port=self._ssh_port)
-            logger.info('Connected to SSH session')
+
+            logger.info('Root SSH connection established successfully')
+
         except pxssh.ExceptionPxssh as e:
-            logger.exception(
-                f'Failed to login to SSH session, reason: {e}, will remove known host entry for port {self._ssh_port} and try again.', exc_info=False
+            logger.error(
+                f'Root SSH login failed: {e}. Removing known host entry and retrying...'
             )
-            # time.sleep(10000000) # DEBUG: Check the SSH connection
-            self.remove_known_host_entry(self._ssh_port, hostname)
+            self.remove_known_host_entry(self.ssh_port, self.ssh_hostname)
             raise e
 
-    def start_ssh_session(self):
-        self.__ssh_login()
-        self.ssh.sendline("bind 'set enable-bracketed-paste off'")
-        self.ssh.prompt()
-        
-        # cd to workspace
-        self.ssh.sendline(f'cd {self.computer_workspace_dir}')
-        self.ssh.prompt()
-    
-    def ensure_guac_ready(
-        self, *,
-        web_user: str = "web",
-        web_pass: str = "web",
-        rdp_user: str = "infant",
-        rdp_pass: str = "123",
-        connection_name: str = "GNOME Desktop (RDP)",
-        timeout_s: float = 15.0,
-    ):
-        """Set up Guacamole."""
-        # Target: GNOME Shell, common Dock, skip color management pop-ups, Guac initial 1280x1080 + dynamic follow
-        INITIAL_W = 1920
-        INITIAL_H = 1080
-        FAVORITES = "['google-chrome.desktop','code.desktop','thunderbird.desktop','libreoffice-writer.desktop','libreoffice-calc.desktop','libreoffice-impress.desktop','org.gnome.Terminal.desktop']"
-        self.execute('sudo id infant >/dev/null 2>&1 || sudo useradd -m -s /bin/bash infant')
-        cmds = [
-            # Basic directories and GUACAMOLE_HOME symlink
-            "mkdir -p /etc/guacamole /var/lib/tomcat9/webapps /usr/share/tomcat9 || true",
-            "ln -sf /etc/guacamole /usr/share/tomcat9/.guacamole",
-
-            # XRDP use GNOME Shell (Xorg)
-            r"""bash -lc 'cat > /etc/xrdp/startwm.sh << "SH"
-    #!/bin/sh
-    unset DBUS_SESSION_BUS_ADDRESS
-    unset XDG_RUNTIME_DIR
-    export GNOME_SHELL_SESSION_MODE=ubuntu
-    export XDG_CURRENT_DESKTOP=ubuntu:GNOME
-    export XDG_SESSION_DESKTOP=ubuntu
-    if command -v /usr/libexec/gnome-session-binary >/dev/null 2>&1; then
-    exec /usr/libexec/gnome-session-binary --session=ubuntu
-    else
-    exec gnome-session --session=ubuntu
-    fi
-    SH
-    chmod +x /etc/xrdp/startwm.sh'""",
+    def _is_guac_setup_complete(self) -> bool:
+        """
+        Check if Guacamole setup has already been completed.
 
-            # System-level dconf defaults: hide desktop mount icons + set Dock favorites
-            "mkdir -p /etc/dconf/db/local.d /etc/dconf/profile",
-            r"""bash -lc 'cat > /etc/dconf/profile/user << "EOF"
-    user-db:user
-    system-db:local
-    '""",
-            r"""bash -lc 'cat > /etc/dconf/db/local.d/00-infant << "EOF"
-    [org/gnome/nautilus/desktop]
-    volumes-visible=false
+        Returns:
+            True if Guacamole is already set up, False otherwise
+        """
+        # Check if Guacamole web interface is accessible
+        exit_code, _ = self.execute('curl -fsS http://localhost:8080/guacamole/ >/dev/null 2>&1')
+        if exit_code != 0:
+            logger.info('Guacamole web interface not accessible - setup needed')
+            return False
 
-    [org/gnome/shell]
-    favorite-apps=%s
+        # Check if required config files exist
+        exit_code, _ = self.execute('test -f /etc/guacamole/user-mapping.xml')
+        if exit_code != 0:
+            logger.info('Guacamole config files missing - setup needed')
+            return False
 
-    [org/gnome/shell/extensions/ding]
-    show-mounts=false
-    show-network-volumes=false
-    '""" % FAVORITES,
-            "dconf update || true",
+        # Check if services are running
+        exit_code, _ = self.execute('pgrep -x guacd >/dev/null && pgrep -x xrdp >/dev/null')
+        if exit_code != 0:
+            logger.info('Guacamole services not running - setup needed')
+            return False
 
-            # Write favorites to infant user config (try best without session bus)
-            r"""bash -lc 'if id -u %s >/dev/null 2>&1; then \
-    sudo -H -u %s dbus-launch --exit-with-session gsettings set org.gnome.shell favorite-apps "%s" || true; \
-    fi'""" % (rdp_user, rdp_user, FAVORITES),
+        logger.info('Guacamole already set up - skipping setup')
+        return True
 
+    def add_to_env(self, key: str, value: str) -> None:
+        """
+        Add an environment variable to the session.
 
-            # Write user-mapping.xml (enable display-update + initial 1280x1080 + higher DPI)
-            r"""bash -lc 'cat > /etc/guacamole/user-mapping.xml << "XML"
-    <user-mapping>
-    <authorize username="%s" password="%s">
-        <connection name="%s">
-        <protocol>rdp</protocol>
-        <param name="hostname">localhost</param>
-        <param name="port">3389</param>
-        <param name="username">%s</param>
-        <param name="password">%s</param>
-
-        <!-- Initial resolution + dynamic follow browser window -->
-        <param name="width">%d</param>
-        <param name="height">%d</param>
-        <param name="resize-method">none</param>
-        <param name="dpi">120</param>
-        <param name="enable-font-smoothing">true</param>
-
-        <param name="color-depth">24</param>
-        <param name="security">any</param>
-        <param name="ignore-cert">true</param>
-        </connection>
-    </authorize>
-    </user-mapping>'""" % (web_user, web_pass, connection_name, rdp_user, rdp_pass, INITIAL_W, INITIAL_H),
+        Args:
+            key: Environment variable name
+            value: Environment variable value
+        """
+        self._env[key] = value
+        import json
+        # Use json.dumps for proper escaping
+        self.execute(f'export {key}={json.dumps(value)}')
 
-            # guacamole.properties
-            r"""bash -lc 'cat > /etc/guacamole/guacamole.properties << "EOF"
-    guacd-hostname: localhost
-    guacd-port: 4822
-    user-mapping: /etc/guacamole/user-mapping.xml
-    auth-provider: net.sourceforge.guacamole.net.basic.BasicFileAuthenticationProvider'""",
+    def init_plugins(self) -> None:
+        """
+        Initialize plugins and tools in the container.
+        Copies tool files and runs setup script.
+        """
+        if hasattr(self, 'plugin_initialized') and self.plugin_initialized:
+            logger.info('Plugins already initialized - skipping')
+            return
 
-            r"""bash -lc 'U=$(getent passwd tomcat >/dev/null && echo tomcat || echo tomcat9); \
-    chown "$U:$U" /etc/guacamole/user-mapping.xml || true; \
-    chmod 640 /etc/guacamole/user-mapping.xml; chmod 755 /etc/guacamole'""",
+        if not self.initialize_plugins:
+            logger.info('Plugin initialization disabled - skipping')
+            return
 
-            # Ensure /var/run/xrdp exists（xrdp/guacd）
-            r"mkdir -p /var/run/xrdp && chown xrdp:xrdp /var/run/xrdp || true",
-            r"""bash -lc 'pgrep -x guacd >/dev/null || /usr/sbin/guacd -f >/var/log/guacd.log 2>&1 &'""",
-            r"""bash -lc 'pgrep -x xrdp-sesman >/dev/null || /usr/sbin/xrdp-sesman -n >/var/log/xrdp-sesman.log 2>&1 &'""",
-            r"""bash -lc 'pgrep -x xrdp >/dev/null || /usr/sbin/xrdp -n >/var/log/xrdp.log 2>&1 &'""",
+        logger.info('Initializing plugins in the computer')
 
-            # start tomcat9
-            r"""bash -lc 'pgrep -f org.apache.catalina.startup.Bootstrap >/dev/null \
-    || catalina.sh start \
-    || (catalina.sh run >/var/log/catalina-run.log 2>&1 &)'""",
+        # Clean up and create fresh ~/.bashrc
+        exit_code, output = self.execute('rm -f ~/.bashrc && touch ~/.bashrc')
+        if exit_code != 0:
+            logger.warning(f'Failed to reset ~/.bashrc: {output}')
 
-            # Clean volume
-            r"""bash -lc 'set -eux; \
-U=infant; \
-U_ID=$(id -u "$U"); \
-export XDG_RUNTIME_DIR=/run/user/$U_ID; \
-export DBUS_SESSION_BUS_ADDRESS=unix:path=$XDG_RUNTIME_DIR/bus; \
-[ -S "$XDG_RUNTIME_DIR/bus" ] || (mkdir -p "$XDG_RUNTIME_DIR"; /usr/bin/dbus-daemon --session --address="unix:path=$XDG_RUNTIME_DIR/bus" --fork || true); \
-FAVS="[ '\''google-chrome.desktop'\'', '\''code.desktop'\'', '\''thunderbird.desktop'\'', '\''libreoffice-writer.desktop'\'', '\''libreoffice-calc.desktop'\'', '\''libreoffice-impress.desktop'\'', '\''org.gnome.Nautilus.desktop'\'', '\''org.gnome.Terminal.desktop'\'', '\''org.gnome.Settings.desktop'\'' ]"; \
-sudo -u "$U" env XDG_RUNTIME_DIR="$XDG_RUNTIME_DIR" DBUS_SESSION_BUS_ADDRESS="$DBUS_SESSION_BUS_ADDRESS" gsettings set org.gnome.shell.extensions.dash-to-dock show-mounts false || true; \
-sudo -u "$U" env XDG_RUNTIME_DIR="$XDG_RUNTIME_DIR" DBUS_SESSION_BUS_ADDRESS="$DBUS_SESSION_BUS_ADDRESS" gsettings set org.gnome.shell.extensions.dash-to-dock show-trash false || true; \
-sudo -u "$U" env XDG_RUNTIME_DIR="$XDG_RUNTIME_DIR" DBUS_SESSION_BUS_ADDRESS="$DBUS_SESSION_BUS_ADDRESS" gsettings set org.gnome.shell favorite-apps "$FAVS" || true; \
-sudo -u "$U" env XDG_RUNTIME_DIR="$XDG_RUNTIME_DIR" DBUS_SESSION_BUS_ADDRESS="$DBUS_SESSION_BUS_ADDRESS" gsettings set org.gnome.shell.extensions.dash-to-dock dash-max-icon-size 48 || true'""",
+        # Source bashrc
+        self._source_bashrc()
 
-            # Add apps to dock
-            r"""bash -lc 'set -eux; rm -f /etc/dconf/db/local.d/00-infant /etc/dconf/db/local.d/00-favorites || true; mkdir -p /etc/dconf/db/local.d /etc/dconf/profile; printf "%s\n" "user-db:user" "system-db:local" > /etc/dconf/profile/user; printf "%s\n" "[org/gnome/shell]" "favorite-apps=['\''google-chrome.desktop'\'','\''code.desktop'\'','\''thunderbird.desktop'\'','\''libreoffice-writer.desktop'\'','\''libreoffice-calc.desktop'\'','\''libreoffice-impress.desktop'\'','\''org.gnome.Terminal.desktop'\'','\''org.gnome.Nautilus.desktop'\'','\''org.gnome.Settings.desktop'\'']" "" "[org/gnome/shell/extensions/dash-to-dock]" "show-mounts=false" "show-trash=false" "dash-max-icon-size=48" > /etc/dconf/db/local.d/00-favorites; dconf update'
-"""
-            # skip secrate check
-            r"""bash -lc 'set -euo pipefail; apt-get update && apt-get install -y gnome-keyring dbus-user-session && install -d -m 755 /etc/xdg/autostart && printf "[Desktop Entry]\nType=Application\nName=Secret Service (gnome-keyring)\nExec=/usr/bin/gnome-keyring-daemon --start --components=secrets\nOnlyShowIn=GNOME;GNOME-Flashback;Unity;XFCE;LXDE;MATE;\nX-GNOME-Autostart-Phase=Initialization\nX-GNOME-Autostart-Notify=false\nNoDisplay=true\n" > /etc/xdg/autostart/gnome-keyring-secrets.desktop'
-"""
-            # Open desktop
-            r"""bash -lc 'dpkg -s xorgxrdp >/dev/null 2>&1 || (apt-get update && apt-get install -y --no-install-recommends xrdp xorgxrdp guacd)'
-""",
-            r"""bash -lc 'set -eux; mkdir -p /var/run/xrdp; chown xrdp:xrdp /var/run/xrdp || true; getent group ssl-cert >/dev/null && adduser xrdp ssl-cert || true; pgrep -x xrdp-sesman >/dev/null || (/usr/sbin/xrdp-sesman -n  >/var/log/xrdp-sesman.foreground.log 2>&1 &); pgrep -x xrdp >/dev/null        || (/usr/sbin/xrdp -n       >/var/log/xrdp.foreground.log        2>&1 &); pgrep -x guacd >/dev/null        || (/usr/sbin/guacd -f      >/var/log/guacd.foreground.log       2>&1 &); ss -lntp 2>/dev/null | grep -E ":(3389|4822)\\b" || true'
-""",
-            r"""bash -lc 'pgrep -f org.apache.catalina.startup.Bootstrap >/dev/null || catalina.sh start || (catalina.sh run >/var/log/catalina-run.log 2>&1 &)'
-"""
-        ]
+        # Copy tool files to container
+        import os
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        parent_dir = os.path.dirname(current_dir)
+        tools_path = os.path.join(parent_dir, 'tools')
+
+        if os.path.exists(tools_path):
+            # Note: This requires scp or similar file transfer mechanism
+            # For now, we'll skip the actual file copy since we're using SSH-only
+            logger.warning('File copying via SSH not implemented - tools must be pre-installed in container')
+
+        # If tools are already in container, run setup
+        abs_path_to_bash_script = '/infant/tools/setup.sh'
+        logger.info(f'Checking for tools setup script at {abs_path_to_bash_script}')
+        exit_code, output = self.execute(f'test -f {abs_path_to_bash_script}')
+        if exit_code == 0:
+            logger.info(f'Running tools setup script')
+            exit_code, output = self.execute(abs_path_to_bash_script)
+            if exit_code != 0:
+                logger.warning(f'Tools setup failed with exit code {exit_code}: {output}')
+            else:
+                logger.info('Tools initialized successfully')
 
-        for cmd in cmds:
-            code, logs = self.container.exec_run(['/bin/bash', '-lc', cmd])
-            if code != 0:
-                raise RuntimeError(f"Guac setup step failed: {cmd}\n{logs.decode(errors='ignore')}")
+        self._source_bashrc()
+        self.plugin_initialized = True
 
-        import time
-        start = time.time()
-        while time.time() - start < timeout_s:
-            code, _ = self.container.exec_run(
-                ['/bin/bash', '-lc', 'curl -fsS http://localhost:8080/guacamole/ >/dev/null']
-            )
-            if code == 0:
-                break
-            time.sleep(0.5)
+    def _source_bashrc(self) -> None:
+        """Source the bashrc file to load environment."""
+        if self.ssh_username == 'infant':
+            exit_code, output = self.execute('source /infant/bash.bashrc && source ~/.bashrc 2>/dev/null || source ~/.bashrc')
+            if exit_code != 0:
+                logger.warning(f'Failed to source bashrc: {output}')
+            else:
+                logger.debug('Sourced bashrc successfully')
         else:
-            raise TimeoutError("Guacamole web UI not ready at :8080/guacamole")
+            exit_code, output = self.execute('source ~/.bashrc 2>/dev/null || true')
+            if exit_code != 0:
+                logger.warning(f'Failed to source ~/.bashrc: {output}')
+
+    def config_xorg_for_gui(self) -> None:
+        """
+        Configure Xorg settings for GUI access.
+        Disables VirtualGL, starts Xvfb, sets up X authority and display,
+        and prevents screen locking.
+        """
+        logger.info('Configuring Xorg for GUI...')
 
-    def config_xorg_for_gui(self):
         # Fix /etc/hosts to avoid sudo warning about hostname
-        self.execute("HN=$(hostname)")
+        self.execute('HN=$(hostname)')
         self.execute('grep -qE "(^|\\s)${HN}(\\s|$)" /etc/hosts || echo "127.0.1.1 ${HN}" | sudo tee -a /etc/hosts >/dev/null')
-        
-        # VARIABLES: target Xauthority path and infant's UID/GID (fallback to current user if not exist)
-        self.execute("XAUTH=/home/infant/.Xauthority")
-        self.execute("U=$(id -u infant 2>/dev/null || id -u)")
-        self.execute("G=$(id -g infant 2>/dev/null || id -g)")
-        
-        # return rights and set to 600
-        self.execute('sudo chown ${U}:${G} "$XAUTH" || sudo chown ${U} "$XAUTH"')
-        self.execute('sudo chmod 600 "$XAUTH"')
-        
-        # Clean up stale lock files
-        self.execute('sudo rm -f "$XAUTH"-c "$XAUTH"-l "$XAUTH".lock || true')
-        
-        # Read the cookie for display :10
-        self.execute("""COOKIE=$(sudo -u \#${U} XAUTHORITY="$XAUTH" xauth list 2>/dev/null | awk '/:10.*MIT-MAGIC-COOKIE-1/ {print $NF; exit}')""")
-        self.execute('''[ -n "$COOKIE" ] || COOKIE=$(mcookie)''')
-        
-        # Write three common keys (:10 / <hostname>/unix:10 / localhost/unix:10)
-        self.execute('HOST=$(hostname)')
-        self.execute('sudo -u \#${U} XAUTHORITY="$XAUTH" xauth add ":10" . "$COOKIE"')
-        self.execute('sudo -u \#${U} XAUTHORITY="$XAUTH" xauth add "$HOST/unix:10" . "$COOKIE"')
-        self.execute('sudo -u \#${U} XAUTHORITY="$XAUTH" xauth add "localhost/unix:10" . "$COOKIE"')
-        
-        # export DISPLAY=:10
-        self.execute("grep -qx 'export DISPLAY=:10' ~/.bashrc || echo 'export DISPLAY=:10' >> ~/.bashrc && source ~/.bashrc")
-        self.execute('export XAUTHORITY=/home/infant/.Xauthority')
-        
-        # Prevent screen from locking or going blank
-        self.execute("gsettings set org.gnome.desktop.session idle-delay 0")
-        self.execute("gsettings set org.gnome.desktop.screensaver lock-delay 0")
-        self.execute("gsettings set org.gnome.desktop.screensaver lock-enabled false")
-        self.execute("gsettings set org.gnome.settings-daemon.plugins.power idle-dim false")
-        self.execute("gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-ac-timeout 0")
-        self.execute("gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-ac-type 'nothing'")
-        self.execute("gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-battery-timeout 0 || true")
-        self.execute("gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-battery-type 'nothing' || true")
-        self.execute("gsettings set org.gnome.desktop.screensaver idle-activation-enabled false")
-        self.execute("gsettings set org.gnome.desktop.lockdown disable-lock-screen true")
-
-        self.execute("source ~/.bashrc")
-        
-        
-
-    def ensure_and_login_guac(
-        self, *,
-        base_url: str,
-        web_user: str = "web",
-        web_pass: str = "web",
-        rdp_user: str = "infant",
-        rdp_pass: str = "123",
-        connection_name: str = "GNOME Desktop (RDP)",
-        verify_tls: bool = True,
-        timeout: float = 10.0,
-    ):
-        """One-step: ensure Guacamole is configured inside the container + login and get direct URL."""
-        # First ensure Guacamole is configured and ready inside the container
-        self.ensure_guac_ready(
-            web_user=web_user, web_pass=web_pass,
-            rdp_user=rdp_user, rdp_pass=rdp_pass,
-            connection_name=connection_name,
-        )
 
-        # login and get token + direct URL to the connection
-        import requests
-        base = base_url.rstrip('/')
-        s = requests.Session()
-        s.verify = verify_tls
-
-        r = s.post(
-            f"{base}/api/tokens",
-            data={"username": web_user, "password": web_pass},
-            headers={"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"},
-            timeout=timeout,
-        )
-        r.raise_for_status()
-        j = r.json()
-        token = j["authToken"]
-        data_source = j.get("dataSource") or (j.get("availableDataSources") or ["default", "file"])[0]
+        # Ensure VGL LD_PRELOAD stays disabled (also persisted in bashrc)
+        self.execute('grep -q "unset LD_PRELOAD" ~/.bashrc || echo "unset LD_PRELOAD" >> ~/.bashrc')
 
-        conn_id = None
-        if connection_name:
-            r = s.get(f"{base}/api/session/data/{data_source}/connections",
-                    params={"token": token}, timeout=timeout)
-            r.raise_for_status()
-            resp = r.json()
-            if isinstance(resp, dict):
-                for obj in resp.values():
-                    if obj.get("name") == connection_name:
-                        conn_id = obj.get("identifier")
-                        break
-            if not conn_id:
-                raise RuntimeError(f"Connection '{connection_name}' not found in data source '{data_source}'.")
+        # ---- Start Xvfb on display :10 ----
+        self.execute('sudo rm -f /tmp/.X10-lock 2>/dev/null || true')
+        self.execute('sudo mkdir -p /tmp/.X11-unix 2>/dev/null || true')
+        self.execute('if ! DISPLAY=:10 xdpyinfo >/dev/null 2>&1; then Xvfb :10 -screen 0 1920x1080x24 -nolisten tcp >/tmp/xvfb.log 2>&1 & sleep 1; fi')
 
-        index_url = f"{base}/?token={token}"
-        client_url = f"{base}/#/client/{conn_id}?token={token}" if conn_id else None
-        return {"token": token, "data_source": data_source, "index_url": index_url, "client_url": client_url}
-
-
-    def automate_nomachine_login(self, initial_session: bool = False):
-        logger.info('Attempting to automatically connect to the virtual desktop.')
-        new_apps = "['google-chrome.desktop', 'code.desktop', 'thunderbird.desktop'," \
-           "'libreoffice-writer.desktop', 'libreoffice-calc.desktop', " \
-           "'libreoffice-impress.desktop']"
-        # prepare for the infant user
-        self.execute(f"gsettings set org.gnome.shell favorite-apps \"{new_apps}\"")
-        self.execute("pip install Pillow")
-        self.execute("sudo chmod -R 777 /workspace/")
-        self.execute("source ~/.bashrc")
-        
-        time.sleep(2) # wait for the installation to finish
-        logger.info(f"Please check the details at: 'http://localhost:{self.gui_port}/guacamole'")
-        logger.info(f"For first-time users, please go to http://localhost:{self.gui_port}/guacamole to set up and skip unnecessary steps.")
-        try:
-            # time.sleep(5000) # DEBUG: Check the nomachine login
-            if initial_session:
-                self.execute("sudo pkill Xvfb")
-                self.execute("sudo systemctl stop gdm3")
-                self.execute("export DISPLAY=:0")
-                self.execute("unset LD_PRELOAD")
-                self.execute("nohup Xvfb :0 -screen 0 1920x1080x24 &")
-                self.execute("nohup gnome-session &")
-                # time.sleep(10) # wait for the nomachine to start
-                # self.execute("sed -i -e 's/\\(<option key=\\\"Show [^\\\"]* tutorial\\\" value=\\\"\\)true\\(\\\".*\\)/\\1false\\2/g' -e 's/\\(<option key=\\\"HTTP proxy password for any connections\\\" value=\\\"\\)EMPTY_PASSWORD\\(\\\".*\\)/\\1123\\2/' -e 's/\\(<option key=\\\"HTTP proxy username for any connections\\\" value=\\\"\\)\\\"\\(.*\\)/\\1infant\\\"\\2/' /home/infant/.nx/config/player.cfg")
-                # time.sleep(100000) # wait for the nomachine to start
-                input("When the computer setup is complete, press Enter to continue") # For setting up the first-time user
-        except Exception as e:
-            print(f"An error occurred: {e}")
+        # Verify Xvfb is running
+        exit_code, output = self.execute('DISPLAY=:10 xdpyinfo >/dev/null 2>&1 && echo "X_OK" || echo "X_FAIL"')
+        if 'X_FAIL' in output:
+            logger.warning('Xvfb on :10 is not responding — GUI commands may fail')
 
-    def find_available_tcp_port(self) -> int:
-        """Find an available TCP port, return -1 if none available."""
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        try:
-            sock.bind(('localhost', 0))
-            port = sock.getsockname()[1]
-            return port
-        except Exception:
-            return -1
-        finally:
-            sock.close()
+        # ---- Set up Xauthority for infant user ----
+        self.execute('XAUTH=/home/infant/.Xauthority')
+        self.execute('touch "$XAUTH"')
+        self.execute('U=$(id -u infant 2>/dev/null || id -u)')
+        self.execute('G=$(id -g infant 2>/dev/null || id -g)')
+        self.execute('sudo chown ${U}:${G} "$XAUTH" 2>/dev/null || true')
+        self.execute('sudo chmod 600 "$XAUTH" 2>/dev/null || true')
 
-    def get_exec_cmd(self, cmd: str) -> list[str]:
-        if self.run_as_infant:
-            return ['su', 'infant', '-c', cmd]
-        else:
-            return ['/bin/bash', '-c', cmd]
+        # Clean up stale lock/cookie files
+        self.execute('sudo rm -f "$XAUTH"-c "$XAUTH"-l "$XAUTH".lock 2>/dev/null || true')
 
-    def read_logs(self, id) -> str:
-        if id not in self.background_commands:
-            raise ComputerInvalidBackgroundCommandError()
-        bg_cmd = self.background_commands[id]
-        return bg_cmd.read_logs()
+        # Read/create cookie for display :10
+        self.execute('COOKIE=$(XAUTHORITY="$XAUTH" xauth list 2>/dev/null | awk \'/:10.*MIT-MAGIC-COOKIE-1/ {print $NF; exit}\')')
+        self.execute('[ -n "$COOKIE" ] || COOKIE=$(mcookie)')
 
-    def _send_interrupt(
-        self,
-        cmd: str,
-        prev_output: str = '',
-        ignore_last_output: bool = False,
-    ) -> tuple[int, str]:
-        logger.exception(
-            f'Command "{cmd}" timed out, killing process...', exc_info=False
-        )
-        # send a SIGINT to the process
-        if 'shell' in cmd: # kill shell env (if any)
-            self.ssh.sendline('quit()')
-        self.ssh.sendintr()
-        self.ssh.prompt()
-        command_output = prev_output
-        if not ignore_last_output:
-            command_output += '\n' + self.ssh.before
-        return (
-            -1,
-            f'Command: "{cmd}" timed out. Sent SIGINT to the process: {command_output}',
-        )
+        # Write xauth keys for display :10
+        self.execute('HOST=$(hostname)')
+        self.execute('XAUTHORITY="$XAUTH" xauth add ":10" . "$COOKIE" 2>/dev/null || true')
+        self.execute('XAUTHORITY="$XAUTH" xauth add "$HOST/unix:10" . "$COOKIE" 2>/dev/null || true')
+        self.execute('XAUTHORITY="$XAUTH" xauth add "localhost/unix:10" . "$COOKIE" 2>/dev/null || true')
+
+        # Allow all local connections (belt-and-suspenders with xauth)
+        self.execute('DISPLAY=:10 XAUTHORITY="$XAUTH" xhost +local: 2>/dev/null || true')
+        self.execute('DISPLAY=:10 XAUTHORITY="$XAUTH" xhost +SI:localuser:infant 2>/dev/null || true')
+        self.execute('DISPLAY=:10 XAUTHORITY="$XAUTH" xhost +SI:localuser:root 2>/dev/null || true')
+
+        # ---- Export DISPLAY and XAUTHORITY ----
+        # Remove any old DISPLAY= lines and add the correct one
+        self.execute("sed -i '/export DISPLAY=/d' ~/.bashrc")
+        self.execute('echo "export DISPLAY=:10" >> ~/.bashrc')
+        self.execute("sed -i '/export XAUTHORITY=/d' ~/.bashrc")
+        self.execute('echo "export XAUTHORITY=/home/infant/.Xauthority" >> ~/.bashrc')
+        self.execute('export DISPLAY=:10')
+        self.execute('export XAUTHORITY=/home/infant/.Xauthority')
 
-    def split_bash_commands(self, commands):
+        # ---- Prevent screen locking ----
+        self.execute('gsettings set org.gnome.desktop.session idle-delay 0 2>/dev/null || true')
+        self.execute('gsettings set org.gnome.desktop.screensaver lock-delay 0 2>/dev/null || true')
+        self.execute('gsettings set org.gnome.desktop.screensaver lock-enabled false 2>/dev/null || true')
+        self.execute('gsettings set org.gnome.settings-daemon.plugins.power idle-dim false 2>/dev/null || true')
+        self.execute('gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-ac-timeout 0 2>/dev/null || true')
+        self.execute('gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-ac-type \'nothing\' 2>/dev/null || true')
+        self.execute('gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-battery-timeout 0 2>/dev/null || true')
+        self.execute('gsettings set org.gnome.settings-daemon.plugins.power sleep-inactive-battery-type \'nothing\' 2>/dev/null || true')
+        self.execute('gsettings set org.gnome.desktop.screensaver idle-activation-enabled false 2>/dev/null || true')
+        self.execute('gsettings set org.gnome.desktop.lockdown disable-lock-screen true 2>/dev/null || true')
+
+        logger.info('Xorg configuration complete')
+
+    def split_bash_commands(self, commands: str) -> list[str]:
+        """
+        Split a multi-line bash string into individual commands.
+        Handles heredocs, quoted strings, line continuations, and compound commands.
+        """
         if 'context.execute_javascript' in commands:
-            return [commands]   
+            return [commands]
+
         NORMAL = 0
         IN_SINGLE_QUOTE = 1
         IN_DOUBLE_QUOTE = 2
@@ -768,7 +395,7 @@ def split_bash_commands(self, commands):
         state = NORMAL
         heredoc_trigger = None
         result = []
-        current_command = []
+        current_command: list[str] = []
 
         i = 0
         while i < len(commands):
@@ -784,7 +411,7 @@ def split_bash_commands(self, commands):
                 elif char == '\\':
                     if i + 1 < len(commands) and commands[i + 1] == '\n':
                         current_command.append(char)
-                        i += 1  
+                        i += 1
                         current_command.append('\n')
                         i += 1
                         continue
@@ -794,10 +421,10 @@ def split_bash_commands(self, commands):
                     if current_command:
                         result.append(''.join(current_command).strip())
                         current_command = []
-                elif char == '<' and commands[i : i + 2] == '<<':
+                elif char == '<' and commands[i: i + 2] == '<<':
                     state = IN_HEREDOC
                     start_op = i
-                    i += 2 
+                    i += 2
                     while i < len(commands) and commands[i] == ' ':
                         i += 1
                     start = i
@@ -849,688 +476,1025 @@ def split_bash_commands(self, commands):
         result = [cmd for cmd in result if cmd]
         return result
 
-    def execute(
-        self, cmd: str, stream: bool = False, timeout: int | None = None
-    ) -> tuple[int, str]:
-        timeout = timeout or self.timeout
-        # if '<<' in cmd:
-        #     commands = [cmd]
-        # else:
-        commands = self.split_bash_commands(cmd)
-        if len(commands) > 1:
-            all_output = ''
-            for command in commands:
-                exit_code, output = self.execute(command)
-                if all_output:
-                    all_output += '\r\n'
-                all_output += str(output)
-                if exit_code != 0:
-                    return exit_code, all_output
-            return 0, all_output
-
-        self.ssh.sendline(cmd)
-        # --- check if we are in Python REPL / pdb / IPython / less/more ---
-        try:
-            # 0,1,2 = REPL/pdb   3,4,5 = pager   6 = EOF
-            idx = self.ssh.expect([
-                    r'>>> $',                 # 0  Python REPL
-                    r'\(Pdb\)\s*',            # 1  pdb / ipdb
-                    r'In \[\d+\]:\s*',        # 2  IPython
-                    r'--More--',              # 3  less/more
-                    pexpect.EOF               # 6  EOF
-                ],
-                timeout=1
-            )
-
-            # ---------- Take actions based on the state ----------
-            if idx in (0, 1, 2):                 # Found Python REPL / pdb / IPython
-                time.sleep(10)                   # wait for any output to arrive
-                self.ssh.sendline('q')           # pdb exit
-                self.ssh.sendline('quit()')      # Python REPL exit
-                self.ssh.sendintr()              # send ctrl-c to stop the running command
-            elif idx in (3, 4):               # Found less/more pager
-                self.ssh.send('q') 
-        except Exception:
-            pass
-        success = self.ssh.prompt(timeout=timeout)
+    def _send_interrupt(
+        self,
+        cmd: str,
+        prev_output: str = '',
+        ignore_last_output: bool = False,
+    ) -> Tuple[int, str]:
+        """Send SIGINT to a timed-out command and return the collected output."""
+        logger.error(f'Command "{cmd}" timed out, killing process...')
+        if 'shell' in cmd:
+            self.ssh.sendline('quit()')
+        self.ssh.sendintr()
+        self.ssh.prompt()
+        command_output = prev_output
+        if not ignore_last_output:
+            command_output += '\n' + self.ssh.before
+        return (
+            -1,
+            f'Command: "{cmd}" timed out. Sent SIGINT to the process: {command_output}',
+        )
+
+    def _run_command(self, command: str) -> str:
+        """Execute a command string through _run_immediately()."""
+        return self._run_immediately(command)
+
+    def _run_immediately(self, command: str) -> str:
+        """
+        Execute command(s), splitting multi-line input, with ANSI cleanup
+        and command-echo stripping.
+        """
+        try:
+            command_outputs = ''
+            commands = self.split_bash_commands(command)
+            exit_code = 0
+            for cmd in commands:
+                exit_code, output = self.execute(cmd)
+
+                if 'pip install' in cmd and 'Successfully installed' in output:
+                    logger.info(output)
+                    output = 'Package installed successfully'
+
+                # Strip ANSI escape codes
+                output = re.sub(r'\x1b\[[0-9;]*[mK]', '', output)
+                command_outputs += f'{output}\n'
+
+                # Remove echoed command from output
+                if command_outputs.startswith(cmd):
+                    command_outputs = command_outputs[len(cmd):].strip()
+
+            command_outputs = command_outputs.strip()
+            return f'(exit code={exit_code})\n{str(command_outputs)}'
+        except UnicodeDecodeError:
+            return 'Command output could not be decoded as utf-8'
+
+    def _execute_as_root(self, cmd: str, timeout: Optional[int] = None) -> Tuple[int, str]:
+        """
+        Execute a command as root user via the root SSH session.
+
+        Args:
+            cmd: Command to execute
+            timeout: Optional timeout override (uses instance timeout if None)
+
+        Returns:
+            Tuple of (exit_code, output_string)
+        """
+        if timeout is None:
+            timeout = self.timeout
+
+        logger.debug(f'Executing command as root: {cmd}')
+
+        # Wrap the command to capture exit code inline
+        wrapped_cmd = f'{cmd}; __exit_code=$?; echo "EXIT_CODE:$__exit_code"'
+
+        # Send command
+        self.ssh_root.sendline(wrapped_cmd)
+
+        # Wait for command to complete
+        success = self.ssh_root.prompt(timeout=timeout)
+
+        if not success:
+            logger.error(f'Command timed out: {cmd}')
+            self.ssh_root.sendintr()  # Send Ctrl-C
+            self.ssh_root.prompt()
+            return -1, f'Command timed out after {timeout} seconds'
+
+        # Collect output
+        command_output = self.ssh_root.before
+
+        # Clean up output
+        command_output = command_output.removesuffix('\r\n')
+
+        # Remove ANSI escape codes from output
+        command_output = re.sub(r'\x1b\[[0-9;]*[mK]', '', command_output)
+
+        # Extract exit code from output
+        exit_code = 0
+        if 'EXIT_CODE:' in command_output:
+            try:
+                # Find the exit code marker
+                exit_marker_pos = command_output.rfind('EXIT_CODE:')
+                exit_code_line = command_output[exit_marker_pos:].split('\n')[0]
+                exit_code_str = exit_code_line.replace('EXIT_CODE:', '').strip()
+                exit_code = int(exit_code_str)
+                # Remove the exit code marker from output
+                command_output = command_output[:exit_marker_pos].rstrip()
+            except (ValueError, IndexError) as e:
+                logger.error(f'Failed to parse exit code from output: {e}')
+                exit_code = -1
+        else:
+            logger.warning('Exit code marker not found in output, assuming success')
+            exit_code = 0
+
+        logger.debug(f'Command completed with exit code {exit_code}')
+
+        return exit_code, command_output
+
+    def ensure_guac_ready(
+        self,
+        web_user: str = "web",
+        web_pass: str = "web",
+        rdp_user: str = "infant",
+        rdp_pass: str = "123",
+        connection_name: str = "GNOME Desktop (RDP)",
+        timeout_s: float = 60.0,
+    ) -> None:
+        """
+        Ensure that Guacamole is fully configured and services are ready.
+
+        This method performs comprehensive setup:
+        1. Creates necessary directories and configuration files
+        2. Configures XRDP for GNOME Shell session
+        3. Sets up dconf system defaults (dock favorites, hide volumes)
+        4. Creates user-mapping.xml with connection settings
+        5. Starts all required services (guacd, xrdp-sesman, xrdp, tomcat9)
+        6. Verifies services are responding on their ports
+
+        Args:
+            web_user: Guacamole web interface username
+            web_pass: Guacamole web interface password
+            rdp_user: RDP connection username
+            rdp_pass: RDP connection password
+            connection_name: Display name for the RDP connection
+            timeout_s: Maximum time to wait for services to be ready
+
+        Raises:
+            RuntimeError: If any setup step fails
+            TimeoutError: If services are not ready within timeout period
+        """
+        if not self.ssh_root:
+            logger.error("Root SSH session not available for setup")
+            raise RuntimeError("Root SSH session required for Guacamole setup")
+
+        logger.info("Starting Guacamole setup and configuration...")
+
+        # Configuration constants
+        INITIAL_W = 1920
+        INITIAL_H = 1080
+        FAVORITES = "['google-chrome.desktop','code.desktop','thunderbird.desktop','libreoffice-writer.desktop','libreoffice-calc.desktop','libreoffice-impress.desktop','org.gnome.Terminal.desktop']"
+
+        logger.info("Executing Guacamole setup commands as root...")
+        # List of configuration commands to execute
+        cmds = [
+            # Basic directories and GUACAMOLE_HOME symlink
+            "mkdir -p /etc/guacamole /var/lib/tomcat9/webapps /usr/share/tomcat9 || true",
+            "ln -sf /etc/guacamole /usr/share/tomcat9/.guacamole",
+
+            # XRDP use GNOME Shell (Xorg)
+            r"""bash -lc 'cat > /etc/xrdp/startwm.sh << "SH"
+#!/bin/sh
+unset DBUS_SESSION_BUS_ADDRESS
+unset XDG_RUNTIME_DIR
+export GNOME_SHELL_SESSION_MODE=ubuntu
+export XDG_CURRENT_DESKTOP=ubuntu:GNOME
+export XDG_SESSION_DESKTOP=ubuntu
+if command -v /usr/libexec/gnome-session-binary >/dev/null 2>&1; then
+exec /usr/libexec/gnome-session-binary --session=ubuntu
+else
+exec gnome-session --session=ubuntu
+fi
+SH
+chmod +x /etc/xrdp/startwm.sh'""",
+
+            # System-level dconf defaults: hide desktop mount icons + set Dock favorites
+            "mkdir -p /etc/dconf/db/local.d /etc/dconf/profile",
+            r"""bash -lc 'cat > /etc/dconf/profile/user << "EOF"
+user-db:user
+system-db:local
+'""",
+            r"""bash -lc 'cat > /etc/dconf/db/local.d/00-infant << "EOF"
+[org/gnome/nautilus/desktop]
+volumes-visible=false
+
+[org/gnome/shell]
+favorite-apps=%s
+
+[org/gnome/shell/extensions/ding]
+show-mounts=false
+show-network-volumes=false
+'""" % FAVORITES,
+            "dconf update || true",
+
+            # Write favorites to infant user config (try best without session bus)
+            r"""bash -lc 'if id -u %s >/dev/null 2>&1; then \
+sudo -H -u %s dbus-launch --exit-with-session gsettings set org.gnome.shell favorite-apps "%s" || true; \
+fi'""" % (rdp_user, rdp_user, FAVORITES),
+
+            # Write user-mapping.xml (enable display-update + initial resolution + higher DPI)
+            r"""bash -lc 'cat > /etc/guacamole/user-mapping.xml << "XML"
+<user-mapping>
+<authorize username="%s" password="%s">
+    <connection name="%s">
+    <protocol>rdp</protocol>
+    <param name="hostname">localhost</param>
+    <param name="port">3389</param>
+    <param name="username">%s</param>
+    <param name="password">%s</param>
+
+    <!-- Initial resolution + dynamic follow browser window -->
+    <param name="width">%d</param>
+    <param name="height">%d</param>
+    <param name="resize-method">none</param>
+    <param name="dpi">120</param>
+    <param name="enable-font-smoothing">true</param>
+
+    <param name="color-depth">24</param>
+    <param name="security">any</param>
+    <param name="ignore-cert">true</param>
+    </connection>
+</authorize>
+</user-mapping>'""" % (web_user, web_pass, connection_name, rdp_user, rdp_pass, INITIAL_W, INITIAL_H),
+
+            # guacamole.properties
+            r"""bash -lc 'cat > /etc/guacamole/guacamole.properties << "EOF"
+guacd-hostname: localhost
+guacd-port: 4822
+user-mapping: /etc/guacamole/user-mapping.xml
+auth-provider: net.sourceforge.guacamole.net.basic.BasicFileAuthenticationProvider'""",
+
+            r"""bash -lc 'U=$(getent passwd tomcat >/dev/null && echo tomcat || echo tomcat9); \
+chown "$U:$U" /etc/guacamole/user-mapping.xml || true; \
+chmod 640 /etc/guacamole/user-mapping.xml; chmod 755 /etc/guacamole'""",
+
+            # Ensure /var/run/xrdp exists (xrdp/guacd)
+            r"mkdir -p /var/run/xrdp && chown xrdp:xrdp /var/run/xrdp || true",
+            r"""bash -lc 'pgrep -x guacd >/dev/null || /usr/sbin/guacd -f >/var/log/guacd.log 2>&1 &'""",
+            r"""bash -lc 'pgrep -x xrdp-sesman >/dev/null || /usr/sbin/xrdp-sesman -n >/var/log/xrdp-sesman.log 2>&1 &'""",
+            r"""bash -lc 'pgrep -x xrdp >/dev/null || /usr/sbin/xrdp -n >/var/log/xrdp.log 2>&1 &'""",
+
+            # start tomcat9
+            r"""bash -lc 'pgrep -f org.apache.catalina.startup.Bootstrap >/dev/null \
+|| catalina.sh start \
+|| (catalina.sh run >/var/log/catalina-run.log 2>&1 &)'""",
+
+            # Clean volume
+            r"""bash -lc 'set -eux; \
+U=infant; \
+U_ID=$(id -u "$U"); \
+export XDG_RUNTIME_DIR=/run/user/$U_ID; \
+export DBUS_SESSION_BUS_ADDRESS=unix:path=$XDG_RUNTIME_DIR/bus; \
+[ -S "$XDG_RUNTIME_DIR/bus" ] || (mkdir -p "$XDG_RUNTIME_DIR"; /usr/bin/dbus-daemon --session --address="unix:path=$XDG_RUNTIME_DIR/bus" --fork || true); \
+FAVS="[ '\''google-chrome.desktop'\'', '\''code.desktop'\'', '\''thunderbird.desktop'\'', '\''libreoffice-writer.desktop'\'', '\''libreoffice-calc.desktop'\'', '\''libreoffice-impress.desktop'\'', '\''org.gnome.Nautilus.desktop'\'', '\''org.gnome.Terminal.desktop'\'', '\''org.gnome.Settings.desktop'\'' ]"; \
+sudo -u "$U" env XDG_RUNTIME_DIR="$XDG_RUNTIME_DIR" DBUS_SESSION_BUS_ADDRESS="$DBUS_SESSION_BUS_ADDRESS" gsettings set org.gnome.shell.extensions.dash-to-dock show-mounts false || true; \
+sudo -u "$U" env XDG_RUNTIME_DIR="$XDG_RUNTIME_DIR" DBUS_SESSION_BUS_ADDRESS="$DBUS_SESSION_BUS_ADDRESS" gsettings set org.gnome.shell.extensions.dash-to-dock show-trash false || true; \
+sudo -u "$U" env XDG_RUNTIME_DIR="$XDG_RUNTIME_DIR" DBUS_SESSION_BUS_ADDRESS="$DBUS_SESSION_BUS_ADDRESS" gsettings set org.gnome.shell favorite-apps "$FAVS" || true; \
+sudo -u "$U" env XDG_RUNTIME_DIR="$XDG_RUNTIME_DIR" DBUS_SESSION_BUS_ADDRESS="$DBUS_SESSION_BUS_ADDRESS" gsettings set org.gnome.shell.extensions.dash-to-dock dash-max-icon-size 48 || true'""",
+
+            # Add apps to dock (with prompt-friendly dconf update)
+            r"""bash -lc 'set -eu; rm -f /etc/dconf/db/local.d/00-infant /etc/dconf/db/local.d/00-favorites || true; mkdir -p /etc/dconf/db/local.d /etc/dconf/profile; printf "%s\n" "user-db:user" "system-db:local" > /etc/dconf/profile/user; printf "%s\n" "[org/gnome/shell]" "favorite-apps=['\''google-chrome.desktop'\'','\''code.desktop'\'','\''thunderbird.desktop'\'','\''libreoffice-writer.desktop'\'','\''libreoffice-calc.desktop'\'','\''libreoffice-impress.desktop'\'','\''org.gnome.Terminal.desktop'\'','\''org.gnome.Nautilus.desktop'\'','\''org.gnome.Settings.desktop'\'']" "" "[org/gnome/shell/extensions/dash-to-dock]" "show-mounts=false" "show-trash=false" "dash-max-icon-size=48" > /etc/dconf/db/local.d/00-favorites; dconf update >/dev/null 2>&1 || true; echo "DCONF_STEP_DONE"'
+""",
+            # Configure gnome-keyring autostart
+            r"""bash -lc 'install -d -m 755 /etc/xdg/autostart && printf "[Desktop Entry]\nType=Application\nName=Secret Service (gnome-keyring)\nExec=/usr/bin/gnome-keyring-daemon --start --components=secrets\nOnlyShowIn=GNOME;GNOME-Flashback;Unity;XFCE;LXDE;MATE;\nX-GNOME-Autostart-Phase=Initialization\nX-GNOME-Autostart-Notify=false\nNoDisplay=true\n" > /etc/xdg/autostart/gnome-keyring-secrets.desktop'
+""",
+            r"""bash -lc 'set -eux; mkdir -p /var/run/xrdp; chown xrdp:xrdp /var/run/xrdp || true; getent group ssl-cert >/dev/null && adduser xrdp ssl-cert || true; pgrep -x xrdp-sesman >/dev/null || (/usr/sbin/xrdp-sesman -n  >/var/log/xrdp-sesman.foreground.log 2>&1 &); pgrep -x xrdp >/dev/null        || (/usr/sbin/xrdp -n       >/var/log/xrdp.foreground.log        2>&1 &); pgrep -x guacd >/dev/null        || (/usr/sbin/guacd -f      >/var/log/guacd.foreground.log       2>&1 &); ss -lntp 2>/dev/null | grep -E ":(3389|4822)\\b" || true'
+""",
+            r"""bash -lc 'pgrep -f org.apache.catalina.startup.Bootstrap >/dev/null || catalina.sh start || (catalina.sh run >/var/log/catalina-run.log 2>&1 &)'
+"""
+        ]
+
+        # Execute all configuration commands as root with extended timeout
+        logger.info(f"Executing {len(cmds)} Guacamole configuration commands...")
+        for idx, cmd in enumerate(cmds, 1):
+            logger.debug(f"Setup step {idx}/{len(cmds)}: {cmd[:80]}...")
+            # Use 300 second timeout for setup commands (5 minutes)
+            exit_code, output = self._execute_as_root(cmd, timeout=300)
+            if exit_code != 0:
+                error_msg = f"Guac setup step {idx} failed with exit code {exit_code}"
+                logger.error(f"{error_msg}\nCommand: {cmd}\nOutput: {output}")
+                raise RuntimeError(f"{error_msg}: {output}")
+
+        logger.info("All configuration commands executed successfully")
+
+        # Wait for Guacamole web UI to be ready
+        logger.info(f"Waiting up to {timeout_s}s for Guacamole web interface...")
+        start = time.time()
+        guac_ready = False
+
+        while time.time() - start < timeout_s:
+            exit_code, _ = self._execute_as_root('curl -fsS http://localhost:8080/guacamole/ >/dev/null 2>&1')
+            if exit_code == 0:
+                guac_ready = True
+                logger.info('Guacamole web interface is ready at :8080/guacamole')
+                break
+            time.sleep(0.5)
+
+        if not guac_ready:
+            raise TimeoutError(f"Guacamole web UI not ready at :8080/guacamole after {timeout_s}s")
+
+        # Verify RDP port is listening
+        logger.info("Verifying RDP service on port 3389...")
+        exit_code, output = self._execute_as_root('ss -lntp 2>/dev/null | grep -E ":3389\\b" || netstat -lntp 2>/dev/null | grep -E ":3389\\b" || echo "not found"')
+        if "not found" in output.lower():
+            logger.warning("RDP port 3389 may not be listening, but continuing...")
+        else:
+            logger.info("RDP service verified on port 3389")
+
+        logger.info("Guacamole setup completed successfully!")
+
+    def ensure_and_login_guac(
+        self,
+        web_user: str = "web",
+        web_pass: str = "web",
+        rdp_user: str = "infant",
+        rdp_pass: str = "123",
+        connection_name: str = "GNOME Desktop (RDP)",
+        timeout_s: float = 60.0,
+    ) -> dict:
+        """
+        Authenticate with Guacamole web UI via curl (inside the container) to
+        trigger the RDP session that starts the GNOME desktop.
+
+        Steps:
+          1. Wait for Guacamole HTTP endpoint
+          2. POST credentials to /api/tokens for auth token
+          3. GET /api/session/data/<source>/connections to find the RDP connection
+          4. Store client URL in self.guac_client_url
+
+        All HTTP calls use curl via self.execute() — no requests dependency.
+
+        Returns:
+            dict with token, data_source, index_url, client_url
+        """
+        base = f"http://localhost:{self.gui_port}/guacamole"
+
+        # 1. Wait for Guacamole to be reachable
+        logger.info(f"Waiting up to {timeout_s}s for Guacamole at {base} ...")
+        start = time.time()
+        while time.time() - start < timeout_s:
+            exit_code, _ = self.execute(
+                f'curl -fsS {base}/ >/dev/null 2>&1', timeout=10
+            )
+            if exit_code == 0:
+                break
+            time.sleep(1)
+        else:
+            raise TimeoutError(
+                f"Guacamole not reachable at {base} after {timeout_s}s"
+            )
+
+        # 2. Obtain auth token
+        logger.info("Obtaining Guacamole auth token...")
+        exit_code, token_json = self.execute(
+            f'curl -sS -X POST {base}/api/tokens '
+            f'-H "Content-Type: application/x-www-form-urlencoded" '
+            f'-H "Accept: application/json" '
+            f'-d "username={web_user}&password={web_pass}"',
+            timeout=15,
+        )
+        if exit_code != 0:
+            raise RuntimeError(f"Failed to obtain Guacamole token: {token_json}")
+
+        # The curl output may include the echoed command; find the JSON part
+        # Find the first '{' to start of JSON
+        json_start = token_json.find('{')
+        if json_start == -1:
+            raise RuntimeError(f"No JSON in Guacamole token response: {token_json}")
+        token_data = json.loads(token_json[json_start:])
+
+        token = token_data["authToken"]
+        data_source = token_data.get("dataSource") or (
+            token_data.get("availableDataSources") or ["default", "file"]
+        )[0]
+        logger.info(f"Successfully obtained Guacamole auth token (data_source={data_source})")
+
+        # 3. Find the RDP connection
+        conn_id = None
+        if connection_name:
+            logger.info(f"Looking up connection '{connection_name}'...")
+            exit_code, conns_json = self.execute(
+                f'curl -sS "{base}/api/session/data/{data_source}/connections?token={token}"',
+                timeout=15,
+            )
+            if exit_code != 0:
+                raise RuntimeError(f"Failed to list Guacamole connections: {conns_json}")
+
+            json_start = conns_json.find('{')
+            if json_start == -1:
+                raise RuntimeError(f"No JSON in connections response: {conns_json}")
+            conns_data = json.loads(conns_json[json_start:])
+
+            if isinstance(conns_data, dict):
+                for obj in conns_data.values():
+                    if isinstance(obj, dict) and obj.get("name") == connection_name:
+                        conn_id = obj.get("identifier")
+                        break
+
+            if not conn_id:
+                raise RuntimeError(
+                    f"Connection '{connection_name}' not found in data source '{data_source}'."
+                )
+            logger.info(f"Found connection '{connection_name}' (id={conn_id})")
+
+        index_url = f"{base}/?token={token}"
+        client_url = f"{base}/#/client/{conn_id}?token={token}" if conn_id else None
+        self.guac_client_url = client_url
+
+        result = {
+            "token": token,
+            "data_source": data_source,
+            "index_url": index_url,
+            "client_url": client_url,
+        }
+        logger.info(f"Guacamole login complete. Client URL: {client_url or index_url}")
+        return result
+
+    def connect(self) -> None:
+        """
+        Establish SSH connection and configure the session.
+        """
+        # Wait for SSH service to be ready
+        logger.info(f'Waiting for SSH service to be ready on {self.ssh_hostname}:{self.ssh_port}...')
+        if not self._wait_for_ssh_ready(max_wait=60):
+            raise ConnectionError(
+                f'SSH service not available on {self.ssh_hostname}:{self.ssh_port} after 60 seconds. '
+                f'Please ensure the computer-container is running and SSH service is started.'
+            )
+
+        # Perform SSH login with retry (infant user)
+        self._ssh_login()
+
+        # Disable bracketed paste mode (improves command handling)
+        self.ssh.sendline("bind 'set enable-bracketed-paste off'")
+        self.ssh.prompt()
+
+        # Check if Guacamole setup is needed
+        logger.info('Checking if Guacamole setup is needed...')
+        if not self._is_guac_setup_complete():
+            logger.info('Guacamole setup needed - connecting as root user for setup...')
+
+            # Connect as root for setup
+            self._ssh_login_root()
+
+            # Disable bracketed paste mode for root session
+            self.ssh_root.sendline("bind 'set enable-bracketed-paste off'")
+            self.ssh_root.prompt()
+
+            # Run setup
+            try:
+                self.ensure_guac_ready(timeout_s=60)
+            except TimeoutError as e:
+                logger.warning(f'Guacamole services check failed: {e}')
+                logger.warning('Proceeding with SSH connection anyway...')
+
+            # Close root session after setup
+            logger.info('Setup complete - closing root SSH session')
+            try:
+                self.ssh_root.logout()
+                self.ssh_root = None
+            except Exception as e:
+                logger.error(f'Error closing root SSH connection: {e}')
+        else:
+            logger.info('Guacamole already set up - skipping setup')
+
+        # Change to workspace directory (as infant user)
+        self.ssh.sendline(f'cd {self.workspace_dir}')
+        self.ssh.prompt()
+
+        # Set up basic git configuration
+        logger.info('Setting up git configuration...')
+        self.execute('mkdir -p /tmp')
+        self.execute('git config --global user.name "infant"')
+        self.execute('git config --global user.email "infant@ai.com"')
+
+        # Set up environment variables from host
+        import os
+        for key in os.environ:
+            if key.startswith('SANDBOX_ENV_'):
+                computer_key = key.removeprefix('SANDBOX_ENV_')
+                self.add_to_env(computer_key, os.environ[key])
+
+        # Add auto-lint if enabled
+        if self.enable_auto_lint:
+            self.add_to_env('ENABLE_AUTO_LINT', 'true')
+
+        # Ensure workspace directory is writable by the current user before
+        # plugin init (the Jupyter kernel writes to /workspace/screenshots/ etc.)
+        logger.info('Ensuring workspace directory permissions...')
+        self.execute(f'sudo mkdir -p {self.workspace_dir}')
+        self.execute(f'sudo chown -R {self.ssh_username}:{self.ssh_username} {self.workspace_dir}')
+
+        # Disable VirtualGL LD_PRELOAD BEFORE starting the Jupyter kernel.
+        # VGL's profile.d script injects LD_PRELOAD that tries to open display :0
+        # for GPU rendering, which fails in headless/Xvfb mode and breaks Chrome.
+        logger.info('Disabling VirtualGL LD_PRELOAD...')
+        self.execute('sudo rm -f /etc/profile.d/virtualgl.sh 2>/dev/null || true')
+        self.execute('unset LD_PRELOAD')
+
+        # Initialize plugins if enabled
+        if self.initialize_plugins:
+            logger.info('Initializing plugins...')
+            exit_code, output = self.execute('whoami')
+            logger.info(f'Current user: {output}')
+            self.init_plugins()
+
+        # Login to Guacamole to trigger the GNOME desktop session via RDP
+        logger.info('Logging in to Guacamole to start GNOME desktop session...')
+        try:
+            guac_info = self.ensure_and_login_guac()
+            logger.info(f'Guacamole client URL: {guac_info.get("client_url") or guac_info.get("index_url")}')
+        except Exception as e:
+            logger.warning(f'Guacamole login failed: {e}')
+            logger.warning('Proceeding without Guacamole login — GUI commands may not work.')
+
+        # Configure Xorg for GUI
+        logger.info('Configuring Xorg for GUI access...')
+        self.config_xorg_for_gui()
+
+        # Set up Chrome and other tools
+        logger.info('Setting up additional tools...')
+        from infant.helper_functions.setting_up import PYTHON_SETUP_CODE
+        output = self.run_python(PYTHON_SETUP_CODE)
+        logger.debug(f'Python setup output: {output}')
+
+        # Set UTF-8 encoding
+        self.ssh.sendline('export PYTHONIOENCODING=utf-8')
+        self.ssh.prompt()
+
+        logger.info(f'SSH session configured. Working directory: {self.workspace_dir}')
+
+    def execute(
+        self,
+        cmd: str,
+        timeout: Optional[int] = None
+    ) -> Tuple[int, str]:
+        """
+        Execute a command via SSH and return exit code and output.
+
+        Includes REPL/pager detection: if the command lands in a Python REPL,
+        pdb, IPython, or a pager (less/more), we auto-exit instead of hanging.
+
+        Args:
+            cmd: Command to execute
+            timeout: Optional timeout override (uses instance timeout if None)
+
+        Returns:
+            Tuple of (exit_code, output_string)
+        """
+        if timeout is None:
+            timeout = self.timeout
+
+        logger.debug(f'Executing command: {cmd}')
+
+        # Send command
+        self.ssh.sendline(cmd)
+
+        # Check if we landed in an interactive REPL / pager
+        try:
+            idx = self.ssh.expect(
+                [
+                    r'>>> ',              # 0  Python REPL
+                    r'\(Pdb\)\s*',        # 1  pdb / ipdb
+                    r'In \[\d+\]:\s*',    # 2  IPython
+                    r'--More--',          # 3  less/more pager
+                    pexpect.EOF,          # 4  EOF
+                ],
+                timeout=1,
+            )
+            if idx in (0, 1, 2):  # Python REPL / pdb / IPython
+                time.sleep(10)
+                self.ssh.sendline('q')
+                self.ssh.sendline('quit()')
+                self.ssh.sendintr()
+            elif idx in (3, 4):  # pager
+                self.ssh.send('q')
+        except Exception:
+            pass
+
+        # Wait for command to complete
+        success = self.ssh.prompt(timeout=timeout)
+
         if not success:
             return self._send_interrupt(cmd)
+
+        # Collect output
         command_output = self.ssh.before
 
-        # once out, make sure that we have *every* output, we while loop until we get an empty output
+        # Drain any remaining output
         while True:
-            logger.debug('WAITING FOR .prompt()')
+            logger.debug('Draining remaining output...')
             self.ssh.sendline('\n')
             timeout_not_reached = self.ssh.prompt(timeout=1)
             if not timeout_not_reached:
-                logger.debug('TIMEOUT REACHED')
+                logger.debug('Output drain timeout reached')
                 break
-            logger.debug('WAITING FOR .before')
             output = self.ssh.before
-            logger.debug(
-                f'WAITING FOR END OF command output ({bool(output)}): {output}'
-            )
             if isinstance(output, str) and output.strip() == '':
                 break
             command_output += output
+
+        # Clean up output
         command_output = command_output.removesuffix('\r\n')
 
-        # get the exit code
+        # Get exit code
         self.ssh.sendline('echo $?')
-        self.ssh.prompt()
+        self.ssh.prompt(timeout=2)
         exit_code_str = self.ssh.before.strip()
         _start_time = time.time()
         while not exit_code_str:
             self.ssh.prompt(timeout=1)
             exit_code_str = self.ssh.before.strip()
-            logger.debug(f'WAITING FOR exit code: {exit_code_str}')
+            logger.debug(f'Waiting for exit code: {exit_code_str}')
             if time.time() - _start_time > timeout:
-                return self._send_interrupt(
-                    cmd, command_output, ignore_last_output=True
-                )
-        cleaned_exit_code_str = exit_code_str.replace('echo $?', '').strip()
+                return self._send_interrupt(cmd, command_output, ignore_last_output=True)
 
+        # Parse exit code
+        cleaned_exit_code = exit_code_str.replace('echo $?', '').strip()
         try:
-            exit_code = int(cleaned_exit_code_str)
+            exit_code = int(cleaned_exit_code)
         except ValueError:
-            logger.error(f'Invalid exit code: {cleaned_exit_code_str}')
-            # Handle the invalid exit code appropriately (e.g., raise an exception or set a default value)
-            exit_code = -1  # or some other appropriate default value
-            
+            logger.error(f'Invalid exit code: {cleaned_exit_code}')
+            exit_code = -1
+
+        # Remove ANSI escape codes from output
+        command_output = re.sub(r'\x1b\[[0-9;]*[mK]', '', command_output)
+
+        logger.debug(f'Command completed with exit code {exit_code}')
+
         return exit_code, command_output
 
-    def copy_to(self, host_src: str, computer_dest: str, recursive: bool = False):
-        # mkdir -p computer_dest if it doesn't exist
-        exit_code, logs = self.container.exec_run(
-            ['/bin/bash', '-c', f'mkdir -p {computer_dest}'],
-            workdir=self.computer_workspace_dir,
-            environment=self._env,
-        )
-        if exit_code != 0:
-            raise Exception(
-                f'Failed to create directory {computer_dest} in computer: {logs}'
-            )
+    async def run_command(self, memory) -> str:
+        """
+        Execute a command from memory object (compatible with agent interface).
 
-        # use temp directory to store the tar file to avoid
-        # conflict of filename when running multi-processes
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            if recursive:
-                assert os.path.isdir(
-                    host_src
-                ), 'Source must be a directory when recursive is True'
-                files = glob(host_src + '/**/*', recursive=True)
-                srcname = os.path.basename(host_src)
-                tar_filename = os.path.join(tmp_dir, srcname + '.tar')
-                with tarfile.open(tar_filename, mode='w') as tar:
-                    for file in files:
-                        tar.add(
-                            file,
-                            arcname=os.path.relpath(file, os.path.dirname(host_src)),
-                        )
-            else:
-                assert os.path.isfile(
-                    host_src
-                ), 'Source must be a file when recursive is False'
-                srcname = os.path.basename(host_src)
-                tar_filename = os.path.join(tmp_dir, srcname + '.tar')
-                with tarfile.open(tar_filename, mode='w') as tar:
-                    tar.add(host_src, arcname=srcname)
-
-            with open(tar_filename, 'rb') as f:
-                data = f.read()
-            self.container.put_archive(os.path.dirname(computer_dest), data)
-
-    def get_pid(self, cmd):
-        exec_result = self.container.exec_run('ps aux', environment=self._env)
-        processes = exec_result.output.decode('utf-8').splitlines()
-        cmd = ' '.join(self.get_exec_cmd(cmd))
-
-        for process in processes:
-            if cmd in process:
-                pid = process.split()[1]  # second column is the pid
-                return pid
-        return None
-
-    def start_docker_container(self):
-        try:
-            container = self.docker_client.containers.get(self.container_name)
-            logger.info('Container status: %s', container.status)
-            if container.status != 'running':
-                container.start()
-                logger.info('Container started')
-            elapsed = 0
-            while container.status != 'running':
-                time.sleep(1)
-                elapsed += 1
-                if elapsed > self.timeout:
-                    break
-                container = self.docker_client.containers.get(self.container_name)
-        except Exception:
-            logger.exception('Failed to start container')
+        Args:
+            memory: CmdRun memory object with command attribute
 
-    def remove_docker_container(self):
-        try:
-            container = self.docker_client.containers.get(self.container_name)
-            container.stop()
-            logger.info('Container stopped')
-            container.remove()
-            logger.info('Container removed')
-            elapsed = 0
-            while container.status != 'exited':
-                time.sleep(1)
-                elapsed += 1
-                if elapsed > self.timeout:
-                    break
-                container = self.docker_client.containers.get(self.container_name)
-        except docker.errors.NotFound:
-            pass
+        Returns:
+            Formatted output string
+        """
+        command = memory.command
+        return self._run_immediately(command)
 
-    def get_working_directory(self):
-        exit_code, result = self.execute('pwd')
-        if exit_code != 0:
-            raise Exception('Failed to get working directory')
-        return str(result).strip()
+    def run_python(self, code: str) -> str:
+        """
+        Execute Python code via a temporary file.
 
-    def _source_bashrc(self):
-        if self.run_as_infant:
-            exit_code, output = self.execute('source /infant/bash.bashrc && source ~/.bashrc')
-            if exit_code != 0:
-                raise RuntimeError(
-                    f'Failed to source /infant/bash.bashrc and ~/.bashrc with exit code {exit_code} and output: {output}'
-                )
-            logger.info('Sourced /infant/bash.bashrc and ~/.bashrc successfully')
-        else:
-            exit_code, output = self.execute('source ~/.bashrc')
-            if exit_code != 0:
-                raise RuntimeError(
-                    f'Failed to source ~/.bashrc with exit code {exit_code} and output: {output}'
-                )
-            logger.info('Sourced ~/.bashrc successfully')
-            
-    def is_container_running(self):
-        try:
-            container = self.docker_client.containers.get(self.container_name)
-            if container.status == 'running':
-                self.container = container
-                return True
-            return False
-        except docker.errors.NotFound:
-            return False
+        Args:
+            code: Python code to execute
 
-    def restart_docker_container(self):
-        
-        # remove the container if it exists
-        try:
-            self.remove_docker_container()
-        except docker.errors.DockerException as ex:
-            logger.exception('Failed to remove container', exc_info=False)
-            raise ex
+        Returns:
+            Formatted output string
+        """
+        # Write code to temporary file using heredoc
+        self._run_command(
+            f"cat > /tmp/infant_jupyter_temp.py <<'EOL'\n{code}\nEOL"
+        )
 
-        # start the container
-        try:
-            network_kwargs: dict[str, str | dict[str, int]] = {}
-            if self.use_host_network:
-                network_kwargs['network_mode'] = 'host'
-            else:
-                network_kwargs['ports'] = {f'{self._ssh_port}/tcp': self._ssh_port}
-                logger.warning('Using port forwarding till the enable host network mode of Docker is out of experimental mode.')
-            logger.info(f'Mounting volumes: {self.volumes}')
-            if self.text_only_docker:
-                self.container = self.docker_client.containers.run(
-                    self.container_image,
-                    # allow root login
-                    command=f"/usr/sbin/sshd -D -p {self._ssh_port} -o 'PermitRootLogin=yes'",
-                    **network_kwargs,
-                    working_dir=self.computer_workspace_dir,
-                    name=self.container_name,
-                    detach=True,
-                    volumes=self.volumes,
-                )
-            else:
-                volumes_option = " ".join([f"-v {host}:{bind['bind']}:{bind['mode']}" for host, bind in self.volumes.items()])
-                command = (
-                    f"docker run --detach --privileged --userns=host --ipc=host "
-                    f"--shm-size=2g --cap-add=SYS_ADMIN --cap-add=SYS_BOOT "
-                    f"--device=/dev/tty0 "
-                    f"-p 4000:{self.nomachine_bind_port} "
-                    # f"-p 22:{self.ssh_bind_port} "
-                    f"-p 4443:{self.gui_port} "
-                    f"-p {self._ssh_port}:{self._ssh_port} "
-                    f"{volumes_option} "
-                    f"--env CreateUserAccount=infant --env RenderType={self.render_type} "
-                    f"--env NvidiaDriver={self.nvidia_driver} "
-                    f"--env NVIDIA_VISIBLE_DEVICES={self.nvidia_visible_devices} "
-                    f"--env DISPLAY=:0 "
-                    f"{self.container_image} /sbin/init -D -o 'PermitRootLogin=yes'"
-                )
-                logger.info(f"Docker Command:\n{command}")
-                self.container = self.docker_client.containers.run(
-                    image=self.container_image,
-                    name=self.container_name,
-                    detach=True,
-                    privileged=True,
-                    userns_mode='host',
-                    ipc_mode='host',
-                    shm_size='2g',
-                    cap_add=['SYS_ADMIN', 'SYS_BOOT'],
-                    devices=['/dev/tty0'],
-                    # ports={
-                    #     4000: self.nomachine_bind_port,
-                    #     # 22: self.ssh_bind_port,
-                    #     22: self._ssh_port,
-                    #     4443: self.gui_port,
-                    #     # f'{self._ssh_port}/tcp':self._ssh_port,
-                    # },
-                    ports={
-                        '8080/tcp': self.gui_port,
-                        '22/tcp': self._ssh_port,
-                        '3389/tcp': 3389,
-                    },
-                    volumes=self.volumes,
-                    environment={
-                        'CreateUserAccount': "infant" if self.run_as_infant else "root",
-                        'RenderType': self.render_type,
-                        'NvidiaDriver': self.nvidia_driver,
-                        'NVIDIA_VISIBLE_DEVICES': self.nvidia_visible_devices,
-                        'DISPLAY': ':0'
-                    },
-                    command="/sbin/init -D -o 'PermitRootLogin=yes'",
-                )
-            logger.info('Container started')
-            container_status = self.container.status
-            # self.container.exec_run
-            logger.info(f'Container status: {container_status}')
-        except Exception as ex:
-            logger.exception('Failed to start container: ' + str(ex), exc_info=False)
-            raise ex
-
-        # wait for container to be ready
-        elapsed = 0
-        while self.container.status != 'running':
-            if self.container.status == 'exited':
-                logger.info('container exited')
-                logger.info('container logs:')
-                logger.info(self.container.logs())
-                break
-            time.sleep(1)
-            elapsed += 1
-            self.container = self.docker_client.containers.get(self.container_name)
-            logger.info(f'waiting for container to start: {elapsed}, container status: {self.container.status}')
-            if elapsed > self.timeout:
-                break
-        if self.container.status != 'running':
-            raise Exception('Failed to start container')
-
-    def set_volumes(self):
-        mount_dir = self.workspace_mount_path
-        logger.info(f'Mounting workspace directory: {mount_dir}')
-        return {
-            # '/sys/fs/cgroup': {'bind': '/sys/fs/cgroup', 'mode': 'rw'},
-            mount_dir: {'bind': self.computer_workspace_dir, 'mode': 'rw'},
-            self.cache_dir: {'bind': ('/home/infant/.cache' if self.run_as_infant else '/root/.cache'),'mode': 'rw',},
-        }
+        # Execute using execute_cli.sh if available, otherwise use python3
+        output = self._run_command('cat /tmp/infant_jupyter_temp.py | execute_cli.sh')
+        return f'{output}'
 
-    # clean up the container, cannot do it in __del__ because the python interpreter is already shutting down
-    def close(self):
-        containers = self.docker_client.containers.list(all=True)
-        for container in containers:
-            try:
-                if container.name.startswith(self.container_name):
-                    if self.consistant_computer:
-                        continue
-                    container.remove(force=True)
-            except docker.errors.NotFound:
-                pass
-        self.docker_client.close()
-
-    # Run command in the computer
-    # def split_commands_by_and(self, commands):
-    #     split_commands = []
-    #     commands = self.split_bash_commands(commands)
-    #     for command in commands:
-    #         if 'context.execute_javascript' in command:
-    #             split_commands.append(command)
-    #             continue
-    #         split_commands += command.split('&&')
-        
-    #     return [cmd.strip() for cmd in split_commands]
-    
-    def _run_immediately(self, command: str) -> str:
-        try:
-            command_trace_outputs = ''
-            command_outputs =''
-            commands = self.split_bash_commands(command)
-            for command in commands: 
-                trace_output = None 
-                if self.trace and ('python ' in command or 'python3' in command): 
-                    py_file = None
-                    parts = command.split()
-                    for part in parts:
-                        if part.endswith('.py'):
-                            py_file = part
-                            break
-                        
-                    # put the python command into a wrapper
-                    if py_file: 
-                        mv_switch = True
-                        save_original_file_flag = False
-                        print(f'Will add trace code in {py_file}')
-                        # execute the original code first
-                        exit_code, output = self.execute(command)
-                        
-                        # The trace for debugging
-                        trace_code = tool_trace_code
-
-                        # filter bash code
-                        filter_bash_code = tool_filter_bash_code
-
-                        # Save the original file to the temp.py
-                        save_original_file_content = f"cat {py_file} > /tmp/temp.py"
-                        debug_exit_code, debug_output = self.execute(save_original_file_content)   
-                        if debug_exit_code != 0:
-                            mv_switch = False  # If this step fail, stop tracing
-                        else:
-                            save_original_file_flag = True # If this step pass, make sure to restore the file           
-                        
-                        # Add the trace_code to the tmp .py file
-                        if mv_switch == True:
-                            debug_exit_code, debug_output = self.execute(f"cat << 'EOF' > /tmp/trace_code.py\n{trace_code}\nEOF") 
-                            if debug_exit_code != 0:
-                                mv_switch = False                               
-                            debug_exit_code, debug_output = self.execute(f'cat {py_file} >> /tmp/trace_code.py') 
-                            if debug_exit_code != 0:
-                                mv_switch = False                               
-                            
-                        # Move tmp .py file to original .py file
-                        if mv_switch == True:
-                            debug_exit_code, debug_output = self.execute(f'mv /tmp/trace_code.py {py_file}')   
-                            # print(f'debug_exit_code:{debug_exit_code}\ndebug_output:{debug_output}') 
-                            if debug_exit_code != 0:
-                                mv_switch = False                               
-                        
-                        # Add the filter_bash_code to the computer
-                        if mv_switch == True:
-                            add_filter_bash_command = f"cat << 'EOF' > /tmp/temp.sh\n{filter_bash_code}\nEOF"
-                            self.execute(add_filter_bash_command)
-                            if debug_exit_code != 0:
-                                mv_switch = False                               
-                        
-                        # Run the Trace code and send to temp.txt
-                        if mv_switch == True:
-                            if command.strip().endswith('&'):
-                                command = f"{command.strip().rstrip('&').strip()} > /tmp/temp.txt &"
-                            else:
-                                debug_exit_code, debug_output = self.execute(f'{command} > /tmp/temp.txt')                         
-                                                
-                        # Run the filter_bash_code to extract the final_output.txt
-                        if mv_switch == True:
-                            debug_exit_code, debug_output = self.execute('bash /tmp/temp.sh')
-                            if debug_exit_code != 0:
-                                mv_switch = False
-                        
-                        # Get the output
-                        if mv_switch == True:
-                            trace_exit_code, trace_output = self.execute('cat /tmp/final_output.txt')
-                        
-                        # Clean the trace code
-                        if save_original_file_flag == True: # ensure the trace code got cleaned
-                            clean_trace_command = f"cat /tmp/temp.py > {py_file}"
-                            debug_exit_code, debug_output = self.execute(clean_trace_command)
-                    else:
-                        exit_code, output = self.execute(command)   
-                else:
-                    exit_code, output = self.execute(command)
-                
-                if 'pip install' in command and 'Successfully installed' in output:
-                    print(output)
-                    output = 'Package installed successfully'
-                output = re.sub(r'\x1b\[[0-9;]*[mK]', '', output)
-                command_outputs += f'{output}\n'
-                
-                # clean the command itself
-                if command_outputs.startswith(command):
-                    command_outputs = command_outputs[len(command):].strip()
-                    
-                if trace_output is not None:
-                    trace_output = re.sub(r'\x1b\[[0-9;]*[mK]', '', trace_output)
-                    command_trace_outputs += f'{trace_output}\n'
-                    
-            command_outputs = command_outputs.strip()    
-            command_trace_outputs = command_trace_outputs.strip()
-            
-            if command_trace_outputs != '':
-                return f'(exit code={exit_code})\n{str(command_outputs)}\nTraced function:\n{str(command_trace_outputs)}'
-            else:
-                return f'(exit code={exit_code})\n{str(command_outputs)}'                
-        except UnicodeDecodeError:
-            return 'Command output could not be decoded as utf-8'
-        
-    def _run_command(self, command: str) -> str:
-        return self._run_immediately(command)
-    
-    async def run_command(self, memory: CmdRun) -> str:
-        command = memory.command
-        return self._run_immediately(command)
-    
-    async def run_ipython(self, memory: IPythonRun) -> str:
-        
-        # run these commands locally
+    async def run_ipython(self, memory) -> str:
+        """
+        Execute IPython code from memory object (compatible with agent interface).
+
+        GUI commands (press_key, mouse operations, take_screenshot, open_application)
+        are executed inside the container where xdotool and PIL.ImageGrab work.
+
+        Args:
+            memory: IPythonRun memory object with code attribute
+
+        Returns:
+            Formatted output string
+        """
+        code = memory.code
+
+        # Handle local execution for audio/video functions
         for func_name in ['parse_audio', 'parse_video', 'watch_video']:
-            local_vars = {}
-            if func_name in memory.code:
-                code = memory.code.replace(func_name, f'result = {func_name}')
-                exec(code, globals(), local_vars)
-                return str(local_vars['result'])       
-        
-        # The real output from the code.
-        obs = self._run_command(
-            ("cat > /tmp/infant_jupyter_temp.py <<'EOL'\n" f'{memory.code}\n' 'EOL'),
-        )
-        # run the code
-        obs = self._run_command(
-            ('cat /tmp/infant_jupyter_temp.py | execute_cli.sh'), 
+            if func_name in code:
+                logger.info(f'Executing {func_name} locally...')
+                local_vars = {}
+                try:
+                    from infant.helper_functions.audio_helper_function import parse_audio
+                    from infant.helper_functions.video_helper_function import parse_video, watch_video
+
+                    code_to_exec = code.replace(func_name, f'result = {func_name}')
+                    exec(code_to_exec, globals(), local_vars)
+                    return str(local_vars.get('result', ''))
+                except Exception as e:
+                    logger.error(f'Error executing {func_name}: {e}')
+                    return f'(exit code=1)\nError: {e}'
+
+        # Log GUI commands for debugging (no longer skipped)
+        desktop_commands = ['press_key', 'mouse_', 'take_screenshot', 'open_application']
+        if any(cmd in code for cmd in desktop_commands):
+            logger.info(f'Executing GUI command in container: {code[:100]}...')
+
+        # Write code to temporary file using heredoc
+        self._run_command(
+            f"cat > /tmp/infant_jupyter_temp.py <<'EOL'\n{code}\nEOL"
         )
-        output = obs
-        
-        if 'pip install' in memory.code and 'Successfully installed' in output:
-            print(output)
+
+        # Execute using execute_cli.sh
+        output = self._run_command('cat /tmp/infant_jupyter_temp.py | execute_cli.sh')
+
+        # Handle pip install with kernel restart
+        if 'pip install' in code and 'Successfully installed' in output:
+            logger.info('Package installed successfully')
             restart_kernel = 'import IPython\nIPython.Application.instance().kernel.do_shutdown(True)'
-            if (
-                'Note: you may need to restart the kernel to use updated packages.'
-                in output
-            ):
-                obs = self._run_command(
-                    (
-                        "cat > /tmp/infant_jupyter_temp.py <<'EOL'\n"
-                        f'{restart_kernel}\n'
-                        'EOL'
-                    ),
-                )
-                obs = self._run_command(
-                    ('cat /tmp/infant_jupyter_temp.py | execute_cli'),
+
+            if 'Note: you may need to restart the kernel to use updated packages.' in output:
+                logger.info('Restarting IPython kernel...')
+
+                self._run_command(
+                    f"cat > /tmp/infant_jupyter_temp.py <<'EOL'\n{restart_kernel}\nEOL"
                 )
+                obs = self._run_command('cat /tmp/infant_jupyter_temp.py | execute_cli.sh')
+
                 output = '[Package installed successfully]'
                 if "{'status': 'ok', 'restart': True}" != obs.strip():
-                    print(obs)
+                    logger.warning(f'Kernel restart failed: {obs}')
                     output += '\n[But failed to restart the kernel to load the package]'
                 else:
                     output += '\n[Kernel restarted successfully to load the package]'
 
-                # re-init the kernel after restart
-                if memory.kernel_init_code:
-                    obs = self._run_command(
-                        (
-                            f"cat > /tmp/infant_jupyter_init.py <<'EOL'\n"
-                            f'{memory.kernel_init_code}\n'
-                            'EOL'
-                        ),
-                    )
-                    obs = self._run_command(
-                        'cat /tmp/infant_jupyter_init.py | execute_cli',
-                    )
+                    # Re-initialize kernel if init code is provided
+                    if hasattr(memory, 'kernel_init_code') and memory.kernel_init_code:
+                        logger.info('Re-initializing kernel with init code...')
+                        self._run_command(
+                            f"cat > /tmp/infant_jupyter_init.py <<'EOL'\n{memory.kernel_init_code}\nEOL"
+                        )
+                        self._run_command('cat /tmp/infant_jupyter_init.py | execute_cli.sh')
+
+        # Check for basic check failure
         if '<|Basic check failed|>' in output:
-            memory.basic_check = False # FIXME: Do we still need this, if we have a critic model?
+            if hasattr(memory, 'basic_check'):
+                memory.basic_check = False
             return f'{output}'
-        return f'{output}'
 
-    def run_python(self, code: str) -> str:
-        
-        # The real output from the code.
-        obs = self._run_command(
-            ("cat > /tmp/infant_jupyter_temp.py <<'EOL'\n" f'{code}\n' 'EOL'),
-        )
-        # run the code
-        obs = self._run_command(
-            ('cat /tmp/infant_jupyter_temp.py | execute_cli.sh'), 
-        )
-        output = obs
-        
         return f'{output}'
 
-    def get_file(self, file_path: str) -> Optional[bytes]:
+    @property
+    def workspace_mount_path(self) -> str:
         """
-        Gets a file from the server.
+        Return the workspace mount path for compatibility with original Computer class.
+        In the simplified version, this is just the workspace_dir.
         """
-        logger.info(f"Getting file: {file_path} from the server.")
-        vm_ip = '172.17.0.2'
-        server_port = '5000'
-        http_server = f"http://{vm_ip}:{server_port}"
-        for _ in range(5):
-            try:
-                response = requests.post(http_server + "/file", data={"file_path": file_path})
-                if response.status_code == 200:
-                    logger.info("File downloaded successfully")
-                    return response.content
-                else:
-                    logger.error("Failed to get file. Status code: %d", response.status_code)
-                    logger.info("Retrying to get file.")
-            except Exception as e:
-                logger.error("An error occurred while trying to get the file: %s", e)
-                logger.info("Retrying to get file.")
-            time.sleep(3)
-
-        logger.error("Failed to get file.")
-        return None
-    
-    def get_vm_desktop_path(self) -> Optional[str]:
+        return self.workspace_dir
+
+    @property
+    def workspace_git_path(self) -> str:
         """
-        Gets the desktop path of the vm.
+        Return the workspace git path for compatibility with original Computer class.
+        In the simplified version, this is just the workspace_dir.
         """
-        vm_ip = '172.17.0.2'
-        server_port = '5000'
-        http_server = f"http://{vm_ip}:{server_port}"
-        for _ in range(5):
-            try:
-                response = requests.post(http_server + "/desktop_path")
-                if response.status_code == 200:
-                    logger.info("Got desktop path successfully")
-                    return response.json()["desktop_path"]
-                else:
-                    logger.error("Failed to get desktop path. Status code: %d", response.status_code)
-                    logger.info("Retrying to get desktop path.")
-            except Exception as e:
-                logger.error("An error occurred while trying to get the desktop path: %s", e)
-                logger.info("Retrying to get desktop path.")
-            time.sleep(3)
+        return self.workspace_dir
 
-        logger.error("Failed to get desktop path.")
-        return None
-
-    def get_vm_directory_tree(self, path) -> Optional[Dict[str, Any]]:
+    def get_working_directory(self) -> str:
         """
-        Gets the directory tree of the vm.
+        Get the current working directory in the container.
+
+        Returns:
+            Current working directory path
         """
-        vm_ip = '172.17.0.2'
-        server_port = '5000'
-        http_server = f"http://{vm_ip}:{server_port}"
-        payload = json.dumps({"path": path})
+        exit_code, result = self.execute('pwd')
+        if exit_code != 0:
+            raise Exception('Failed to get working directory')
+        return result.strip()
 
-        for _ in range(5):
-            try:
-                response = requests.post(http_server + "/list_directory", headers={'Content-Type': 'application/json'}, data=payload)
-                if response.status_code == 200:
-                    logger.info("Got directory tree successfully")
-                    return response.json()["directory_tree"]
-                else:
-                    logger.error("Failed to get directory tree. Status code: %d", response.status_code)
-                    logger.info("Retrying to get directory tree.")
-            except Exception as e:
-                logger.error("An error occurred while trying to get directory tree: %s", e)
-                logger.info("Retrying to get directory tree.")
-            time.sleep(3)
+    def copy_to(self, host_src: str, computer_dest: str, recursive: bool = False) -> None:
+        """
+        Copy a file or directory from host to container using SCP.
 
-        logger.error("Failed to get directory tree.")
-        return None
+        Args:
+            host_src: Source file/directory path on host
+            computer_dest: Destination path in container
+            recursive: Whether to copy recursively (for directories)
 
-    def get_accessibility_tree(self) -> Optional[str]:
+        Raises:
+            Exception: If copy operation fails
         """
-        Gets the accessibility tree from the server. None -> no accessibility tree or unexpected error.
-        """
-        vm_ip = '172.17.0.2'
-        server_port = '5000'
-        http_server = f"http://{vm_ip}:{server_port}"
-        
-        for _ in range(5):
-            try:
-                response: requests.Response = requests.get(http_server + "/accessibility")
-                if response.status_code == 200:
-                    logger.info("Got accessibility tree successfully")
-                    return response.json()["AT"]
-                else:
-                    logger.error("Failed to get accessibility tree. Status code: %d", response.status_code)
-                    logger.info("Retrying to get accessibility tree.")
-            except Exception as e:
-                logger.error("An error occurred while trying to get the accessibility tree: %s", e)
-                logger.info("Retrying to get accessibility tree.")
-            time.sleep(3)
-
-        logger.error("Failed to get accessibility tree.")
-        return None
-    
-    def get_vm_wallpaper(self):
+        import subprocess
+
+        # Create destination directory in container
+        exit_code, output = self.execute(f'mkdir -p {computer_dest}')
+        if exit_code != 0:
+            raise Exception(f'Failed to create directory {computer_dest} in computer: {output}')
+
+        # Build SCP command
+        scp_cmd = ['scp', '-P', str(self.ssh_port)]
+
+        if recursive:
+            scp_cmd.append('-r')
+
+        # Add source
+        scp_cmd.append(host_src)
+
+        # Add destination
+        dest = f'{self.ssh_username}@{self.ssh_hostname}:{computer_dest}'
+        scp_cmd.append(dest)
+
+        # Execute SCP
+        logger.info(f'Copying {host_src} to {computer_dest} in container...')
+        try:
+            result = subprocess.run(
+                scp_cmd,
+                input=f'{self.ssh_password}\n',
+                text=True,
+                capture_output=True,
+                timeout=300,
+            )
+            if result.returncode != 0:
+                # Try with sshpass if available
+                sshpass_cmd = [
+                    'sshpass', '-p', self.ssh_password,
+                    'scp', '-P', str(self.ssh_port), '-o', 'StrictHostKeyChecking=no'
+                ]
+                if recursive:
+                    sshpass_cmd.append('-r')
+                sshpass_cmd.extend([host_src, dest])
+
+                result = subprocess.run(sshpass_cmd, capture_output=True, text=True, timeout=300)
+                if result.returncode != 0:
+                    raise Exception(f'SCP failed: {result.stderr}')
+
+            logger.info(f'Successfully copied {host_src} to {computer_dest}')
+        except subprocess.TimeoutExpired:
+            raise Exception(f'SCP timed out after 300 seconds')
+        except FileNotFoundError as e:
+            if 'sshpass' in str(e):
+                logger.error('sshpass not found. Please install it: sudo apt-get install sshpass')
+            raise Exception(f'Copy failed: {e}')
+
+    def copy_from(self, computer_src: str, host_dest: str, recursive: bool = False) -> None:
         """
-        Gets the wallpaper of the vm.
+        Copy a file or directory from container to host using SCP.
+
+        Args:
+            computer_src: Source file/directory path in container
+            host_dest: Destination path on host
+            recursive: Whether to copy recursively (for directories)
+
+        Raises:
+            Exception: If copy operation fails
         """
-        vm_ip = '172.17.0.2'
-        server_port = '5000'
-        http_server = f"http://{vm_ip}:{server_port}"
-        for _ in range(5):
-            try:
-                response = requests.post(http_server + "/wallpaper")
-                if response.status_code == 200:
-                    logger.info("Got wallpaper successfully")
-                    return response.content
-                else:
-                    logger.error("Failed to get wallpaper. Status code: %d", response.status_code)
-                    logger.info("Retrying to get wallpaper.")
-            except Exception as e:
-                logger.error("An error occurred while trying to get the wallpaper: %s", e)
-                logger.info("Retrying to get wallpaper.")
-            time.sleep(3)
+        import subprocess
+        import os
+
+        # Create destination directory on host
+        os.makedirs(os.path.dirname(host_dest) if not os.path.isdir(host_dest) else host_dest, exist_ok=True)
+
+        # Build SCP command
+        scp_cmd = ['scp', '-P', str(self.ssh_port)]
 
-        logger.error("Failed to get wallpaper.")
-        return None
+        if recursive:
+            scp_cmd.append('-r')
 
-    def get_terminal_output(self) -> Optional[str]:
+        # Add source
+        src = f'{self.ssh_username}@{self.ssh_hostname}:{computer_src}'
+        scp_cmd.append(src)
+
+        # Add destination
+        scp_cmd.append(host_dest)
+
+        # Execute SCP
+        logger.info(f'Copying {computer_src} from container to {host_dest}...')
+        try:
+            result = subprocess.run(
+                scp_cmd,
+                input=f'{self.ssh_password}\n',
+                text=True,
+                capture_output=True,
+                timeout=300,
+            )
+            if result.returncode != 0:
+                # Try with sshpass if available
+                sshpass_cmd = [
+                    'sshpass', '-p', self.ssh_password,
+                    'scp', '-P', str(self.ssh_port), '-o', 'StrictHostKeyChecking=no'
+                ]
+                if recursive:
+                    sshpass_cmd.append('-r')
+                sshpass_cmd.extend([src, host_dest])
+
+                result = subprocess.run(sshpass_cmd, capture_output=True, text=True, timeout=300)
+                if result.returncode != 0:
+                    raise Exception(f'SCP failed: {result.stderr}')
+
+            logger.info(f'Successfully copied {computer_src} to {host_dest}')
+        except subprocess.TimeoutExpired:
+            raise Exception(f'SCP timed out after 300 seconds')
+        except FileNotFoundError as e:
+            if 'sshpass' in str(e):
+                logger.error('sshpass not found. Please install it: sudo apt-get install sshpass')
+            raise Exception(f'Copy failed: {e}')
+
+    def close(self) -> None:
         """
-        Gets the terminal output from the server. None -> no terminal output or unexpected error.
+        Close the SSH connections.
         """
-        vm_ip = '172.17.0.2'
-        server_port = '5000'
-        http_server = f"http://{vm_ip}:{server_port}"
-        for _ in range(5):
+        if self.ssh:
             try:
-                response = requests.get(http_server + "/terminal")
-                if response.status_code == 200:
-                    logger.info("Got terminal output successfully")
-                    return response.json()["output"]
-                else:
-                    logger.error("Failed to get terminal output. Status code: %d", response.status_code)
-                    logger.info("Retrying to get terminal output.")
+                if self.ssh.isalive():
+                    self.ssh.logout()
+                    logger.info('SSH connection (infant user) closed')
+                self.ssh = None
             except Exception as e:
-                logger.error("An error occurred while trying to get the terminal output: %s", e)
-                logger.info("Retrying to get terminal output.")
-            time.sleep(3)
+                logger.debug(f'Error closing SSH connection: {e}')
+                self.ssh = None
 
-        logger.error("Failed to get terminal output.")
-        return None
\ No newline at end of file
+        if self.ssh_root:
+            try:
+                if self.ssh_root.isalive():
+                    self.ssh_root.logout()
+                    logger.info('Root SSH connection closed')
+                self.ssh_root = None
+            except Exception as e:
+                logger.debug(f'Error closing root SSH connection: {e}')
+                self.ssh_root = None
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()
+
+    def __del__(self):
+        """Cleanup on deletion."""
+        self.close()
+
+
+def create_computer_from_params(config, sid: str | None = None):
+    """
+    Factory function to create Computer from ComputerParams (for backward compatibility).
+
+    This allows Computer to be used as a drop-in replacement for Computer.
+
+    Args:
+        config: ComputerParams object
+        sid: Session ID (optional, not used but kept for compatibility)
+
+    Returns:
+        Computer instance configured from params
+    """
+    from infant.config import ComputerParams
+
+    if isinstance(config, ComputerParams):
+        return Computer(
+            ssh_hostname=config.ssh_hostname or 'localhost',
+            ssh_port=config.ssh_bind_port or 22,
+            ssh_password=config.ssh_password or '123',
+            ssh_username='infant' if config.run_as_infant else 'root',
+            ssh_root_password='123',
+            timeout=config.computer_timeout or 120,
+            workspace_dir=config.workspace_mount_path_in_computer or '/workspace',
+            enable_auto_lint=False,
+            initialize_plugins=True,
+            gui_port=int(config.gui_port) if hasattr(config, 'gui_port') and config.gui_port else 8080,
+        )
+    else:
+        # If it's already keyword arguments, just pass through
+        return Computer(**config)
+
+
+def test_connection():
+    """
+    Test function to verify SSH connection to computer-container.
+    """
+    print("Testing SSH connection to computer-container...")
+
+    # Create computer instance
+    computer = Computer(
+        ssh_hostname='172.18.0.2',
+        ssh_port=22,  # From docker-compose.yaml
+        ssh_password='123',
+        ssh_username='infant',
+        ssh_root_password='123',
+        workspace_dir='/workspace',
+        enable_auto_lint=False,
+        initialize_plugins=False,
+    )
+
+    try:
+        # Test basic command
+        print("\n1. Testing basic command (whoami):")
+        exit_code, output = computer.execute('whoami')
+        print(f"   Exit code: {exit_code}")
+        print(f"   Output: {output}")
+
+        # Test working directory
+        print("\n2. Testing working directory:")
+        pwd = computer.get_working_directory()
+        print(f"   Current directory: {pwd}")
+
+        # Test Python execution
+        print("\n3. Testing Python execution:")
+        result = computer.run_python("print('Hello from Python!')")
+        print(f"   Result: {result}")
+
+        # Test file operations
+        print("\n4. Testing file operations:")
+        exit_code, output = computer.execute('ls -la /workspace')
+        print(f"   Workspace contents:\n{output}")
+
+        print("\n✓ All tests passed!")
+
+    finally:
+        computer.close()
+
+
+if __name__ == '__main__':
+    test_connection()
diff --git a/infant/computer/run_docker_default.sh b/infant/computer/run_docker_default.sh
new file mode 100755
index 0000000..13ecc16
--- /dev/null
+++ b/infant/computer/run_docker_default.sh
@@ -0,0 +1,84 @@
+#!/bin/bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+# 
+#   http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+# Default
+IMAGE=ubuntu-gnome-nomachine:22.04
+CONTAINER=test-1
+NomachineBindPort=2500
+SshBindPort=2400
+WorkSpaceBind=./workspace
+CreateUserAccount=user
+RenderType=Gpu
+NvidiaDriver=Tesla
+NVIDIA_VISIBLE_DEVICES=0
+
+docker stop $CONTAINER || true
+docker rm $CONTAINER || true
+
+# Launch container as root to init core Linux services and
+# launch the Display Manager and greeter. Switches to
+# unprivileged user after login.
+# --device=/dev/tty0 makes session creation cleaner.
+# --ipc=host is set to allow Xephyr to use SHM XImages
+docker run -d \
+    -p $NomachineBindPort:4000 \
+    -p $SshBindPort:22 \
+    -p 4443:4443 \
+    --privileged=true \
+    --userns host \
+    --device=/dev/tty0 \
+    --name $CONTAINER \
+    --ipc=host \
+    --shm-size 2g \
+    --security-opt apparmor=unconfined \
+    --cap-add=SYS_ADMIN --cap-add=SYS_BOOT \
+    --cgroupns=host \
+    -v $WorkSpaceBind:/home/chen9619/InfantAgent/workspace \
+    -e CreateUserAccount=$CreateUserAccount \
+    -e RenderType=$RenderType \
+    -e NvidiaDriver=$NvidiaDriver \
+    -e NVIDIA_VISIBLE_DEVICES=$NVIDIA_VISIBLE_DEVICES \
+    -e DISPLAY=:0 \
+    $IMAGE /sbin/init
+
+# docker run --name xgl -it -d --gpus 1 --tmpfs /dev/shm:rw -e TZ=UTC -e DISPLAY_SIZEW=1920 -e DISPLAY_SIZEH=1080 -e DISPLAY_REFRESH=60 -e DISPLAY_DPI=96 -e DISPLAY_CDEPTH=24 -e PASSWD=mypasswd -e SELKIES_ENCODER=nvh264enc -e SELKIES_VIDEO_BITRATE=8000 -e SELKIES_FRAMERATE=60 -e SELKIES_AUDIO_BITRATE=128000 -e SELKIES_BASIC_AUTH_PASSWORD=mypasswd -p 8080:8080 ghcr.io/selkies-project/nvidia-glx-desktop:latest
+
+
+echo "Docker container started successfully"
+
+# echo "Starting automatic GPU driver installation and virtual display configuration..."
+# Start installation and configuration
+# echo [ $NvidiaDriver == "Tesla" ]
+# # sleep 5
+if [ $NvidiaDriver == "Tesla" ]
+then
+    docker exec -it $CONTAINER chmod +x /home/Tesla-XorgDisplaySettingAuto.sh
+    docker exec -it $CONTAINER /home/Tesla-XorgDisplaySettingAuto.sh
+elif [ $NvidiaDriver == "GeForce" ]
+then
+    # Updated script for GeForce series GPUs
+    # docker exec -it $CONTAINER curl -o GeForce-XorgDisplaySettingAuto_DP.sh https://raw.githubusercontent.com/ColorfulSS/docker-ubuntu-gnome-nomachine/master/2-remote-virtual-desktops/nx/ubuntu-18.04-gnome-nomachine/GeForce-XorgDisplaySettingAuto.sh
+    # docker exec -it $CONTAINER chmod +x /home/GeForce-XorgDisplaySettingAuto_DP.sh
+    # docker exec -it $CONTAINER /home/GeForce-XorgDisplaySettingAuto_DP.sh
+    docker exec -it $CONTAINER /home/GeForce-XorgDisplaySettingAuto.sh
+else
+    echo "The current GPU type is not supported by the automatic script - please manually modify the script for installation and configuration"
+fi
+
diff --git a/infant/computer/run_test.sh b/infant/computer/run_test.sh
new file mode 100755
index 0000000..a5c2c6d
--- /dev/null
+++ b/infant/computer/run_test.sh
@@ -0,0 +1,34 @@
+IMAGE=ubuntu-gnome-nomachine:22.04
+CONTAINER=test-1 # Make sure this container name is not already in use or remove it first
+NomachineBindPort=2500
+SshBindPort=2400
+WorkSpaceBind=./workspace # Ensure this path is correct relative to where you run docker
+CreateUserAccount=user
+RenderType=Gpu
+NvidiaDriver=Tesla # or GeForce, depending on your setup
+NVIDIA_VISIBLE_DEVICES=0
+
+# Stop and remove the old container if it exists
+docker stop $CONTAINER || true
+docker rm $CONTAINER || true
+
+docker run -d \
+    -p $NomachineBindPort:4000 \
+    -p $SshBindPort:22 \
+    -p 4443:4443 \
+    --privileged=true \
+    --userns host \
+    --device=/dev/tty0 \
+    --name $CONTAINER \
+    --ipc=host \
+    --shm-size 2g \
+    --security-opt apparmor=unconfined \
+    --cap-add=SYS_ADMIN --cap-add=SYS_BOOT \
+    -v /sys/fs/cgroup:/sys/fs/cgroup \
+    -v $WorkSpaceBind:/home/chen9619/workspace \
+    -e CreateUserAccount=$CreateUserAccount \
+    -e RenderType=$RenderType \
+    -e NvidiaDriver=$NvidiaDriver \
+    -e NVIDIA_VISIBLE_DEVICES=$NVIDIA_VISIBLE_DEVICES \
+    -e DISPLAY=:0 \
+    $IMAGE /sbin/init # Overridden command to start a shell
\ No newline at end of file
diff --git a/infant/config.py b/infant/config.py
index 906105d..697562a 100644
--- a/infant/config.py
+++ b/infant/config.py
@@ -96,7 +96,7 @@ class Config:
     ap_llm: dict | None = None
     
     # litellm Attributes
-    model: str = 'claude-sonnet-4-20250514'
+    model: str = 'claude-sonnet-4-6'
     api_key: str | None = os.getenv("ANTHROPIC_API_KEY")
     base_url: str | None = None
     api_version: str | None = None
@@ -123,7 +123,7 @@ class Config:
     gift_key: bool = False
     
     ## vllm Attributes (OSS-LLM)
-    model_oss: str = 'ByteDance-Seed/UI-TARS-1.5-7B'
+    model_oss: str = 'openai/ByteDance-Seed/UI-TARS-1.5-7B'
     api_key_oss: str | None = None
     base_url_oss: str | None = None
     tensor_parallel_size: int = 1 # Tensor parallelism splits the model's tensors across n GPUs
@@ -185,7 +185,7 @@ class Config:
     workspace_mount_rewrite: str | None = None
     cache_dir: str = '/tmp/cache'
     # computer_container_image: str = 'winsonchen108/ubuntu-gnome-nomachine:latest' # Pull from Docker Hub  
-    computer_container_image: str = 'ubuntu-gnome-nomachine:latest' # Pull from Docker Hub  
+    computer_container_image: str = 'ubuntu-gnome-guacamole:latest' # Pull from Docker Hub  
     e2b_api_key: str = ''
     computer_type: str = 'ssh'  # Can be 'ssh', 'exec', or 'e2b'
     use_host_network: bool = False
@@ -242,7 +242,7 @@ def finalize_config(self):
         if self.computer_type == 'local':
             self.workspace_mount_path_in_computer = self.workspace_mount_path
 
-        if self.workspace_mount_rewrite: 
+        if self.workspace_mount_rewrite:
             base = self.workspace_base or os.getcwd()
             parts = self.workspace_mount_rewrite.split(':')
             self.workspace_mount_path = base.replace(parts[0], parts[1])
@@ -256,6 +256,12 @@ def finalize_config(self):
                 'See https://github.com/docker/roadmap/issues/238#issuecomment-2044688144 for more information.'
             )
 
+        # Override with environment variables if present (for Docker deployments)
+        if os.getenv("base_url_oss"):
+            self.base_url_oss = os.getenv("base_url_oss")
+        if os.getenv("api_key_oss"):
+            self.api_key_oss = os.getenv("api_key_oss")
+
         # make sure cache dir exists
         if self.cache_dir:
             pathlib.Path(self.cache_dir).mkdir(parents=True, exist_ok=True)
@@ -265,6 +271,9 @@ def get_litellm_params(self, overrides: Dict[str, Any] | None = None):
         Returns the parameters for the Litellm API.
         """
         overrides = overrides or {}
+        # Filter out empty string overrides so they don't clobber valid defaults
+        # (e.g. api_key="" in config.toml should not overwrite env var key)
+        filtered_overrides = {k: v for k, v in overrides.items() if v != ""}
 
         base_kwargs = dict(
             model                     = self.model,
@@ -294,7 +303,7 @@ def get_litellm_params(self, overrides: Dict[str, Any] | None = None):
             gift_key                  = self.gift_key,
         )
 
-        base_kwargs.update(overrides)
+        base_kwargs.update(filtered_overrides)
 
         return LitellmParams(**base_kwargs)
 
@@ -303,6 +312,8 @@ def get_vllm_params(self, overrides: Dict[str, Any] | None = None):
         Returns the parameters for the VLLM API.
         """
         overrides = overrides or {}
+        # Filter out empty string overrides so they don't clobber valid defaults
+        filtered_overrides = {k: v for k, v in overrides.items() if v != ""}
 
         base_kwargs = dict(
             model_oss              = self.model_oss,
@@ -321,7 +332,7 @@ def get_vllm_params(self, overrides: Dict[str, Any] | None = None):
             api_key_oss             = self.api_key_oss,
         )
 
-        base_kwargs.update(overrides) 
+        base_kwargs.update(filtered_overrides)
         return VllmParams(**base_kwargs)
 
     def get_agent_params(self):
diff --git a/infant/helper_functions/browser_helper_function.py b/infant/helper_functions/browser_helper_function.py
index 2bcaff2..c668cab 100644
--- a/infant/helper_functions/browser_helper_function.py
+++ b/infant/helper_functions/browser_helper_function.py
@@ -7,7 +7,7 @@
 if TYPE_CHECKING:
     from infant.agent.agent import Agent
 from urllib.parse import urljoin
-from infant.computer.computer import Computer
+from infant.computer.computer import Computer as Computer
 from infant.agent.memory.memory import Memory, IPythonRun
 from infant.util.debug import print_messages # for debug
 from infant.util.logger import infant_logger as logger
diff --git a/infant/helper_functions/file_edit_helper_function.py b/infant/helper_functions/file_edit_helper_function.py
index d6c557c..fc495e1 100644
--- a/infant/helper_functions/file_edit_helper_function.py
+++ b/infant/helper_functions/file_edit_helper_function.py
@@ -3,7 +3,7 @@
 import traceback
 from infant.config import config
 from infant.agent.parser import parse
-from infant.computer.computer import Computer
+from infant.computer.computer import Computer as Computer
 from infant.llm.llm_api_base import LLM_API_BASED
 from infant.agent.memory.memory import IPythonRun
 from infant.util.logger import infant_logger as logger
diff --git a/infant/llm/llm_api_base.py b/infant/llm/llm_api_base.py
index 77cd775..b3c16ab 100644
--- a/infant/llm/llm_api_base.py
+++ b/infant/llm/llm_api_base.py
@@ -160,19 +160,32 @@ def __init__(
                 # Enough tokens for most output actions, and not too many for a bad llm to get carried away responding
                 # with thousands of unwanted tokens
                 self.max_output_tokens = 1024
+        # Anthropic models reject requests that include both `temperature` and
+        # `top_p`. Prefer `temperature` when both are set in the config.
+        if llm_temperature is not None and llm_top_p is not None:
+            logger.info(
+                'Both temperature and top_p are set; sending only temperature '
+                'to avoid provider-side rejection (e.g. Anthropic claude-sonnet-4+).'
+            )
+            llm_top_p = None
+
         if self.gift_key:
             def call_llm(messages, max_tokens, top_p, temperature, stop):
                 try:
                     from openai import OpenAI
                     client = OpenAI()
+                    sampling_kwargs = {}
+                    if temperature is not None:
+                        sampling_kwargs['temperature'] = temperature
+                    elif top_p is not None:
+                        sampling_kwargs['top_p'] = top_p
                     completion = client.chat.completions.create(
                         # model="anthropic.claude-3-5-sonnet-20241022-v2:0",
                         model = 'claude-3-7-sonnet-20250219',
                         messages=messages,
                         max_tokens=max_tokens,
-                        top_p=top_p,
-                        temperature=temperature,
-                        stop=stop
+                        stop=stop,
+                        **sampling_kwargs,
                     )
                     return completion
                 except Exception as e:
@@ -186,8 +199,7 @@ def call_llm(messages, max_tokens, top_p, temperature, stop):
             )
 
         else:
-            self._completion = partial(
-                litellm_completion,
+            completion_kwargs = dict(
                 model=self.model_name,
                 api_key=self.api_key,
                 base_url=self.base_url,
@@ -195,9 +207,12 @@ def call_llm(messages, max_tokens, top_p, temperature, stop):
                 custom_llm_provider=custom_llm_provider,
                 max_tokens=self.max_output_tokens,
                 timeout=self.llm_timeout,
-                temperature=llm_temperature,
-                top_p=llm_top_p,
             )
+            if llm_temperature is not None:
+                completion_kwargs['temperature'] = llm_temperature
+            elif llm_top_p is not None:
+                completion_kwargs['top_p'] = llm_top_p
+            self._completion = partial(litellm_completion, **completion_kwargs)
 
         completion_unwrapped = self._completion
 
diff --git a/infant/llm/llm_oss_base.py b/infant/llm/llm_oss_base.py
index 2ddff14..4d8fea5 100644
--- a/infant/llm/llm_oss_base.py
+++ b/infant/llm/llm_oss_base.py
@@ -98,6 +98,7 @@ def load_model(self):
                 disable_custom_all_reduce=True,
                 enable_prefix_caching=self.args.enable_prefix_caching,
                 trust_remote_code=self.args.trust_remote_code,
+                dtype="float16",
             )
             logger.info(f"Model {self.model} loaded into GPU memory")
 
diff --git a/infant/main.py b/infant/main.py
index f6b8b9d..5803654 100644
--- a/infant/main.py
+++ b/infant/main.py
@@ -5,7 +5,7 @@
 from datetime import datetime
 from infant.agent.agent import Agent
 from infant.config import Config, config
-from infant.computer.computer import Computer
+from infant.computer.computer import Computer as Computer
 from infant.llm.llm_api_base import LLM_API_BASED
 from infant.llm.llm_oss_base import LLM_OSS_BASED
 from infant.agent.memory.memory import Userrequest
@@ -48,12 +48,16 @@ async def run_single_step(agent: Agent, user_request_text: str, image = None):
 async def initialize_agent(config: Config = None):
     if config is None:
         config = Config()
-        config.finalize_config()
         current_dir = os.path.dirname(os.path.abspath(__file__))
         root_dir = Path(current_dir).resolve().parent
         CONFIG_FILE = root_dir / "config.toml"
         user_config = config._load()
         config.__dict__.update(user_config)
+        config.finalize_config()
+
+    # Initialize variables to None for error handling
+    computer = None
+    agent = None
 
     # Initialize the API Based LLM
     plan_parameter = config.get_litellm_params(overrides = config.planning_llm)
@@ -71,19 +75,43 @@ async def initialize_agent(config: Config = None):
     ap_parameter = config.get_litellm_params(overrides = config.ap_llm)
     ap_llm = LLM_API_BASED(ap_parameter)
      
-    # Initialize the computer
+    # Initialize the computer using SSH-based connection
+    # When running from within the infant-agent container, connect to computer-container
+    # via the docker network using the container name as hostname
     computer_parameter = config.get_computer_params()
-    sid = str(uuid.uuid4())
-    computer = Computer(computer_parameter, sid = sid)
-    constant.MOUNT_PATH = computer.workspace_mount_path
+
+    # Create Computer instance
+    # Connect to 'infant-computer' (container name) on port 22 within docker network
+    computer = Computer(
+        ssh_hostname='infant-computer',  # Docker network container name
+        ssh_port=22,  # Internal container port (not the mapped host port)
+        ssh_password=computer_parameter.ssh_password or '123',
+        ssh_username='infant' if computer_parameter.run_as_infant else 'root',
+        ssh_root_password='123',  # Root password for setup
+        timeout=computer_parameter.computer_timeout or 120,
+        workspace_dir=computer_parameter.workspace_mount_path_in_computer or '/workspace',
+        enable_auto_lint=False,  # Set to True to enable auto-linting
+        initialize_plugins=True,  # Initialize plugins and tools
+        gui_port=8080,  # Always use internal container port (host port mapping is irrelevant here)
+    )
+
+    # Set the workspace mount path for constant
+    constant.MOUNT_PATH = config.workspace_mount_path
+
     # cd to the workspace/clear the workspace/activate conda
-    exit_code, output = computer.execute(f'cd /workspace && rm -rf *')
+    # Use sudo to handle permission issues, or change ownership first
+    exit_code, output = computer.execute(f'cd /workspace && sudo rm -rf * 2>/dev/null || rm -rf *')
     if exit_code != 0:
-        logger.error(f'Failed to clear the workspace directory: {output}')
-        sys.exit(1)
+        logger.warning(f'Failed to clear some files in workspace directory: {output}')
+        # Try changing ownership and removing again
+        exit_code, output = computer.execute(f'cd /workspace && sudo chown -R {computer.ssh_username}:{computer.ssh_username} . && rm -rf *')
+        if exit_code != 0:
+            logger.error(f'Failed to clear the workspace directory after changing ownership: {output}')
+        else:
+            logger.info("Workspace directory has been cleared successfully (after ownership change).")
     else:
         logger.info("Workspace directory has been cleared successfully.")
-    
+
     # activate conda
     exit_code, output = computer.execute(f'source /infant/miniforge3/etc/profile.d/conda.sh')
     exit_code, output = computer.execute('export PATH=/infant/miniforge3/bin:$PATH')
@@ -113,13 +141,22 @@ async def initialize_agent(config: Config = None):
     await computer.run_ipython(import_memory)
     return agent, computer
 
+    # Note: If an exception occurs during initialization, agent and/or computer may be None
+    # The calling function should handle this appropriately
+
 
 async def main():
+    # Initialize variables to None for error handling
+    agent = None
+    computer = None
 
     try:
         # Initialize the agent
         agent, computer = await initialize_agent()
-        constant.MOUNT_PATH = computer.workspace_mount_path
+        # MOUNT_PATH is already set correctly in initialize_agent() from config.
+        # Do NOT overwrite with computer.workspace_mount_path which returns the
+        # path inside the computer container (/workspace), not the agent's mount
+        # point (/app/workspace).
 
         # Run the agent
         while True:
@@ -157,6 +194,10 @@ async def main():
         await cleanup(agent=agent, computer=computer)
 
 async def cleanup(agent: None | Agent = None, computer: None | Computer = None):
+    # Check if computer is available
+    if computer is None:
+        logger.warning("Computer not initialized, skipping cleanup")
+        return
 
     # Handle the screenshots
     screenshots_dir = "/workspace/screenshots/"
@@ -176,6 +217,10 @@ async def cleanup(agent: None | Agent = None, computer: None | Computer = None):
         save_to_dataset(agent.state.memory_list, image_data_path)
 
 
+def cli_entry():
+    """Entry point for the CLI command."""
+    asyncio.run(main())
+
 # Run the main function
 if __name__ == "__main__":
-    asyncio.run(main())
+    cli_entry()
diff --git a/infant/server.py b/infant/server.py
new file mode 100644
index 0000000..b1040be
--- /dev/null
+++ b/infant/server.py
@@ -0,0 +1,405 @@
+# main_api.py
+import asyncio
+import os
+import select # For non-blocking reads from file descriptors
+import subprocess # For cleaning up ssh_tunnel_proc
+from typing import Any, Optional
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
+
+# Assuming these can be imported and potentially adapted for async/await if needed
+from infant.main import initialize_agent, run_single_step
+from infant.computer.computer import Computer # For type hinting
+from infant.agent.agent import Agent # For type hinting
+# from infant.agent.state.task_state import TaskState # For type hinting if needed for planner
+
+app = FastAPI()
+
+class ActiveShell:
+    """
+    Manages an active shell process (e.g., pexpect.spawn instance)
+    and bridges its I/O with a WebSocket connection using asyncio.
+    """
+    def __init__(self, process: Any, websocket: WebSocket, loop: asyncio.AbstractEventLoop):
+        self.process = process # This should be a pexpect.spawn-like object
+        self.websocket = websocket
+        self.loop = loop
+        self.fd = self.process.child_fd # File descriptor for reading
+        self.reader_task: Optional[asyncio.Task] = None
+
+    async def start_reading(self):
+        """Starts the background task to read from the shell and send to WebSocket."""
+        if self.reader_task is None or self.reader_task.done():
+            self.reader_task = self.loop.create_task(self._read_loop())
+            print(f"Shell reader task started for fd {self.fd}.")
+
+    async def _read_loop(self):
+        """Continuously reads from the shell process and sends data to the WebSocket."""
+        try:
+            while self.process.isalive():
+                # Use run_in_executor for the blocking select call
+                readable, _, _ = await self.loop.run_in_executor(
+                    None, select.select, [self.fd], [], [], 0.1 # 0.1s timeout
+                )
+                if readable:
+                    try:
+                        # Use run_in_executor for the blocking os.read call
+                        data = await self.loop.run_in_executor(None, os.read, self.fd, 4096)
+                        if data:
+                            await self.websocket.send_text(data.decode(errors='replace'))
+                        else: # EOF
+                            print(f"Shell fd {self.fd} EOF.")
+                            break
+                    except (BlockingIOError, InterruptedError):
+                        await asyncio.sleep(0.01) # Try again shortly
+                        continue
+                    except Exception as e:
+                        print(f"Shell read error on fd {self.fd}: {e}")
+                        break
+                else:
+                    # No data, select timed out, pexpect might need a chance to process internal state
+                    await asyncio.sleep(0.01) 
+
+        except asyncio.CancelledError:
+            print(f"Shell reader task for fd {self.fd} cancelled.")
+        except Exception as e:
+            print(f"Unexpected error in shell reader task for fd {self.fd}: {e}")
+        finally:
+            print(f"Shell read loop ended for fd {self.fd}.")
+            # Consider closing WebSocket if shell dies unexpectedly, or notify client
+            # await self.websocket.close(code=1011, reason="Shell process terminated")
+
+
+    async def write(self, data: str):
+        """Writes data to the shell process's stdin."""
+        if self.process.isalive():
+            try:
+                # pexpect's send/sendline are typically synchronous.
+                # Running in executor if they block significantly.
+                # For simple 'send', direct call might be okay if it's just writing to a buffer.
+                # self.process.send(data) # For pexpect
+                # If self.fd is a true PTY master, os.write is appropriate
+                await self.loop.run_in_executor(None, os.write, self.fd, data.encode())
+
+            except Exception as e:
+                print(f"Shell write error on fd {self.fd}: {e}")
+                # Handle error, maybe close connection
+
+    async def close(self):
+        """Closes the shell process and cancels the reader task."""
+        print(f"Closing ActiveShell for fd {self.fd}.")
+        if self.reader_task and not self.reader_task.done():
+            self.reader_task.cancel()
+            try:
+                await self.reader_task
+            except asyncio.CancelledError:
+                pass # Expected
+        
+        if self.process.isalive():
+            try:
+                # For pexpect, you'd use process.close() or process.terminate()
+                # self.process.close(force=True)
+                # If it's a raw PTY, os.close(self.fd) might be part of cleanup,
+                # but pexpect usually handles its child process.
+                # Here we assume pexpect's close() is the right method.
+                await self.loop.run_in_executor(None, self.process.close, False) # force=False initially
+                if self.process.isalive(): # If still alive, force
+                     await self.loop.run_in_executor(None, self.process.close, True)
+
+            except Exception as e:
+                print(f"Error closing shell process for fd {self.fd}: {e}")
+        print(f"ActiveShell for fd {self.fd} resources released.")
+
+
+class ConnectionManager:
+    def __init__(self):
+        self.active_chat_connections: dict[str, WebSocket] = {}
+        self.agent_instances: dict[str, tuple[Agent, Computer]] = {}
+        # client_id -> { "terminal": ActiveShell, "jupyter": ActiveShell }
+        self.active_shells: dict[str, dict[str, ActiveShell]] = {}
+        self.loop = asyncio.get_event_loop()
+
+    async def _ensure_agent_computer(self, client_id: str) -> tuple[Optional[Agent], Optional[Computer]]:
+        if client_id not in self.agent_instances:
+            try:
+                print(f"Initializing agent/computer for client {client_id}.")
+                agent, computer = await initialize_agent() # From your infant/main.py
+                self.agent_instances[client_id] = (agent, computer)
+                
+                # Ensure Jupyter kernel server is running (idempotent call from infant/main.py)
+                # This is typically called within initialize_agent or Computer's init
+                # If not, you might need: await computer.start_jupyter_server()
+                print(f"Agent/computer initialized for {client_id}.")
+                return agent, computer
+            except Exception as e:
+                print(f"CRITICAL: Error initializing agent/computer for {client_id}: {e}")
+                return None, None
+        return self.agent_instances[client_id]
+
+    async def connect_chat(self, websocket: WebSocket, client_id: str):
+        await websocket.accept()
+        self.active_chat_connections[client_id] = websocket
+        _, computer = await self._ensure_agent_computer(client_id)
+        if not computer: # Failed to initialize
+            await websocket.close(code=1011, reason="Agent initialization failed")
+            del self.active_chat_connections[client_id] # Clean up
+            return
+        print(f"Chat client {client_id} connected.")
+
+    async def disconnect_chat(self, client_id: str):
+        if client_id in self.active_chat_connections:
+            del self.active_chat_connections[client_id]
+        print(f"Chat client {client_id} disconnected.")
+        await self.cleanup_client_resources_if_idle(client_id)
+
+    async def process_chat_message(self, message: str, client_id: str):
+        if client_id in self.agent_instances:
+            agent, _ = self.agent_instances[client_id]
+            try:
+                # Ensure run_single_step is awaitable or adapt if it's synchronous
+                print(message)
+                agent_response_obj = await run_single_step(agent, user_request_text=message, images=None)
+                print(agent_response_obj)
+                response_text = ""
+                if isinstance(agent_response_obj, dict):
+                    # Try to extract a meaningful string representation
+                    # This depends heavily on the structure of agent_response_obj
+                    if "output" in agent_response_obj:
+                        response_text = agent_response_obj["output"]
+                    elif "plan" in agent_response_obj:
+                         response_text = f"Plan: {agent_response_obj['plan']}"
+                    else:
+                        response_text = str(agent_response_obj) # Fallback
+                elif isinstance(agent_response_obj, str):
+                    response_text = agent_response_obj
+                else:
+                    response_text = str(agent_response_obj)
+
+                await self.active_chat_connections[client_id].send_text(f"Agent: {response_text}")
+
+            except Exception as e:
+                print(f"Error processing chat message for agent {client_id}: {e}")
+                await self.active_chat_connections[client_id].send_text(f"Error: Could not process message due to: {e}")
+        else:
+            await self.active_chat_connections[client_id].send_text("Error: Agent not initialized for chat.")
+
+    async def connect_shell(self, websocket: WebSocket, client_id: str, shell_type: str):
+        await websocket.accept()
+        _, computer = await self._ensure_agent_computer(client_id)
+
+        if not computer:
+            await websocket.close(code=1011, reason="Agent/Computer initialization failed.")
+            return
+
+        # Ensure the computer's interactive SSH shell is ready.
+        # The infant.computer.Computer.connect_ssh() initializes self.ssh_interactive_shell.
+        # It uses pexpect.spawn(ssh_command...)
+        if not computer.ssh_interactive_shell or not computer.ssh_interactive_shell.process.isalive():
+            try:
+                print(f"Re-establishing SSH interactive shell for {client_id} for {shell_type}.")
+                await self.loop.run_in_executor(None, computer.connect_ssh) # connect_ssh is synchronous
+            except Exception as e:
+                print(f"Failed to establish SSH interactive shell for {client_id} ({shell_type}): {e}")
+                await websocket.close(code=1011, reason="Shell backend SSH error")
+                return
+        
+        pexpect_process = None
+        if shell_type == "terminal":
+            # For the terminal, we directly use the main interactive shell.
+            # WARNING: This is a simplified approach. Ideally, you'd spawn a new, dedicated pexpect
+            # session for each terminal, not share the agent's primary one.
+            pexpect_process = computer.ssh_interactive_shell.process
+            print(f"Terminal for {client_id} using agent's main interactive shell process.")
+            # If the shell was just (re)created, it might have login banners.
+            # You might want to consume initial output here before handing over.
+            # await asyncio.sleep(0.5) # give it a moment to settle
+            # initial_output = await self.loop.run_in_executor(None, pexpect_process.read_nonblocking, 4096, 1)
+            # if initial_output:
+            #     await websocket.send_text(initial_output.decode(errors='replace'))
+
+
+        elif shell_type == "jupyter":
+            # For Jupyter, run the execute_cli.py in interactive mode within the SSH shell.
+            # The Jupyter Kernel Gateway (execute_server.py) must be running in the Docker env.
+            # initialize_computer -> computer.start_jupyter_server() handles this.
+            kernel_id = f"kernel_{client_id}_{shell_type.replace('-', '_')}" # Ensure valid kernel_id chars
+            jupyter_cmd = f"python -u -m infant.tools.code_execute.execute_cli --kernel-id {kernel_id} --interactive\n"
+            print(f"Starting Jupyter CLI for {client_id} with command: {jupyter_cmd.strip()}")
+            
+            # This sends the command to the *existing* interactive shell.
+            # Output from this Jupyter CLI will be mixed with other shell output if not careful.
+            # A dedicated pexpect process is much cleaner:
+            # e.g., pexpect_process = await self.loop.run_in_executor(None, computer.pexpect_spawn_new_command, jupyter_cmd)
+            # For now, sending to the main shell:
+            await self.loop.run_in_executor(None, computer.ssh_interactive_shell.process.sendline, jupyter_cmd)
+            pexpect_process = computer.ssh_interactive_shell.process # Still using the main shell's pexpect instance
+            print(f"Jupyter CLI for {client_id} running in agent's main interactive shell.")
+
+
+        if not pexpect_process or not pexpect_process.isalive():
+            err_msg = f"Failed to obtain a live pexpect process for {shell_type} on client {client_id}."
+            print(err_msg)
+            await websocket.close(code=1011, reason=err_msg)
+            return
+
+        active_shell_instance = ActiveShell(pexpect_process, websocket, self.loop)
+        
+        if client_id not in self.active_shells:
+            self.active_shells[client_id] = {}
+        # Close any existing shell of the same type for this client
+        if shell_type in self.active_shells[client_id]:
+             print(f"Closing pre-existing {shell_type} shell for {client_id}.")
+             await self.active_shells[client_id][shell_type].close()
+
+        self.active_shells[client_id][shell_type] = active_shell_instance
+        await active_shell_instance.start_reading()
+        print(f"{shell_type.capitalize()} shell WebSocket connected for client {client_id}")
+
+    async def disconnect_shell(self, client_id: str, shell_type: str):
+        if client_id in self.active_shells and shell_type in self.active_shells[client_id]:
+            shell = self.active_shells[client_id][shell_type]
+            await shell.close()
+            del self.active_shells[client_id][shell_type]
+            if not self.active_shells[client_id]: # No more shells for this client type
+                del self.active_shells[client_id]
+        print(f"{shell_type.capitalize()} shell for client {client_id} disconnected.")
+        await self.cleanup_client_resources_if_idle(client_id)
+
+    async def forward_to_shell(self, data: str, client_id: str, shell_type: str):
+        if client_id in self.active_shells and shell_type in self.active_shells[client_id]:
+            shell = self.active_shells[client_id][shell_type]
+            if shell.process.isalive():
+                await shell.write(data)
+            else:
+                print(f"Cannot forward to {shell_type} shell: process is not alive for client {client_id}")
+                # Optionally notify the WebSocket client
+                await shell.websocket.close(1011, "Shell process terminated unexpectedly.")
+                await self.disconnect_shell(client_id, shell_type) # Cleanup
+        else:
+            # This case should ideally not happen if disconnect cleans up properly
+            print(f"Cannot forward to {shell_type} shell: No active shell for client {client_id}")
+
+
+    async def cleanup_client_resources_if_idle(self, client_id: str):
+        has_chat = client_id in self.active_chat_connections
+        has_shells = client_id in self.active_shells and bool(self.active_shells[client_id])
+        
+        if not has_chat and not has_shells:
+            if client_id in self.agent_instances:
+                agent, computer = self.agent_instances[client_id]
+                print(f"Cleaning up all resources for idle client {client_id}.")
+                
+                # Close computer's interactive SSH shell if it's open
+                if computer.ssh_interactive_shell and computer.ssh_interactive_shell.process.isalive():
+                    print(f"Closing main interactive shell for computer of client {client_id}.")
+                    await self.loop.run_in_executor(None, computer.ssh_interactive_shell.close)
+
+                # Terminate SSH tunnel process if it's running
+                if computer.ssh_tunnel_proc and computer.ssh_tunnel_proc.poll() is None:
+                    print(f"Terminating SSH tunnel for computer of client {client_id}.")
+                    computer.ssh_tunnel_proc.terminate()
+                    try:
+                        await self.loop.run_in_executor(None, computer.ssh_tunnel_proc.wait, 5)
+                    except subprocess.TimeoutExpired:
+                        computer.ssh_tunnel_proc.kill()
+                
+                # Add any other agent-specific cleanup if necessary
+                # e.g., agent.cleanup()
+
+                del self.agent_instances[client_id]
+                print(f"All resources for client {client_id} cleaned up.")
+
+manager = ConnectionManager()
+
+# --- WebSocket Endpoints ---
+@app.websocket("/ws/chat/{client_id}")
+async def websocket_chat_endpoint(websocket: WebSocket, client_id: str):
+    await manager.connect_chat(websocket, client_id)
+    print(websocket.client_state)
+    if not websocket.client_state == 'connected': return # Connection failed in connect_chat
+    try:
+        while True:
+            data = await websocket.receive_text()
+            print(data)
+            await manager.process_chat_message(data, client_id)
+    except WebSocketDisconnect:
+        print(f"Chat WebSocket for {client_id} disconnected by client.")
+    except Exception as e:
+        print(f"Error in chat WebSocket for {client_id}: {e}")
+    finally:
+        await manager.disconnect_chat(client_id)
+
+@app.websocket("/ws/terminal/{client_id}")
+async def websocket_terminal_endpoint(websocket: WebSocket, client_id: str):
+    await manager.connect_shell(websocket, client_id, "terminal")
+    if not websocket.client_state == 'connected': return
+
+    try:
+        while True:
+            data = await websocket.receive_text()
+            await manager.forward_to_shell(data, client_id, "terminal")
+    except WebSocketDisconnect:
+        print(f"Terminal WebSocket for {client_id} disconnected by client.")
+    except Exception as e:
+        print(f"Error in terminal WebSocket for {client_id}: {e}")
+    finally:
+        await manager.disconnect_shell(client_id, "terminal")
+
+@app.websocket("/ws/jupyter/{client_id}")
+async def websocket_jupyter_endpoint(websocket: WebSocket, client_id: str):
+    await manager.connect_shell(websocket, client_id, "jupyter")
+    if not websocket.client_state == 'connected': return
+
+    try:
+        while True:
+            data = await websocket.receive_text() # Input from xterm.js (Jupyter console)
+            await manager.forward_to_shell(data, client_id, "jupyter")
+    except WebSocketDisconnect:
+        print(f"Jupyter WebSocket for {client_id} disconnected by client.")
+    except Exception as e:
+        print(f"Error in Jupyter WebSocket for {client_id}: {e}")
+    finally:
+        await manager.disconnect_shell(client_id, "jupyter")
+
+# --- HTTP API Endpoints ---
+@app.get("/api/planner/{client_id}")
+async def get_planner_info(client_id: str):
+    if client_id not in manager.agent_instances:
+        # Try to initialize if not present, e.g. if planner is accessed before chat/shell
+        # This might be desired if planner can be viewed independently.
+        # For now, assume agent must be active from a WS connection first.
+        raise HTTPException(status_code=404, detail="Agent not found for client_id. Establish a WebSocket connection first.")
+
+    agent, _ = manager.agent_instances[client_id]
+    if hasattr(agent, 'state') and hasattr(agent.state, 'task_state'):
+        task_state = agent.state.task_state # This is an instance of infant.agent.state.task_state.TaskState
+        
+        # Serialize TaskState to a dictionary
+        # This depends on the attributes of your TaskState class
+        sub_tasks_data = []
+        if hasattr(task_state, 'sub_tasks') and isinstance(task_state.sub_tasks, list):
+            for sub_task in task_state.sub_tasks:
+                # Assuming sub_task is an object with attributes like 'description', 'status', 'tool_input_preview', etc.
+                # Or if it's a dictionary already.
+                if isinstance(sub_task, dict):
+                    sub_tasks_data.append(sub_task)
+                elif hasattr(sub_task, '__dict__'): # Basic object to dict
+                    sub_tasks_data.append(vars(sub_task))
+                else:
+                    sub_tasks_data.append(str(sub_task)) # Fallback
+
+        planner_data = {
+            "goal": getattr(task_state, 'goal', None),
+            "main_task_assessment": getattr(task_state, 'main_task_assessment', None),
+            "sub_tasks": sub_tasks_data,
+            "current_sub_task_index": getattr(task_state, 'current_sub_task_index', None),
+            "status": str(getattr(task_state, 'status', None)), # Enum to string
+            "last_error": getattr(task_state, 'last_error', None),
+        }
+        return planner_data
+    else:
+        raise HTTPException(status_code=404, detail="Task state not found for agent.")
+
+# To run this (save as main_api.py):
+# pip install fastapi "uvicorn[standard]" pexpect python-dotenv # Add any other infantagent deps
+# uvicorn infant.server:app --reload --ws-ping-interval 20 --ws-ping-timeout 20 --port 4000
\ No newline at end of file
diff --git a/infant/tools/setup.sh b/infant/tools/setup.sh
index 65fdbc0..bd4f3af 100755
--- a/infant/tools/setup.sh
+++ b/infant/tools/setup.sh
@@ -38,7 +38,7 @@ source ~/.bashrc
 
 # ADD /infant/tools to PATH to make `jupyter_cli` available
 echo 'export PATH=$PATH:/infant/tools/code_execute' >> ~/.bashrc
-echo 'export DISPLAY=:0' >> ~/.bashrc
+echo 'export DISPLAY=:10' >> ~/.bashrc
 export PATH=/infant/tools/code_execute:$PATH
 
 # if user name is `infant`, add '/home/infant/.local/bin' to PATH
diff --git a/pyproject.toml b/pyproject.toml
index 09e1a2f..caaa065 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -63,6 +63,9 @@ dependencies = [
   "pytest-forked",
   "flake8",
   "openai",
+  "httpx",
+  "aiohttp",
+  "multidict",
   "python-docx",
   "PyPDF2",
   "pylatexenc",
@@ -74,7 +77,6 @@ dependencies = [
   "whatthepatch",
   "retry",
   "evaluate",
-  "swebench @ git+https://github.com/All-Hands-AI/SWE-bench.git@main",
   "llama-index",
   "llama-index-vector-stores-chroma",
   "chromadb",
@@ -101,3 +103,6 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["infant*"]
+
+[project.scripts]
+infant = "infant.main:cli_entry"
diff --git a/send_prompt.py b/send_prompt.py
new file mode 100755
index 0000000..8792a59
--- /dev/null
+++ b/send_prompt.py
@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+Simple CLI tool to send prompts to the InfantAgent running in a Docker container.
+
+Usage:
+    python send_prompt.py "Your task here"
+    python send_prompt.py --interactive  # For interactive mode
+"""
+
+import sys
+import subprocess
+import argparse
+
+
+def send_prompt_to_agent(prompt: str, container_name: str = "infant-agent-cli"):
+    """
+    Send a prompt to the running agent container via docker exec.
+
+    Args:
+        prompt: The user request/task to send to the agent
+        container_name: Name of the agent container (default: infant-agent-cli)
+    """
+    try:
+        # Check if container is running
+        check_cmd = ["docker", "ps", "--filter", f"name={container_name}", "--format", "{{.Names}}"]
+        result = subprocess.run(check_cmd, capture_output=True, text=True, check=True)
+
+        if container_name not in result.stdout:
+            print(f"❌ Error: Container '{container_name}' is not running.")
+            print("Please start the containers with: docker compose up -d")
+            return False
+
+        # Escape single quotes in the prompt for bash
+        escaped_prompt = prompt.replace("'", "'\\''")
+
+        # Send the prompt to the container's stdin (PID 1)
+        # We need to write to /proc/1/fd/0 which is the stdin of the main process
+        exec_cmd = ["docker", "exec", "-i", container_name, "bash", "-c",
+                   f"printf '%s\\n' '{escaped_prompt}' > /proc/1/fd/0"]
+
+        print(f"📤 Sending prompt to agent: {prompt}")
+        print(f"⏳ Agent is processing your request...")
+        print("-" * 60)
+
+        result = subprocess.run(exec_cmd, capture_output=True, text=True, check=True)
+
+        if result.returncode == 0:
+            print("✅ Prompt sent successfully!")
+            print("\n📋 To view agent logs in real-time, run:")
+            print(f"   docker logs -f {container_name}")
+            print("\n💡 Or use: python send_prompt.py --logs --follow")
+            return True
+        else:
+            print(f"❌ Error sending prompt: {result.stderr}")
+            return False
+
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error: {e}")
+        if e.stderr:
+            print(f"stderr: {e.stderr}")
+        return False
+    except Exception as e:
+        print(f"❌ Unexpected error: {e}")
+        return False
+
+
+def interactive_mode(container_name: str = "infant-agent-cli"):
+    """Run in interactive mode, allowing multiple prompts."""
+    print("🤖 InfantAgent Interactive Mode")
+    print("=" * 60)
+    print(f"Connected to container: {container_name}")
+    print("Type 'exit' or 'quit' to stop, 'logs' to view agent logs")
+    print("=" * 60)
+    print()
+
+    while True:
+        try:
+            prompt = input("💬 Enter your request: ").strip()
+
+            if not prompt:
+                continue
+
+            if prompt.lower() in ['exit', 'quit', 'q']:
+                print("👋 Goodbye!")
+                break
+
+            if prompt.lower() == 'logs':
+                print("\n📋 Fetching agent logs...")
+                try:
+                    subprocess.run(["docker", "logs", "--tail", "50", container_name])
+                except Exception as e:
+                    print(f"❌ Error fetching logs: {e}")
+                print()
+                continue
+
+            if prompt.lower() == 'status':
+                print("\n📊 Container Status:")
+                try:
+                    subprocess.run(["docker", "ps", "--filter", f"name={container_name}",
+                                  "--format", "table {{.Names}}\\t{{.Status}}\\t{{.Ports}}"])
+                except Exception as e:
+                    print(f"❌ Error fetching status: {e}")
+                print()
+                continue
+
+            send_prompt_to_agent(prompt, container_name)
+            print()
+
+        except KeyboardInterrupt:
+            print("\n👋 Interrupted. Goodbye!")
+            break
+        except EOFError:
+            print("\n👋 EOF received. Goodbye!")
+            break
+
+
+def view_logs(container_name: str = "infant-agent-cli", follow: bool = False):
+    """View agent logs."""
+    try:
+        cmd = ["docker", "logs"]
+        if follow:
+            cmd.append("-f")
+        else:
+            cmd.extend(["--tail", "100"])
+        cmd.append(container_name)
+
+        print(f"📋 Viewing logs from {container_name}...")
+        print("-" * 60)
+        subprocess.run(cmd)
+    except KeyboardInterrupt:
+        print("\n👋 Stopped viewing logs")
+    except Exception as e:
+        print(f"❌ Error viewing logs: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Send prompts to InfantAgent running in Docker",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Send a single prompt
+  python send_prompt.py "Create a Python script to analyze data"
+
+  # Interactive mode
+  python send_prompt.py --interactive
+  python send_prompt.py -i
+
+  # View logs
+  python send_prompt.py --logs
+  python send_prompt.py --logs --follow
+
+  # Specify custom container name
+  python send_prompt.py "Your task" --container my-agent-container
+        """
+    )
+
+    parser.add_argument(
+        "prompt",
+        nargs="?",
+        help="The prompt/task to send to the agent"
+    )
+
+    parser.add_argument(
+        "-i", "--interactive",
+        action="store_true",
+        help="Run in interactive mode"
+    )
+
+    parser.add_argument(
+        "-l", "--logs",
+        action="store_true",
+        help="View agent logs"
+    )
+
+    parser.add_argument(
+        "-f", "--follow",
+        action="store_true",
+        help="Follow logs (use with --logs)"
+    )
+
+    parser.add_argument(
+        "-c", "--container",
+        default="infant-agent-cli",
+        help="Container name (default: infant-agent-cli)"
+    )
+
+    args = parser.parse_args()
+
+    # Handle different modes
+    if args.logs:
+        view_logs(args.container, args.follow)
+    elif args.interactive:
+        interactive_mode(args.container)
+    elif args.prompt:
+        success = send_prompt_to_agent(args.prompt, args.container)
+        sys.exit(0 if success else 1)
+    else:
+        parser.print_help()
+        print("\n❌ Error: Please provide a prompt or use --interactive mode")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/unit/config/test_config.py b/tests/unit/config/test_config.py
index 4a704dc..e6877a9 100644
--- a/tests/unit/config/test_config.py
+++ b/tests/unit/config/test_config.py
@@ -20,7 +20,7 @@ def test_config_init_with_defaults(self):
         config = Config()
         
         # Test default values
-        assert config.model == 'claude-sonnet-4-20250514'
+        assert config.model == 'claude-sonnet-4-6'
         assert config.max_iterations == 100
         assert config.max_voting == 5
         assert config.temperature == 1.0
@@ -76,7 +76,7 @@ def test_config_vllm_attributes(self):
         """Test VLLM-related configuration attributes."""
         config = Config()
         
-        assert config.model_oss == 'ByteDance-Seed/UI-TARS-1.5-7B'
+        assert config.model_oss == 'openai/ByteDance-Seed/UI-TARS-1.5-7B'
         assert config.tensor_parallel_size == 1
         assert config.max_model_len == 8192
         assert config.vllm_temperature == 0