diff --git a/.claude/settings.local.json b/.claude/settings.local.json
new file mode 100644
index 0000000000000000000000000000000000000000..71eaf97db02b1807f330ce577064ca84e98096ae
--- /dev/null
+++ b/.claude/settings.local.json
@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(dir:*)",
+      "Bash(del nul)",
+      "Bash(rm:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}
diff --git a/APPLICATIONS_GUIDE.md b/APPLICATIONS_GUIDE.md
new file mode 100644
index 0000000000000000000000000000000000000000..6faa3d30bf5a64749a24573bb3bbbbd421949483
--- /dev/null
+++ b/APPLICATIONS_GUIDE.md
@@ -0,0 +1,200 @@
+# Applications Guide
+
+## Integrated Desktop Applications
+
+Your web-based desktop OS now includes the following applications:
+
+### 1. **Web Browser** 🌐
+- **Icon**: Globe icon (blue/cyan gradient)
+- **Location**: Desktop + Dock
+- **Features**:
+  - Multi-tab browsing
+  - Navigation controls (back, forward, refresh, home)
+  - URL bar with HTTPS indicator
+  - Quick links to iframe-friendly sites
+  - CORS proxy option for better website compatibility
+  - Fullscreen mode
+  - Open in new window option
+  - Resizable and draggable window
+
+**CORS Proxy Solution**:
+- Toggle in settings to enable/disable
+- Uses `allorigins.win` proxy by default
+- Bypasses cross-origin restrictions
+- May affect performance slightly
+
+**Quick Access Sites**:
+- Google
+- Wikipedia
+- MDN Web Docs
+- Stack Overflow
+- GitHub
+- DuckDuckGo
+
+### 2. **Gemini Chat** ✨
+- **Icon**: Sparkle icon (orange gradient #E95420)
+- **Location**: Desktop + Dock
+- **Features**:
+  - AI-powered chat interface
+  - Conversation history (saved to localStorage)
+  - Message timestamps
+  - Draggable and resizable window
+  - Clean, modern UI matching Ubuntu style
+  - API key management (stored locally)
+
+**Setup**:
+1. Click the Gemini Chat icon on desktop or dock
+2. Enter your Gemini API key (get from [Google AI Studio](https://makersuite.google.com/app/apikey))
+3. Start chatting!
+
+**Features**:
+- Context-aware responses (last 10 messages)
+- Real-time typing indicators
+- Clear chat history option
+- Persistent chat across sessions
+- Secure API key storage
+
+### 3. **File Manager** 📁
+- Document management
+- File browsing
+- Multiple file type support
+
+### 4. **Calendar** 📅
+- Exam scheduling
+- Date management
+- Event tracking
+
+### 5. **Help** ❓
+- System help and information
+- Usage guides
+
+## API Integration
+
+### Gemini API Routes
+
+**Chat Endpoint**: `/api/gemini/chat`
+- Method: POST
+- Body: `{ message, apiKey, history }`
+- Response: `{ response }` or `{ error }`
+- Uses: Gemini 1.5 Flash model
+
+**Transcription Endpoint**: `/api/gemini/transcribe`
+- Method: POST
+- Body: FormData with audio file and apiKey
+- Response: `{ transcription }` or `{ error }`
+- Note: Full audio support requires Gemini 1.5 Pro
+
+## Accessing Applications
+
+### Desktop Icons
+Click any icon on the desktop (center of screen):
+- Documents
+- Exam Calendar
+- Web Browser
+- Gemini Chat
+
+### Dock (Left sidebar)
+Quick access to all applications:
+- Applications menu
+- Documents
+- Exam Calendar
+- Web Browser
+- Gemini Chat
+- Help
+
+## Window Management
+
+All applications support:
+- **Dragging**: Click and drag the title bar
+- **Resizing**: Drag from edges or corners
+- **Closing**: Click the red close button (top-left)
+- **Minimize/Maximize**: Click window control buttons
+
+## Browser Usage Tips
+
+1. **For Best Compatibility**: Enable CORS proxy in browser settings
+2. **Interactive Sites**: Some features may not work through proxy
+3. **Performance**: Direct access (no proxy) is faster but limited
+4. **Quick Links**: Use provided shortcuts for reliable access
+
+## Gemini Chat Tips
+
+1. **API Key**: Keep it secure, it's stored locally in your browser
+2. **Context**: The AI remembers last 10 messages in conversation
+3. **Clear History**: Use "Clear" button to start fresh conversation
+4. **Error Handling**: Check API key if you encounter errors
+5. **Conversation**: Chat naturally, Gemini understands context
+
+## Technical Details
+
+### Technologies Used
+- **Frontend**: React 19, Next.js 16, TypeScript
+- **Styling**: Tailwind CSS 4
+- **Icons**: Phosphor Icons
+- **Animations**: Framer Motion
+- **State**: React hooks + localStorage
+
+### File Structure
+```
+app/
+├── components/
+│   ├── Desktop.tsx          # Main desktop container
+│   ├── Dock.tsx             # Application dock
+│   ├── DesktopIcon.tsx      # Desktop icon component
+│   ├── WebBrowserApp.tsx    # Browser application
+│   ├── GeminiChat.tsx       # Gemini chat application
+│   └── ...
+├── api/
+│   └── gemini/
+│       ├── chat/route.ts    # Chat API endpoint
+│       └── transcribe/route.ts # Transcription endpoint
+└── page.tsx                 # Main entry point
+```
+
+## Future Enhancements
+
+Potential improvements:
+- [ ] Browser bookmarks system
+- [ ] Download manager
+- [ ] Browser history
+- [ ] Gemini voice input
+- [ ] Gemini image analysis
+- [ ] Multiple chat sessions
+- [ ] Chat export/import
+- [ ] Custom themes
+- [ ] Keyboard shortcuts
+- [ ] Window snapping
+
+## Troubleshooting
+
+### Browser Not Loading Sites
+- Enable CORS proxy in settings
+- Try quick link sites first
+- Some sites block iframe embedding
+
+### Gemini Chat Not Working
+- Verify API key is correct
+- Check internet connection
+- Ensure API key has proper permissions
+- Try clearing chat and starting fresh
+
+### Window Issues
+- Refresh page if window becomes unresponsive
+- Check that window isn't dragged off-screen
+- Clear localStorage if persistent issues
+
+## Development
+
+To run the application:
+```bash
+npm run dev
+```
+
+Access at: `http://localhost:3000`
+
+## API Keys
+
+You'll need:
+- **Gemini API Key**: From [Google AI Studio](https://makersuite.google.com/app/apikey)
+
+Keys are stored locally in browser's localStorage for convenience.
diff --git a/CLAUDE_DESKTOP_SETUP.md b/CLAUDE_DESKTOP_SETUP.md
new file mode 100644
index 0000000000000000000000000000000000000000..d23e8b4263066638ef39d7ebc142c23421456d2e
--- /dev/null
+++ b/CLAUDE_DESKTOP_SETUP.md
@@ -0,0 +1,99 @@
+# Setting Up MCP with Claude Desktop
+
+## Step 1: Find Your Claude Desktop Config File
+
+Open File Explorer and navigate to:
+```
+C:\Users\[YourUsername]\AppData\Roaming\Claude\
+```
+
+Or press `Win+R` and type:
+```
+%APPDATA%\Claude
+```
+
+## Step 2: Edit claude_desktop_config.json
+
+If the file doesn't exist, create it. Add this content:
+
+```json
+{
+  "mcpServers": {
+    "semsoon": {
+      "command": "python",
+      "args": ["E:\\mpc-hackathon\\backend\\mcp_server.py"],
+      "env": {
+        "UPLOAD_PASSCODE": "semsoon-secure-2025",
+        "DATA_DIR": "E:\\mpc-hackathon\\data"
+      }
+    }
+  }
+}
+```
+
+## Step 3: Restart Claude Desktop
+
+1. Completely close Claude Desktop (check system tray)
+2. Open Claude Desktop again
+3. The MCP server should start automatically
+
+## Step 4: Test in Claude Desktop
+
+Open a new conversation and try these:
+
+1. **Basic test**: "What MCP servers are available?"
+   - Claude should mention "semsoon"
+
+2. **List documents**: "Using semsoon, show me all available documents"
+   - Should list the sample documents
+
+3. **Check exams**: "Using semsoon, what exams are scheduled?"
+   - Should show the sample exams
+
+4. **Read a file**: "Using semsoon, read the study_tips.md file"
+   - Should display the content
+
+## If It's Not Working
+
+### Check 1: Python Path
+Make sure Python is in your PATH:
+```cmd
+python --version
+```
+
+If not, use full path in config:
+```json
+"command": "C:\\Python311\\python.exe"
+```
+
+### Check 2: Dependencies
+```cmd
+pip install fastmcp PyPDF2 python-docx python-dotenv
+```
+
+### Check 3: Test Server Manually
+```cmd
+cd E:\mpc-hackathon\backend
+python mcp_server.py
+```
+Should show: "Uvicorn running on http://127.0.0.1:8000"
+
+### Check 4: Claude Desktop Logs
+In Claude Desktop, press `Ctrl+Shift+I` to open DevTools and check Console for errors.
+
+## What Success Looks Like
+
+When properly connected, Claude Desktop will:
+1. Show "semsoon" as an available MCP server
+2. Be able to list documents
+3. Be able to show exam schedules
+4. Be able to read files
+5. Be able to upload files (with passcode)
+
+## Current Server Status
+
+✅ Your MCP server is currently running at http://localhost:8000
+✅ Sample documents have been created in E:\mpc-hackathon\data\documents
+✅ Sample exams have been added to the database
+
+Just add the config to Claude Desktop and restart it!
\ No newline at end of file
diff --git a/DEPLOYMENT.md b/DEPLOYMENT.md
new file mode 100644
index 0000000000000000000000000000000000000000..04f739860e1d8b78982d45efe8e312b02f4b08dc
--- /dev/null
+++ b/DEPLOYMENT.md
@@ -0,0 +1,107 @@
+# Deployment Guide for Hugging Face Spaces
+
+## Prerequisites
+- Hugging Face account
+- Hugging Face Spaces access
+- Git installed locally
+
+## Deployment Steps
+
+### 1. Create a New Space on Hugging Face
+1. Go to https://huggingface.co/spaces
+2. Click "Create new Space"
+3. Choose a name for your space
+4. Select "Docker" as the SDK
+5. Choose visibility (public/private)
+6. Click "Create Space"
+
+### 2. Configure Environment Variables
+In your Hugging Face Space settings:
+1. Go to Settings → Variables and Secrets
+2. Add the following secrets:
+   - `GEMINI_API_KEY`: Your Google Gemini API key
+   - `UPLOAD_PASSCODE`: Your secure upload passcode
+   - `MCP_SERVER_URL`: The MCP backend URL (if external)
+
+### 3. Prepare Your Repository
+```bash
+# Clone your HF Space repository
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+
+# Copy all project files
+cp -r /path/to/mpc-hackathon/* .
+
+# Make sure Dockerfile is in root
+ls Dockerfile
+
+# Add all files
+git add .
+git commit -m "Initial deployment"
+```
+
+### 4. Deploy to Hugging Face Spaces
+```bash
+# Push to Hugging Face
+git push origin main
+```
+
+### 5. Monitor Deployment
+- Check the build logs in your Space
+- The app will be available at: https://YOUR_USERNAME-YOUR_SPACE_NAME.hf.space
+
+## Docker Configuration
+
+The Dockerfile is configured to:
+1. Build the Next.js application
+2. Install Python backend dependencies
+3. Run both frontend (port 3000) and backend (port 8000)
+4. Create necessary data directories
+5. Run as non-root user for security
+
+## File Structure for Deployment
+```
+/
+├── app/                 # Next.js application
+├── backend/            # Python MCP backend
+├── public/             # Static assets
+├── data/               # Data storage (created at runtime)
+├── Dockerfile          # Docker configuration
+├── package.json        # Node dependencies
+├── requirements.txt    # Python dependencies
+├── next.config.mjs     # Next.js configuration
+└── .env               # Environment variables (create from .env.example)
+```
+
+## Troubleshooting
+
+### Build Failures
+- Check Dockerfile syntax
+- Verify all dependencies in package.json and requirements.txt
+- Check HF Space logs for specific errors
+
+### Runtime Issues
+- Verify environment variables are set
+- Check port configurations
+- Ensure data directories have proper permissions
+
+### Performance
+- HF Spaces have resource limits
+- Consider optimizing images and assets
+- Use production builds
+
+## Security Notes
+- Never commit `.env` files with real credentials
+- Use HF Spaces secrets for sensitive data
+- The app runs as non-root user for security
+- Upload passcode protects write operations
+
+## Updates
+To update your deployed app:
+```bash
+git add .
+git commit -m "Update description"
+git push origin main
+```
+
+The Space will automatically rebuild and redeploy.
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..0dbb4e39b32445d33a02d7fc86ae419820e60968
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,69 @@
+# Use Node.js 20 as the base image
+FROM node:20-alpine AS base
+
+# Install dependencies only when needed
+FROM base AS deps
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+
+# Install dependencies
+COPY package.json package-lock.json* ./
+RUN npm ci
+
+# Build the application
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+
+# Set environment variables for build
+ENV NEXT_TELEMETRY_DISABLED 1
+
+# Build Next.js application
+RUN npm run build
+
+# Production image
+FROM base AS runner
+WORKDIR /app
+
+ENV NODE_ENV production
+ENV NEXT_TELEMETRY_DISABLED 1
+
+# Create a non-root user
+RUN addgroup --system --gid 1001 nodejs
+RUN adduser --system --uid 1001 nextjs
+
+# Copy built application
+COPY --from=builder /app/public ./public
+COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
+COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
+
+# Create data directory for file uploads
+RUN mkdir -p /app/data/documents /app/data/public /app/data/exams
+RUN chown -R nextjs:nodejs /app/data
+
+# Install Python for MCP backend
+RUN apk add --no-cache python3 py3-pip
+
+# Copy Python backend
+COPY --chown=nextjs:nodejs backend /app/backend
+WORKDIR /app/backend
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+WORKDIR /app
+
+# Switch to non-root user
+USER nextjs
+
+# Expose ports
+EXPOSE 3000 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD node -e "require('http').get('http://localhost:3000/api/health', (res) => process.exit(res.statusCode === 200 ? 0 : 1))"
+
+# Start both services
+CMD ["sh", "-c", "python3 backend/mcp_server.py & node server.js"]
\ No newline at end of file
diff --git "a/E\357\200\272mpc-hackathonbackendmcp_server.py" "b/E\357\200\272mpc-hackathonbackendmcp_server.py"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/E\357\200\272mpc-hackathonpublicbackground_readme.txt" "b/E\357\200\272mpc-hackathonpublicbackground_readme.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..5e8827c44d6f92bcbf0e95708506ae4855943447
--- /dev/null
+++ "b/E\357\200\272mpc-hackathonpublicbackground_readme.txt"
@@ -0,0 +1 @@
+Please add your background.webp file to the public directory at E:\mpc-hackathon\public\background.webp
diff --git a/HACKATHON_README.md b/HACKATHON_README.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac147397c97069386514095684a07eb1feb1293c
--- /dev/null
+++ b/HACKATHON_README.md
@@ -0,0 +1,215 @@
+# 🎓 Exam Hub - AI-Powered Academic Assistant
+
+## 🏆 MCP Hackathon Submission
+
+An innovative exam calendar and document management system that integrates with Claude through the Model Context Protocol (MCP), featuring a stunning Ubuntu-styled desktop interface.
+
+## 🌟 What Makes This Special
+
+### 🚀 First-Mover Innovation
+- **Early MCP Adopter**: One of the first applications built with Anthropic's brand-new Model Context Protocol
+- **AI-Native Design**: Not just AI-enabled, but designed from the ground up for AI interaction
+- **Practical Application**: Solves real problems students face every day
+
+### 💡 Key Features
+
+#### 📚 Smart Document Management
+- Upload and organize study materials
+- AI-powered document search and extraction
+- PDF and DOCX text extraction
+- Full-text search within documents
+- Automatic categorization by subject
+
+#### 📅 Intelligent Exam Calendar
+- Track all upcoming exams in one place
+- Get AI-generated study schedules
+- Find related documents for each exam
+- Urgency-based exam prioritization
+- Study session tracking
+
+#### 🤖 Claude Integration (MCP)
+- Natural language queries: "What exams do I have this week?"
+- Smart document retrieval: "Find all chemistry notes"
+- Study assistance: "Create a study plan for my math midterm"
+- Document summarization: "Summarize the key points from chapter 5"
+
+#### 🎨 Beautiful Ubuntu-Style Desktop UI
+- Familiar desktop metaphor
+- File manager with folder navigation
+- Calendar application
+- Matrix rain effect (because why not!)
+- Responsive and intuitive design
+
+## 🛠️ Technical Stack
+
+### Frontend
+- **Next.js 14** - React framework with App Router
+- **Tailwind CSS** - Utility-first styling
+- **Framer Motion** - Smooth animations
+- **Phosphor Icons** - Beautiful icon set
+
+### Backend
+- **FastMCP** - Model Context Protocol server
+- **Python** - Backend logic
+- **SQLite** - Exam database
+- **FastAPI** - REST API for demos
+
+### AI Integration
+- **MCP Tools** - 20+ custom tools for Claude
+- **Document Intelligence** - PDF/DOCX extraction
+- **Natural Language Interface** - Talk to your documents
+
+## 🚦 Quick Start
+
+### 1. Install Dependencies
+
+```bash
+# Frontend
+npm install
+
+# Backend
+pip install -r requirements.txt
+```
+
+### 2. Run the Application
+
+```bash
+# Start Next.js UI (Terminal 1)
+npm run dev
+
+# Start MCP Server (Terminal 2)
+cd backend
+python mcp_server.py
+
+# Optional: Start Demo API (Terminal 3)
+cd backend
+python demo_api.py
+```
+
+### 3. Access the Application
+
+- **Web UI**: http://localhost:3000
+- **MCP Server**: http://localhost:8000
+- **Demo API**: http://localhost:8001/docs
+
+## 🎮 Demo Instructions
+
+### Web UI Demo
+1. Open http://localhost:3000
+2. Click on the File Manager icon
+3. Browse through the virtual file system
+4. Open the Calendar to see upcoming exams
+
+### Claude Desktop Integration
+1. Install Claude Desktop
+2. The configuration has been added to: `%APPDATA%\Claude\claude_desktop_config.json`
+3. Restart Claude Desktop
+4. Try: "Show me all documents in the exam hub"
+
+### API Demo
+1. Open http://localhost:8001/docs
+2. Try the interactive API documentation
+3. Test endpoints like `/exams/upcoming` or `/documents`
+
+## 📊 MCP Tools Available
+
+### Document Tools (11 tools)
+- `list_all_documents` - View all files
+- `get_folder_structure` - Browse folders
+- `search_documents` - Find files by name
+- `extract_pdf_text` - Read PDFs
+- `extract_docx_text` - Read Word docs
+- `read_text_file` - Read text files
+- `search_in_document` - Search within files
+- `get_document_summary` - Get file previews
+- `upload_file` - Upload new files (secured)
+- `create_folder` - Create directories
+- `delete_file` - Remove files
+
+### Calendar Tools (10 tools)
+- `get_all_exams` - List all exams
+- `get_exams_this_week` - Current week
+- `get_exams_next_week` - Next week
+- `get_exams_by_month` - Monthly view
+- `find_exam_by_subject` - Subject search
+- `get_exams_by_date` - Specific date
+- `get_upcoming_exams` - Next N days
+- `search_related_documents` - Find study materials
+- `get_study_schedule` - Study sessions
+- `get_exam_statistics` - Analytics
+
+## 🎯 Use Cases
+
+### For Students
+- "What exams are coming up this week?"
+- "Find all my chemistry notes"
+- "Create a study schedule for finals"
+- "Summarize this PDF for me"
+
+### For Educators
+- Track student exam schedules
+- Organize course materials
+- Generate study guides
+- Monitor academic calendars
+
+## 🔒 Security
+
+- **Passcode Protection**: Upload operations require authentication
+- **Local Storage**: All data stays on your machine
+- **Secure Design**: No external data transmission
+
+## 🌍 Deployment Options
+
+### Hugging Face Spaces
+- Ready for deployment with Docker
+- Persistent storage configured
+- Environment variables set
+
+### Local Installation
+- Works on Windows, Mac, Linux
+- No internet required
+- Full privacy control
+
+## 📈 Future Enhancements
+
+- [ ] Mobile app version
+- [ ] Collaborative study groups
+- [ ] AI-generated practice exams
+- [ ] Integration with university systems
+- [ ] Voice commands
+- [ ] Smart notifications
+
+## 🏗️ Architecture
+
+```
+┌─────────────────┐     ┌─────────────────┐
+│   Next.js UI    │────▶│   REST API      │
+└─────────────────┘     └─────────────────┘
+         │                       │
+         │                       ▼
+         │              ┌─────────────────┐
+         └─────────────▶│   MCP Server    │
+                        └─────────────────┘
+                                 │
+                        ┌────────┴────────┐
+                        ▼                 ▼
+                 ┌──────────┐      ┌──────────┐
+                 │ Documents│      │  SQLite  │
+                 └──────────┘      └──────────┘
+```
+
+## 👏 Acknowledgments
+
+- Built for the Anthropic MCP Hackathon
+- Powered by Claude and the Model Context Protocol
+- Ubuntu desktop design inspiration
+
+## 📝 License
+
+MIT License - Feel free to use and modify!
+
+---
+
+**Built with ❤️ for students everywhere**
+
+*Making exam preparation smarter with AI*
\ No newline at end of file
diff --git a/MCP_SETUP_GUIDE.md b/MCP_SETUP_GUIDE.md
new file mode 100644
index 0000000000000000000000000000000000000000..639fe6a08151650c6338f17cbb163a8540fe3eb1
--- /dev/null
+++ b/MCP_SETUP_GUIDE.md
@@ -0,0 +1,201 @@
+# MCP Integration Setup Guide for Claude Desktop
+
+## Quick Start
+
+### 1. Locate Claude Desktop Config File
+
+The Claude Desktop configuration file is located at:
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+### 2. Add MCP Server Configuration
+
+Open the config file and add this configuration:
+
+```json
+{
+  "mcpServers": {
+    "exam-hub": {
+      "command": "python",
+      "args": ["E:\\mpc-hackathon\\backend\\mcp_server.py"],
+      "env": {
+        "UPLOAD_PASSCODE": "exam-hub-secure-2025",
+        "DATA_DIR": "E:\\mpc-hackathon\\data"
+      }
+    }
+  }
+}
+```
+
+**Note**: Adjust the path to match your actual project location.
+
+### 3. Install Python Dependencies
+
+Make sure you have Python installed and run:
+
+```bash
+cd E:\mpc-hackathon
+pip install -r requirements.txt
+```
+
+### 4. Restart Claude Desktop
+
+After updating the configuration:
+1. Completely close Claude Desktop
+2. Reopen Claude Desktop
+3. The MCP server should start automatically
+
+## Testing the MCP Integration
+
+### Test Commands to Try in Claude Desktop
+
+Once connected, try these commands in a new Claude Desktop conversation:
+
+#### 1. Check Server Status
+Ask: "Can you check the exam hub server status?"
+- Claude should use the `get_server_info` tool
+
+#### 2. List Documents
+Ask: "What documents are available?"
+- Claude should use the `list_all_documents` tool
+
+#### 3. View Exam Schedule
+Ask: "What exams are coming up this week?"
+- Claude should use the `get_exams_this_week` tool
+
+#### 4. Search for Documents
+Ask: "Find all PDF files"
+- Claude should use the `search_documents` tool with file_type="pdf"
+
+#### 5. Get Exam Statistics
+Ask: "Show me exam statistics"
+- Claude should use the `get_exam_statistics` tool
+
+#### 6. Read a Document
+Ask: "Read the study_tips.md file"
+- Claude should use the `read_text_file` tool
+
+#### 7. Search Within Documents
+Ask: "Search for 'exam' in all documents"
+- Claude should use the `search_in_document` tool
+
+#### 8. Upload a File (Requires Passcode)
+Ask: "Upload a test file with content 'Hello World' as test.txt"
+- Claude will ask for the passcode
+- Provide: `exam-hub-secure-2025`
+- Claude should use the `upload_file` tool
+
+## Available MCP Tools
+
+### Document Management Tools (No Passcode)
+- `list_all_documents()` - List all files with metadata
+- `get_folder_structure()` - View folder hierarchy
+- `search_documents(query, file_type)` - Search files by name
+- `extract_pdf_text(filename, max_pages)` - Extract PDF content
+- `extract_docx_text(filename)` - Extract Word document content
+- `read_text_file(filename)` - Read text files
+- `search_in_document(filename, query)` - Search within files
+- `get_document_summary(filename)` - Get file preview and metadata
+
+### Document Management Tools (Passcode Required)
+- `upload_file(filename, file_data, passcode)` - Upload new files
+- `create_folder(folder_path, passcode)` - Create folders
+- `delete_file(filename, passcode)` - Delete files
+
+### Exam Calendar Tools
+- `get_all_exams()` - List all exams
+- `get_exams_this_week()` - Current week's exams
+- `get_exams_next_week()` - Next week's exams
+- `get_exams_by_month(year, month)` - Exams by month
+- `find_exam_by_subject(subject)` - Search by subject
+- `get_exams_by_date(date)` - Exams on specific date
+- `get_upcoming_exams(days)` - Upcoming exams in N days
+- `search_related_documents(subject)` - Find related study materials
+- `get_study_schedule(exam_id)` - View study sessions
+- `get_exam_statistics()` - Exam statistics and analytics
+
+## Troubleshooting
+
+### MCP Server Not Connecting
+
+1. **Check Python Installation**:
+   ```bash
+   python --version
+   ```
+   Should show Python 3.8 or higher
+
+2. **Check Dependencies**:
+   ```bash
+   pip list | grep fastmcp
+   ```
+   Should show fastmcp installed
+
+3. **Test Server Manually**:
+   ```bash
+   cd E:\mpc-hackathon\backend
+   python mcp_server.py
+   ```
+   Should show "Uvicorn running on http://127.0.0.1:8000"
+
+4. **Check Claude Desktop Logs**:
+   - Open Developer Tools in Claude Desktop (Ctrl+Shift+I or Cmd+Option+I)
+   - Look for MCP-related errors in the console
+
+### Common Issues
+
+**Issue**: "MCP server failed to start"
+**Solution**: Check the Python path in the config file is correct
+
+**Issue**: "No tools available"
+**Solution**: Restart Claude Desktop after updating config
+
+**Issue**: "Invalid passcode" when uploading
+**Solution**: Check the UPLOAD_PASSCODE in your .env file matches what you're using
+
+## Environment Variables
+
+The MCP server uses these environment variables (set in `.env` file):
+
+```env
+UPLOAD_PASSCODE=exam-hub-secure-2025  # Required for upload operations
+MCP_PORT=8000                         # Server port (default: 8000)
+DATA_DIR=./data                       # Data directory path
+```
+
+## Sample Data
+
+The server automatically creates sample files on first run:
+- `README.txt` - Welcome message
+- `study_tips.md` - Study tips document
+- `exam_schedule.txt` - Sample exam schedule
+
+Sample exams are also added to the database:
+- Mathematics Midterm (Feb 15)
+- Physics Final (Feb 20)
+- Computer Science Quiz (Feb 10)
+- Chemistry Midterm (Feb 18)
+- History Essay (Feb 25)
+- Biology Lab Exam (Feb 22)
+
+## Security Notes
+
+- The upload passcode (`exam-hub-secure-2025`) protects write operations
+- Change this passcode in production
+- Files are stored locally in the `data/documents` directory
+- The exam database is stored in `data/exams/exams.db`
+
+## Next Steps
+
+1. **Test Basic Operations**: Try the test commands above
+2. **Upload Real Documents**: Use the upload tool with your study materials
+3. **Customize Exam Data**: Add your actual exam schedule
+4. **Integrate with Web UI**: The Next.js frontend can be updated to use the same data directory
+
+## Support
+
+If you encounter issues:
+1. Check the logs in Claude Desktop's Developer Tools
+2. Verify the MCP server is running manually
+3. Ensure all paths in the config are absolute paths
+4. Make sure Python and all dependencies are installed correctly
\ No newline at end of file
diff --git a/TEST_MCP_CONNECTION.md b/TEST_MCP_CONNECTION.md
new file mode 100644
index 0000000000000000000000000000000000000000..bed18eb14f9804744f2cb886c48a14083de80143
--- /dev/null
+++ b/TEST_MCP_CONNECTION.md
@@ -0,0 +1,76 @@
+# Testing MCP Connection in Claude
+
+## Your MCP Server is Running!
+
+The MCP server is currently running at: `http://localhost:8000/sse`
+
+## How to Connect in Claude
+
+Since you're using Claude in the browser, you can test the MCP tools directly here! The server is already running in the background.
+
+## Test Commands to Try Right Now
+
+Try asking me these questions to test the MCP integration:
+
+### 1. Basic Server Check
+"Can you check what tools are available on the exam hub server?"
+
+### 2. List Documents
+"Show me all documents in the exam hub"
+
+### 3. View Exams
+"What exams are scheduled this week?"
+
+### 4. Read a File
+"Read the study_tips.md file from the exam hub"
+
+### 5. Search Documents
+"Search for PDF files in the document repository"
+
+### 6. Get Exam Statistics
+"Show me statistics about upcoming exams"
+
+### 7. Upload Test (Requires Passcode)
+"Upload a test file called 'hello.txt' with content 'Hello from Claude!'"
+(Use passcode: exam-hub-secure-2025)
+
+## Server Details
+
+- **Status**: Running ✅
+- **URL**: http://localhost:8000
+- **SSE Endpoint**: http://localhost:8000/sse
+- **Data Directory**: E:\mpc-hackathon\data
+- **Documents**: E:\mpc-hackathon\data\documents
+- **Database**: E:\mpc-hackathon\data\exams\exams.db
+
+## Available Tools Summary
+
+### Document Tools (No Auth Required)
+- list_all_documents
+- get_folder_structure
+- search_documents
+- extract_pdf_text
+- extract_docx_text
+- read_text_file
+- search_in_document
+- get_document_summary
+
+### Document Tools (Passcode Required)
+- upload_file (passcode: exam-hub-secure-2025)
+- create_folder
+- delete_file
+
+### Calendar/Exam Tools
+- get_all_exams
+- get_exams_this_week
+- get_exams_next_week
+- get_exams_by_month
+- find_exam_by_subject
+- get_exams_by_date
+- get_upcoming_exams
+- search_related_documents
+- get_study_schedule
+- get_exam_statistics
+- get_server_info
+
+The server is ready for testing! Just ask me to use any of these tools.
\ No newline at end of file
diff --git a/TTT_CLAUDE_DESKTOP_GUIDE.md b/TTT_CLAUDE_DESKTOP_GUIDE.md
new file mode 100644
index 0000000000000000000000000000000000000000..8710592ed405f8c71ff1c451b8b34d3fd60d35e9
--- /dev/null
+++ b/TTT_CLAUDE_DESKTOP_GUIDE.md
@@ -0,0 +1,257 @@
+# Playing Tic Tac Toe with Claude via MCP
+
+This guide explains how to play Tic Tac Toe with Claude Desktop using the Semsoon MCP server.
+
+## Overview
+
+The Tic Tac Toe game has been integrated into the **Semsoon MCP Server**. You can play directly through:
+1. **Claude Desktop** (via MCP tools)
+2. **Web UI** (browser interface)
+ 
+Both interfaces connect to the same game backend, so you could even start a game in one and continue in the other!
+
+---
+
+## Playing via Claude Desktop (MCP)
+
+### Prerequisites
+
+1. **Start the Semsoon MCP Server:**
+   ```bash
+   cd backend
+   python mcp_server.py
+   ```
+
+2. **Ensure Claude Desktop is configured** to connect to the Semsoon MCP server (see `CLAUDE_DESKTOP_SETUP.md`)
+
+### How to Play
+
+Once connected, you can play Tic Tac Toe by simply talking to Claude! Here are the available commands:
+
+#### 1. Start a New Game
+Just ask Claude to start a game:
+```
+"Let's play Tic Tac Toe!"
+```
+
+Or be more explicit:
+```
+"Start a new Tic Tac Toe game"
+```
+
+Claude will call `ttt_new_game()` and show you:
+- A game ID
+- The empty board
+- Board position numbers (0-8)
+
+#### 2. Make Your Move
+Tell Claude where you want to place your X:
+```
+"I'll take position 4" (center)
+"Place my X at position 0" (top-left)
+"I choose 8" (bottom-right)
+```
+
+Claude will:
+1. Place your X at the chosen position
+2. Automatically make its own move (O)
+3. Show you the updated board
+4. Check for a winner or draw
+
+#### 3. Continue Playing
+Keep making moves until someone wins or it's a draw!
+
+#### 4. Game Help
+Ask Claude for help anytime:
+```
+"How do I play Tic Tac Toe?"
+"Show me the board positions"
+"What are the TTT commands?"
+```
+
+### Board Layout
+
+```
+0 | 1 | 2
+---------
+3 | 4 | 5
+---------
+6 | 7 | 8
+```
+
+- **Position 0**: Top-left
+- **Position 4**: Center
+- **Position 8**: Bottom-right
+
+---
+
+## Available MCP Tools
+
+If you want to call the tools directly, here they are:
+
+### `ttt_new_game()`
+Start a new game. Returns a game ID and initial board.
+
+### `ttt_make_move(game_id, position)`
+Make your move and Claude responds automatically.
+- `game_id`: The ID from `ttt_new_game()`
+- `position`: 0-8 (see board layout above)
+
+### `ttt_get_game_state(game_id)`
+View the current state of a game.
+
+### `ttt_list_games()`
+List all active games.
+
+### `ttt_claude_move(game_id)`
+Make Claude play (if it's Claude's turn).
+
+### `ttt_help()`
+Get detailed help and instructions.
+
+---
+
+## Example Conversation
+
+**You:** Let's play Tic Tac Toe!
+
+**Claude:** *[Calls ttt_new_game()]*
+Great! I've started a new game. You are X, and I'm O. You go first!
+
+```
+0 | 1 | 2
+---------
+3 | 4 | 5
+---------
+6 | 7 | 8
+```
+
+Where would you like to place your X?
+
+**You:** I'll take the center, position 4
+
+**Claude:** *[Calls ttt_make_move(game_id, 4)]*
+You placed X at position 4 (center). I'll place O at position 0 (top-left).
+
+```
+O | 1 | 2
+---------
+3 | X | 5
+---------
+6 | 7 | 8
+```
+
+Your turn! Where would you like to go?
+
+**You:** Position 8
+
+**Claude:** *[Calls ttt_make_move(game_id, 8)]*
+You placed X at position 8. I'll block you with O at position 2!
+
+```
+O | 1 | O
+---------
+3 | X | 5
+---------
+6 | 7 | X
+```
+
+And so on...
+
+---
+
+## Playing via Web UI
+
+The TTT game is also available as a desktop app in your Web OS!
+
+1. **Start the Web UI** (if not already running)
+2. **Click the Tic Tac Toe icon** (pink game controller) on the desktop or dock
+3. **Play directly in the window** - click any empty cell to make your move
+4. Claude (AI) will automatically respond
+
+The web version uses the same game engine but provides a visual interface with:
+- Visual board with clickable cells
+- Score tracking
+- New game button
+- Animated moves
+
+---
+
+## Backend Architecture
+
+### Game State Storage
+- Games are stored in-memory in `backend/ttt_game.py`
+- Each game has a unique ID
+- Game state includes: board, current player, winner, game status
+
+### AI Algorithm
+Claude uses the **Minimax algorithm** with alpha-beta pruning to play optimally. This means:
+- Claude will never lose if it plays perfectly
+- Best you can do is draw (if you play perfectly too)
+- Good luck! 🎮
+
+### API Endpoints (for Web UI)
+- `POST /ttt/new` - Create new game
+- `POST /ttt/{game_id}/move` - Make a move
+- `GET /ttt/{game_id}/state` - Get game state
+- `GET /ttt/games` - List all games
+
+---
+
+## Troubleshooting
+
+### Claude doesn't have TTT tools
+1. Make sure the Semsoon MCP server is running
+2. Check Claude Desktop config includes Semsoon server
+3. Restart Claude Desktop
+4. Try: "What tools do you have available?" to verify
+
+### Game not responding
+1. Check if MCP server is still running
+2. Look for errors in server console
+3. Try starting a new game
+
+### Can't find my game
+- Games are stored in-memory, so they're lost if server restarts
+- Use `ttt_list_games()` to see all active games
+
+---
+
+## Tips for Playing
+
+1. **Center first** (position 4) is often a strong opening
+2. **Watch for two in a row** - block Claude or complete your own line
+3. **Control corners** - positions 0, 2, 6, 8 are strategic
+4. **Think ahead** - Claude is using minimax, so play carefully!
+
+---
+
+## Integration Details
+
+### File Structure
+```
+backend/
+├── mcp_server.py           # Main Semsoon MCP server
+├── ttt_game.py             # Game logic and AI
+├── demo_api.py             # REST API endpoints
+└── tools/
+    └── ttt_tools.py        # MCP tool registrations
+```
+
+### How It Works
+1. You talk to Claude Desktop
+2. Claude calls MCP tools (e.g., `ttt_make_move`)
+3. Tools execute game logic in `ttt_game.py`
+4. Results returned to Claude
+5. Claude shows you the board and responds naturally
+
+---
+
+## Have Fun!
+
+Enjoy playing Tic Tac Toe with Claude! It's a great way to:
+- Take study breaks
+- Test the MCP integration
+- Challenge yourself against perfect AI play
+
+Remember: You're X, Claude is O. May the best player win! 🏆
diff --git a/USE_NGROK.md b/USE_NGROK.md
new file mode 100644
index 0000000000000000000000000000000000000000..ff1b84ab5cfb7a7a5192ad9e03f9426095a99a14
--- /dev/null
+++ b/USE_NGROK.md
@@ -0,0 +1,27 @@
+# Using ngrok for HTTPS Access
+
+If you need an HTTPS endpoint for your MCP server:
+
+## 1. Install ngrok
+Download from: https://ngrok.com/download
+
+## 2. Start your MCP server
+```bash
+cd backend
+python mcp_server.py
+```
+
+## 3. Create HTTPS tunnel
+```bash
+ngrok http 8000
+``` 
+
+This will give you a public HTTPS URL like:
+`https://abc123.ngrok.io`
+
+## 4. Use the HTTPS URL
+You can then use `https://abc123.ngrok.io/sse` as your MCP endpoint.
+
+---
+
+**BUT REMEMBER**: Claude's web interface doesn't support custom MCP connectors. You need Claude Desktop for MCP integration!
\ No newline at end of file
diff --git a/app/api/code/execute/route.ts b/app/api/code/execute/route.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6d437812c21dd76df633fc1d06d08782f748dfcd
--- /dev/null
+++ b/app/api/code/execute/route.ts
@@ -0,0 +1,186 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import fs from 'fs/promises'
+import path from 'path'
+import crypto from 'crypto'
+
+const execAsync = promisify(exec)
+
+// Session storage (in production, use a proper database)
+const sessions = new Map<string, any>()
+
+export async function POST(request: NextRequest) {
+  try {
+    const { sessionId, language, code, timestamp } = await request.json()
+
+    if (!sessionId || !language || !code) {
+      return NextResponse.json(
+        { error: 'Missing required parameters' },
+        { status: 400 }
+      )
+    }
+
+    // Create a temporary directory for this execution
+    const tempDir = path.join(process.cwd(), 'temp', sessionId)
+    await fs.mkdir(tempDir, { recursive: true })
+
+    let output = ''
+    let error = null
+
+    try {
+      switch (language) {
+        case 'python': {
+          const fileName = path.join(tempDir, `script_${timestamp}.py`)
+          await fs.writeFile(fileName, code)
+
+          try {
+            const result = await execAsync(`python "${fileName}"`, {
+              timeout: 10000, // 10 second timeout
+              maxBuffer: 1024 * 1024 // 1MB buffer
+            })
+            output = result.stdout
+            if (result.stderr) {
+              error = result.stderr
+            }
+          } catch (execError: any) {
+            error = execError.message || 'Execution failed'
+            output = execError.stdout || ''
+          }
+
+          // Clean up
+          await fs.unlink(fileName).catch(() => {})
+          break
+        }
+
+        case 'javascript':
+        case 'typescript': {
+          const fileName = path.join(tempDir, `script_${timestamp}.${language === 'typescript' ? 'ts' : 'js'}`)
+          await fs.writeFile(fileName, code)
+
+          try {
+            const command = language === 'typescript'
+              ? `npx ts-node "${fileName}"`
+              : `node "${fileName}"`
+
+            const result = await execAsync(command, {
+              timeout: 10000,
+              maxBuffer: 1024 * 1024
+            })
+            output = result.stdout
+            if (result.stderr) {
+              error = result.stderr
+            }
+          } catch (execError: any) {
+            error = execError.message || 'Execution failed'
+            output = execError.stdout || ''
+          }
+
+          await fs.unlink(fileName).catch(() => {})
+          break
+        }
+
+        case 'react':
+        case 'flutter': {
+          // For React and Flutter, we'll return a message since they need build processes
+          output = `${language === 'react' ? 'React' : 'Flutter'} code saved successfully.
+To run ${language} applications, use the integrated development server.`
+
+          // Save the code for later use
+          const fileName = path.join(tempDir, `app_${timestamp}.${language === 'react' ? 'jsx' : 'dart'}`)
+          await fs.writeFile(fileName, code)
+          break
+        }
+
+        case 'html':
+        case 'css': {
+          // HTML and CSS don't execute, just save them
+          const extension = language === 'html' ? 'html' : 'css'
+          const fileName = path.join(tempDir, `file_${timestamp}.${extension}`)
+          await fs.writeFile(fileName, code)
+          output = `${language.toUpperCase()} file saved successfully. Use the preview pane to see the result.`
+          break
+        }
+
+        default:
+          error = `Unsupported language: ${language}`
+      }
+
+      // Store in session
+      if (!sessions.has(sessionId)) {
+        sessions.set(sessionId, {
+          files: [],
+          executions: []
+        })
+      }
+
+      const session = sessions.get(sessionId)
+      session.executions.push({
+        language,
+        code,
+        output,
+        error,
+        timestamp
+      })
+
+      // Keep only last 50 executions
+      if (session.executions.length > 50) {
+        session.executions = session.executions.slice(-50)
+      }
+
+      return NextResponse.json({
+        output,
+        error,
+        timestamp,
+        sessionId
+      })
+
+    } catch (err: any) {
+      return NextResponse.json(
+        { error: err.message || 'Execution failed' },
+        { status: 500 }
+      )
+    } finally {
+      // Clean up temp directory after some time
+      setTimeout(async () => {
+        try {
+          await fs.rmdir(tempDir, { recursive: true })
+        } catch {}
+      }, 60000) // Clean after 1 minute
+    }
+
+  } catch (err: any) {
+    return NextResponse.json(
+      { error: err.message || 'Request failed' },
+      { status: 500 }
+    )
+  }
+}
+
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams
+  const sessionId = searchParams.get('sessionId')
+
+  if (!sessionId) {
+    return NextResponse.json(
+      { error: 'Session ID required' },
+      { status: 400 }
+    )
+  }
+
+  const session = sessions.get(sessionId)
+
+  if (!session) {
+    return NextResponse.json({
+      sessionId,
+      executions: [],
+      files: []
+    })
+  }
+
+  return NextResponse.json({
+    sessionId,
+    executions: session.executions || [],
+    files: session.files || []
+  })
+}
\ No newline at end of file
diff --git a/app/api/code/public/route.ts b/app/api/code/public/route.ts
new file mode 100644
index 0000000000000000000000000000000000000000..85dd72f027cdc91664c66e8435a5ebde017db8ad
--- /dev/null
+++ b/app/api/code/public/route.ts
@@ -0,0 +1,85 @@
+import { NextRequest, NextResponse } from 'next/server'
+import fs from 'fs/promises'
+import path from 'path'
+
+const PUBLIC_DIR = path.join(process.cwd(), 'public', 'shared-code')
+
+// Initialize public directory
+async function ensurePublicDir() {
+  await fs.mkdir(PUBLIC_DIR, { recursive: true })
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    await ensurePublicDir()
+
+    // Read all public files
+    const files = await fs.readdir(PUBLIC_DIR)
+    const publicFiles = []
+
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        try {
+          const content = await fs.readFile(path.join(PUBLIC_DIR, file), 'utf-8')
+          const fileData = JSON.parse(content)
+          publicFiles.push(fileData)
+        } catch (err) {
+          console.error(`Error reading file ${file}:`, err)
+        }
+      }
+    }
+
+    // Sort by timestamp (newest first)
+    publicFiles.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))
+
+    return NextResponse.json(publicFiles)
+  } catch (err: any) {
+    return NextResponse.json(
+      { error: 'Failed to load public files' },
+      { status: 500 }
+    )
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const { sessionId, file } = await request.json()
+
+    if (!sessionId || !file) {
+      return NextResponse.json(
+        { error: 'Missing required parameters' },
+        { status: 400 }
+      )
+    }
+
+    await ensurePublicDir()
+
+    // Add metadata
+    const publicFile = {
+      ...file,
+      id: `public_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      timestamp: Date.now(),
+      author: sessionId,
+      downloads: 0,
+      likes: 0
+    }
+
+    // Save to public directory
+    const fileName = `${publicFile.id}.json`
+    const filePath = path.join(PUBLIC_DIR, fileName)
+
+    await fs.writeFile(filePath, JSON.stringify(publicFile, null, 2))
+
+    return NextResponse.json({
+      success: true,
+      file: publicFile,
+      path: `/shared-code/${fileName}`
+    })
+
+  } catch (err: any) {
+    return NextResponse.json(
+      { error: err.message || 'Failed to save public file' },
+      { status: 500 }
+    )
+  }
+}
\ No newline at end of file
diff --git a/app/api/code/save/route.ts b/app/api/code/save/route.ts
new file mode 100644
index 0000000000000000000000000000000000000000..74a4f348982f04edfd799952298141d898cfb1b2
--- /dev/null
+++ b/app/api/code/save/route.ts
@@ -0,0 +1,130 @@
+import { NextRequest, NextResponse } from 'next/server'
+import fs from 'fs'
+import path from 'path'
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json()
+    const { sessionId, code, timestamp } = body
+
+    // Define the base path for saved code (accessible by MCP)
+    const baseDir = path.join(process.cwd(), 'data', 'vscode_sessions')
+
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(baseDir)) {
+      fs.mkdirSync(baseDir, { recursive: true })
+    }
+
+    // Create session directory
+    const sessionDir = path.join(baseDir, sessionId)
+    if (!fs.existsSync(sessionDir)) {
+      fs.mkdirSync(sessionDir, { recursive: true })
+    }
+
+    // Save each file
+    for (const file of code) {
+      const filePath = path.join(sessionDir, file.name)
+      fs.writeFileSync(filePath, file.content, 'utf-8')
+    }
+
+    // Create metadata file
+    const metadata = {
+      sessionId,
+      timestamp,
+      files: code.map((f: any) => ({
+        name: f.name,
+        language: f.language,
+        size: f.content.length
+      })),
+      created: new Date().toISOString()
+    }
+
+    fs.writeFileSync(
+      path.join(sessionDir, 'metadata.json'),
+      JSON.stringify(metadata, null, 2),
+      'utf-8'
+    )
+
+    return NextResponse.json({
+      success: true,
+      message: 'Code saved successfully',
+      path: sessionDir,
+      sessionId
+    })
+  } catch (error) {
+    console.error('Error saving code:', error)
+    return NextResponse.json(
+      { success: false, error: 'Failed to save code' },
+      { status: 500 }
+    )
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const searchParams = request.nextUrl.searchParams
+    const sessionId = searchParams.get('sessionId')
+
+    if (!sessionId) {
+      // List all sessions
+      const baseDir = path.join(process.cwd(), 'data', 'vscode_sessions')
+
+      if (!fs.existsSync(baseDir)) {
+        return NextResponse.json({ sessions: [] })
+      }
+
+      const sessions = fs.readdirSync(baseDir)
+        .filter(dir => fs.statSync(path.join(baseDir, dir)).isDirectory())
+        .map(dir => {
+          const metadataPath = path.join(baseDir, dir, 'metadata.json')
+          if (fs.existsSync(metadataPath)) {
+            const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'))
+            return {
+              sessionId: dir,
+              ...metadata
+            }
+          }
+          return { sessionId: dir }
+        })
+
+      return NextResponse.json({ sessions })
+    }
+
+    // Get specific session
+    const sessionDir = path.join(process.cwd(), 'data', 'vscode_sessions', sessionId)
+
+    if (!fs.existsSync(sessionDir)) {
+      return NextResponse.json(
+        { error: 'Session not found' },
+        { status: 404 }
+      )
+    }
+
+    const files = fs.readdirSync(sessionDir)
+      .filter(file => file !== 'metadata.json')
+      .map(filename => {
+        const content = fs.readFileSync(path.join(sessionDir, filename), 'utf-8')
+        return {
+          name: filename,
+          content
+        }
+      })
+
+    const metadataPath = path.join(sessionDir, 'metadata.json')
+    const metadata = fs.existsSync(metadataPath)
+      ? JSON.parse(fs.readFileSync(metadataPath, 'utf-8'))
+      : {}
+
+    return NextResponse.json({
+      sessionId,
+      files,
+      metadata
+    })
+  } catch (error) {
+    console.error('Error reading code:', error)
+    return NextResponse.json(
+      { error: 'Failed to read code' },
+      { status: 500 }
+    )
+  }
+}
\ No newline at end of file
diff --git a/app/api/download/route.ts b/app/api/download/route.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b895377efc9a1cd68a0c3973904b00b7e1f04264
--- /dev/null
+++ b/app/api/download/route.ts
@@ -0,0 +1,99 @@
+import { NextRequest, NextResponse } from 'next/server'
+import fs from 'fs'
+import path from 'path'
+
+const DATA_DIR = path.join(process.cwd(), 'data')
+const DOCS_DIR = path.join(DATA_DIR, 'documents')
+
+export async function GET(request: NextRequest) {
+  try {
+    const searchParams = request.nextUrl.searchParams
+    const filePath = searchParams.get('path')
+    const preview = searchParams.get('preview') === 'true'
+
+    if (!filePath) {
+      return NextResponse.json({ error: 'File path required' }, { status: 400 })
+    }
+
+    const fullPath = path.join(DOCS_DIR, filePath)
+
+    // Security check
+    if (!fullPath.startsWith(DOCS_DIR)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
+    }
+
+    if (!fs.existsSync(fullPath)) {
+      return NextResponse.json({ error: 'File not found' }, { status: 404 })
+    }
+
+    const stats = fs.statSync(fullPath)
+    if (stats.isDirectory()) {
+      return NextResponse.json({ error: 'Cannot download directory' }, { status: 400 })
+    }
+
+    const fileBuffer = fs.readFileSync(fullPath)
+    const fileName = path.basename(filePath)
+    const ext = path.extname(fileName).toLowerCase()
+
+    // Determine content type
+    let contentType = 'application/octet-stream'
+    const mimeTypes: Record<string, string> = {
+      '.pdf': 'application/pdf',
+      '.doc': 'application/msword',
+      '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      '.xls': 'application/vnd.ms-excel',
+      '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      '.ppt': 'application/vnd.ms-powerpoint',
+      '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+      '.txt': 'text/plain',
+      '.md': 'text/markdown',
+      '.json': 'application/json',
+      '.html': 'text/html',
+      '.css': 'text/css',
+      '.js': 'text/javascript',
+      '.ts': 'text/typescript',
+      '.py': 'text/x-python',
+      '.java': 'text/x-java',
+      '.cpp': 'text/x-c++',
+      '.jpg': 'image/jpeg',
+      '.jpeg': 'image/jpeg',
+      '.png': 'image/png',
+      '.gif': 'image/gif',
+      '.svg': 'image/svg+xml',
+      '.mp3': 'audio/mpeg',
+      '.mp4': 'video/mp4',
+      '.zip': 'application/zip',
+      '.rar': 'application/x-rar-compressed'
+    }
+
+    if (mimeTypes[ext]) {
+      contentType = mimeTypes[ext]
+    }
+
+    const headers = new Headers({
+      'Content-Type': contentType,
+      'Content-Length': fileBuffer.length.toString(),
+    })
+
+    // If not preview mode, add download header
+    if (!preview) {
+      headers.set('Content-Disposition', `attachment; filename="${fileName}"`)
+    } else {
+      // For preview, use inline disposition for supported types
+      if (['application/pdf', 'text/plain', 'text/markdown', 'application/json'].includes(contentType) ||
+          contentType.startsWith('image/') || contentType.startsWith('text/')) {
+        headers.set('Content-Disposition', `inline; filename="${fileName}"`)
+      } else {
+        headers.set('Content-Disposition', `attachment; filename="${fileName}"`)
+      }
+    }
+
+    return new NextResponse(fileBuffer, { headers })
+  } catch (error) {
+    console.error('Error downloading file:', error)
+    return NextResponse.json(
+      { error: 'Failed to download file' },
+      { status: 500 }
+    )
+  }
+}
\ No newline at end of file
diff --git a/app/api/files/route.ts b/app/api/files/route.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f827da5f8f31db61b014e9132a91beef5b45d3aa
--- /dev/null
+++ b/app/api/files/route.ts
@@ -0,0 +1,183 @@
+import { NextRequest, NextResponse } from 'next/server'
+import fs from 'fs'
+import path from 'path'
+
+const DATA_DIR = path.join(process.cwd(), 'data')
+const DOCS_DIR = path.join(DATA_DIR, 'documents')
+
+// Ensure directories exist
+if (!fs.existsSync(DATA_DIR)) {
+  fs.mkdirSync(DATA_DIR, { recursive: true })
+}
+if (!fs.existsSync(DOCS_DIR)) {
+  fs.mkdirSync(DOCS_DIR, { recursive: true })
+}
+
+interface FileItem {
+  name: string
+  type: 'file' | 'folder'
+  size?: number
+  modified?: string
+  path: string
+  extension?: string
+}
+
+function getFileExtension(filename: string): string {
+  const ext = path.extname(filename).toLowerCase()
+  return ext.startsWith('.') ? ext.substring(1) : ext
+}
+
+function getFilesRecursively(dir: string, basePath: string = ''): FileItem[] {
+  const files: FileItem[] = []
+
+  try {
+    const items = fs.readdirSync(dir)
+
+    for (const item of items) {
+      // Skip hidden files and system files
+      if (item.startsWith('.') || item === 'exams.db') continue
+
+      const fullPath = path.join(dir, item)
+      const relativePath = path.join(basePath, item).replace(/\\/g, '/')
+      const stats = fs.statSync(fullPath)
+
+      if (stats.isDirectory()) {
+        files.push({
+          name: item,
+          type: 'folder',
+          path: relativePath,
+          modified: stats.mtime.toISOString()
+        })
+        // Recursively get files from subdirectories
+        const subFiles = getFilesRecursively(fullPath, relativePath)
+        files.push(...subFiles)
+      } else {
+        files.push({
+          name: item,
+          type: 'file',
+          size: stats.size,
+          modified: stats.mtime.toISOString(),
+          path: relativePath,
+          extension: getFileExtension(item)
+        })
+      }
+    }
+  } catch (error) {
+    console.error('Error reading directory:', error)
+  }
+
+  return files
+}
+
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams
+  const folder = searchParams.get('folder') || ''
+
+  try {
+    const targetDir = path.join(DOCS_DIR, folder)
+
+    // Security check - prevent directory traversal
+    if (!targetDir.startsWith(DOCS_DIR)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
+    }
+
+    if (!fs.existsSync(targetDir)) {
+      // If directory doesn't exist, create it
+      fs.mkdirSync(targetDir, { recursive: true })
+    }
+
+    const files = getFilesRecursively(targetDir, folder)
+
+    return NextResponse.json({
+      files,
+      currentPath: folder,
+      dataDir: DATA_DIR
+    })
+  } catch (error) {
+    console.error('Error listing files:', error)
+    return NextResponse.json(
+      { error: 'Failed to list files' },
+      { status: 500 }
+    )
+  }
+}
+
+// Create folder endpoint
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json()
+    const { folderName, parentPath = '' } = body
+
+    if (!folderName) {
+      return NextResponse.json({ error: 'Folder name required' }, { status: 400 })
+    }
+
+    const folderPath = path.join(DOCS_DIR, parentPath, folderName)
+
+    // Security check
+    if (!folderPath.startsWith(DOCS_DIR)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
+    }
+
+    if (fs.existsSync(folderPath)) {
+      return NextResponse.json({ error: 'Folder already exists' }, { status: 400 })
+    }
+
+    fs.mkdirSync(folderPath, { recursive: true })
+
+    return NextResponse.json({
+      success: true,
+      path: path.join(parentPath, folderName).replace(/\\/g, '/')
+    })
+  } catch (error) {
+    console.error('Error creating folder:', error)
+    return NextResponse.json(
+      { error: 'Failed to create folder' },
+      { status: 500 }
+    )
+  }
+}
+
+// Delete file endpoint
+export async function DELETE(request: NextRequest) {
+  try {
+    const searchParams = request.nextUrl.searchParams
+    const filePath = searchParams.get('path')
+
+    if (!filePath) {
+      return NextResponse.json({ error: 'File path required' }, { status: 400 })
+    }
+
+    const fullPath = path.join(DOCS_DIR, filePath)
+
+    // Security check
+    if (!fullPath.startsWith(DOCS_DIR)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
+    }
+
+    if (!fs.existsSync(fullPath)) {
+      return NextResponse.json({ error: 'File not found' }, { status: 404 })
+    }
+
+    // Move to trash instead of permanent delete
+    const trashDir = path.join(DATA_DIR, '.trash')
+    if (!fs.existsSync(trashDir)) {
+      fs.mkdirSync(trashDir, { recursive: true })
+    }
+
+    const timestamp = Date.now()
+    const trashPath = path.join(trashDir, `${timestamp}_${path.basename(filePath)}`)
+    fs.renameSync(fullPath, trashPath)
+
+    return NextResponse.json({
+      success: true,
+      message: 'File moved to trash'
+    })
+  } catch (error) {
+    console.error('Error deleting file:', error)
+    return NextResponse.json(
+      { error: 'Failed to delete file' },
+      { status: 500 }
+    )
+  }
+}
\ No newline at end of file
diff --git a/app/api/gemini/chat/route.ts b/app/api/gemini/chat/route.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7bf9f537a0939a2b404562a59974f7e76f597d16
--- /dev/null
+++ b/app/api/gemini/chat/route.ts
@@ -0,0 +1,113 @@
+import { NextRequest, NextResponse } from 'next/server'
+
+const GEMINI_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent'
+const GEMINI_API_KEY = process.env.GEMINI_API_KEY
+
+export async function POST(request: NextRequest) {
+  try {
+    const { message, imageUrl, history, generateImage } = await request.json()
+
+    if (!GEMINI_API_KEY) {
+      return NextResponse.json(
+        { error: 'Gemini API key not configured on server. Please set GEMINI_API_KEY environment variable.' },
+        { status: 500 }
+      )
+    }
+
+    // For image generation requests
+    if (generateImage) {
+      // Note: Gemini doesn't directly generate images, but we can use a prompt to describe what an image should contain
+      // You would typically integrate with an image generation service like Stable Diffusion or DALL-E here
+      return NextResponse.json({
+        response: `I can describe the image for you: "${message}". For actual image generation, you would need to integrate with services like DALL-E or Stable Diffusion.`,
+        imageDescription: message,
+        note: 'Image generation requires integration with specialized services.'
+      })
+    }
+
+    // Prepare the request body for Gemini API
+    const requestBody: any = {
+      contents: [],
+      generationConfig: {
+        temperature: 0.9,
+        topK: 1,
+        topP: 1,
+        maxOutputTokens: 2048,
+      }
+    }
+
+    // Add conversation history if available
+    if (history && history.length > 0) {
+      history.forEach((msg: any) => {
+        requestBody.contents.push({
+          role: msg.role === 'user' ? 'user' : 'model',
+          parts: [{ text: msg.content }]
+        })
+      })
+    }
+
+    // Prepare the current message
+    const parts: any[] = []
+
+    if (message) {
+      parts.push({ text: message })
+    }
+
+    if (imageUrl) {
+      // Extract base64 data from data URL
+      const base64Data = imageUrl.split(',')[1]
+      parts.push({
+        inline_data: {
+          mime_type: imageUrl.split(':')[1].split(';')[0],
+          data: base64Data
+        }
+      })
+    }
+
+    requestBody.contents.push({
+      role: 'user',
+      parts: parts
+    })
+
+    // Make request to Gemini API
+    const response = await fetch(`${GEMINI_API_URL}?key=${GEMINI_API_KEY}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(requestBody)
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      console.error('Gemini API error:', errorText)
+      return NextResponse.json(
+        { error: 'Failed to get response from Gemini', details: errorText },
+        { status: response.status }
+      )
+    }
+
+    const data = await response.json()
+
+    if (!data.candidates || data.candidates.length === 0) {
+      return NextResponse.json(
+        { error: 'No response generated' },
+        { status: 500 }
+      )
+    }
+
+    const generatedText = data.candidates[0].content.parts[0].text
+
+    return NextResponse.json({
+      response: generatedText
+    })
+
+  } catch (error) {
+    console.error('Error in Gemini chat API:', error)
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred'
+    return NextResponse.json(
+      { error: 'Failed to process request', details: errorMessage },
+      { status: 500 }
+    )
+  }
+}
\ No newline at end of file
diff --git a/app/api/gemini/transcribe/route.ts b/app/api/gemini/transcribe/route.ts
new file mode 100644
index 0000000000000000000000000000000000000000..57c06f26a0f2c3be94dc8ebb1bb651b77276d62a
--- /dev/null
+++ b/app/api/gemini/transcribe/route.ts
@@ -0,0 +1,94 @@
+import { NextRequest, NextResponse } from 'next/server'
+
+// Note: For audio transcription, we'll use Gemini's multimodal capabilities
+// In production, you might want to use Google Cloud Speech-to-Text API for better accuracy
+
+export async function POST(request: NextRequest) {
+  try {
+    const formData = await request.formData()
+    const audioFile = formData.get('audio') as File
+    const apiKey = formData.get('apiKey') as string
+
+    if (!apiKey) {
+      return NextResponse.json(
+        { error: 'API key is required' },
+        { status: 400 }
+      )
+    }
+
+    if (!audioFile) {
+      return NextResponse.json(
+        { error: 'Audio file is required' },
+        { status: 400 }
+      )
+    }
+
+    // Convert audio file to base64
+    const bytes = await audioFile.arrayBuffer()
+    const buffer = Buffer.from(bytes)
+    const base64Audio = buffer.toString('base64')
+
+    // Use Gemini API to transcribe
+    // Note: Gemini 1.5 Pro supports audio, but Flash might have limitations
+    const GEMINI_API_URL = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent'
+
+    const requestBody = {
+      contents: [{
+        role: 'user',
+        parts: [
+          {
+            text: 'Please transcribe the following audio accurately. Only return the transcription text, nothing else.'
+          },
+          {
+            inline_data: {
+              mime_type: audioFile.type || 'audio/wav',
+              data: base64Audio
+            }
+          }
+        ]
+      }],
+      generationConfig: {
+        temperature: 0.1,
+        topK: 1,
+        topP: 1,
+        maxOutputTokens: 2048,
+      }
+    }
+
+    const response = await fetch(`${GEMINI_API_URL}?key=${apiKey}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(requestBody)
+    })
+
+    if (!response.ok) {
+      const error = await response.json()
+
+      // If Gemini doesn't support audio, provide alternative solution
+      if (error.error?.message?.includes('audio') || error.error?.message?.includes('unsupported')) {
+        return NextResponse.json({
+          transcription: '[Audio transcription requires Gemini 1.5 Pro or Google Cloud Speech-to-Text API. Please upgrade your API access or use the chat feature with text input.]',
+          warning: 'Audio transcription not fully supported with current model'
+        })
+      }
+
+      throw new Error(error.error?.message || 'Failed to transcribe audio')
+    }
+
+    const data = await response.json()
+    const transcription = data.candidates?.[0]?.content?.parts?.[0]?.text || 'Could not transcribe audio'
+
+    return NextResponse.json({ transcription })
+
+  } catch (error) {
+    console.error('Transcription error:', error)
+
+    // Provide a helpful fallback message
+    return NextResponse.json({
+      transcription: '',
+      error: error instanceof Error ? error.message : 'Transcription failed. Note: Audio transcription requires Gemini 1.5 Pro or a dedicated speech-to-text API.'
+    }, { status: 500 })
+  }
+}
\ No newline at end of file
diff --git a/app/api/public/route.ts b/app/api/public/route.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ed5f7ac5629b96597c6ac39a8707341704459bbe
--- /dev/null
+++ b/app/api/public/route.ts
@@ -0,0 +1,178 @@
+import { NextRequest, NextResponse } from 'next/server'
+import fs from 'fs'
+import path from 'path'
+
+const DATA_DIR = path.join(process.cwd(), 'data')
+const PUBLIC_DIR = path.join(DATA_DIR, 'public')
+
+// Ensure public directory exists
+if (!fs.existsSync(PUBLIC_DIR)) {
+  fs.mkdirSync(PUBLIC_DIR, { recursive: true })
+}
+
+interface FileItem {
+  name: string
+  type: 'file' | 'folder'
+  size?: number
+  modified?: string
+  path: string
+  extension?: string
+  uploadedBy?: string
+  uploadedAt?: string
+}
+
+function getFileExtension(filename: string): string {
+  const ext = path.extname(filename).toLowerCase()
+  return ext.startsWith('.') ? ext.substring(1) : ext
+}
+
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams
+  const folder = searchParams.get('folder') || ''
+
+  try {
+    const targetDir = path.join(PUBLIC_DIR, folder)
+
+    // Security check - prevent directory traversal
+    if (!targetDir.startsWith(PUBLIC_DIR)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
+    }
+
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true })
+    }
+
+    const files: FileItem[] = []
+    const items = fs.readdirSync(targetDir)
+
+    for (const item of items) {
+      // Skip hidden files
+      if (item.startsWith('.')) continue
+
+      const fullPath = path.join(targetDir, item)
+      const relativePath = path.join(folder, item).replace(/\\/g, '/')
+      const stats = fs.statSync(fullPath)
+
+      if (stats.isDirectory()) {
+        files.push({
+          name: item,
+          type: 'folder',
+          path: relativePath,
+          modified: stats.mtime.toISOString()
+        })
+      } else {
+        // Try to read metadata if it exists
+        const metadataPath = fullPath + '.meta.json'
+        let metadata: any = {}
+        if (fs.existsSync(metadataPath)) {
+          try {
+            metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'))
+          } catch (e) {
+            // Ignore metadata errors
+          }
+        }
+
+        files.push({
+          name: item,
+          type: 'file',
+          size: stats.size,
+          modified: stats.mtime.toISOString(),
+          path: relativePath,
+          extension: getFileExtension(item),
+          uploadedBy: metadata.uploadedBy || 'Anonymous',
+          uploadedAt: metadata.uploadedAt || stats.birthtime.toISOString()
+        })
+      }
+    }
+
+    return NextResponse.json({
+      files,
+      currentPath: folder,
+      isPublic: true
+    })
+  } catch (error) {
+    console.error('Error listing public files:', error)
+    return NextResponse.json(
+      { error: 'Failed to list public files' },
+      { status: 500 }
+    )
+  }
+}
+
+// Upload to public folder
+export async function POST(request: NextRequest) {
+  try {
+    const formData = await request.formData()
+    const file = formData.get('file') as File
+    const folder = formData.get('folder') as string || ''
+    const uploadedBy = formData.get('uploadedBy') as string || 'Anonymous'
+
+    if (!file) {
+      return NextResponse.json({ error: 'No file provided' }, { status: 400 })
+    }
+
+    const targetDir = path.join(PUBLIC_DIR, folder)
+
+    // Security check
+    if (!targetDir.startsWith(PUBLIC_DIR)) {
+      return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
+    }
+
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true })
+    }
+
+    const fileName = file.name
+    const filePath = path.join(targetDir, fileName)
+
+    // Check if file already exists
+    if (fs.existsSync(filePath)) {
+      // Add timestamp to filename
+      const timestamp = Date.now()
+      const ext = path.extname(fileName)
+      const baseName = path.basename(fileName, ext)
+      const newFileName = `${baseName}_${timestamp}${ext}`
+      const newFilePath = path.join(targetDir, newFileName)
+
+      const buffer = Buffer.from(await file.arrayBuffer())
+      fs.writeFileSync(newFilePath, buffer)
+
+      // Save metadata
+      const metadataPath = newFilePath + '.meta.json'
+      fs.writeFileSync(metadataPath, JSON.stringify({
+        uploadedBy,
+        uploadedAt: new Date().toISOString(),
+        originalName: fileName
+      }))
+
+      return NextResponse.json({
+        success: true,
+        message: 'File uploaded to public folder',
+        path: path.join(folder, newFileName).replace(/\\/g, '/'),
+        renamed: true
+      })
+    } else {
+      const buffer = Buffer.from(await file.arrayBuffer())
+      fs.writeFileSync(filePath, buffer)
+
+      // Save metadata
+      const metadataPath = filePath + '.meta.json'
+      fs.writeFileSync(metadataPath, JSON.stringify({
+        uploadedBy,
+        uploadedAt: new Date().toISOString()
+      }))
+
+      return NextResponse.json({
+        success: true,
+        message: 'File uploaded to public folder',
+        path: path.join(folder, fileName).replace(/\\/g, '/')
+      })
+    }
+  } catch (error) {
+    console.error('Error uploading to public folder:', error)
+    return NextResponse.json(
+      { error: 'Failed to upload file' },
+      { status: 500 }
+    )
+  }
+}
\ No newline at end of file
diff --git a/app/api/upload/route.ts b/app/api/upload/route.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1ec85c63c2bd96ae9eb94613b9fbb02a15f2602d
--- /dev/null
+++ b/app/api/upload/route.ts
@@ -0,0 +1,84 @@
+import { NextRequest, NextResponse } from 'next/server'
+import fs from 'fs'
+import path from 'path'
+
+const DATA_DIR = path.join(process.cwd(), 'data')
+const DOCS_DIR = path.join(DATA_DIR, 'documents')
+const MAX_FILE_SIZE = 50 * 1024 * 1024 // 50MB
+
+export async function POST(request: NextRequest) {
+  try {
+    const formData = await request.formData()
+    const file = formData.get('file') as File
+    const folderPath = formData.get('folder') as string || ''
+
+    if (!file) {
+      return NextResponse.json({ error: 'No file provided' }, { status: 400 })
+    }
+
+    // Check file size
+    if (file.size > MAX_FILE_SIZE) {
+      return NextResponse.json(
+        { error: `File size exceeds ${MAX_FILE_SIZE / 1024 / 1024}MB limit` },
+        { status: 400 }
+      )
+    }
+
+    // Sanitize filename
+    const fileName = file.name.replace(/[^a-zA-Z0-9._-]/g, '_')
+    const uploadDir = path.join(DOCS_DIR, folderPath)
+    const filePath = path.join(uploadDir, fileName)
+
+    // Security check
+    if (!filePath.startsWith(DOCS_DIR)) {
+      return NextResponse.json({ error: 'Invalid upload path' }, { status: 400 })
+    }
+
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(uploadDir)) {
+      fs.mkdirSync(uploadDir, { recursive: true })
+    }
+
+    // Check if file already exists
+    if (fs.existsSync(filePath)) {
+      // Add timestamp to filename if it exists
+      const timestamp = Date.now()
+      const ext = path.extname(fileName)
+      const baseName = path.basename(fileName, ext)
+      const newFileName = `${baseName}_${timestamp}${ext}`
+      const newFilePath = path.join(uploadDir, newFileName)
+
+      // Convert file to buffer and save
+      const bytes = await file.arrayBuffer()
+      const buffer = Buffer.from(bytes)
+      fs.writeFileSync(newFilePath, buffer)
+
+      return NextResponse.json({
+        success: true,
+        message: 'File uploaded (renamed due to conflict)',
+        fileName: newFileName,
+        path: path.join(folderPath, newFileName).replace(/\\/g, '/'),
+        size: file.size
+      })
+    }
+
+    // Convert file to buffer and save
+    const bytes = await file.arrayBuffer()
+    const buffer = Buffer.from(bytes)
+    fs.writeFileSync(filePath, buffer)
+
+    return NextResponse.json({
+      success: true,
+      message: 'File uploaded successfully',
+      fileName: fileName,
+      path: path.join(folderPath, fileName).replace(/\\/g, '/'),
+      size: file.size
+    })
+  } catch (error) {
+    console.error('Error uploading file:', error)
+    return NextResponse.json(
+      { error: 'Failed to upload file' },
+      { status: 500 }
+    )
+  }
+}
\ No newline at end of file
diff --git a/app/components/AboutModal.tsx b/app/components/AboutModal.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..4455f6de0c21a04f122f570470c177a4ab749e67
--- /dev/null
+++ b/app/components/AboutModal.tsx
@@ -0,0 +1,179 @@
+'use client'
+
+import React, { useEffect, useState } from 'react'
+import { X, Info, HardDrive, Cpu, Globe, Key } from '@phosphor-icons/react'
+import { motion, AnimatePresence } from 'framer-motion'
+
+interface AboutModalProps {
+  isOpen: boolean
+  onClose: () => void
+}
+
+export function AboutModal({ isOpen, onClose }: AboutModalProps) {
+  const [systemId, setSystemId] = useState<string>('')
+  const [publicPath, setPublicPath] = useState<string>('')
+  const [tempPath, setTempPath] = useState<string>('')
+
+  useEffect(() => {
+    // Generate unique system ID based on browser fingerprint
+    const generateSystemId = () => {
+      const nav = window.navigator
+      const screen = window.screen
+      const fingerprint = [
+        nav.userAgent,
+        nav.language,
+        screen.colorDepth,
+        screen.width,
+        screen.height,
+        new Date().getTimezoneOffset(),
+        nav.hardwareConcurrency,
+        nav.platform
+      ].join('|')
+
+      // Create a simple hash
+      let hash = 0
+      for (let i = 0; i < fingerprint.length; i++) {
+        const char = fingerprint.charCodeAt(i)
+        hash = ((hash << 5) - hash) + char
+        hash = hash & hash // Convert to 32-bit integer
+      }
+
+      // Convert to hex and make it look like a system ID
+      const hexHash = Math.abs(hash).toString(16).toUpperCase()
+      return `REUBEN-${hexHash.substring(0, 4)}-${hexHash.substring(4, 8)}-${Date.now().toString(36).toUpperCase()}`
+    }
+
+    // Set system paths
+    setSystemId(generateSystemId())
+    setPublicPath('E:\\mpc-hackathon\\public')
+    setTempPath(`E:\\mpc-hackathon\\data\\temp_${Date.now()}`)
+  }, [])
+
+  if (!isOpen) return null
+
+  return (
+    <AnimatePresence>
+      {isOpen && (
+        <>
+          <div className="fixed inset-0 bg-black/50 z-[100]" onClick={onClose} />
+          <motion.div
+            initial={{ scale: 0.9, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            exit={{ scale: 0.9, opacity: 0 }}
+            transition={{ duration: 0.2 }}
+            className="fixed top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 z-[101]"
+          >
+            <div className="bg-white rounded-2xl shadow-2xl p-8 min-w-[500px] max-w-[600px]">
+              {/* Logo and Title */}
+              <div className="text-center mb-6">
+                <div className="w-24 h-24 mx-auto mb-4 bg-gradient-to-br from-purple-600 to-blue-600 rounded-2xl flex items-center justify-center">
+                  <span className="text-white font-bold text-3xl">R</span>
+                </div>
+                <h1 className="text-3xl font-bold text-gray-900">Reuben OS</h1>
+                <p className="text-gray-500 mt-2">Advanced Desktop Environment</p>
+                <p className="text-sm text-gray-400 mt-1">Version 1.0.0</p>
+              </div>
+
+              {/* System Information */}
+              <div className="space-y-4 mb-6">
+                <div className="bg-gray-50 rounded-lg p-4">
+                  <div className="flex items-center mb-2">
+                    <Key className="text-purple-600 mr-2" size={20} weight="fill" />
+                    <span className="font-semibold text-gray-700">System ID</span>
+                  </div>
+                  <code className="text-xs bg-white px-2 py-1 rounded border border-gray-200 text-gray-600 font-mono block">
+                    {systemId || 'Generating...'}
+                  </code>
+                </div>
+
+                <div className="bg-gray-50 rounded-lg p-4">
+                  <div className="flex items-center mb-2">
+                    <HardDrive className="text-blue-600 mr-2" size={20} weight="fill" />
+                    <span className="font-semibold text-gray-700">Storage Paths</span>
+                  </div>
+                  <div className="space-y-2">
+                    <div>
+                      <span className="text-xs text-gray-500">Public:</span>
+                      <code className="text-xs bg-white px-2 py-1 rounded border border-gray-200 text-gray-600 font-mono block mt-1">
+                        {publicPath}
+                      </code>
+                    </div>
+                    <div>
+                      <span className="text-xs text-gray-500">Temp:</span>
+                      <code className="text-xs bg-white px-2 py-1 rounded border border-gray-200 text-gray-600 font-mono block mt-1">
+                        {tempPath}
+                      </code>
+                    </div>
+                  </div>
+                </div>
+
+                <div className="bg-gray-50 rounded-lg p-4">
+                  <div className="flex items-center mb-2">
+                    <Cpu className="text-green-600 mr-2" size={20} weight="fill" />
+                    <span className="font-semibold text-gray-700">Capabilities</span>
+                  </div>
+                  <div className="text-xs text-gray-600 space-y-1">
+                    <div className="flex items-center">
+                      <span className="w-2 h-2 bg-green-500 rounded-full mr-2"></span>
+                      Python Code Execution (via MCP)
+                    </div>
+                    <div className="flex items-center">
+                      <span className="w-2 h-2 bg-green-500 rounded-full mr-2"></span>
+                      HTML/CSS/JS Preview
+                    </div>
+                    <div className="flex items-center">
+                      <span className="w-2 h-2 bg-green-500 rounded-full mr-2"></span>
+                      File Management System
+                    </div>
+                    <div className="flex items-center">
+                      <span className="w-2 h-2 bg-green-500 rounded-full mr-2"></span>
+                      Claude AI Integration
+                    </div>
+                    <div className="flex items-center">
+                      <span className="w-2 h-2 bg-yellow-500 rounded-full mr-2"></span>
+                      Flutter/Dart (Coming Soon)
+                    </div>
+                  </div>
+                </div>
+
+                <div className="bg-gray-50 rounded-lg p-4">
+                  <div className="flex items-center mb-2">
+                    <Globe className="text-indigo-600 mr-2" size={20} weight="fill" />
+                    <span className="font-semibold text-gray-700">MCP Server</span>
+                  </div>
+                  <div className="text-xs text-gray-600">
+                    <div>Status: <span className="text-green-600 font-semibold">Connected</span></div>
+                    <div>Endpoint: <code className="font-mono">reuben-os</code></div>
+                    <div>Tools: 25+ available</div>
+                  </div>
+                </div>
+              </div>
+
+              {/* Footer */}
+              <div className="text-center text-xs text-gray-400 mb-4">
+                <p>© 2024 Reuben OS. All rights reserved.</p>
+                <p className="mt-1">Built with Next.js, React, and MCP Technology</p>
+              </div>
+
+              {/* Close Button */}
+              <button
+                onClick={onClose}
+                className="w-full bg-gradient-to-r from-purple-600 to-blue-600 text-white py-2 rounded-lg font-semibold hover:opacity-90 transition-opacity"
+              >
+                Close
+              </button>
+
+              {/* X button in corner */}
+              <button
+                onClick={onClose}
+                className="absolute top-4 right-4 text-gray-400 hover:text-gray-600 transition-colors"
+              >
+                <X size={20} weight="bold" />
+              </button>
+            </div>
+          </motion.div>
+        </>
+      )}
+    </AnimatePresence>
+  )
+}
\ No newline at end of file
diff --git a/app/components/BackgroundSelector.tsx b/app/components/BackgroundSelector.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..9dea81d5fb12d8a975d735282e3c8702d664a867
--- /dev/null
+++ b/app/components/BackgroundSelector.tsx
@@ -0,0 +1,217 @@
+'use client'
+
+import React, { useState, useRef } from 'react'
+import { motion, AnimatePresence } from 'framer-motion'
+import { X, Upload, Image, Check } from '@phosphor-icons/react'
+
+interface BackgroundSelectorProps {
+  isOpen: boolean
+  onClose: () => void
+  onSelectBackground: (background: string | File) => void
+  currentBackground: string
+}
+
+const presetBackgrounds = [
+  {
+    id: 'gradient-purple',
+    name: 'Ubuntu Purple',
+    style: 'linear-gradient(135deg, #77216F 0%, #5E2750 50%, #2C001E 100%)'
+  },
+  {
+    id: 'gradient-blue',
+    name: 'Ocean Blue',
+    style: 'linear-gradient(135deg, #1e3c72 0%, #2a5298 50%, #7e8ba3 100%)'
+  },
+  {
+    id: 'gradient-green',
+    name: 'Forest Green',
+    style: 'linear-gradient(135deg, #134e5e 0%, #71b280 50%, #a8e063 100%)'
+  },
+  {
+    id: 'gradient-orange',
+    name: 'Sunset Orange',
+    style: 'linear-gradient(135deg, #ff512f 0%, #dd2476 50%, #f09819 100%)'
+  },
+  {
+    id: 'gradient-dark',
+    name: 'Dark Mode',
+    style: 'linear-gradient(135deg, #0f0f0f 0%, #1a1a1a 50%, #2d2d2d 100%)'
+  },
+  {
+    id: 'gradient-cosmic',
+    name: 'Cosmic',
+    style: 'linear-gradient(135deg, #667eea 0%, #764ba2 50%, #f093fb 100%)'
+  }
+]
+
+export function BackgroundSelector({
+  isOpen,
+  onClose,
+  onSelectBackground,
+  currentBackground
+}: BackgroundSelectorProps) {
+  const [selectedTab, setSelectedTab] = useState<'presets' | 'upload'>('presets')
+  const [uploadedImage, setUploadedImage] = useState<string | null>(null)
+  const fileInputRef = useRef<HTMLInputElement>(null)
+
+  const handleFileUpload = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const file = event.target.files?.[0]
+    if (file) {
+      const reader = new FileReader()
+      reader.onload = (e) => {
+        const result = e.target?.result as string
+        setUploadedImage(result)
+        onSelectBackground(file)
+      }
+      reader.readAsDataURL(file)
+    }
+  }
+
+  return (
+    <AnimatePresence>
+      {isOpen && (
+        <>
+          {/* Backdrop */}
+          <motion.div
+            initial={{ opacity: 0 }}
+            animate={{ opacity: 1 }}
+            exit={{ opacity: 0 }}
+            onClick={onClose}
+            className="fixed inset-0 bg-black/50 backdrop-blur-sm z-50"
+          />
+
+          {/* Modal */}
+          <motion.div
+            initial={{ scale: 0.9, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            exit={{ scale: 0.9, opacity: 0 }}
+            transition={{ type: "spring", damping: 20, stiffness: 300 }}
+            className="fixed top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 w-[90%] max-w-2xl bg-[#2C2C2C]/95 backdrop-blur-md rounded-xl shadow-2xl z-50 border border-white/10"
+          >
+            {/* Header */}
+            <div className="flex items-center justify-between p-6 border-b border-white/10">
+              <h2 className="text-xl font-semibold text-white">Change Desktop Background</h2>
+              <button
+                onClick={onClose}
+                className="text-gray-400 hover:text-white transition-colors p-1 hover:bg-white/10 rounded-lg"
+              >
+                <X size={20} />
+              </button>
+            </div>
+
+            {/* Tabs */}
+            <div className="flex border-b border-white/10">
+              <button
+                onClick={() => setSelectedTab('presets')}
+                className={`flex-1 px-4 py-3 text-sm font-medium transition-colors ${
+                  selectedTab === 'presets'
+                    ? 'text-white border-b-2 border-blue-500'
+                    : 'text-gray-400 hover:text-white'
+                }`}
+              >
+                Gallery
+              </button>
+              <button
+                onClick={() => setSelectedTab('upload')}
+                className={`flex-1 px-4 py-3 text-sm font-medium transition-colors ${
+                  selectedTab === 'upload'
+                    ? 'text-white border-b-2 border-blue-500'
+                    : 'text-gray-400 hover:text-white'
+                }`}
+              >
+                Upload Image
+              </button>
+            </div>
+
+            {/* Content */}
+            <div className="p-6">
+              {selectedTab === 'presets' ? (
+                <div className="grid grid-cols-3 gap-4">
+                  {presetBackgrounds.map((bg) => (
+                    <button
+                      key={bg.id}
+                      onClick={() => onSelectBackground(bg.id)}
+                      className={`relative aspect-video rounded-lg overflow-hidden border-2 transition-all ${
+                        currentBackground === bg.id
+                          ? 'border-blue-500 scale-105'
+                          : 'border-white/20 hover:border-white/40'
+                      }`}
+                    >
+                      <div
+                        className="w-full h-full"
+                        style={{ background: bg.style }}
+                      />
+                      {currentBackground === bg.id && (
+                        <div className="absolute top-2 right-2 w-6 h-6 bg-blue-500 rounded-full flex items-center justify-center">
+                          <Check size={14} weight="bold" className="text-white" />
+                        </div>
+                      )}
+                      <div className="absolute bottom-0 left-0 right-0 bg-black/50 backdrop-blur-sm px-2 py-1">
+                        <span className="text-xs text-white">{bg.name}</span>
+                      </div>
+                    </button>
+                  ))}
+                </div>
+              ) : (
+                <div className="flex flex-col items-center justify-center py-12">
+                  <input
+                    ref={fileInputRef}
+                    type="file"
+                    accept="image/*"
+                    onChange={handleFileUpload}
+                    className="hidden"
+                  />
+
+                  {uploadedImage ? (
+                    <div className="relative w-full max-w-md">
+                      <img
+                        src={uploadedImage}
+                        alt="Uploaded background"
+                        className="w-full h-48 object-cover rounded-lg"
+                      />
+                      <button
+                        onClick={() => fileInputRef.current?.click()}
+                        className="mt-4 w-full px-4 py-2 bg-blue-500 hover:bg-blue-600 text-white rounded-lg transition-colors"
+                      >
+                        Choose Different Image
+                      </button>
+                    </div>
+                  ) : (
+                    <>
+                      <div
+                        onClick={() => fileInputRef.current?.click()}
+                        className="w-32 h-32 border-2 border-dashed border-white/30 rounded-lg flex flex-col items-center justify-center cursor-pointer hover:border-white/50 transition-colors"
+                      >
+                        <Upload size={32} className="text-gray-400 mb-2" />
+                        <span className="text-sm text-gray-400">Click to upload</span>
+                      </div>
+                      <p className="mt-4 text-sm text-gray-400">
+                        Supported formats: JPG, PNG, WEBP, GIF
+                      </p>
+                    </>
+                  )}
+                </div>
+              )}
+            </div>
+
+            {/* Footer */}
+            <div className="p-6 pt-0 flex gap-3 justify-end">
+              <button
+                onClick={onClose}
+                className="px-4 py-2 text-gray-300 hover:text-white transition-colors"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={onClose}
+                className="px-4 py-2 bg-gradient-to-r from-blue-500 to-purple-500 text-white rounded-lg font-medium hover:from-blue-600 hover:to-purple-600 transition-all"
+              >
+                Apply
+              </button>
+            </div>
+          </motion.div>
+        </>
+      )}
+    </AnimatePresence>
+  )
+}
\ No newline at end of file
diff --git a/app/components/Calendar.tsx b/app/components/Calendar.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..c3741c4db7a5008cfe3bf48eca9235d5e7045ccd
--- /dev/null
+++ b/app/components/Calendar.tsx
@@ -0,0 +1,301 @@
+'use client'
+
+import React, { useState } from 'react'
+import { X, Minus, Square, CaretLeft, CaretRight } from '@phosphor-icons/react'
+import { motion } from 'framer-motion'
+import { useKV } from '../hooks/useKV'
+
+interface CalendarProps {
+  onClose: () => void
+}
+
+interface Event {
+  id: string
+  date: string
+  title: string
+  type: 'holiday' | 'custom'
+}
+
+const defaultHolidays: Event[] = [
+  { id: '1', date: '2025-01-01', title: 'New Year\'s Day', type: 'holiday' },
+  { id: '2', date: '2025-02-14', title: 'Valentine\'s Day', type: 'holiday' },
+  { id: '3', date: '2025-03-17', title: 'St. Patrick\'s Day', type: 'holiday' },
+  { id: '4', date: '2025-04-20', title: 'Easter Sunday', type: 'holiday' },
+  { id: '5', date: '2025-05-11', title: 'Mother\'s Day', type: 'holiday' },
+  { id: '6', date: '2025-06-15', title: 'Father\'s Day', type: 'holiday' },
+  { id: '7', date: '2025-07-04', title: 'Independence Day', type: 'holiday' },
+  { id: '8', date: '2025-10-31', title: 'Halloween', type: 'holiday' },
+  { id: '9', date: '2025-11-27', title: 'Thanksgiving', type: 'holiday' },
+  { id: '10', date: '2025-12-25', title: 'Christmas Day', type: 'holiday' },
+  { id: '11', date: '2025-12-31', title: 'New Year\'s Eve', type: 'holiday' },
+]
+
+export function Calendar({ onClose }: CalendarProps) {
+  const [currentDate, setCurrentDate] = useState(new Date())
+  const [windowPos, setWindowPos] = useState({ x: 100, y: 100 })
+  const [isDragging, setIsDragging] = useState(false)
+  const [dragStart, setDragStart] = useState({ x: 0, y: 0 })
+  const [events, setEvents] = useKV<Event[]>('calendar-events', defaultHolidays)
+  const [selectedDay, setSelectedDay] = useState<number | null>(null)
+
+  const handleMouseDown = (e: React.MouseEvent) => {
+    if ((e.target as HTMLElement).closest('.window-controls')) return
+    setIsDragging(true)
+    setDragStart({ x: e.clientX - windowPos.x, y: e.clientY - windowPos.y })
+  }
+
+  const handleMouseMove = (e: MouseEvent) => {
+    if (isDragging) {
+      setWindowPos({
+        x: e.clientX - dragStart.x,
+        y: e.clientY - dragStart.y,
+      })
+    }
+  }
+
+  const handleMouseUp = () => {
+    setIsDragging(false)
+  }
+
+  React.useEffect(() => {
+    if (isDragging) {
+      window.addEventListener('mousemove', handleMouseMove)
+      window.addEventListener('mouseup', handleMouseUp)
+      return () => {
+        window.removeEventListener('mousemove', handleMouseMove)
+        window.removeEventListener('mouseup', handleMouseUp)
+      }
+    }
+  }, [isDragging, dragStart])
+
+  const monthNames = [
+    'January', 'February', 'March', 'April', 'May', 'June',
+    'July', 'August', 'September', 'October', 'November', 'December'
+  ]
+
+  const daysOfWeek = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+
+  const getDaysInMonth = (date: Date) => {
+    const year = date.getFullYear()
+    const month = date.getMonth()
+    const firstDay = new Date(year, month, 1)
+    const lastDay = new Date(year, month + 1, 0)
+    const daysInMonth = lastDay.getDate()
+    const startingDayOfWeek = firstDay.getDay()
+
+    const days: (number | null)[] = []
+    for (let i = 0; i < startingDayOfWeek; i++) {
+      days.push(null)
+    }
+    for (let i = 1; i <= daysInMonth; i++) {
+      days.push(i)
+    }
+    return days
+  }
+
+  const days = getDaysInMonth(currentDate)
+  const today = new Date()
+  const isToday = (day: number | null) => {
+    if (!day) return false
+    return (
+      day === today.getDate() &&
+      currentDate.getMonth() === today.getMonth() &&
+      currentDate.getFullYear() === today.getFullYear()
+    )
+  }
+
+  const getEventsForDay = (day: number | null) => {
+    if (!day || !events) return []
+    const dateStr = `${currentDate.getFullYear()}-${String(currentDate.getMonth() + 1).padStart(2, '0')}-${String(day).padStart(2, '0')}`
+    return events.filter(event => event.date === dateStr)
+  }
+
+  const hasEvent = (day: number | null) => {
+    return getEventsForDay(day).length > 0
+  }
+
+  const previousMonth = () => {
+    setCurrentDate(new Date(currentDate.getFullYear(), currentDate.getMonth() - 1))
+    setSelectedDay(null)
+  }
+
+  const nextMonth = () => {
+    setCurrentDate(new Date(currentDate.getFullYear(), currentDate.getMonth() + 1))
+    setSelectedDay(null)
+  }
+
+  const handleDayClick = (day: number | null) => {
+    if (day) {
+      setSelectedDay(day)
+    }
+  }
+
+  const selectedDayEvents = selectedDay ? getEventsForDay(selectedDay) : []
+
+  return (
+    <motion.div
+      style={{ left: windowPos.x, top: windowPos.y }}
+      className="fixed w-[420px] bg-white rounded-lg shadow-2xl overflow-hidden flex flex-col z-30 select-none"
+    >
+      <div
+        onMouseDown={handleMouseDown}
+        className="h-11 bg-gradient-to-b from-[#f6f5f4] to-[#edebe9] border-b border-[#d0d0d0] flex items-center justify-between px-3 cursor-move"
+      >
+        <div className="flex items-center gap-2 flex-1">
+          <div className="flex items-center gap-1 window-controls">
+            <button
+              onClick={(e) => {
+                e.stopPropagation()
+                onClose()
+              }}
+              className="w-5 h-5 rounded-full bg-[#E95420] hover:bg-[#d14818] flex items-center justify-center group transition-colors"
+            >
+              <X size={12} weight="bold" className="text-white opacity-0 group-hover:opacity-100 transition-opacity" />
+            </button>
+            <button className="w-5 h-5 rounded-full bg-[#ddd] hover:bg-[#ccc] flex items-center justify-center group transition-colors">
+              <Minus size={12} weight="bold" className="text-[#666] opacity-0 group-hover:opacity-100 transition-opacity" />
+            </button>
+            <button className="w-5 h-5 rounded-full bg-[#ddd] hover:bg-[#ccc] flex items-center justify-center group transition-colors">
+              <Square size={10} weight="bold" className="text-[#666] opacity-0 group-hover:opacity-100 transition-opacity" />
+            </button>
+          </div>
+          <span className="text-sm font-medium text-[#2c2c2c] ml-2">Calendar</span>
+        </div>
+      </div>
+
+      <div className="p-6">
+        <div className="flex items-center justify-between mb-4">
+          <button
+            onClick={previousMonth}
+            className="p-2 hover:bg-[#f0f0f0] rounded"
+          >
+            <CaretLeft size={20} weight="bold" />
+          </button>
+          <div className="text-base font-semibold text-[#2c2c2c]">
+            {monthNames[currentDate.getMonth()]} {currentDate.getFullYear()}
+          </div>
+          <button
+            onClick={nextMonth}
+            className="p-2 hover:bg-[#f0f0f0] rounded"
+          >
+            <CaretRight size={20} weight="bold" />
+          </button>
+        </div>
+
+        <div className="grid grid-cols-7 gap-1 mb-2">
+          {daysOfWeek.map((day) => (
+            <div
+              key={day}
+              className="text-center text-xs font-medium text-[#666] py-1"
+            >
+              {day}
+            </div>
+          ))}
+        </div>
+
+        <div className="grid grid-cols-7 gap-1">
+          {days.map((day, index) => (
+            day ? (
+              <button
+                key={index}
+                onClick={() => handleDayClick(day)}
+                className={`
+                  aspect-square flex flex-col items-center justify-center text-sm rounded relative
+                  hover:bg-[#f0f0f0]
+                  ${isToday(day) ? 'bg-[#E95420] text-white hover:bg-[#d14818] font-bold' : 'text-[#2c2c2c]'}
+                  ${selectedDay === day && !isToday(day) ? 'bg-[#f0f0f0] ring-2 ring-[#E95420]' : ''}
+                `}
+              >
+                <span>{day}</span>
+                {hasEvent(day) && (
+                  <div className="absolute bottom-1 flex gap-0.5">
+                    {getEventsForDay(day).slice(0, 3).map((event, i) => (
+                      <div
+                        key={i}
+                        className={`w-1 h-1 rounded-full ${
+                          event.type === 'holiday'
+                            ? isToday(day) ? 'bg-white' : 'bg-purple-500'
+                            : isToday(day) ? 'bg-white' : 'bg-blue-500'
+                        }`}
+                      />
+                    ))}
+                  </div>
+                )}
+              </button>
+            ) : (
+              <div
+                key={index}
+                className="aspect-square"
+              />
+            )
+          ))}
+        </div>
+
+        {selectedDayEvents.length > 0 && (
+          <div className="mt-4 pt-4 border-t border-[#e0e0e0]">
+            <div className="text-xs text-[#666] mb-2">
+              {monthNames[currentDate.getMonth()]} {selectedDay}, {currentDate.getFullYear()}
+            </div>
+            <div className="space-y-2 max-h-32 overflow-y-auto">
+              {selectedDayEvents.map((event) => (
+                <div
+                  key={event.id}
+                  className="flex items-start gap-2 p-2 bg-[#f9f9f9] rounded"
+                >
+                  <div
+                    className={`w-2 h-2 rounded-full mt-1.5 flex-shrink-0 ${
+                      event.type === 'holiday' ? 'bg-purple-500' : 'bg-blue-500'
+                    }`}
+                  />
+                  <div className="flex-1">
+                    <div className="text-sm font-medium text-[#2c2c2c]">
+                      {event.title}
+                    </div>
+                    <div className="text-xs text-[#666]">
+                      {event.type === 'holiday' ? 'Holiday' : 'Event'}
+                    </div>
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {!selectedDay && (
+          <div className="mt-4 pt-4 border-t border-[#e0e0e0]">
+            <div className="text-xs text-[#666] mb-2">Today</div>
+            <div className="text-sm font-medium text-[#2c2c2c]">
+              {today.toLocaleDateString('en-US', { 
+                weekday: 'long', 
+                year: 'numeric', 
+                month: 'long', 
+                day: 'numeric' 
+              })}
+            </div>
+            {getEventsForDay(today.getDate()).length > 0 && (
+              <div className="mt-3 space-y-2">
+                {getEventsForDay(today.getDate()).map((event) => (
+                  <div
+                    key={event.id}
+                    className="flex items-start gap-2 p-2 bg-[#fff3e6] rounded"
+                  >
+                    <div
+                      className={`w-2 h-2 rounded-full mt-1.5 flex-shrink-0 ${
+                        event.type === 'holiday' ? 'bg-purple-500' : 'bg-blue-500'
+                      }`}
+                    />
+                    <div className="flex-1">
+                      <div className="text-sm font-medium text-[#2c2c2c]">
+                        {event.title}
+                      </div>
+                    </div>
+                  </div>
+                ))}
+              </div>
+            )}
+          </div>
+        )}
+      </div>
+    </motion.div>
+  )
+}
diff --git a/app/components/ClaudeIntegration.tsx b/app/components/ClaudeIntegration.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..31ebf891365efe0019885b09e5b7a66010e40ce3
--- /dev/null
+++ b/app/components/ClaudeIntegration.tsx
@@ -0,0 +1,240 @@
+'use client'
+
+import React, { useState } from 'react'
+import { motion } from 'framer-motion'
+import {
+  Upload,
+  Robot,
+  FileText,
+  CheckCircle,
+  Warning,
+  Info,
+  Copy,
+  Download
+} from '@phosphor-icons/react'
+
+interface ClaudeIntegrationProps {
+  file: File | null
+  onClose: () => void
+}
+
+export function ClaudeIntegration({ file, onClose }: ClaudeIntegrationProps) {
+  const [uploadMethod, setUploadMethod] = useState<'direct' | 'chunked' | 'reference'>('direct')
+  const [processing, setProcessing] = useState(false)
+  const [result, setResult] = useState<string>('')
+
+  const handleProcess = async () => {
+    if (!file) return
+
+    setProcessing(true)
+
+    try {
+      if (uploadMethod === 'direct') {
+        // Direct upload - best for small files < 1MB
+        const content = await file.text()
+        setResult(`File: ${file.name}\n\nContent:\n${content}`)
+      } else if (uploadMethod === 'chunked') {
+        // Chunked upload - for larger files, split into manageable chunks
+        const CHUNK_SIZE = 50000 // 50KB chunks
+        const content = await file.text()
+        const chunks = []
+
+        for (let i = 0; i < content.length; i += CHUNK_SIZE) {
+          chunks.push(content.slice(i, i + CHUNK_SIZE))
+        }
+
+        setResult(
+          `File: ${file.name}\n` +
+          `Total chunks: ${chunks.length}\n` +
+          `Chunk size: ${CHUNK_SIZE} characters\n\n` +
+          `Instructions for Claude:\n` +
+          `This file has been split into ${chunks.length} chunks.\n` +
+          `You can process each chunk sequentially.\n\n` +
+          `First chunk:\n${chunks[0].slice(0, 500)}...`
+        )
+      } else {
+        // Reference method - store file and provide reference
+        setResult(
+          `File Reference Created:\n` +
+          `Name: ${file.name}\n` +
+          `Size: ${formatFileSize(file.size)}\n` +
+          `Type: ${file.type}\n\n` +
+          `This file has been stored in the system.\n` +
+          `You can reference it by name in your conversation with Claude.\n` +
+          `Claude can access and analyze the file content when needed.`
+        )
+      }
+    } catch (error) {
+      console.error('Error processing file:', error)
+      setResult('Error processing file')
+    } finally {
+      setProcessing(false)
+    }
+  }
+
+  const formatFileSize = (bytes: number) => {
+    const units = ['B', 'KB', 'MB', 'GB']
+    let size = bytes
+    let unitIndex = 0
+
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024
+      unitIndex++
+    }
+
+    return `${size.toFixed(2)} ${units[unitIndex]}`
+  }
+
+  const copyToClipboard = () => {
+    navigator.clipboard.writeText(result)
+  }
+
+  return (
+    <motion.div
+      initial={{ opacity: 0, y: 20 }}
+      animate={{ opacity: 1, y: 0 }}
+      className="fixed inset-0 bg-black/50 backdrop-blur-sm z-50 flex items-center justify-center p-4"
+      onClick={onClose}
+    >
+      <motion.div
+        initial={{ scale: 0.9 }}
+        animate={{ scale: 1 }}
+        className="bg-[#2C2C2C]/95 backdrop-blur-md rounded-xl shadow-2xl max-w-2xl w-full max-h-[80vh] overflow-hidden border border-white/10"
+        onClick={(e) => e.stopPropagation()}
+      >
+        {/* Header */}
+        <div className="p-6 border-b border-white/10">
+          <div className="flex items-center gap-3">
+            <Robot size={24} className="text-blue-400" />
+            <h2 className="text-xl font-semibold text-white">Claude Integration</h2>
+          </div>
+          <p className="text-sm text-gray-400 mt-2">
+            Optimize file upload for Claude to preserve context
+          </p>
+        </div>
+
+        {/* Content */}
+        <div className="p-6 space-y-4 max-h-[60vh] overflow-y-auto">
+          {file && (
+            <div className="bg-white/5 rounded-lg p-4">
+              <div className="flex items-center gap-3">
+                <FileText size={24} className="text-gray-400" />
+                <div>
+                  <p className="text-white font-medium">{file.name}</p>
+                  <p className="text-sm text-gray-400">{formatFileSize(file.size)}</p>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Upload Methods */}
+          <div className="space-y-3">
+            <h3 className="text-sm font-medium text-gray-300 uppercase tracking-wider">
+              Upload Method
+            </h3>
+
+            <label className="flex items-start gap-3 p-3 rounded-lg border border-white/10 hover:border-white/20 cursor-pointer transition-colors">
+              <input
+                type="radio"
+                value="direct"
+                checked={uploadMethod === 'direct'}
+                onChange={(e) => setUploadMethod(e.target.value as any)}
+                className="mt-1"
+              />
+              <div>
+                <p className="text-white font-medium">Direct Upload</p>
+                <p className="text-xs text-gray-400">
+                  Best for small files (&lt; 1MB). Uploads entire content at once.
+                </p>
+              </div>
+            </label>
+
+            <label className="flex items-start gap-3 p-3 rounded-lg border border-white/10 hover:border-white/20 cursor-pointer transition-colors">
+              <input
+                type="radio"
+                value="chunked"
+                checked={uploadMethod === 'chunked'}
+                onChange={(e) => setUploadMethod(e.target.value as any)}
+                className="mt-1"
+              />
+              <div>
+                <p className="text-white font-medium">Chunked Upload</p>
+                <p className="text-xs text-gray-400">
+                  For larger files. Splits content into manageable chunks.
+                </p>
+              </div>
+            </label>
+
+            <label className="flex items-start gap-3 p-3 rounded-lg border border-white/10 hover:border-white/20 cursor-pointer transition-colors">
+              <input
+                type="radio"
+                value="reference"
+                checked={uploadMethod === 'reference'}
+                onChange={(e) => setUploadMethod(e.target.value as any)}
+                className="mt-1"
+              />
+              <div>
+                <p className="text-white font-medium">Reference Method</p>
+                <p className="text-xs text-gray-400">
+                  Store file and provide reference. Claude accesses when needed.
+                </p>
+              </div>
+            </label>
+          </div>
+
+          {/* Info Box */}
+          <div className="bg-blue-500/10 border border-blue-500/20 rounded-lg p-4 flex gap-3">
+            <Info size={20} className="text-blue-400 flex-shrink-0 mt-0.5" />
+            <div className="text-sm text-gray-300">
+              <p className="font-medium mb-1">Context Preservation Tips:</p>
+              <ul className="space-y-1 text-xs text-gray-400">
+                <li>• Use direct upload for code files and short documents</li>
+                <li>• Use chunked upload for large documents or datasets</li>
+                <li>• Use reference method for binary files or archives</li>
+              </ul>
+            </div>
+          </div>
+
+          {/* Result */}
+          {result && (
+            <div className="bg-green-500/10 border border-green-500/20 rounded-lg p-4">
+              <div className="flex items-center justify-between mb-2">
+                <div className="flex items-center gap-2">
+                  <CheckCircle size={20} className="text-green-400" />
+                  <span className="text-sm font-medium text-green-400">Ready for Claude</span>
+                </div>
+                <button
+                  onClick={copyToClipboard}
+                  className="text-gray-400 hover:text-white transition-colors p-1"
+                  title="Copy to clipboard"
+                >
+                  <Copy size={18} />
+                </button>
+              </div>
+              <pre className="text-xs text-gray-300 whitespace-pre-wrap font-mono max-h-40 overflow-y-auto">
+                {result}
+              </pre>
+            </div>
+          )}
+        </div>
+
+        {/* Footer */}
+        <div className="p-6 pt-0 flex gap-3 justify-end">
+          <button
+            onClick={onClose}
+            className="px-4 py-2 text-gray-300 hover:text-white transition-colors"
+          >
+            Cancel
+          </button>
+          <button
+            onClick={handleProcess}
+            disabled={!file || processing}
+            className="px-4 py-2 bg-gradient-to-r from-blue-500 to-purple-500 text-white rounded-lg font-medium hover:from-blue-600 hover:to-purple-600 transition-all disabled:opacity-50"
+          >
+            {processing ? 'Processing...' : 'Process File'}
+          </button>
+        </div>
+      </motion.div>
+    </motion.div>
+  )
+}
\ No newline at end of file
diff --git a/app/components/Clock.tsx b/app/components/Clock.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..65e82c46840e1142bc8c636e40619de995cb1c14
--- /dev/null
+++ b/app/components/Clock.tsx
@@ -0,0 +1,188 @@
+'use client'
+
+import React, { useState, useEffect } from 'react'
+import Window from './Window'
+
+interface ClockProps {
+  onClose: () => void
+}
+
+export function Clock({ onClose }: ClockProps) {
+  const [time, setTime] = useState(new Date())
+  const [viewMode, setViewMode] = useState<'analog' | 'digital' | 'world'>('analog')
+
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setTime(new Date())
+    }, 1000)
+
+    return () => clearInterval(timer)
+  }, [])
+
+  // Calculate rotation angles for clock hands
+  const seconds = time.getSeconds()
+  const minutes = time.getMinutes()
+  const hours = time.getHours()
+
+  const secondDegrees = (seconds / 60) * 360 - 90
+  const minuteDegrees = ((minutes / 60) * 360) + ((seconds / 60) * 6) - 90
+  const hourDegrees = ((hours % 12 / 12) * 360) + ((minutes / 60) * 30) - 90
+
+  const worldClocks = [
+    { city: 'New York', offset: -5 },
+    { city: 'London', offset: 0 },
+    { city: 'Tokyo', offset: 9 },
+    { city: 'Sydney', offset: 11 }
+  ]
+
+  const getWorldTime = (offset: number) => {
+    const utc = time.getTime() + (time.getTimezoneOffset() * 60000)
+    const cityTime = new Date(utc + (3600000 * offset))
+    return cityTime.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit' })
+  }
+
+  return (
+    <Window
+      id="clock"
+      title="Clock"
+      isOpen={true}
+      onClose={onClose}
+      width={380}
+      height={480}
+      x={window.innerWidth / 2 - 190}
+      y={window.innerHeight / 2 - 240}
+      darkMode={true}
+      className="clock-app-window"
+    >
+      <div className="flex flex-col h-full bg-gradient-to-b from-gray-900 via-gray-800 to-black">
+        {/* Tab Bar */}
+        <div className="flex border-b border-gray-700 bg-gray-900/50">
+          <button
+            onClick={() => setViewMode('analog')}
+            className={`flex-1 py-3 text-sm font-medium transition-all ${
+              viewMode === 'analog'
+                ? 'text-orange-400 border-b-2 border-orange-400'
+                : 'text-gray-400 hover:text-white'
+            }`}
+          >
+            Analog
+          </button>
+          <button
+            onClick={() => setViewMode('digital')}
+            className={`flex-1 py-3 text-sm font-medium transition-all ${
+              viewMode === 'digital'
+                ? 'text-orange-400 border-b-2 border-orange-400'
+                : 'text-gray-400 hover:text-white'
+            }`}
+          >
+            Digital
+          </button>
+          <button
+            onClick={() => setViewMode('world')}
+            className={`flex-1 py-3 text-sm font-medium transition-all ${
+              viewMode === 'world'
+                ? 'text-orange-400 border-b-2 border-orange-400'
+                : 'text-gray-400 hover:text-white'
+            }`}
+          >
+            World Clock
+          </button>
+        </div>
+
+        {/* Clock Display */}
+        <div className="flex-1 flex items-center justify-center p-6">
+          {viewMode === 'analog' && (
+            <div className="flex flex-col items-center">
+              <div className="relative w-64 h-64">
+                {/* Clock Face */}
+                <div className="absolute inset-0 rounded-full bg-gradient-to-br from-gray-800 to-black shadow-inner border-4 border-gray-700">
+                  {/* Hour Markers */}
+                  {[...Array(12)].map((_, i) => (
+                    <div key={i}>
+                      <div
+                        className="absolute bg-white"
+                        style={{
+                          width: i % 3 === 0 ? '3px' : '1px',
+                          height: i % 3 === 0 ? '12px' : '8px',
+                          top: '10px',
+                          left: '50%',
+                          transform: `translateX(-50%) rotate(${i * 30}deg)`,
+                          transformOrigin: '50% 118px'
+                        }}
+                      />
+                    </div>
+                  ))}
+
+                  {/* Clock Hands */}
+                  <div
+                    className="absolute top-1/2 left-1/2 w-2 h-20 bg-white rounded-full origin-bottom shadow-lg"
+                    style={{
+                      transform: `translate(-50%, -100%) rotate(${hourDegrees}deg)`
+                    }}
+                  />
+                  <div
+                    className="absolute top-1/2 left-1/2 w-1.5 h-28 bg-gray-300 rounded-full origin-bottom shadow-lg"
+                    style={{
+                      transform: `translate(-50%, -100%) rotate(${minuteDegrees}deg)`
+                    }}
+                  />
+                  <div
+                    className="absolute top-1/2 left-1/2 w-0.5 h-32 bg-orange-500 rounded-full origin-bottom"
+                    style={{
+                      transform: `translate(-50%, -100%) rotate(${secondDegrees}deg)`
+                    }}
+                  />
+
+                  {/* Center Dot */}
+                  <div className="absolute top-1/2 left-1/2 w-4 h-4 bg-orange-500 rounded-full transform -translate-x-1/2 -translate-y-1/2 shadow-lg z-10" />
+                </div>
+              </div>
+
+              {/* Digital Time Below Analog Clock */}
+              <div className="mt-6 text-center">
+                <div className="text-2xl font-mono text-gray-300">
+                  {time.toLocaleTimeString()}
+                </div>
+                <div className="text-sm text-gray-500 mt-2">
+                  {time.toLocaleDateString('en-US', { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' })}
+                </div>
+              </div>
+            </div>
+          )}
+
+          {viewMode === 'digital' && (
+            <div className="text-center">
+              <div className="text-7xl font-mono font-bold text-transparent bg-clip-text bg-gradient-to-r from-orange-400 to-orange-600">
+                {time.toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', second: '2-digit' })}
+              </div>
+              <div className="mt-8 text-2xl text-gray-400">
+                {time.toLocaleDateString('en-US', { weekday: 'long' })}
+              </div>
+              <div className="text-lg text-gray-500">
+                {time.toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' })}
+              </div>
+            </div>
+          )}
+
+          {viewMode === 'world' && (
+            <div className="w-full max-w-sm">
+              <div className="space-y-4">
+                {worldClocks.map((clock) => (
+                  <div key={clock.city} className="bg-gray-800 rounded-lg p-4 flex justify-between items-center">
+                    <div>
+                      <div className="text-white font-medium">{clock.city}</div>
+                      <div className="text-xs text-gray-400">UTC{clock.offset >= 0 ? '+' : ''}{clock.offset}</div>
+                    </div>
+                    <div className="text-2xl font-mono text-orange-400">
+                      {getWorldTime(clock.offset)}
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+        </div>
+      </div>
+    </Window>
+  )
+}
\ No newline at end of file
diff --git a/app/components/CodeExecutor.tsx b/app/components/CodeExecutor.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..957b31d1ff33a6a22a43d44756b84044eb851fb0
--- /dev/null
+++ b/app/components/CodeExecutor.tsx
@@ -0,0 +1,306 @@
+'use client'
+
+import React, { useState } from 'react'
+import Window from './Window'
+import Editor from '@monaco-editor/react'
+import {
+  Play,
+  Code,
+  FileText,
+  Download,
+  Copy,
+  CheckCircle,
+  Warning,
+  CloudArrowUp
+} from '@phosphor-icons/react'
+
+interface CodeExecutorProps {
+  onClose: () => void
+  initialCode?: string
+  language?: string
+}
+
+export function CodeExecutor({ onClose, initialCode = '', language = 'python' }: CodeExecutorProps) {
+  const [code, setCode] = useState(initialCode || `# Reuben OS Code Executor
+# Write your Python code here and click Run to execute
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Create sample data
+x = np.linspace(0, 10, 100)
+y = np.sin(x)
+
+# Create plot
+plt.figure(figsize=(10, 6))
+plt.plot(x, y, 'b-', linewidth=2, label='sin(x)')
+plt.grid(True, alpha=0.3)
+plt.xlabel('X axis')
+plt.ylabel('Y axis')
+plt.title('Sample Plot in Reuben OS')
+plt.legend()
+
+# This will automatically save and display the plot
+plt.show()
+
+print("Plot generated successfully!")
+print(f"X range: {x[0]:.2f} to {x[-1]:.2f}")
+print(f"Y range: {y.min():.2f} to {y.max():.2f}")`)
+
+  const [output, setOutput] = useState('')
+  const [isRunning, setIsRunning] = useState(false)
+  const [error, setError] = useState('')
+  const [plotPath, setPlotPath] = useState('')
+  const [selectedLanguage, setSelectedLanguage] = useState(language)
+
+  const executeCode = async () => {
+    setIsRunning(true)
+    setOutput('')
+    setError('')
+    setPlotPath('')
+
+    try {
+      // Save code to file system first
+      const sessionId = `exec_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+      const saveResponse = await fetch('/api/code/save', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          sessionId,
+          code: [{
+            name: `script.${selectedLanguage === 'python' ? 'py' : selectedLanguage === 'javascript' ? 'js' : 'html'}`,
+            language: selectedLanguage,
+            content: code
+          }],
+          timestamp: Date.now()
+        })
+      })
+
+      if (!saveResponse.ok) {
+        throw new Error('Failed to save code')
+      }
+
+      // Execute based on language
+      if (selectedLanguage === 'python') {
+        // For Python, we need MCP to execute it
+        setOutput('Python code saved! Use MCP tools to execute:\n')
+        setOutput(prev => prev + `\nSession ID: ${sessionId}\n`)
+        setOutput(prev => prev + `\nFile saved to: data/vscode_sessions/${sessionId}/script.py\n`)
+        setOutput(prev => prev + '\n📝 Note: To execute Python code, use the MCP execute_python_code tool from Claude Desktop.')
+
+        // Show sample MCP command
+        setOutput(prev => prev + '\n\n💡 MCP Command Example:\n')
+        setOutput(prev => prev + 'execute_python_code(code=<your_code>, save_output=true)\n')
+
+        // If it's matplotlib code, suggest using execute_matplotlib_code
+        if (code.includes('matplotlib') || code.includes('plt.')) {
+          setOutput(prev => prev + '\n🎨 For matplotlib plots, use:\n')
+          setOutput(prev => prev + 'execute_matplotlib_code(code=<your_code>, output_format="png")')
+        }
+      } else if (selectedLanguage === 'html' || selectedLanguage === 'javascript') {
+        // For HTML/JS, we can execute in browser
+        executeWebCode()
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Unknown error occurred')
+    } finally {
+      setIsRunning(false)
+    }
+  }
+
+  const executeWebCode = () => {
+    if (selectedLanguage === 'html') {
+      // Create iframe for HTML preview
+      const iframe = document.createElement('iframe')
+      iframe.style.width = '100%'
+      iframe.style.height = '100%'
+      iframe.style.border = 'none'
+      iframe.srcdoc = code
+
+      const outputElement = document.getElementById('code-output')
+      if (outputElement) {
+        outputElement.innerHTML = ''
+        outputElement.appendChild(iframe)
+      }
+      setOutput('HTML rendered in preview pane')
+    } else if (selectedLanguage === 'javascript') {
+      // Execute JavaScript in sandboxed environment
+      try {
+        // Capture console.log outputs
+        const logs: string[] = []
+        const originalLog = console.log
+        console.log = (...args) => {
+          logs.push(args.map(arg => String(arg)).join(' '))
+        }
+
+        // Execute the code
+        const func = new Function(code)
+        const result = func()
+
+        // Restore console.log
+        console.log = originalLog
+
+        // Display output
+        let outputText = logs.join('\n')
+        if (result !== undefined) {
+          outputText += `\n\nReturn value: ${JSON.stringify(result, null, 2)}`
+        }
+        setOutput(outputText || 'Code executed successfully (no output)')
+      } catch (err) {
+        setError(err instanceof Error ? err.message : 'JavaScript execution error')
+      }
+    }
+  }
+
+  const copyOutput = () => {
+    navigator.clipboard.writeText(output || error)
+
+    // Show copied feedback
+    const copiedDiv = document.createElement('div')
+    copiedDiv.className = 'fixed bottom-4 right-4 bg-blue-600 text-white px-4 py-2 rounded-lg shadow-lg z-[200] flex items-center gap-2'
+    copiedDiv.innerHTML = '<svg class="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M9 2a1 1 0 000 2h2a1 1 0 100-2H9z"></path><path fill-rule="evenodd" d="M4 5a2 2 0 012-2 1 1 0 000 2H6a2 2 0 100 4h8a2 2 0 100-4 1 1 0 100-2 2 2 0 00-2 2H8a2 2 0 00-2-2z" clip-rule="evenodd"></path></svg> Copied!'
+    document.body.appendChild(copiedDiv)
+
+    setTimeout(() => {
+      copiedDiv.remove()
+    }, 2000)
+  }
+
+  return (
+    <Window
+      id="code-executor"
+      title="Code Executor - Reuben OS"
+      isOpen={true}
+      onClose={onClose}
+      width={1200}
+      height={700}
+      x={100}
+      y={50}
+      darkMode={true}
+    >
+      <div className="flex flex-col h-full bg-[#1e1e1e]">
+        {/* Header */}
+        <div className="flex items-center justify-between bg-[#2d2d2d] px-4 py-2 border-b border-[#3e3e3e]">
+          <div className="flex items-center gap-4">
+            <Code size={20} weight="bold" className="text-blue-400" />
+            <select
+              value={selectedLanguage}
+              onChange={(e) => setSelectedLanguage(e.target.value)}
+              className="bg-[#1e1e1e] text-white px-3 py-1 rounded border border-[#3e3e3e] text-sm"
+            >
+              <option value="python">Python</option>
+              <option value="javascript">JavaScript</option>
+              <option value="html">HTML</option>
+            </select>
+          </div>
+
+          <div className="flex items-center gap-2">
+            <button
+              onClick={executeCode}
+              disabled={isRunning}
+              className="px-4 py-1 bg-green-600 hover:bg-green-700 disabled:bg-gray-600 text-white rounded text-sm flex items-center gap-2"
+            >
+              <Play size={16} weight="fill" />
+              {isRunning ? 'Running...' : 'Run'}
+            </button>
+
+            <button
+              onClick={() => setCode('')}
+              className="px-3 py-1 bg-gray-600 hover:bg-gray-700 text-white rounded text-sm"
+            >
+              Clear
+            </button>
+          </div>
+        </div>
+
+        {/* Main Content */}
+        <div className="flex flex-1 overflow-hidden">
+          {/* Code Editor */}
+          <div className="w-1/2 border-r border-[#3e3e3e]">
+            <Editor
+              theme="vs-dark"
+              language={selectedLanguage}
+              value={code}
+              onChange={(value) => setCode(value || '')}
+              options={{
+                minimap: { enabled: false },
+                fontSize: 14,
+                lineNumbers: 'on',
+                roundedSelection: false,
+                scrollBeyondLastLine: false,
+                automaticLayout: true,
+                wordWrap: 'on'
+              }}
+            />
+          </div>
+
+          {/* Output Panel */}
+          <div className="w-1/2 flex flex-col bg-[#1e1e1e]">
+            <div className="flex items-center justify-between bg-[#252526] px-4 py-2 border-b border-[#3e3e3e]">
+              <span className="text-sm text-gray-300 flex items-center gap-2">
+                <FileText size={16} />
+                Output
+              </span>
+              <button
+                onClick={copyOutput}
+                className="text-gray-400 hover:text-white transition-colors"
+                disabled={!output && !error}
+              >
+                <Copy size={16} />
+              </button>
+            </div>
+
+            <div id="code-output" className="flex-1 p-4 font-mono text-sm overflow-auto">
+              {error ? (
+                <div className="text-red-400">
+                  <div className="flex items-center gap-2 mb-2">
+                    <Warning size={16} />
+                    Error:
+                  </div>
+                  <pre className="whitespace-pre-wrap">{error}</pre>
+                </div>
+              ) : output ? (
+                <div className="text-green-400">
+                  <pre className="whitespace-pre-wrap">{output}</pre>
+                  {plotPath && (
+                    <div className="mt-4">
+                      <p className="text-blue-400 mb-2">Plot saved to:</p>
+                      <code className="bg-[#2d2d2d] px-2 py-1 rounded">{plotPath}</code>
+                    </div>
+                  )}
+                </div>
+              ) : (
+                <div className="text-gray-500 flex items-center justify-center h-full">
+                  <div className="text-center">
+                    <Code size={48} className="mx-auto mb-4 opacity-20" />
+                    <p>Write code and click Run to see output</p>
+                    <p className="text-xs mt-2 text-gray-600">
+                      Python execution requires MCP tools from Claude Desktop
+                    </p>
+                  </div>
+                </div>
+              )}
+            </div>
+
+            {/* Info Panel */}
+            <div className="bg-[#252526] p-3 border-t border-[#3e3e3e]">
+              <div className="text-xs text-gray-400">
+                {selectedLanguage === 'python' ? (
+                  <div className="flex items-center gap-2">
+                    <CloudArrowUp size={14} />
+                    <span>Python code is saved to disk. Use MCP tools to execute.</span>
+                  </div>
+                ) : (
+                  <div className="flex items-center gap-2">
+                    <CheckCircle size={14} />
+                    <span>HTML/JS executes directly in browser sandbox.</span>
+                  </div>
+                )}
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </Window>
+  )
+}
\ No newline at end of file
diff --git a/app/components/CodePlayground.tsx b/app/components/CodePlayground.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..90b082881610549bb9a14c03f57366a46153418c
--- /dev/null
+++ b/app/components/CodePlayground.tsx
@@ -0,0 +1,668 @@
+'use client'
+
+import React, { useState, useRef, useEffect } from 'react'
+import Window from './Window'
+import Editor from '@monaco-editor/react'
+import {
+  Code,
+  Play,
+  FileHtml,
+  FileCss,
+  FileJs,
+  FilePy,
+  FileCode,
+  Download,
+  Upload,
+  FloppyDisk,
+  Eye,
+  EyeSlash,
+  ArrowsOutSimple,
+  ArrowsInSimple,
+  Plus,
+  X,
+  Globe,
+  Lock,
+  Users,
+  Folder,
+  Terminal as TerminalIcon,
+  Lightning
+} from '@phosphor-icons/react'
+
+interface CodePlaygroundProps {
+  onClose: () => void
+  userSession: string
+}
+
+interface Tab {
+  id: string
+  name: string
+  language: string
+  content: string
+  isPublic?: boolean
+  type: 'html' | 'css' | 'javascript' | 'python' | 'react' | 'flutter' | 'typescript'
+}
+
+interface ExecutionResult {
+  output: string
+  error?: string
+  timestamp: number
+}
+
+export function CodePlayground({ onClose, userSession }: CodePlaygroundProps) {
+  const [activeTab, setActiveTab] = useState<string>('main')
+  const [showPreview, setShowPreview] = useState(true)
+  const [showConsole, setShowConsole] = useState(true)
+  const [isFullscreen, setIsFullscreen] = useState(false)
+  const [isSaving, setIsSaving] = useState(false)
+  const [isExecuting, setIsExecuting] = useState(false)
+  const [executionResults, setExecutionResults] = useState<ExecutionResult[]>([])
+  const [publicFiles, setPublicFiles] = useState<Tab[]>([])
+  const previewRef = useRef<HTMLIFrameElement>(null)
+  const [draggedTab, setDraggedTab] = useState<string | null>(null)
+  const [dragOverTab, setDragOverTab] = useState<string | null>(null)
+
+  // Enhanced tab icons with more languages
+  const getTabIcon = (type: string) => {
+    const icons: Record<string, JSX.Element> = {
+      'html': <FileHtml size={16} weight="fill" className="text-orange-500" />,
+      'css': <FileCss size={16} weight="fill" className="text-blue-500" />,
+      'javascript': <FileJs size={16} weight="fill" className="text-yellow-500" />,
+      'typescript': <FileCode size={16} weight="fill" className="text-blue-600" />,
+      'python': <FilePy size={16} weight="fill" className="text-green-500" />,
+      'react': <FileJs size={16} weight="fill" className="text-cyan-500" />,
+      'flutter': <FileCode size={16} weight="fill" className="text-blue-400" />
+    }
+    return icons[type] || <Code size={16} weight="fill" className="text-gray-500" />
+  }
+
+  const [tabs, setTabs] = useState<Tab[]>([
+    {
+      id: 'main',
+      name: 'main.py',
+      language: 'python',
+      type: 'python',
+      content: `# Welcome to WebOS Code Playground!
+# You can write and execute Python code here
+
+def greet(name):
+    return f"Hello, {name}! Welcome to WebOS"
+
+# Example usage
+result = greet("Developer")
+print(result)
+
+# Your code here
+for i in range(5):
+    print(f"Count: {i}")
+`,
+      isPublic: false
+    }
+  ])
+
+  // Load public files from backend
+  useEffect(() => {
+    loadPublicFiles()
+  }, [])
+
+  const loadPublicFiles = async () => {
+    try {
+      const response = await fetch('/api/code/public')
+      if (response.ok) {
+        const files = await response.json()
+        setPublicFiles(files)
+      }
+    } catch (error) {
+      console.error('Failed to load public files:', error)
+    }
+  }
+
+  // Tab drag and drop handlers
+  const handleDragStart = (e: React.DragEvent, tabId: string) => {
+    setDraggedTab(tabId)
+    e.dataTransfer.effectAllowed = 'move'
+  }
+
+  const handleDragOver = (e: React.DragEvent, tabId: string) => {
+    e.preventDefault()
+    if (draggedTab && draggedTab !== tabId) {
+      setDragOverTab(tabId)
+    }
+  }
+
+  const handleDragLeave = () => {
+    setDragOverTab(null)
+  }
+
+  const handleDrop = (e: React.DragEvent, targetTabId: string) => {
+    e.preventDefault()
+
+    if (draggedTab && draggedTab !== targetTabId) {
+      const draggedIndex = tabs.findIndex(t => t.id === draggedTab)
+      const targetIndex = tabs.findIndex(t => t.id === targetTabId)
+
+      if (draggedIndex !== -1 && targetIndex !== -1) {
+        const newTabs = [...tabs]
+        const [draggedTabObj] = newTabs.splice(draggedIndex, 1)
+        newTabs.splice(targetIndex, 0, draggedTabObj)
+        setTabs(newTabs)
+      }
+    }
+
+    setDraggedTab(null)
+    setDragOverTab(null)
+  }
+
+  const handleDragEnd = () => {
+    setDraggedTab(null)
+    setDragOverTab(null)
+  }
+
+  // Create new tab with language selection
+  const createNewTab = (language: Tab['type']) => {
+    const templates: Record<Tab['type'], { name: string, content: string, lang: string }> = {
+      'python': {
+        name: 'script.py',
+        lang: 'python',
+        content: `# Python Script
+def main():
+    print("Hello from Python!")
+
+if __name__ == "__main__":
+    main()
+`
+      },
+      'javascript': {
+        name: 'script.js',
+        lang: 'javascript',
+        content: `// JavaScript Code
+console.log("Hello from JavaScript!");
+
+function calculate(a, b) {
+    return a + b;
+}
+
+console.log("Result:", calculate(5, 3));
+`
+      },
+      'typescript': {
+        name: 'script.ts',
+        lang: 'typescript',
+        content: `// TypeScript Code
+interface User {
+    name: string;
+    age: number;
+}
+
+function greetUser(user: User): void {
+    console.log(\`Hello, \${user.name}! You are \${user.age} years old.\`);
+}
+
+greetUser({ name: "Alice", age: 25 });
+`
+      },
+      'react': {
+        name: 'App.jsx',
+        lang: 'javascript',
+        content: `// React Component
+import React, { useState } from 'react';
+
+function App() {
+    const [count, setCount] = useState(0);
+
+    return (
+        <div>
+            <h1>React Counter</h1>
+            <p>Count: {count}</p>
+            <button onClick={() => setCount(count + 1)}>
+                Increment
+            </button>
+        </div>
+    );
+}
+
+export default App;
+`
+      },
+      'flutter': {
+        name: 'main.dart',
+        lang: 'dart',
+        content: `// Flutter Widget
+import 'package:flutter/material.dart';
+
+class MyWidget extends StatefulWidget {
+  @override
+  _MyWidgetState createState() => _MyWidgetState();
+}
+
+class _MyWidgetState extends State<MyWidget> {
+  int counter = 0;
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: Text('Flutter App')),
+      body: Center(
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            Text('Counter: $counter'),
+            ElevatedButton(
+              onPressed: () => setState(() => counter++),
+              child: Text('Increment'),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+`
+      },
+      'html': {
+        name: 'index.html',
+        lang: 'html',
+        content: `<!DOCTYPE html>
+<html>
+<head>
+    <title>HTML Page</title>
+</head>
+<body>
+    <h1>Hello WebOS!</h1>
+</body>
+</html>`
+      },
+      'css': {
+        name: 'style.css',
+        lang: 'css',
+        content: `/* CSS Styles */
+body {
+    font-family: Arial, sans-serif;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+}
+`
+      }
+    }
+
+    const template = templates[language]
+    const newTab: Tab = {
+      id: `tab_${Date.now()}`,
+      name: template.name,
+      language: template.lang,
+      type: language,
+      content: template.content,
+      isPublic: false
+    }
+
+    setTabs(prev => [...prev, newTab])
+    setActiveTab(newTab.id)
+  }
+
+  // Execute code based on language
+  const executeCode = async () => {
+    setIsExecuting(true)
+    const activeTabData = tabs.find(t => t.id === activeTab)
+
+    if (!activeTabData) {
+      setIsExecuting(false)
+      return
+    }
+
+    try {
+      const response = await fetch('/api/code/execute', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          sessionId: userSession,
+          language: activeTabData.type,
+          code: activeTabData.content,
+          timestamp: Date.now()
+        })
+      })
+
+      const result = await response.json()
+
+      setExecutionResults(prev => [...prev, {
+        output: result.output || 'No output',
+        error: result.error,
+        timestamp: Date.now()
+      }])
+    } catch (error) {
+      setExecutionResults(prev => [...prev, {
+        output: '',
+        error: `Execution failed: ${error}`,
+        timestamp: Date.now()
+      }])
+    }
+
+    setIsExecuting(false)
+  }
+
+  // Save to public folder
+  const saveToPublic = async () => {
+    const activeTabData = tabs.find(t => t.id === activeTab)
+    if (!activeTabData) return
+
+    setIsSaving(true)
+    try {
+      const response = await fetch('/api/code/public/save', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          sessionId: userSession,
+          file: {
+            ...activeTabData,
+            isPublic: true,
+            author: userSession
+          }
+        })
+      })
+
+      if (response.ok) {
+        setTabs(prev => prev.map(tab =>
+          tab.id === activeTab ? { ...tab, isPublic: true } : tab
+        ))
+        await loadPublicFiles()
+      }
+    } catch (error) {
+      console.error('Failed to save to public:', error)
+    }
+    setIsSaving(false)
+  }
+
+  const handleEditorChange = (value: string | undefined) => {
+    if (!value) return
+
+    setTabs(prev => prev.map(tab =>
+      tab.id === activeTab ? { ...tab, content: value } : tab
+    ))
+  }
+
+  const activeTabContent = tabs.find(t => t.id === activeTab)
+
+  // Close tab
+  const closeTab = (tabId: string) => {
+    if (tabs.length === 1) return // Keep at least one tab
+
+    setTabs(prev => prev.filter(t => t.id !== tabId))
+    if (activeTab === tabId) {
+      setActiveTab(tabs[0].id)
+    }
+  }
+
+  // Load file from public
+  const loadPublicFile = (file: Tab) => {
+    const newTab: Tab = {
+      ...file,
+      id: `tab_${Date.now()}`,
+      isPublic: false
+    }
+    setTabs(prev => [...prev, newTab])
+    setActiveTab(newTab.id)
+  }
+
+  return (
+    <Window
+      id="code-playground"
+      title={`Code Playground - Session: ${userSession.substring(0, 8)}...`}
+      isOpen={true}
+      onClose={onClose}
+      width={isFullscreen ? window.innerWidth : 1400}
+      height={isFullscreen ? window.innerHeight - 32 : 850}
+      x={isFullscreen ? 0 : 50}
+      y={isFullscreen ? 32 : 30}
+      darkMode={true}
+      className="code-playground-window"
+    >
+      <div className="flex flex-col h-full bg-[#1e1e1e]">
+        {/* Toolbar */}
+        <div className="flex items-center justify-between bg-[#2d2d2d] px-4 py-2 border-b border-[#3e3e3e]">
+          <div className="flex items-center gap-3">
+            <Lightning size={20} weight="bold" className="text-yellow-400" />
+            <span className="text-gray-300 text-sm font-medium">Multi-Language Playground</span>
+            <div className="flex items-center gap-1 px-2 py-1 bg-[#1e1e1e] rounded text-xs text-gray-400">
+              <Users size={14} />
+              <span>{userSession.substring(0, 8)}</span>
+            </div>
+          </div>
+
+          <div className="flex items-center gap-2">
+            <button
+              onClick={executeCode}
+              disabled={isExecuting}
+              className="px-3 py-1 bg-green-600 hover:bg-green-700 text-white rounded text-sm flex items-center gap-2 disabled:opacity-50"
+            >
+              <Play size={16} weight="fill" />
+              {isExecuting ? 'Running...' : 'Run'}
+            </button>
+
+            <button
+              onClick={saveToPublic}
+              disabled={isSaving}
+              className="px-3 py-1 bg-blue-600 hover:bg-blue-700 text-white rounded text-sm flex items-center gap-2 disabled:opacity-50"
+            >
+              <Globe size={16} />
+              {isSaving ? 'Publishing...' : 'Publish'}
+            </button>
+
+            <button
+              onClick={() => setShowConsole(!showConsole)}
+              className="px-3 py-1 bg-gray-600 hover:bg-gray-700 text-white rounded text-sm flex items-center gap-2"
+            >
+              <TerminalIcon size={16} />
+              Console
+            </button>
+
+            <button
+              onClick={() => setShowPreview(!showPreview)}
+              className="px-3 py-1 bg-gray-600 hover:bg-gray-700 text-white rounded text-sm flex items-center gap-2"
+            >
+              {showPreview ? <EyeSlash size={16} /> : <Eye size={16} />}
+              Preview
+            </button>
+
+            <button
+              onClick={() => setIsFullscreen(!isFullscreen)}
+              className="px-3 py-1 bg-gray-600 hover:bg-gray-700 text-white rounded text-sm"
+            >
+              {isFullscreen ? <ArrowsInSimple size={16} /> : <ArrowsOutSimple size={16} />}
+            </button>
+          </div>
+        </div>
+
+        {/* Main Content Area */}
+        <div className="flex flex-1 overflow-hidden">
+          {/* Sidebar - Public Files */}
+          <div className="w-64 bg-[#252526] border-r border-[#3e3e3e] flex flex-col">
+            <div className="p-3 border-b border-[#3e3e3e]">
+              <div className="flex items-center gap-2 text-gray-300 text-sm font-medium">
+                <Folder size={16} />
+                Public Files
+              </div>
+            </div>
+            <div className="flex-1 overflow-y-auto p-2">
+              {publicFiles.map(file => (
+                <button
+                  key={file.id}
+                  onClick={() => loadPublicFile(file)}
+                  className="w-full text-left px-2 py-1.5 text-xs text-gray-400 hover:bg-[#2d2d2d] rounded flex items-center gap-2"
+                >
+                  {getTabIcon(file.type)}
+                  <span className="truncate">{file.name}</span>
+                </button>
+              ))}
+            </div>
+          </div>
+
+          {/* Editor Section */}
+          <div className={`flex flex-col ${showPreview ? 'w-1/2' : 'flex-1'}`}>
+            {/* Tabs with drag and drop */}
+            <div className="flex bg-[#252526] border-b border-[#3e3e3e] items-center">
+              <div className="flex-1 flex overflow-x-auto">
+                {tabs.map(tab => (
+                  <div
+                    key={tab.id}
+                    draggable
+                    onDragStart={(e) => handleDragStart(e, tab.id)}
+                    onDragOver={(e) => handleDragOver(e, tab.id)}
+                    onDragLeave={handleDragLeave}
+                    onDrop={(e) => handleDrop(e, tab.id)}
+                    onDragEnd={handleDragEnd}
+                    className={`
+                      flex items-center gap-2 px-3 py-2 text-sm border-r border-[#3e3e3e]
+                      cursor-move transition-all select-none
+                      ${activeTab === tab.id ? 'bg-[#1e1e1e] text-white' : 'text-gray-400 hover:text-white hover:bg-[#2d2d2d]'}
+                      ${dragOverTab === tab.id ? 'border-l-2 border-l-blue-500' : ''}
+                    `}
+                    onClick={() => setActiveTab(tab.id)}
+                  >
+                    {getTabIcon(tab.type)}
+                    <span>{tab.name}</span>
+                    {tab.isPublic && (
+                      <Globe size={12} className="text-green-400" />
+                    )}
+                    {tabs.length > 1 && (
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          closeTab(tab.id)
+                        }}
+                        className="ml-1 hover:bg-[#3e3e3e] rounded p-0.5"
+                      >
+                        <X size={12} />
+                      </button>
+                    )}
+                  </div>
+                ))}
+              </div>
+
+              {/* Add new tab dropdown */}
+              <div className="relative group">
+                <button className="px-3 py-2 text-gray-400 hover:text-white hover:bg-[#2d2d2d]">
+                  <Plus size={16} />
+                </button>
+                <div className="absolute right-0 top-full mt-1 bg-[#252526] border border-[#3e3e3e] rounded shadow-lg opacity-0 invisible group-hover:opacity-100 group-hover:visible transition-all z-10">
+                  <button
+                    onClick={() => createNewTab('python')}
+                    className="block w-full px-3 py-2 text-sm text-gray-300 hover:bg-[#2d2d2d] text-left"
+                  >
+                    Python
+                  </button>
+                  <button
+                    onClick={() => createNewTab('javascript')}
+                    className="block w-full px-3 py-2 text-sm text-gray-300 hover:bg-[#2d2d2d] text-left"
+                  >
+                    JavaScript
+                  </button>
+                  <button
+                    onClick={() => createNewTab('typescript')}
+                    className="block w-full px-3 py-2 text-sm text-gray-300 hover:bg-[#2d2d2d] text-left"
+                  >
+                    TypeScript
+                  </button>
+                  <button
+                    onClick={() => createNewTab('react')}
+                    className="block w-full px-3 py-2 text-sm text-gray-300 hover:bg-[#2d2d2d] text-left"
+                  >
+                    React
+                  </button>
+                  <button
+                    onClick={() => createNewTab('flutter')}
+                    className="block w-full px-3 py-2 text-sm text-gray-300 hover:bg-[#2d2d2d] text-left"
+                  >
+                    Flutter/Dart
+                  </button>
+                  <button
+                    onClick={() => createNewTab('html')}
+                    className="block w-full px-3 py-2 text-sm text-gray-300 hover:bg-[#2d2d2d] text-left"
+                  >
+                    HTML
+                  </button>
+                  <button
+                    onClick={() => createNewTab('css')}
+                    className="block w-full px-3 py-2 text-sm text-gray-300 hover:bg-[#2d2d2d] text-left"
+                  >
+                    CSS
+                  </button>
+                </div>
+              </div>
+            </div>
+
+            {/* Monaco Editor */}
+            <div className={`flex-1 ${showConsole ? 'h-3/5' : ''}`}>
+              <Editor
+                height="100%"
+                language={activeTabContent?.language || 'python'}
+                value={activeTabContent?.content || ''}
+                onChange={handleEditorChange}
+                theme="vs-dark"
+                options={{
+                  minimap: { enabled: true },
+                  fontSize: 14,
+                  wordWrap: 'on',
+                  automaticLayout: true,
+                  scrollBeyondLastLine: false,
+                  tabSize: 4
+                }}
+              />
+            </div>
+
+            {/* Console Output */}
+            {showConsole && (
+              <div className="h-2/5 bg-[#1e1e1e] border-t border-[#3e3e3e] flex flex-col">
+                <div className="flex items-center justify-between px-3 py-1 bg-[#252526] border-b border-[#3e3e3e]">
+                  <span className="text-xs text-gray-400">Console Output</span>
+                  <button
+                    onClick={() => setExecutionResults([])}
+                    className="text-xs text-gray-400 hover:text-white"
+                  >
+                    Clear
+                  </button>
+                </div>
+                <div className="flex-1 overflow-y-auto p-3 font-mono text-xs">
+                  {executionResults.map((result, index) => (
+                    <div key={index} className="mb-2">
+                      <div className="text-gray-500 text-xs mb-1">
+                        [{new Date(result.timestamp).toLocaleTimeString()}]
+                      </div>
+                      {result.error ? (
+                        <div className="text-red-400">{result.error}</div>
+                      ) : (
+                        <div className="text-green-400 whitespace-pre-wrap">{result.output}</div>
+                      )}
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+          </div>
+
+          {/* Preview Section (for HTML/CSS/JS) */}
+          {showPreview && (activeTabContent?.type === 'html' || activeTabContent?.type === 'css' || activeTabContent?.type === 'javascript') && (
+            <div className="flex-1 flex flex-col bg-white">
+              <div className="bg-gray-100 px-4 py-2 border-b border-gray-300 flex items-center justify-between">
+                <span className="text-sm font-medium">Live Preview</span>
+                <button
+                  onClick={() => {
+                    if (previewRef.current) {
+                      previewRef.current.src = previewRef.current.src
+                    }
+                  }}
+                  className="p-1 hover:bg-gray-200 rounded"
+                >
+                  <Play size={16} className="text-gray-600" />
+                </button>
+              </div>
+              <iframe
+                ref={previewRef}
+                className="flex-1 w-full bg-white"
+                sandbox="allow-scripts"
+                srcDoc={activeTabContent?.content}
+                title="Code Preview"
+              />
+            </div>
+          )}
+        </div>
+      </div>
+    </Window>
+  )
+}
\ No newline at end of file
diff --git a/app/components/ContextMenu.tsx b/app/components/ContextMenu.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..3e824b0d04897cc7a5526e854a5b78a1c4896014
--- /dev/null
+++ b/app/components/ContextMenu.tsx
@@ -0,0 +1,90 @@
+'use client'
+
+import React from 'react'
+import { motion, AnimatePresence } from 'framer-motion'
+import {
+  FolderPlus,
+  Info,
+  Image,
+  Broom,
+  ArrowsClockwise,
+  Desktop
+} from '@phosphor-icons/react'
+
+interface ContextMenuProps {
+  isOpen: boolean
+  position: { x: number; y: number }
+  onClose: () => void
+  onAction: (action: string) => void
+}
+
+export function ContextMenu({ isOpen, position, onClose, onAction }: ContextMenuProps) {
+  const menuItems = [
+    { id: 'new-folder', label: 'New Folder', icon: FolderPlus },
+    { id: 'get-info', label: 'Get Info', icon: Info },
+    { type: 'separator' },
+    { id: 'change-wallpaper', label: 'Change Wallpaper', icon: Image },
+    { id: 'clean-up', label: 'Clean Up', icon: Broom },
+    { id: 'refresh', label: 'Refresh', icon: ArrowsClockwise },
+    { type: 'separator' },
+    { id: 'display-settings', label: 'Display Settings', icon: Desktop },
+  ]
+
+  const handleAction = (actionId: string) => {
+    onAction(actionId)
+    onClose()
+  }
+
+  return (
+    <AnimatePresence>
+      {isOpen && (
+        <>
+          {/* Invisible backdrop to detect outside clicks */}
+          <div
+            className="fixed inset-0 z-[79]"
+            onClick={onClose}
+          />
+
+          {/* Context Menu */}
+          <motion.div
+            initial={{ opacity: 0, scale: 0.95 }}
+            animate={{ opacity: 1, scale: 1 }}
+            exit={{ opacity: 0, scale: 0.95 }}
+            transition={{ duration: 0.1 }}
+            className="fixed glass rounded-lg shadow-xl py-1 z-[80] min-w-[200px]"
+            style={{
+              left: position.x,
+              top: position.y,
+              // Prevent menu from going off-screen
+              maxWidth: `calc(100vw - ${position.x}px - 20px)`,
+              maxHeight: `calc(100vh - ${position.y}px - 20px)`
+            }}
+          >
+            {menuItems.map((item, index) => {
+              if (item.type === 'separator') {
+                return (
+                  <div
+                    key={`separator-${index}`}
+                    className="h-px bg-gray-300/50 my-1 mx-2"
+                  />
+                )
+              }
+
+              const Icon = item.icon!
+              return (
+                <button
+                  key={item.id}
+                  onClick={() => handleAction(item.id!)}
+                  className="w-full text-left px-4 py-1.5 hover:bg-blue-500 hover:text-white transition-colors flex items-center gap-3 text-sm"
+                >
+                  <Icon size={16} weight="regular" />
+                  <span>{item.label}</span>
+                </button>
+              )
+            })}
+          </motion.div>
+        </>
+      )}
+    </AnimatePresence>
+  )
+}
\ No newline at end of file
diff --git a/app/components/Desktop.tsx b/app/components/Desktop.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..8a33dece54ac10168fe5a5d81669d5087c09a4fc
--- /dev/null
+++ b/app/components/Desktop.tsx
@@ -0,0 +1,498 @@
+'use client'
+
+import React, { useState, useEffect } from 'react'
+import { Dock } from './Dock'
+import { TopBar } from './TopBar'
+import { FileManager } from './FileManager'
+import { Calendar } from './Calendar'
+import { DraggableDesktopIcon } from './DraggableDesktopIcon'
+import { MatrixRain } from './MatrixRain'
+import { HelpModal } from './HelpModal'
+import { DesktopContextMenu } from './DesktopContextMenu'
+import { BackgroundSelector } from './BackgroundSelector'
+import WebBrowserApp from './WebBrowserApp'
+import { GeminiChat } from './GeminiChat'
+import { Clock } from './Clock'
+import { Terminal } from './Terminal'
+import { SpotlightSearch } from './SpotlightSearch'
+import { ContextMenu } from './ContextMenu'
+import { VSCodeEditor } from './VSCodeEditor'
+import { CodePlayground } from './CodePlayground'
+import { AboutModal } from './AboutModal'
+import { CodeExecutor } from './CodeExecutor'
+import { motion } from 'framer-motion'
+
+export function Desktop() {
+  const [fileManagerOpen, setFileManagerOpen] = useState(true)
+  const [calendarOpen, setCalendarOpen] = useState(false)
+  const [clockOpen, setClockOpen] = useState(false)
+  const [browserOpen, setBrowserOpen] = useState(false)
+  const [geminiChatOpen, setGeminiChatOpen] = useState(false)
+  const [terminalOpen, setTerminalOpen] = useState(false)
+  const [vscodeOpen, setVscodeOpen] = useState(false)
+  const [codePlaygroundOpen, setCodePlaygroundOpen] = useState(false)
+  const [spotlightOpen, setSpotlightOpen] = useState(false)
+  const [contextMenuVisible, setContextMenuVisible] = useState(false)
+  const [contextMenuPosition, setContextMenuPosition] = useState({ x: 0, y: 0 })
+  const [userSession, setUserSession] = useState<string>(`session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`)
+  const [currentPath, setCurrentPath] = useState('')
+  const [matrixActive, setMatrixActive] = useState(false)
+  const [helpModalOpen, setHelpModalOpen] = useState(false)
+  const [contextMenuOpen, setContextMenuOpen] = useState(false)
+  const [contextMenuPos, setContextMenuPos] = useState({ x: 0, y: 0 })
+  const [backgroundSelectorOpen, setBackgroundSelectorOpen] = useState(false)
+  const [currentBackground, setCurrentBackground] = useState('/background.webp')
+  const [aboutModalOpen, setAboutModalOpen] = useState(false)
+  const [codeExecutorOpen, setCodeExecutorOpen] = useState(false)
+
+  const openFileManager = (path: string) => {
+    setCurrentPath(path)
+    setFileManagerOpen(true)
+  }
+
+  const closeFileManager = () => {
+    setFileManagerOpen(false)
+  }
+
+  const openCalendar = () => {
+    setCalendarOpen(true)
+  }
+
+  const closeCalendar = () => {
+    setCalendarOpen(false)
+  }
+
+  const openClock = () => {
+    setClockOpen(true)
+  }
+
+  const closeClock = () => {
+    setClockOpen(false)
+  }
+
+  const openBrowser = () => {
+    setBrowserOpen(true)
+  }
+
+  const closeBrowser = () => {
+    setBrowserOpen(false)
+  }
+
+  const openGeminiChat = () => {
+    setGeminiChatOpen(true)
+  }
+
+  const closeGeminiChat = () => {
+    setGeminiChatOpen(false)
+  }
+
+  const openTerminal = () => {
+    setTerminalOpen(true)
+  }
+
+  const closeTerminal = () => {
+    setTerminalOpen(false)
+  }
+
+  const openVSCode = () => {
+    setVscodeOpen(true)
+  }
+
+  const closeVSCode = () => {
+    setVscodeOpen(false)
+  }
+
+  const openCodePlayground = () => {
+    setCodePlaygroundOpen(true)
+  }
+
+  const closeCodePlayground = () => {
+    setCodePlaygroundOpen(false)
+  }
+
+  const openCodeExecutor = () => {
+    setCodeExecutorOpen(true)
+  }
+
+  const closeCodeExecutor = () => {
+    setCodeExecutorOpen(false)
+  }
+
+  const handleOpenApp = (appId: string) => {
+    switch(appId) {
+      case 'files':
+        openFileManager('')
+        break
+      case 'calendar':
+        openCalendar()
+        break
+      case 'clock':
+        openClock()
+        break
+      case 'browser':
+        openBrowser()
+        break
+      case 'gemini':
+        openGeminiChat()
+        break
+      case 'terminal':
+        openTerminal()
+        break
+      case 'vscode':
+        openVSCode()
+        break
+      case 'playground':
+        openCodePlayground()
+        break
+      case 'executor':
+        openCodeExecutor()
+        break
+    }
+  }
+
+  const handleContextMenuAction = (action: string) => {
+    switch(action) {
+      case 'change-wallpaper':
+        setBackgroundSelectorOpen(true)
+        break
+      case 'new-folder':
+        // Add folder creation logic if needed
+        break
+      case 'refresh':
+        window.location.reload()
+        break
+    }
+  }
+
+  const triggerMatrix = () => {
+    setMatrixActive(true)
+  }
+
+  const handleMatrixComplete = () => {
+    setMatrixActive(false)
+  }
+
+  const openHelpModal = () => {
+    setHelpModalOpen(true)
+  }
+
+  const closeHelpModal = () => {
+    setHelpModalOpen(false)
+  }
+
+  const handleDesktopRightClick = (e: React.MouseEvent) => {
+    e.preventDefault()
+    setContextMenuPosition({ x: e.clientX, y: e.clientY })
+    setContextMenuVisible(true)
+  }
+
+  const handleChangeBackground = (type: 'upload' | 'preset') => {
+    setContextMenuOpen(false)
+    setBackgroundSelectorOpen(true)
+  }
+
+  const handleSelectBackground = (background: string | File) => {
+    if (typeof background === 'string') {
+      // Handle preset backgrounds
+      if (background.startsWith('gradient-')) {
+        setCurrentBackground(background)
+      } else {
+        setCurrentBackground(background)
+      }
+    } else {
+      // Handle uploaded file
+      const url = URL.createObjectURL(background)
+      setCurrentBackground(url)
+    }
+  }
+
+  // Keyboard shortcuts
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      // Cmd/Ctrl + Space for Spotlight Search
+      if ((e.metaKey || e.ctrlKey) && e.key === ' ') {
+        e.preventDefault()
+        setSpotlightOpen(true)
+      }
+      // Cmd/Ctrl + K for Spotlight Search (alternative)
+      if ((e.metaKey || e.ctrlKey) && e.key === 'k') {
+        e.preventDefault()
+        setSpotlightOpen(true)
+      }
+    }
+
+    window.addEventListener('keydown', handleKeyDown)
+    return () => window.removeEventListener('keydown', handleKeyDown)
+  }, [])
+
+  const getBackgroundStyle = () => {
+    if (currentBackground.startsWith('gradient-')) {
+      const gradients: Record<string, string> = {
+        'gradient-purple': 'linear-gradient(135deg, #77216F 0%, #5E2750 50%, #2C001E 100%)',
+        'gradient-blue': 'linear-gradient(135deg, #1e3c72 0%, #2a5298 50%, #7e8ba3 100%)',
+        'gradient-green': 'linear-gradient(135deg, #134e5e 0%, #71b280 50%, #a8e063 100%)',
+        'gradient-orange': 'linear-gradient(135deg, #ff512f 0%, #dd2476 50%, #f09819 100%)',
+        'gradient-dark': 'linear-gradient(135deg, #0f0f0f 0%, #1a1a1a 50%, #2d2d2d 100%)',
+        'gradient-cosmic': 'linear-gradient(135deg, #667eea 0%, #764ba2 50%, #f093fb 100%)'
+      }
+      return { background: gradients[currentBackground] || gradients['gradient-purple'] }
+    } else {
+      return {
+        backgroundImage: `url('${currentBackground}')`,
+        backgroundSize: 'cover',
+        backgroundPosition: 'center',
+        backgroundRepeat: 'no-repeat'
+      }
+    }
+  }
+
+  return (
+    <div className="relative h-screen w-screen overflow-hidden flex" onContextMenu={handleDesktopRightClick}>
+      <div
+        className="absolute inset-0"
+        style={getBackgroundStyle()}
+      >
+        {/* Overlay for better text visibility */}
+        {!currentBackground.startsWith('gradient-') && (
+          <div
+            className="absolute inset-0 bg-black/20"
+            style={{
+              mixBlendMode: 'multiply'
+            }}
+          />
+        )}
+        <svg className="absolute inset-0 w-full h-full opacity-10" xmlns="http://www.w3.org/2000/svg">
+          <defs>
+            <pattern id="ubuntu-pattern" x="0" y="0" width="100" height="100" patternUnits="userSpaceOnUse">
+              <circle cx="50" cy="50" r="2" fill="white" opacity="0.3"/>
+            </pattern>
+          </defs>
+          <rect width="100%" height="100%" fill="url(#ubuntu-pattern)" />
+        </svg>
+      </div>
+
+      <TopBar onPowerAction={triggerMatrix} onAboutClick={() => setAboutModalOpen(true)} />
+
+      <Dock onOpenFileManager={openFileManager} onOpenCalendar={openCalendar} onOpenClock={openClock} onOpenBrowser={openBrowser} onOpenGeminiChat={openGeminiChat} onOpenVSCode={openVSCode} onOpenCodePlayground={openCodePlayground} />
+
+      <div className="flex-1">
+        {/* Desktop Icons - Positioned in a grid layout */}
+        <div className="absolute top-20 left-8">
+          <DraggableDesktopIcon
+            id="files"
+            label="Files"
+            iconType="files"
+            initialPosition={{ x: 20, y: 20 }}
+            onClick={() => {}}
+            onDoubleClick={() => openFileManager('')}
+          />
+          <DraggableDesktopIcon
+            id="browser"
+            label="Browser"
+            iconType="browser"
+            initialPosition={{ x: 120, y: 20 }}
+            onClick={() => {}}
+            onDoubleClick={openBrowser}
+          />
+          <DraggableDesktopIcon
+            id="gemini"
+            label="Gemini"
+            iconType="gemini"
+            initialPosition={{ x: 220, y: 20 }}
+            onClick={() => {}}
+            onDoubleClick={openGeminiChat}
+          />
+          <DraggableDesktopIcon
+            id="clock"
+            label="Clock"
+            iconType="clock"
+            initialPosition={{ x: 20, y: 120 }}
+            onClick={() => {}}
+            onDoubleClick={openClock}
+          />
+          <DraggableDesktopIcon
+            id="calendar"
+            label="Calendar"
+            iconType="calendar"
+            initialPosition={{ x: 120, y: 120 }}
+            onClick={() => {}}
+            onDoubleClick={openCalendar}
+          />
+          <DraggableDesktopIcon
+            id="terminal"
+            label="Terminal"
+            iconType="terminal"
+            initialPosition={{ x: 20, y: 220 }}
+            onClick={() => {}}
+            onDoubleClick={openTerminal}
+          />
+          <DraggableDesktopIcon
+            id="harddrive"
+            label="System"
+            iconType="harddrive"
+            initialPosition={{ x: 120, y: 220 }}
+            onClick={() => {}}
+            onDoubleClick={() => openFileManager('')}
+          />
+          <DraggableDesktopIcon
+            id="vscode"
+            label="VS Code"
+            iconType="vscode"
+            initialPosition={{ x: 320, y: 20 }}
+            onClick={() => {}}
+            onDoubleClick={openVSCode}
+          />
+          <DraggableDesktopIcon
+            id="playground"
+            label="Code Playground"
+            iconType="playground"
+            initialPosition={{ x: 220, y: 220 }}
+            onClick={() => {}}
+            onDoubleClick={openCodePlayground}
+          />
+          <DraggableDesktopIcon
+            id="executor"
+            label="Code Executor"
+            iconType="terminal"
+            initialPosition={{ x: 320, y: 120 }}
+            onClick={() => {}}
+            onDoubleClick={openCodeExecutor}
+          />
+        </div>
+
+        {fileManagerOpen && (
+          <motion.div
+            initial={{ scale: 0.95, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            transition={{ duration: 0.15 }}
+          >
+            <FileManager 
+              currentPath={currentPath}
+              onNavigate={setCurrentPath}
+              onClose={closeFileManager}
+            />
+          </motion.div>
+        )}
+
+        {calendarOpen && (
+          <motion.div
+            initial={{ scale: 0.95, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            transition={{ duration: 0.15 }}
+          >
+            <Calendar onClose={closeCalendar} />
+          </motion.div>
+        )}
+
+        {clockOpen && (
+          <motion.div
+            initial={{ scale: 0.95, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            transition={{ duration: 0.15 }}
+          >
+            <Clock onClose={closeClock} />
+          </motion.div>
+        )}
+
+        {browserOpen && (
+          <motion.div
+            initial={{ scale: 0.95, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            transition={{ duration: 0.15 }}
+          >
+            <WebBrowserApp onClose={closeBrowser} />
+          </motion.div>
+        )}
+
+        {geminiChatOpen && (
+          <GeminiChat onClose={closeGeminiChat} />
+        )}
+
+        {terminalOpen && (
+          <motion.div
+            initial={{ scale: 0.95, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            transition={{ duration: 0.15 }}
+          >
+            <Terminal onClose={closeTerminal} />
+          </motion.div>
+        )}
+
+        {vscodeOpen && (
+          <motion.div
+            initial={{ scale: 0.95, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            transition={{ duration: 0.15 }}
+          >
+            <VSCodeEditor onClose={closeVSCode} userSession={userSession} />
+          </motion.div>
+        )}
+
+        {codePlaygroundOpen && (
+          <motion.div
+            initial={{ scale: 0.95, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            transition={{ duration: 0.15 }}
+          >
+            <CodePlayground onClose={closeCodePlayground} userSession={userSession} />
+          </motion.div>
+        )}
+
+        {codeExecutorOpen && (
+          <motion.div
+            initial={{ scale: 0.95, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            transition={{ duration: 0.15 }}
+          >
+            <CodeExecutor onClose={closeCodeExecutor} />
+          </motion.div>
+        )}
+      </div>
+
+      {/* Spotlight Search */}
+      <SpotlightSearch
+        isOpen={spotlightOpen}
+        onClose={() => setSpotlightOpen(false)}
+        onOpenApp={handleOpenApp}
+      />
+
+      {/* Context Menu */}
+      <ContextMenu
+        isOpen={contextMenuVisible}
+        position={contextMenuPosition}
+        onClose={() => setContextMenuVisible(false)}
+        onAction={handleContextMenuAction}
+      />
+
+      {/* Matrix Rain Effect */}
+      <div onClick={handleMatrixComplete} style={{ cursor: matrixActive ? 'pointer' : 'default' }}>
+        <MatrixRain isActive={matrixActive} onComplete={handleMatrixComplete} />
+      </div>
+
+      {/* Help Modal */}
+      <HelpModal isOpen={helpModalOpen} onClose={closeHelpModal} />
+
+      {/* Desktop Context Menu */}
+      <DesktopContextMenu
+        isOpen={contextMenuOpen}
+        position={contextMenuPos}
+        onClose={() => setContextMenuOpen(false)}
+        onChangeBackground={handleChangeBackground}
+      />
+
+      {/* Background Selector Modal */}
+      <BackgroundSelector
+        isOpen={backgroundSelectorOpen}
+        onClose={() => setBackgroundSelectorOpen(false)}
+        onSelectBackground={handleSelectBackground}
+        currentBackground={currentBackground}
+      />
+
+      {/* About Modal */}
+      <AboutModal
+        isOpen={aboutModalOpen}
+        onClose={() => setAboutModalOpen(false)}
+      />
+    </div>
+  )
+}
diff --git a/app/components/DesktopContextMenu.tsx b/app/components/DesktopContextMenu.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..75450f4b2d8c87320b2dfdaab66414add031823b
--- /dev/null
+++ b/app/components/DesktopContextMenu.tsx
@@ -0,0 +1,123 @@
+'use client'
+
+import React, { useRef, useEffect } from 'react'
+import { motion, AnimatePresence } from 'framer-motion'
+import {
+  Image,
+  PaintBrush,
+  Upload,
+  Palette,
+  Desktop as DesktopIcon,
+  Gradient
+} from '@phosphor-icons/react'
+
+interface DesktopContextMenuProps {
+  isOpen: boolean
+  position: { x: number; y: number }
+  onClose: () => void
+  onChangeBackground: (type: 'upload' | 'preset') => void
+}
+
+const presetBackgrounds = [
+  { name: 'Ubuntu Purple', value: 'gradient-purple' },
+  { name: 'Ocean Blue', value: 'gradient-blue' },
+  { name: 'Forest Green', value: 'gradient-green' },
+  { name: 'Sunset Orange', value: 'gradient-orange' },
+  { name: 'Dark Mode', value: 'gradient-dark' },
+]
+
+export function DesktopContextMenu({
+  isOpen,
+  position,
+  onClose,
+  onChangeBackground
+}: DesktopContextMenuProps) {
+  const menuRef = useRef<HTMLDivElement>(null)
+
+  useEffect(() => {
+    const handleClickOutside = (event: MouseEvent) => {
+      if (menuRef.current && !menuRef.current.contains(event.target as Node)) {
+        onClose()
+      }
+    }
+
+    const handleEscape = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        onClose()
+      }
+    }
+
+    if (isOpen) {
+      document.addEventListener('mousedown', handleClickOutside)
+      document.addEventListener('keydown', handleEscape)
+    }
+
+    return () => {
+      document.removeEventListener('mousedown', handleClickOutside)
+      document.removeEventListener('keydown', handleEscape)
+    }
+  }, [isOpen, onClose])
+
+  return (
+    <AnimatePresence>
+      {isOpen && (
+        <motion.div
+          ref={menuRef}
+          initial={{ opacity: 0, scale: 0.95 }}
+          animate={{ opacity: 1, scale: 1 }}
+          exit={{ opacity: 0, scale: 0.95 }}
+          transition={{ duration: 0.1 }}
+          className="fixed z-50 bg-[#2C2C2C]/95 backdrop-blur-md rounded-lg shadow-2xl border border-white/10 py-2 min-w-[240px]"
+          style={{
+            left: `${position.x}px`,
+            top: `${position.y}px`,
+            maxHeight: 'calc(100vh - 20px)',
+            overflowY: 'auto'
+          }}
+        >
+          {/* Change Background Section */}
+          <div className="px-3 py-1.5 text-xs font-medium text-gray-400 uppercase tracking-wider">
+            Change Background
+          </div>
+
+          <button
+            onClick={() => onChangeBackground('upload')}
+            className="w-full px-3 py-2 flex items-center gap-3 hover:bg-white/10 transition-colors text-left"
+          >
+            <Upload size={18} className="text-blue-400" />
+            <span className="text-sm text-gray-200">Upload Image</span>
+          </button>
+
+          <button
+            onClick={() => onChangeBackground('preset')}
+            className="w-full px-3 py-2 flex items-center gap-3 hover:bg-white/10 transition-colors text-left"
+          >
+            <Palette size={18} className="text-purple-400" />
+            <span className="text-sm text-gray-200">Choose from Gallery</span>
+          </button>
+
+          <div className="h-px bg-white/10 my-2" />
+
+          {/* Display Settings */}
+          <div className="px-3 py-1.5 text-xs font-medium text-gray-400 uppercase tracking-wider">
+            Display
+          </div>
+
+          <button
+            className="w-full px-3 py-2 flex items-center gap-3 hover:bg-white/10 transition-colors text-left"
+          >
+            <DesktopIcon size={18} className="text-green-400" />
+            <span className="text-sm text-gray-200">Desktop Icons</span>
+          </button>
+
+          <button
+            className="w-full px-3 py-2 flex items-center gap-3 hover:bg-white/10 transition-colors text-left"
+          >
+            <Gradient size={18} className="text-orange-400" />
+            <span className="text-sm text-gray-200">Visual Effects</span>
+          </button>
+        </motion.div>
+      )}
+    </AnimatePresence>
+  )
+}
\ No newline at end of file
diff --git a/app/components/DesktopIcon.tsx b/app/components/DesktopIcon.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..099a851ae42c43bebf8b6f468a121175d10be478
--- /dev/null
+++ b/app/components/DesktopIcon.tsx
@@ -0,0 +1,64 @@
+'use client'
+
+import React from 'react'
+import { House, Trash, Calendar as CalendarIcon, Clock, Folder, Globe, Sparkle, GameController } from '@phosphor-icons/react'
+
+interface DesktopIconProps {
+  icon: 'home' | 'trash' | 'calendar' | 'clock' | 'game' | 'folder' | 'browser' | 'gemini'
+  label: string
+  onClick: () => void
+}
+
+export function DesktopIcon({ icon, label, onClick }: DesktopIconProps) {
+  const getIcon = () => {
+    switch(icon) {
+      case 'home': return House
+      case 'calendar': return CalendarIcon
+      case 'clock': return Clock
+      case 'game': return GameController
+      case 'folder': return Folder
+      case 'browser': return Globe
+      case 'gemini': return Sparkle
+      case 'trash': return Trash
+      default: return Folder
+    }
+  }
+
+  const Icon = getIcon()
+
+  const getGradient = () => {
+    if (icon === 'calendar') {
+      return 'from-purple-500/80 to-purple-700/80 group-hover:from-purple-400/80 group-hover:to-purple-600/80'
+    }
+    if (icon === 'clock') {
+      return 'from-teal-500/80 to-cyan-600/80 group-hover:from-teal-400/80 group-hover:to-cyan-500/80'
+    }
+    if (icon === 'game') {
+      return 'from-pink-500/80 to-rose-600/80 group-hover:from-pink-400/80 group-hover:to-rose-500/80'
+    }
+    if (icon === 'folder') {
+      return 'from-orange-500/80 to-orange-700/80 group-hover:from-orange-400/80 group-hover:to-orange-600/80'
+    }
+    if (icon === 'browser') {
+      return 'from-blue-500/80 to-cyan-600/80 group-hover:from-blue-400/80 group-hover:to-cyan-500/80'
+    }
+    if (icon === 'gemini') {
+      return 'from-[#E95420]/80 to-[#d14818]/80 group-hover:from-[#E95420] group-hover:to-[#d14818]'
+    }
+    return 'from-gray-600/80 to-gray-700/80 group-hover:from-gray-500/80 group-hover:to-gray-600/80'
+  }
+
+  return (
+    <button
+      onClick={onClick}
+      className="flex flex-col items-center gap-1 p-2 rounded hover:bg-white/10 transition-colors w-24 group mb-2"
+    >
+      <div className={`w-16 h-16 rounded-lg bg-gradient-to-br ${getGradient()} backdrop-blur-sm flex items-center justify-center transition-all`}>
+        <Icon size={32} weight="regular" className="text-white" />
+      </div>
+      <span className="text-white text-xs text-center drop-shadow-[0_1px_2px_rgba(0,0,0,0.8)] font-medium">
+        {label}
+      </span>
+    </button>
+  )
+}
diff --git a/app/components/Dock.tsx b/app/components/Dock.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..c417aced7f0c7b2afc659782d33f45c2049a74ed
--- /dev/null
+++ b/app/components/Dock.tsx
@@ -0,0 +1,170 @@
+'use client'
+
+import React, { useState } from 'react'
+import {
+  Folder,
+  Calendar as CalendarIcon,
+  Clock as ClockIcon,
+  Globe,
+  Sparkle,
+  Trash,
+  FolderOpen,
+  Compass,
+  Code,
+  Lightning
+} from '@phosphor-icons/react'
+
+interface DockProps {
+  onOpenFileManager: (path: string) => void
+  onOpenCalendar: () => void
+  onOpenClock: () => void
+  onOpenBrowser: () => void
+  onOpenGeminiChat: () => void
+  onOpenVSCode?: () => void
+  onOpenCodePlayground?: () => void
+}
+
+interface DockItemProps {
+  icon: React.ReactNode
+  label: string
+  onClick: () => void
+  isActive?: boolean
+  className?: string
+}
+
+const DockItem: React.FC<DockItemProps> = ({ icon, label, onClick, isActive = false, className = '' }) => {
+  const [isHovered, setIsHovered] = useState(false)
+
+  return (
+    <div className="dock-item group">
+      <button
+        onMouseEnter={() => setIsHovered(true)}
+        onMouseLeave={() => setIsHovered(false)}
+        onClick={onClick}
+        className={`app-icon w-12 h-12 rounded-xl shadow-lg flex items-center justify-center cursor-pointer border transition-all ${className}`}
+        title={label}
+      >
+        {icon}
+      </button>
+      <div
+        className={`dock-dot ${isActive ? 'opacity-100' : ''}`}
+        id={`dot-${label.toLowerCase().replace(/\s+/g, '-')}`}
+      />
+    </div>
+  )
+}
+
+export function Dock({
+  onOpenFileManager,
+  onOpenCalendar,
+  onOpenClock,
+  onOpenBrowser,
+  onOpenGeminiChat,
+  onOpenVSCode,
+  onOpenCodePlayground
+}: DockProps) {
+  const dockItems = [
+    {
+      icon: (
+        <div className="bg-gradient-to-br from-blue-400 to-cyan-200 w-full h-full rounded-xl flex items-center justify-center border border-white/30">
+          <Folder size={28} weight="regular" className="text-blue-900" />
+        </div>
+      ),
+      label: 'Files',
+      onClick: () => onOpenFileManager(''),
+      className: ''
+    },
+    {
+      icon: (
+        <div className="bg-white w-full h-full rounded-xl overflow-hidden relative flex items-center justify-center">
+          <div className="absolute inset-0 bg-gradient-to-tr from-blue-500 to-cyan-300" />
+          <Compass size={36} weight="light" className="text-white relative z-10" />
+        </div>
+      ),
+      label: 'Browser',
+      onClick: onOpenBrowser,
+      className: ''
+    },
+    {
+      icon: (
+        <div className="bg-white w-full h-full rounded-xl flex items-center justify-center border border-gray-200">
+          <Sparkle size={28} weight="fill" className="text-blue-500" />
+        </div>
+      ),
+      label: 'Gemini',
+      onClick: onOpenGeminiChat,
+      className: ''
+    },
+    {
+      icon: (
+        <div className="bg-black w-full h-full rounded-full flex items-center justify-center border border-gray-600">
+          <div className="w-10 h-10 rounded-full border border-gray-600 relative bg-black">
+            <div className="absolute top-1/2 left-1/2 w-0.5 h-2.5 bg-white origin-bottom -translate-x-1/2 -translate-y-full" />
+            <div className="absolute top-1/2 left-1/2 w-0.5 h-3.5 bg-gray-300 origin-bottom -translate-x-1/2 -translate-y-full" />
+            <div className="absolute top-1/2 left-1/2 w-0.5 h-4 bg-orange-500 origin-bottom -translate-x-1/2 -translate-y-full animate-spin" style={{ animationDuration: '60s' }} />
+          </div>
+        </div>
+      ),
+      label: 'Clock',
+      onClick: onOpenClock,
+      className: 'rounded-full'
+    },
+    {
+      icon: (
+        <div className="bg-gradient-to-br from-purple-500 to-purple-600 w-full h-full rounded-xl flex items-center justify-center shadow-inner">
+          <CalendarIcon size={28} weight="regular" className="text-white" />
+        </div>
+      ),
+      label: 'Calendar',
+      onClick: onOpenCalendar,
+      className: ''
+    },
+    {
+      icon: (
+        <div className="bg-gradient-to-br from-blue-600 to-blue-800 w-full h-full rounded-xl flex items-center justify-center border border-blue-900/30 shadow-inner">
+          <Code size={28} weight="bold" className="text-white" />
+        </div>
+      ),
+      label: 'VS Code',
+      onClick: onOpenVSCode || (() => {}),
+      className: ''
+    },
+    {
+      icon: (
+        <div className="bg-gradient-to-br from-yellow-500 to-orange-600 w-full h-full rounded-xl flex items-center justify-center border border-orange-700/30 shadow-inner">
+          <Lightning size={28} weight="fill" className="text-white" />
+        </div>
+      ),
+      label: 'Code Playground',
+      onClick: onOpenCodePlayground || (() => {}),
+      className: ''
+    }
+  ]
+
+  return (
+    <div className="dock-container">
+      <div className="dock-glass px-3 pb-2 pt-3 rounded-2xl flex items-end gap-2 shadow-2xl border border-white/20 transition-all duration-300">
+        {dockItems.map((item, index) => (
+          <React.Fragment key={item.label}>
+            <DockItem {...item} />
+            {index === dockItems.length - 1 && (
+              <>
+                <div className="w-px h-10 bg-gray-400/30 mx-1" />
+                <DockItem
+                  icon={
+                    <div className="bg-gradient-to-b from-gray-200 to-gray-300 w-full h-full rounded-xl flex items-center justify-center border border-white/40">
+                      <Trash size={24} weight="regular" className="text-gray-600" />
+                    </div>
+                  }
+                  label="Trash"
+                  onClick={() => {}}
+                  className=""
+                />
+              </>
+            )}
+          </React.Fragment>
+        ))}
+      </div>
+    </div>
+  )
+}
\ No newline at end of file
diff --git a/app/components/DraggableDesktopIcon.tsx b/app/components/DraggableDesktopIcon.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..f1d52523f6bf50412792957ce458caac28aa2430
--- /dev/null
+++ b/app/components/DraggableDesktopIcon.tsx
@@ -0,0 +1,146 @@
+'use client'
+
+import React, { useState, useRef } from 'react'
+import Draggable from 'react-draggable'
+import {
+  Folder,
+  Calendar,
+  Clock,
+  Globe,
+  Sparkle,
+  Terminal,
+  HardDrives,
+  Compass,
+  Code,
+  Lightning
+} from '@phosphor-icons/react'
+
+interface DraggableDesktopIconProps {
+  id: string
+  label: string
+  iconType: string
+  initialPosition?: { x: number; y: number }
+  onClick: () => void
+  onDoubleClick: () => void
+}
+
+export function DraggableDesktopIcon({
+  id,
+  label,
+  iconType,
+  initialPosition = { x: 0, y: 0 },
+  onClick,
+  onDoubleClick
+}: DraggableDesktopIconProps) {
+  const [selected, setSelected] = useState(false)
+  const nodeRef = useRef<HTMLDivElement>(null) as React.MutableRefObject<HTMLDivElement>
+
+  const handleClick = () => {
+    setSelected(true)
+    onClick()
+    // Deselect after a short time
+    setTimeout(() => setSelected(false), 3000)
+  }
+
+  const getIcon = () => {
+    switch (iconType) {
+      case 'files':
+        return (
+          <div className="bg-gradient-to-br from-blue-400 to-cyan-200 w-full h-full rounded-xl flex items-center justify-center border border-white/30">
+            <Folder size={32} weight="regular" className="text-blue-900" />
+          </div>
+        )
+      case 'calendar':
+        return (
+          <div className="bg-gradient-to-br from-purple-500 to-purple-600 w-full h-full rounded-xl flex items-center justify-center shadow-inner">
+            <Calendar size={32} weight="regular" className="text-white" />
+          </div>
+        )
+      case 'clock':
+        return (
+          <div className="bg-black w-full h-full rounded-full flex items-center justify-center border-2 border-gray-600">
+            <Clock size={32} weight="regular" className="text-white" />
+          </div>
+        )
+      case 'browser':
+        return (
+          <div className="bg-white w-full h-full rounded-xl overflow-hidden relative flex items-center justify-center">
+            <div className="absolute inset-0 bg-gradient-to-tr from-blue-500 to-cyan-300" />
+            <Compass size={36} weight="light" className="text-white relative z-10" />
+          </div>
+        )
+      case 'gemini':
+        return (
+          <div className="bg-white w-full h-full rounded-xl flex items-center justify-center border border-gray-200">
+            <Sparkle size={32} weight="fill" className="text-blue-500" />
+          </div>
+        )
+      case 'terminal':
+        return (
+          <div className="bg-gray-800 w-full h-full rounded-xl flex items-center justify-center border border-gray-600">
+            <span className="text-white font-mono font-bold text-xl">&gt;_</span>
+          </div>
+        )
+      case 'harddrive':
+        return (
+          <div className="bg-gray-200 w-full h-full rounded-lg flex items-center justify-center border border-gray-300 relative">
+            <HardDrives size={32} weight="regular" className="text-gray-600" />
+            <div className="absolute bottom-2 right-2 w-1.5 h-1.5 bg-green-400 rounded-full animate-pulse" />
+          </div>
+        )
+      case 'vscode':
+        return (
+          <div className="bg-gradient-to-br from-blue-600 to-blue-800 w-full h-full rounded-xl flex items-center justify-center border border-blue-900/30 shadow-inner">
+            <Code size={32} weight="bold" className="text-white" />
+          </div>
+        )
+      case 'playground':
+        return (
+          <div className="bg-gradient-to-br from-yellow-500 to-orange-600 w-full h-full rounded-xl flex items-center justify-center border border-orange-700/30 shadow-inner">
+            <Lightning size={32} weight="fill" className="text-white" />
+          </div>
+        )
+      default:
+        return (
+          <div className="bg-gray-400 w-full h-full rounded-xl flex items-center justify-center">
+            <Folder size={32} weight="regular" className="text-white" />
+          </div>
+        )
+    }
+  }
+
+  return (
+    <Draggable
+      nodeRef={nodeRef}
+      defaultPosition={initialPosition}
+      grid={[25, 25]}
+      handle=".icon-handle"
+    >
+      <div
+        ref={nodeRef}
+        className="absolute flex flex-col items-center w-20 group cursor-pointer transition-all hover:bg-white/10 rounded p-1"
+        onClick={handleClick}
+        onDoubleClick={onDoubleClick}
+      >
+        <div className="icon-handle">
+          <div
+            className={`w-14 h-14 shadow-lg transition-transform hover:scale-110 ${
+              iconType === 'clock' ? '' : 'rounded-xl'
+            }`}
+          >
+            {getIcon()}
+          </div>
+        </div>
+        <span
+          className={`mt-1 text-xs font-medium drop-shadow-lg text-center leading-tight px-1 py-0.5 rounded transition-colors ${
+            selected
+              ? 'bg-blue-600/80 text-white'
+              : 'text-white bg-black/20 group-hover:bg-blue-600/80'
+          }`}
+        >
+          {label}
+        </span>
+      </div>
+    </Draggable>
+  )
+}
\ No newline at end of file
diff --git a/app/components/FileManager.tsx b/app/components/FileManager.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..8b63b196e28b3fc3e7bd8d5d7933c79e79d2c196
--- /dev/null
+++ b/app/components/FileManager.tsx
@@ -0,0 +1,542 @@
+'use client'
+
+import React, { useState, useEffect } from 'react'
+import {
+  X,
+  Minus,
+  Square,
+  CaretLeft,
+  CaretRight,
+  House,
+  MagnifyingGlass,
+  Folder as FolderIcon,
+  File,
+  Image as ImageIcon,
+  FilePdf,
+  FileDoc,
+  FileText,
+  Upload,
+  Download,
+  Trash,
+  Plus,
+  Eye,
+  Users,
+  Globe
+} from '@phosphor-icons/react'
+import { motion } from 'framer-motion'
+import { FilePreview } from './FilePreview'
+
+interface FileManagerProps {
+  currentPath: string
+  onNavigate: (path: string) => void
+  onClose: () => void
+}
+
+interface FileItem {
+  name: string
+  type: 'folder' | 'file'
+  size?: number
+  modified?: string
+  path: string
+  extension?: string
+}
+
+export function FileManager({ currentPath, onNavigate, onClose }: FileManagerProps) {
+  const [files, setFiles] = useState<FileItem[]>([])
+  const [loading, setLoading] = useState(true)
+  const [searchQuery, setSearchQuery] = useState('')
+  const [selectedFiles, setSelectedFiles] = useState<Set<string>>(new Set())
+  const [uploadModalOpen, setUploadModalOpen] = useState(false)
+  const [previewFile, setPreviewFile] = useState<FileItem | null>(null)
+  const [windowPos, setWindowPos] = useState({ x: 60, y: 60 })
+  const [isDragging, setIsDragging] = useState(false)
+  const [dragStart, setDragStart] = useState({ x: 0, y: 0 })
+  const [isPublicFolder, setIsPublicFolder] = useState(false)
+
+  // Load files when path changes
+  useEffect(() => {
+    // Check if this is the public folder
+    setIsPublicFolder(currentPath === 'public' || currentPath.startsWith('public/'))
+    loadFiles()
+  }, [currentPath])
+
+  const loadFiles = async () => {
+    setLoading(true)
+    try {
+      let response
+      if (currentPath === 'public' || currentPath.startsWith('public/')) {
+        // Load from public folder API
+        const publicPath = currentPath === 'public' ? '' : currentPath.replace('public/', '')
+        response = await fetch(`/api/public?folder=${encodeURIComponent(publicPath)}`)
+      } else {
+        // Load from regular files API
+        response = await fetch(`/api/files?folder=${encodeURIComponent(currentPath)}`)
+      }
+
+      const data = await response.json()
+
+      // Add public folder to root directory
+      if (currentPath === '') {
+        const publicFolder = {
+          name: 'Public Folder',
+          type: 'folder' as const,
+          path: 'public',
+          modified: new Date().toISOString()
+        }
+
+        // Add public folder if it doesn't exist
+        if (!data.files.some((f: FileItem) => f.path === 'public')) {
+          data.files.unshift(publicFolder)
+        }
+      }
+
+      setFiles(data.files || [])
+    } catch (error) {
+      console.error('Error loading files:', error)
+      setFiles([])
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const handleUpload = async (file: File, targetFolder: string) => {
+    const formData = new FormData()
+    formData.append('file', file)
+
+    try {
+      let response
+      if (isPublicFolder) {
+        // Upload to public folder
+        const publicPath = currentPath === 'public' ? '' : currentPath.replace('public/', '')
+        formData.append('folder', publicPath)
+        formData.append('uploadedBy', 'User') // You can customize this
+        response = await fetch('/api/public', {
+          method: 'POST',
+          body: formData
+        })
+      } else {
+        // Upload to regular folder
+        formData.append('folder', targetFolder)
+        response = await fetch('/api/upload', {
+          method: 'POST',
+          body: formData
+        })
+      }
+
+      const result = await response.json()
+      if (result.success) {
+        loadFiles() // Reload files
+        setUploadModalOpen(false)
+      } else {
+        alert(`Upload failed: ${result.error}`)
+      }
+    } catch (error) {
+      console.error('Error uploading file:', error)
+      alert('Failed to upload file')
+    }
+  }
+
+  const handleDownload = (file: FileItem) => {
+    window.open(`/api/download?path=${encodeURIComponent(file.path)}`, '_blank')
+  }
+
+  const handlePreview = (file: FileItem) => {
+    setPreviewFile(file)
+  }
+
+  const handleDelete = async (file: FileItem) => {
+    if (!confirm(`Delete ${file.name}?`)) return
+
+    try {
+      const response = await fetch(`/api/files?path=${encodeURIComponent(file.path)}`, {
+        method: 'DELETE'
+      })
+
+      const result = await response.json()
+      if (result.success) {
+        loadFiles()
+      } else {
+        alert(`Delete failed: ${result.error}`)
+      }
+    } catch (error) {
+      console.error('Error deleting file:', error)
+      alert('Failed to delete file')
+    }
+  }
+
+  const handleCreateFolder = async () => {
+    const folderName = prompt('Enter folder name:')
+    if (!folderName) return
+
+    try {
+      const response = await fetch('/api/files', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          folderName,
+          parentPath: currentPath
+        })
+      })
+
+      const result = await response.json()
+      if (result.success) {
+        loadFiles()
+      } else {
+        alert(`Create folder failed: ${result.error}`)
+      }
+    } catch (error) {
+      console.error('Error creating folder:', error)
+      alert('Failed to create folder')
+    }
+  }
+
+  const getFileIcon = (file: FileItem) => {
+    if (file.type === 'folder') {
+      // Special icon for public folder
+      if (file.path === 'public' || file.name === 'Public Folder') {
+        return <Users size={48} weight="fill" className="text-purple-400" />
+      }
+      return <FolderIcon size={48} weight="fill" className="text-orange-400" />
+    }
+
+    const ext = file.extension?.toLowerCase()
+    switch (ext) {
+      case 'pdf':
+        return <FilePdf size={48} weight="fill" className="text-red-500" />
+      case 'doc':
+      case 'docx':
+        return <FileDoc size={48} weight="fill" className="text-blue-500" />
+      case 'txt':
+      case 'md':
+        return <FileText size={48} weight="fill" className="text-gray-600" />
+      case 'jpg':
+      case 'jpeg':
+      case 'png':
+      case 'gif':
+        return <ImageIcon size={48} weight="fill" className="text-green-500" />
+      default:
+        return <File size={48} weight="regular" className="text-gray-500" />
+    }
+  }
+
+  const formatFileSize = (bytes?: number) => {
+    if (!bytes) return ''
+    const units = ['B', 'KB', 'MB', 'GB']
+    let size = bytes
+    let unitIndex = 0
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024
+      unitIndex++
+    }
+    return `${size.toFixed(1)} ${units[unitIndex]}`
+  }
+
+  const filteredFiles = files.filter(file =>
+    file.name.toLowerCase().includes(searchQuery.toLowerCase())
+  )
+
+  // Group files by current directory level
+  const currentLevelFiles = filteredFiles.filter(file => {
+    const relativePath = currentPath ? file.path.replace(currentPath + '/', '') : file.path
+    return !relativePath.includes('/')
+  })
+
+  const handleMouseDown = (e: React.MouseEvent) => {
+    if ((e.target as HTMLElement).closest('.window-controls')) return
+    setIsDragging(true)
+    setDragStart({ x: e.clientX - windowPos.x, y: e.clientY - windowPos.y })
+  }
+
+  const handleMouseMove = (e: MouseEvent) => {
+    if (isDragging) {
+      setWindowPos({
+        x: e.clientX - dragStart.x,
+        y: e.clientY - dragStart.y,
+      })
+    }
+  }
+
+  const handleMouseUp = () => {
+    setIsDragging(false)
+  }
+
+  useEffect(() => {
+    if (isDragging) {
+      window.addEventListener('mousemove', handleMouseMove)
+      window.addEventListener('mouseup', handleMouseUp)
+      return () => {
+        window.removeEventListener('mousemove', handleMouseMove)
+        window.removeEventListener('mouseup', handleMouseUp)
+      }
+    }
+  }, [isDragging, dragStart])
+
+  return (
+    <>
+      <motion.div
+        style={{ left: windowPos.x, top: windowPos.y }}
+        className="fixed w-[800px] h-[600px] bg-white rounded-lg shadow-2xl overflow-hidden flex flex-col z-30 select-none"
+      >
+        {/* Title Bar */}
+        <div
+          onMouseDown={handleMouseDown}
+          className="h-11 bg-gradient-to-b from-[#f6f5f4] to-[#edebe9] border-b border-[#d0d0d0] flex items-center justify-between px-3 cursor-move"
+        >
+          <div className="flex items-center gap-2 flex-1">
+            <div className="flex items-center gap-1 window-controls">
+              <button
+                onClick={onClose}
+                className="w-5 h-5 rounded-full bg-[#E95420] hover:bg-[#d14818] flex items-center justify-center group"
+              >
+                <X size={12} weight="bold" className="text-white opacity-0 group-hover:opacity-100" />
+              </button>
+              <button className="w-5 h-5 rounded-full bg-[#ddd] hover:bg-[#ccc] flex items-center justify-center group">
+                <Minus size={12} weight="bold" className="text-[#666] opacity-0 group-hover:opacity-100" />
+              </button>
+              <button className="w-5 h-5 rounded-full bg-[#ddd] hover:bg-[#ccc] flex items-center justify-center group">
+                <Square size={10} weight="bold" className="text-[#666] opacity-0 group-hover:opacity-100" />
+              </button>
+            </div>
+            <span className="text-sm font-medium text-[#2c2c2c] ml-2 flex items-center gap-2">
+              File Manager - {isPublicFolder ? (
+                <>
+                  <Globe size={16} className="text-purple-500" />
+                  Public Folder {currentPath.replace('public', '').replace('/', '')}
+                </>
+              ) : (currentPath || 'Documents')}
+            </span>
+          </div>
+        </div>
+
+        {/* Toolbar */}
+        <div className="h-12 bg-[#fafafa] border-b border-[#e0e0e0] flex items-center px-3 gap-2">
+          <div className="flex items-center gap-1">
+            <button
+              onClick={() => {
+                const parent = currentPath.split('/').slice(0, -1).join('/')
+                onNavigate(parent)
+              }}
+              disabled={!currentPath}
+              className="p-1.5 hover:bg-[#e8e8e8] rounded disabled:opacity-40 disabled:hover:bg-transparent"
+            >
+              <CaretLeft size={16} weight="bold" />
+            </button>
+            <button
+              onClick={() => onNavigate('')}
+              className="p-1.5 hover:bg-[#e8e8e8] rounded"
+            >
+              <House size={16} weight="regular" />
+            </button>
+          </div>
+
+          <div className="flex items-center gap-1 px-2 py-1.5 bg-white border border-[#ddd] rounded flex-1">
+            <House size={14} weight="regular" className="text-[#666]" />
+            <span className="text-xs text-[#666]">/</span>
+            <span className="text-xs text-[#2c2c2c]">data/documents/{currentPath}</span>
+          </div>
+
+          <div className="flex items-center gap-1">
+            <button
+              onClick={handleCreateFolder}
+              className="p-1.5 hover:bg-[#e8e8e8] rounded"
+              title="New Folder"
+            >
+              <Plus size={16} weight="bold" />
+            </button>
+            <button
+              onClick={() => setUploadModalOpen(true)}
+              className="p-1.5 hover:bg-[#e8e8e8] rounded"
+              title="Upload File"
+            >
+              <Upload size={16} weight="regular" />
+            </button>
+            <div className="flex items-center gap-1 px-2 py-1 bg-white border border-[#ddd] rounded">
+              <MagnifyingGlass size={14} weight="regular" className="text-[#666]" />
+              <input
+                type="text"
+                placeholder="Search..."
+                value={searchQuery}
+                onChange={(e) => setSearchQuery(e.target.value)}
+                className="text-xs outline-none w-32"
+              />
+            </div>
+          </div>
+        </div>
+
+        {/* File List */}
+        <div className="flex-1 overflow-auto p-4">
+          {loading ? (
+            <div className="flex items-center justify-center h-full text-[#999] text-sm">
+              Loading files...
+            </div>
+          ) : currentLevelFiles.length === 0 ? (
+            <div className="flex items-center justify-center h-full text-[#999] text-sm">
+              {searchQuery ? 'No files found' : 'Folder is empty'}
+            </div>
+          ) : (
+            <div className="grid grid-cols-6 gap-4">
+              {currentLevelFiles.map((file) => (
+                <div
+                  key={file.path}
+                  className="group relative"
+                >
+                  <button
+                    onClick={() => {
+                      if (file.type === 'folder') {
+                        onNavigate(file.path)
+                      } else {
+                        handlePreview(file)
+                      }
+                    }}
+                    className="flex flex-col items-center gap-2 p-2 hover:bg-[#f0f0f0] rounded w-full"
+                  >
+                    <div className="w-16 h-16 flex items-center justify-center">
+                      {getFileIcon(file)}
+                    </div>
+                    <span className="text-xs text-[#2c2c2c] text-center break-all w-full line-clamp-2">
+                      {file.name}
+                    </span>
+                    {file.size && (
+                      <span className="text-xs text-[#666]">
+                        {formatFileSize(file.size)}
+                      </span>
+                    )}
+                  </button>
+
+                  {/* File Actions */}
+                  {file.type === 'file' && (
+                    <div className="absolute top-1 right-1 hidden group-hover:flex gap-1">
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          handlePreview(file)
+                        }}
+                        className="p-1 bg-white rounded shadow hover:bg-[#f0f0f0]"
+                        title="Preview"
+                      >
+                        <Eye size={14} />
+                      </button>
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          handleDownload(file)
+                        }}
+                        className="p-1 bg-white rounded shadow hover:bg-[#f0f0f0]"
+                        title="Download"
+                      >
+                        <Download size={14} />
+                      </button>
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          handleDelete(file)
+                        }}
+                        className="p-1 bg-white rounded shadow hover:bg-red-100"
+                        title="Delete"
+                      >
+                        <Trash size={14} className="text-red-600" />
+                      </button>
+                    </div>
+                  )}
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+
+        {/* Status Bar */}
+        <div className="h-6 bg-[#f6f5f4] border-t border-[#d0d0d0] flex items-center px-3 text-xs text-[#666]">
+          {currentLevelFiles.length} items • {files.filter(f => f.type === 'folder').length} folders • {files.filter(f => f.type === 'file').length} files
+        </div>
+      </motion.div>
+
+      {/* Upload Modal */}
+      {uploadModalOpen && (
+        <UploadModal
+          currentPath={currentPath}
+          onUpload={handleUpload}
+          onClose={() => setUploadModalOpen(false)}
+        />
+      )}
+
+      {/* File Preview Modal */}
+      {previewFile && (
+        <FilePreview
+          file={previewFile}
+          onClose={() => setPreviewFile(null)}
+          onDownload={() => handleDownload(previewFile)}
+        />
+      )}
+    </>
+  )
+}
+
+// Upload Modal Component
+function UploadModal({
+  currentPath,
+  onUpload,
+  onClose
+}: {
+  currentPath: string
+  onUpload: (file: File, folder: string) => void
+  onClose: () => void
+}) {
+  const [selectedFile, setSelectedFile] = useState<File | null>(null)
+  const [targetFolder, setTargetFolder] = useState(currentPath)
+
+  const handleSubmit = () => {
+    if (selectedFile) {
+      onUpload(selectedFile, targetFolder)
+    }
+  }
+
+  return (
+    <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50">
+      <div className="bg-white rounded-lg p-6 w-[400px]">
+        <h2 className="text-lg font-semibold mb-4">Upload File</h2>
+
+        <div className="space-y-4">
+          <div>
+            <label className="block text-sm font-medium mb-2">Select File</label>
+            <input
+              type="file"
+              onChange={(e) => setSelectedFile(e.target.files?.[0] || null)}
+              className="w-full p-2 border rounded"
+            />
+          </div>
+
+          <div>
+            <label className="block text-sm font-medium mb-2">Upload to Folder</label>
+            <input
+              type="text"
+              value={targetFolder}
+              onChange={(e) => setTargetFolder(e.target.value)}
+              placeholder="e.g., homework/math"
+              className="w-full p-2 border rounded"
+            />
+            <p className="text-xs text-gray-500 mt-1">
+              Leave empty for root, or enter path like "folder/subfolder"
+            </p>
+          </div>
+
+          <div className="flex justify-end gap-2">
+            <button
+              onClick={onClose}
+              className="px-4 py-2 text-gray-600 hover:bg-gray-100 rounded"
+            >
+              Cancel
+            </button>
+            <button
+              onClick={handleSubmit}
+              disabled={!selectedFile}
+              className="px-4 py-2 bg-[#E95420] text-white rounded hover:bg-[#d14818] disabled:opacity-50"
+            >
+              Upload
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
diff --git a/app/components/FilePreview.tsx b/app/components/FilePreview.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..295a55fe6c2e97f9a5018213fdc93fe219b076b7
--- /dev/null
+++ b/app/components/FilePreview.tsx
@@ -0,0 +1,372 @@
+'use client'
+
+import React, { useState, useEffect } from 'react'
+import { X, Download, MagnifyingGlassPlus, MagnifyingGlassMinus } from '@phosphor-icons/react'
+import mammoth from 'mammoth'
+import * as XLSX from 'xlsx'
+import { PDFViewer } from './PDFViewer'
+
+interface FilePreviewProps {
+  file: {
+    name: string
+    path: string
+    extension?: string
+    size?: number
+  }
+  onClose: () => void
+  onDownload: () => void
+}
+
+export function FilePreview({ file, onClose, onDownload }: FilePreviewProps) {
+  const [content, setContent] = useState<any>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [scale, setScale] = useState(1)
+
+  // Excel specific state
+  const [activeSheet, setActiveSheet] = useState(0)
+
+  const previewUrl = `/api/download?path=${encodeURIComponent(file.path)}&preview=true`
+  const ext = file.extension?.toLowerCase() || ''
+
+  useEffect(() => {
+    loadFileContent()
+  }, [file])
+
+  const loadFileContent = async () => {
+    setLoading(true)
+    setError(null)
+
+    try {
+      switch (ext) {
+        case 'docx':
+        case 'doc':
+          await loadWordDocument()
+          break
+        case 'xlsx':
+        case 'xls':
+          await loadExcelDocument()
+          break
+        case 'pptx':
+        case 'ppt':
+          await loadPowerPointDocument()
+          break
+        case 'txt':
+        case 'md':
+        case 'json':
+        case 'js':
+        case 'ts':
+        case 'jsx':
+        case 'tsx':
+        case 'css':
+        case 'html':
+        case 'xml':
+        case 'py':
+        case 'java':
+        case 'cpp':
+        case 'c':
+        case 'h':
+        case 'sh':
+        case 'yaml':
+        case 'yml':
+          await loadTextFile()
+          break
+        case 'csv':
+          await loadCSVFile()
+          break
+        default:
+          setContent(null)
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to load file')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const loadWordDocument = async () => {
+    try {
+      const response = await fetch(previewUrl)
+      const arrayBuffer = await response.arrayBuffer()
+      const result = await mammoth.convertToHtml({ arrayBuffer })
+      setContent({ type: 'html', data: result.value })
+    } catch (err) {
+      throw new Error('Failed to load Word document')
+    }
+  }
+
+  const loadExcelDocument = async () => {
+    try {
+      const response = await fetch(previewUrl)
+      const arrayBuffer = await response.arrayBuffer()
+      const workbook = XLSX.read(arrayBuffer, { type: 'array' })
+
+      // Convert all sheets to HTML
+      const sheets = workbook.SheetNames.map(name => ({
+        name,
+        html: XLSX.utils.sheet_to_html(workbook.Sheets[name], {
+          header: '<table class="excel-table">',
+          footer: '</table>'
+        })
+      }))
+
+      setContent({ type: 'excel', data: sheets })
+    } catch (err) {
+      throw new Error('Failed to load Excel document')
+    }
+  }
+
+  const loadPowerPointDocument = async () => {
+    // For PowerPoint, we'll show a message to download
+    // Full PowerPoint rendering requires more complex libraries
+    setContent({ type: 'powerpoint', data: null })
+  }
+
+  const loadTextFile = async () => {
+    try {
+      const response = await fetch(previewUrl)
+      const text = await response.text()
+      setContent({ type: 'text', data: text })
+    } catch (err) {
+      throw new Error('Failed to load text file')
+    }
+  }
+
+  const loadCSVFile = async () => {
+    try {
+      const response = await fetch(previewUrl)
+      const text = await response.text()
+      const workbook = XLSX.read(text, { type: 'string' })
+      const sheet = workbook.Sheets[workbook.SheetNames[0]]
+      const html = XLSX.utils.sheet_to_html(sheet, {
+        header: '<table class="csv-table">',
+        footer: '</table>'
+      })
+      setContent({ type: 'html', data: html })
+    } catch (err) {
+      throw new Error('Failed to load CSV file')
+    }
+  }
+
+
+  const renderContent = () => {
+    if (loading) {
+      return (
+        <div className="flex items-center justify-center h-full">
+          <div className="text-gray-600">Loading...</div>
+        </div>
+      )
+    }
+
+    if (error) {
+      return (
+        <div className="flex flex-col items-center justify-center h-full">
+          <p className="text-red-600 mb-4">{error}</p>
+          <button
+            onClick={onDownload}
+            className="px-4 py-2 bg-blue-500 text-white rounded hover:bg-blue-600"
+          >
+            Download to View
+          </button>
+        </div>
+      )
+    }
+
+    // PDF files
+    if (ext === 'pdf') {
+      return (
+        <PDFViewer
+          url={previewUrl}
+          scale={scale}
+          onZoomIn={() => setScale(prev => Math.min(2, prev + 0.1))}
+          onZoomOut={() => setScale(prev => Math.max(0.5, prev - 0.1))}
+        />
+      )
+    }
+
+    // Image files
+    if (['jpg', 'jpeg', 'png', 'gif', 'svg', 'webp', 'bmp'].includes(ext)) {
+      return (
+        <div className="flex items-center justify-center h-full p-4">
+          <img
+            src={previewUrl}
+            alt={file.name}
+            className="max-w-full max-h-full object-contain"
+            style={{ transform: `scale(${scale})` }}
+          />
+          <div className="absolute bottom-4 left-1/2 -translate-x-1/2 flex items-center gap-2 bg-white rounded-lg shadow-lg p-2">
+            <button
+              onClick={() => setScale(prev => Math.max(0.5, prev - 0.1))}
+              className="p-1 rounded hover:bg-gray-100"
+            >
+              <MagnifyingGlassMinus size={16} />
+            </button>
+            <span className="text-sm px-2">{Math.round(scale * 100)}%</span>
+            <button
+              onClick={() => setScale(prev => Math.min(3, prev + 0.1))}
+              className="p-1 rounded hover:bg-gray-100"
+            >
+              <MagnifyingGlassPlus size={16} />
+            </button>
+          </div>
+        </div>
+      )
+    }
+
+    // HTML content (Word docs, converted HTML)
+    if (content?.type === 'html') {
+      return (
+        <div className="p-4 overflow-auto h-full">
+          <div
+            dangerouslySetInnerHTML={{ __html: content.data }}
+            className="prose max-w-none"
+          />
+        </div>
+      )
+    }
+
+    // Excel sheets
+    if (content?.type === 'excel') {
+      return (
+        <div className="flex flex-col h-full">
+          <div className="flex gap-2 p-2 border-b">
+            {content.data.map((sheet: any, index: number) => (
+              <button
+                key={index}
+                onClick={() => setActiveSheet(index)}
+                className={`px-3 py-1 rounded ${
+                  activeSheet === index ? 'bg-blue-500 text-white' : 'bg-gray-100'
+                }`}
+              >
+                {sheet.name}
+              </button>
+            ))}
+          </div>
+          <div className="flex-1 overflow-auto p-4">
+            <div
+              dangerouslySetInnerHTML={{ __html: content.data[activeSheet].html }}
+              className="excel-preview"
+            />
+          </div>
+        </div>
+      )
+    }
+
+    // Text files
+    if (content?.type === 'text') {
+      return (
+        <div className="h-full overflow-auto">
+          <pre className="p-4 text-sm font-mono whitespace-pre-wrap">
+            {content.data}
+          </pre>
+        </div>
+      )
+    }
+
+    // PowerPoint placeholder
+    if (content?.type === 'powerpoint') {
+      return (
+        <div className="flex flex-col items-center justify-center h-full">
+          <div className="text-6xl mb-4">📊</div>
+          <p className="text-gray-600 mb-4">PowerPoint presentation</p>
+          <p className="text-sm text-gray-500 mb-4">Preview requires download</p>
+          <button
+            onClick={onDownload}
+            className="px-4 py-2 bg-blue-500 text-white rounded hover:bg-blue-600"
+          >
+            Download to View
+          </button>
+        </div>
+      )
+    }
+
+    // Default fallback
+    return (
+      <iframe
+        src={previewUrl}
+        className="w-full h-full border-0"
+        title={file.name}
+      />
+    )
+  }
+
+  return (
+    <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-50">
+      <div className="bg-white rounded-lg w-[90%] h-[90%] flex flex-col">
+        <div className="flex items-center justify-between p-4 border-b">
+          <div>
+            <h2 className="text-lg font-semibold">{file.name}</h2>
+            <p className="text-sm text-gray-500">
+              {ext.toUpperCase()} • {file.size ? formatFileSize(file.size) : 'Unknown size'}
+            </p>
+          </div>
+          <div className="flex gap-2">
+            <button
+              onClick={onDownload}
+              className="px-4 py-2 bg-blue-500 text-white rounded hover:bg-blue-600 flex items-center gap-2"
+            >
+              <Download size={20} />
+              Download
+            </button>
+            <button
+              onClick={onClose}
+              className="p-2 hover:bg-gray-100 rounded"
+            >
+              <X size={20} />
+            </button>
+          </div>
+        </div>
+
+        <div className="flex-1 overflow-hidden relative">
+          {renderContent()}
+        </div>
+      </div>
+
+      <style jsx global>{`
+        .excel-table, .csv-table {
+          border-collapse: collapse;
+          width: 100%;
+        }
+        .excel-table td, .excel-table th,
+        .csv-table td, .csv-table th {
+          border: 1px solid #ddd;
+          padding: 8px;
+          text-align: left;
+        }
+        .excel-table th, .csv-table th {
+          background-color: #f2f2f2;
+          font-weight: bold;
+        }
+        .excel-table tr:nth-child(even),
+        .csv-table tr:nth-child(even) {
+          background-color: #f9f9f9;
+        }
+        .excel-preview {
+          font-family: 'Arial', sans-serif;
+        }
+        .prose {
+          max-width: none;
+        }
+        .prose h1 { font-size: 2em; font-weight: bold; margin: 1em 0 0.5em; }
+        .prose h2 { font-size: 1.5em; font-weight: bold; margin: 1em 0 0.5em; }
+        .prose h3 { font-size: 1.2em; font-weight: bold; margin: 1em 0 0.5em; }
+        .prose p { margin: 1em 0; }
+        .prose ul, .prose ol { margin: 1em 0; padding-left: 2em; }
+        .prose li { margin: 0.5em 0; }
+        .prose strong { font-weight: bold; }
+        .prose em { font-style: italic; }
+      `}</style>
+    </div>
+  )
+}
+
+function formatFileSize(bytes: number): string {
+  const units = ['B', 'KB', 'MB', 'GB']
+  let size = bytes
+  let unitIndex = 0
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024
+    unitIndex++
+  }
+  return `${size.toFixed(1)} ${units[unitIndex]}`
+}
\ No newline at end of file
diff --git a/app/components/GeminiChat.tsx b/app/components/GeminiChat.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..a2398e1945561767741dc906e8c4fbdc43eeb724
--- /dev/null
+++ b/app/components/GeminiChat.tsx
@@ -0,0 +1,258 @@
+'use client'
+
+import React, { useState, useRef, useEffect } from 'react'
+import Window from './Window'
+import {
+  PaperPlaneRight,
+  Sparkle,
+  ArrowUp
+} from '@phosphor-icons/react'
+
+interface GeminiChatProps {
+  onClose: () => void
+}
+
+interface Message {
+  id: string
+  role: 'user' | 'assistant'
+  content: string
+  timestamp: number
+}
+
+export function GeminiChat({ onClose }: GeminiChatProps) {
+  const [messages, setMessages] = useState<Message[]>([
+    {
+      id: '1',
+      role: 'assistant',
+      content: "Hello! I'm Gemini. How can I help you today?",
+      timestamp: Date.now()
+    }
+  ])
+  const [input, setInput] = useState('')
+  const [isLoading, setIsLoading] = useState(false)
+  const scrollRef = useRef<HTMLDivElement>(null)
+  const inputRef = useRef<HTMLInputElement>(null)
+
+  useEffect(() => {
+    // Load messages from localStorage
+    const savedMessages = localStorage.getItem('gemini-chat-messages')
+    if (savedMessages) {
+      try {
+        const parsed = JSON.parse(savedMessages)
+        if (parsed.length > 0) {
+          setMessages(parsed)
+        }
+      } catch (e) {
+        console.error('Failed to load messages')
+      }
+    }
+  }, [])
+
+  useEffect(() => {
+    // Save messages to localStorage
+    if (messages.length > 1) {
+      localStorage.setItem('gemini-chat-messages', JSON.stringify(messages.slice(-20))) // Keep last 20 messages
+    }
+  }, [messages])
+
+  useEffect(() => {
+    if (scrollRef.current) {
+      scrollRef.current.scrollTop = scrollRef.current.scrollHeight
+    }
+  }, [messages])
+
+  const handleSend = async () => {
+    if (!input.trim() || isLoading) return
+
+    const userMessage: Message = {
+      id: Date.now().toString(),
+      role: 'user',
+      content: input.trim(),
+      timestamp: Date.now()
+    }
+
+    setMessages(prev => [...prev, userMessage])
+    setInput('')
+    setIsLoading(true)
+
+    try {
+      // Get conversation history (last 10 messages)
+      const history = messages.slice(-10).map(msg => ({
+        role: msg.role,
+        content: msg.content
+      }))
+
+      const response = await fetch('/api/gemini/chat', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          message: userMessage.content,
+          history
+        }),
+      })
+
+      const data = await response.json()
+
+      if (response.ok && data.response) {
+        const assistantMessage: Message = {
+          id: (Date.now() + 1).toString(),
+          role: 'assistant',
+          content: data.response,
+          timestamp: Date.now()
+        }
+        setMessages(prev => [...prev, assistantMessage])
+      } else {
+        // Fallback response if API fails
+        const fallbackResponses = [
+          "I'm here to help! What would you like to know?",
+          "That's interesting! Tell me more about it.",
+          "I can help with that! Let me think about the best approach.",
+          "Great question! Here's what I think...",
+          "I understand. Let me help you with that."
+        ]
+        const randomResponse = fallbackResponses[Math.floor(Math.random() * fallbackResponses.length)]
+
+        const assistantMessage: Message = {
+          id: (Date.now() + 1).toString(),
+          role: 'assistant',
+          content: randomResponse,
+          timestamp: Date.now()
+        }
+        setMessages(prev => [...prev, assistantMessage])
+      }
+    } catch (error) {
+      console.error('Error sending message:', error)
+      const errorMessage: Message = {
+        id: (Date.now() + 1).toString(),
+        role: 'assistant',
+        content: "I'm currently running in demo mode. For full functionality, please ensure the API is configured.",
+        timestamp: Date.now()
+      }
+      setMessages(prev => [...prev, errorMessage])
+    }
+
+    setIsLoading(false)
+  }
+
+  const handleKeyPress = (e: React.KeyboardEvent) => {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault()
+      handleSend()
+    }
+  }
+
+  const clearChat = () => {
+    setMessages([
+      {
+        id: Date.now().toString(),
+        role: 'assistant',
+        content: "Chat history cleared. How can I help you today?",
+        timestamp: Date.now()
+      }
+    ])
+    localStorage.removeItem('gemini-chat-messages')
+  }
+
+  return (
+    <Window
+      id="gemini"
+      title="Gemini Ultra"
+      isOpen={true}
+      onClose={onClose}
+      width={700}
+      height={500}
+      x={100}
+      y={100}
+      className="gemini-window"
+      headerClassName="bg-white border-b border-gray-100"
+    >
+      <div className="flex flex-col h-full bg-white">
+        {/* Chat Header */}
+        <div className="px-4 py-2 border-b border-gray-100 flex items-center justify-between">
+          <div className="flex items-center gap-2">
+            <div className="w-8 h-8 rounded-full bg-gradient-to-br from-blue-500 to-pink-600 flex items-center justify-center">
+              <Sparkle size={18} weight="fill" className="text-white" />
+            </div>
+            <span className="text-transparent bg-clip-text bg-gradient-to-r from-blue-500 to-pink-600 font-bold">
+              Gemini Ultra
+            </span>
+          </div>
+          <button
+            onClick={clearChat}
+            className="text-xs text-gray-500 hover:text-gray-700"
+          >
+            Clear chat
+          </button>
+        </div>
+
+        {/* Messages Area */}
+        <div
+          ref={scrollRef}
+          className="flex-1 overflow-y-auto p-4 space-y-4"
+        >
+          {messages.map(message => (
+            <div
+              key={message.id}
+              className={`flex ${message.role === 'user' ? 'justify-end' : 'justify-start'}`}
+            >
+              <div
+                className={`max-w-[80%] ${
+                  message.role === 'user'
+                    ? 'bg-blue-600 text-white rounded-2xl rounded-tr-none'
+                    : 'bg-gray-100 text-gray-800 rounded-2xl rounded-tl-none'
+                } px-4 py-2 text-sm`}
+              >
+                {message.role === 'assistant' && (
+                  <p className="font-semibold text-blue-600 mb-1 text-xs">Gemini</p>
+                )}
+                <p className="whitespace-pre-wrap">{message.content}</p>
+              </div>
+            </div>
+          ))}
+
+          {isLoading && (
+            <div className="flex justify-start">
+              <div className="bg-gray-100 rounded-2xl rounded-tl-none px-4 py-3 text-sm">
+                <p className="font-semibold text-blue-600 mb-1 text-xs">Gemini</p>
+                <div className="flex gap-1">
+                  <span className="w-2 h-2 bg-gray-400 rounded-full animate-bounce" style={{ animationDelay: '0ms' }}></span>
+                  <span className="w-2 h-2 bg-gray-400 rounded-full animate-bounce" style={{ animationDelay: '150ms' }}></span>
+                  <span className="w-2 h-2 bg-gray-400 rounded-full animate-bounce" style={{ animationDelay: '300ms' }}></span>
+                </div>
+              </div>
+            </div>
+          )}
+        </div>
+
+        {/* Input Area */}
+        <div className="border-t border-gray-100 p-4">
+          <div className="flex items-center gap-2">
+            <input
+              ref={inputRef}
+              type="text"
+              value={input}
+              onChange={(e) => setInput(e.target.value)}
+              onKeyDown={handleKeyPress}
+              placeholder="Ask Gemini..."
+              className="flex-1 bg-gray-100 rounded-full px-4 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-blue-200 transition-all"
+              disabled={isLoading}
+            />
+            <button
+              onClick={handleSend}
+              disabled={!input.trim() || isLoading}
+              className={`w-8 h-8 rounded-full flex items-center justify-center transition-colors ${
+                input.trim() && !isLoading
+                  ? 'bg-blue-600 hover:bg-blue-700 text-white'
+                  : 'bg-gray-200 text-gray-400 cursor-not-allowed'
+              }`}
+            >
+              <ArrowUp size={16} weight="bold" />
+            </button>
+          </div>
+        </div>
+      </div>
+    </Window>
+  )
+}
\ No newline at end of file
diff --git a/app/components/HelpModal.tsx b/app/components/HelpModal.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..c538313a91a6c82d00327bd45fddceb52ef30ce4
--- /dev/null
+++ b/app/components/HelpModal.tsx
@@ -0,0 +1,172 @@
+'use client'
+
+import React, { useState } from 'react'
+import { motion, AnimatePresence } from 'framer-motion'
+import { X, Minus, Square, Info, UserCircle, Target } from '@phosphor-icons/react'
+
+interface HelpModalProps {
+  isOpen: boolean
+  onClose: () => void
+}
+
+export function HelpModal({ isOpen, onClose }: HelpModalProps) {
+  const [windowPos, setWindowPos] = useState({ x: 100, y: 100 })
+  const [isDragging, setIsDragging] = useState(false)
+  const [dragStart, setDragStart] = useState({ x: 0, y: 0 })
+
+  const handleMouseDown = (e: React.MouseEvent) => {
+    if ((e.target as HTMLElement).closest('.window-controls')) return
+    setIsDragging(true)
+    setDragStart({ x: e.clientX - windowPos.x, y: e.clientY - windowPos.y })
+  }
+
+  const handleMouseMove = (e: MouseEvent) => {
+    if (isDragging) {
+      setWindowPos({
+        x: e.clientX - dragStart.x,
+        y: e.clientY - dragStart.y,
+      })
+    }
+  }
+
+  const handleMouseUp = () => {
+    setIsDragging(false)
+  }
+
+  React.useEffect(() => {
+    if (isDragging) {
+      window.addEventListener('mousemove', handleMouseMove)
+      window.addEventListener('mouseup', handleMouseUp)
+      return () => {
+        window.removeEventListener('mousemove', handleMouseMove)
+        window.removeEventListener('mouseup', handleMouseUp)
+      }
+    }
+  }, [isDragging, dragStart, windowPos])
+
+  return (
+    <AnimatePresence>
+      {isOpen && (
+        <>
+          {/* Backdrop */}
+          <motion.div
+            initial={{ opacity: 0 }}
+            animate={{ opacity: 1 }}
+            exit={{ opacity: 0 }}
+            className="fixed inset-0 bg-black/30 backdrop-blur-sm z-50"
+          />
+
+          {/* Modal */}
+          <motion.div
+            style={{ left: windowPos.x, top: windowPos.y }}
+            initial={{ scale: 0.9, opacity: 0 }}
+            animate={{ scale: 1, opacity: 1 }}
+            exit={{ scale: 0.9, opacity: 0 }}
+            transition={{ type: "spring", damping: 20, stiffness: 300 }}
+            className="fixed w-[600px] bg-white rounded-lg shadow-2xl z-50 select-none"
+          >
+            {/* Ubuntu-style Window Header */}
+            <div
+              onMouseDown={handleMouseDown}
+              className="h-11 bg-gradient-to-b from-[#f6f5f4] to-[#edebe9] border-b border-[#d0d0d0] flex items-center justify-between px-3 cursor-move rounded-t-lg"
+            >
+              <div className="flex items-center gap-2 flex-1">
+                <div className="flex items-center gap-1 window-controls">
+                  <button
+                    onClick={onClose}
+                    className="w-5 h-5 rounded-full bg-[#E95420] hover:bg-[#d14818] flex items-center justify-center group"
+                  >
+                    <X size={12} weight="bold" className="text-white opacity-0 group-hover:opacity-100" />
+                  </button>
+                  <button className="w-5 h-5 rounded-full bg-[#ddd] hover:bg-[#ccc] flex items-center justify-center group">
+                    <Minus size={12} weight="bold" className="text-[#666] opacity-0 group-hover:opacity-100" />
+                  </button>
+                  <button className="w-5 h-5 rounded-full bg-[#ddd] hover:bg-[#ccc] flex items-center justify-center group">
+                    <Square size={10} weight="bold" className="text-[#666] opacity-0 group-hover:opacity-100" />
+                  </button>
+                </div>
+                <div className="flex items-center gap-2 ml-2">
+                  <Info size={18} weight="fill" className="text-[#E95420]" />
+                  <span className="text-sm font-medium text-[#2c2c2c]">About This Application</span>
+                </div>
+              </div>
+            </div>
+
+            {/* Content */}
+            <div className="p-6 space-y-5 bg-white rounded-b-lg">
+              {/* Creator Info */}
+              <div className="flex items-start gap-4 p-4 bg-gradient-to-r from-[#E95420]/10 to-orange-100 rounded-lg border border-[#E95420]/20">
+                <div className="w-10 h-10 rounded-full bg-gradient-to-br from-[#E95420] to-[#d14818] flex items-center justify-center flex-shrink-0">
+                  <UserCircle size={24} weight="fill" className="text-white" />
+                </div>
+                <div>
+                  <h3 className="text-base font-semibold text-[#2c2c2c] mb-1">Created By</h3>
+                  <p className="text-[#555] font-medium">Reuben Chagas Fernandes</p>
+                </div>
+              </div>
+
+              {/* Purpose */}
+              <div className="flex items-start gap-4 p-4 bg-blue-50 rounded-lg border border-blue-200">
+                <div className="w-10 h-10 rounded-full bg-gradient-to-br from-blue-500 to-blue-600 flex items-center justify-center flex-shrink-0">
+                  <Target size={24} weight="fill" className="text-white" />
+                </div>
+                <div>
+                  <h3 className="text-base font-semibold text-[#2c2c2c] mb-2">Purpose</h3>
+                  <p className="text-[#555] leading-relaxed text-sm">
+                    This application was created for sharing study material and making it easily
+                    accessible through Claude. Our goal is to provide a seamless platform for
+                    students to collaborate, share resources, and enhance their learning experience.
+                  </p>
+                </div>
+              </div>
+
+              {/* Features */}
+              <div className="bg-gradient-to-br from-purple-50 to-pink-50 rounded-lg p-4 border border-purple-200">
+                <h4 className="text-sm font-semibold text-[#2c2c2c] uppercase tracking-wider mb-3 flex items-center gap-2">
+                  <span className="w-1 h-4 bg-[#E95420] rounded-full"></span>
+                  Key Features
+                </h4>
+                <ul className="space-y-2.5 text-[#555]">
+                  <li className="flex items-center gap-3">
+                    <span className="w-2 h-2 bg-blue-500 rounded-full flex-shrink-0" />
+                    <span className="text-sm">Easy file upload and sharing</span>
+                  </li>
+                  <li className="flex items-center gap-3">
+                    <span className="w-2 h-2 bg-purple-500 rounded-full flex-shrink-0" />
+                    <span className="text-sm">Integration with Claude AI</span>
+                  </li>
+                  <li className="flex items-center gap-3">
+                    <span className="w-2 h-2 bg-green-500 rounded-full flex-shrink-0" />
+                    <span className="text-sm">Public folder for community sharing</span>
+                  </li>
+                  <li className="flex items-center gap-3">
+                    <span className="w-2 h-2 bg-[#E95420] rounded-full flex-shrink-0" />
+                    <span className="text-sm">Exam calendar and organization tools</span>
+                  </li>
+                  <li className="flex items-center gap-3">
+                    <span className="w-2 h-2 bg-cyan-500 rounded-full flex-shrink-0" />
+                    <span className="text-sm">Web browser with CORS proxy support</span>
+                  </li>
+                  <li className="flex items-center gap-3">
+                    <span className="w-2 h-2 bg-orange-500 rounded-full flex-shrink-0" />
+                    <span className="text-sm">Gemini AI chat assistant</span>
+                  </li>
+                </ul>
+              </div>
+
+              {/* Footer Button */}
+              <div className="pt-2">
+                <button
+                  onClick={onClose}
+                  className="w-full py-2.5 bg-[#E95420] hover:bg-[#d14818] text-white rounded-lg font-medium transition-colors shadow-sm"
+                >
+                  Close
+                </button>
+              </div>
+            </div>
+          </motion.div>
+        </>
+      )}
+    </AnimatePresence>
+  )
+}
\ No newline at end of file
diff --git a/app/components/MatrixRain.tsx b/app/components/MatrixRain.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..d329990d8de8a96b37e7234b3eafeab19aa948a8
--- /dev/null
+++ b/app/components/MatrixRain.tsx
@@ -0,0 +1,236 @@
+'use client'
+
+import React, { useEffect, useRef, useState } from 'react'
+import { motion, AnimatePresence } from 'framer-motion'
+
+interface MatrixRainProps {
+  isActive: boolean
+  onComplete?: () => void
+}
+
+export function MatrixRain({ isActive, onComplete }: MatrixRainProps) {
+  const canvasRef = useRef<HTMLCanvasElement>(null)
+  const [showText, setShowText] = useState(false)
+
+  useEffect(() => {
+    if (!isActive) return
+
+    const canvas = canvasRef.current
+    if (!canvas) return
+
+    const ctx = canvas.getContext('2d')
+    if (!ctx) return
+
+    // Set canvas size
+    canvas.width = window.innerWidth
+    canvas.height = window.innerHeight
+
+    // Matrix rain configuration
+    const fontSize = 14
+    const columns = Math.floor(canvas.width / fontSize)
+    const drops: number[] = []
+
+    // Initialize drops
+    for (let i = 0; i < columns; i++) {
+      drops[i] = Math.random() * -100
+    }
+
+    // Characters to use in the rain
+    const matrix = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%^&*()_+-=[]{}|;:<>,.?/~`'
+    const matrixArray = matrix.split('')
+
+    // Special word to display
+    const specialWord = 'REUBENOS'
+    let specialWordTimer: NodeJS.Timeout
+
+    // Show the special text after 1.5 seconds
+    if (isActive) {
+      specialWordTimer = setTimeout(() => {
+        setShowText(true)
+      }, 1500)
+    }
+
+    // Drawing function
+    function draw() {
+      if (!ctx || !canvas) return
+
+      // Semi-transparent black to create fade effect
+      ctx.fillStyle = 'rgba(0, 0, 0, 0.05)'
+      ctx.fillRect(0, 0, canvas.width, canvas.height)
+
+      // Green text
+      ctx.fillStyle = '#0F0'
+      ctx.font = `${fontSize}px monospace`
+
+      // Draw drops
+      for (let i = 0; i < drops.length; i++) {
+        // Random character
+        const text = matrixArray[Math.floor(Math.random() * matrixArray.length)]
+
+        // Draw the character
+        ctx.fillText(text, i * fontSize, drops[i] * fontSize)
+
+        // Reset drop when it goes off screen
+        if (drops[i] * fontSize > canvas.height && Math.random() > 0.975) {
+          drops[i] = 0
+        }
+
+        // Move drop down
+        drops[i]++
+      }
+    }
+
+    // Animation loop
+    const interval = setInterval(draw, 35)
+
+    // Cleanup
+    return () => {
+      clearInterval(interval)
+      clearTimeout(specialWordTimer)
+      setShowText(false)
+    }
+  }, [isActive])
+
+  // Handle window resize
+  useEffect(() => {
+    if (!isActive) return
+
+    const handleResize = () => {
+      const canvas = canvasRef.current
+      if (canvas) {
+        canvas.width = window.innerWidth
+        canvas.height = window.innerHeight
+      }
+    }
+
+    window.addEventListener('resize', handleResize)
+    return () => window.removeEventListener('resize', handleResize)
+  }, [isActive])
+
+  // Auto-complete after 5 seconds
+  useEffect(() => {
+    if (!isActive) return
+
+    const timer = setTimeout(() => {
+      if (onComplete) {
+        onComplete()
+      }
+    }, 5000)
+
+    return () => clearTimeout(timer)
+  }, [isActive, onComplete])
+
+  return (
+    <AnimatePresence>
+      {isActive && (
+        <>
+          <motion.div
+            initial={{ opacity: 0 }}
+            animate={{ opacity: 1 }}
+            exit={{ opacity: 0 }}
+            transition={{ duration: 0.5 }}
+            className="fixed inset-0 z-[9999] bg-black"
+          >
+            <canvas
+              ref={canvasRef}
+              className="absolute inset-0"
+              style={{ display: 'block' }}
+            />
+
+            {/* REUBENOS Text */}
+            <AnimatePresence>
+              {showText && (
+                <motion.div
+                  initial={{ opacity: 0, scale: 0.5 }}
+                  animate={{ opacity: 1, scale: 1 }}
+                  exit={{ opacity: 0, scale: 0.8 }}
+                  transition={{
+                    duration: 0.8,
+                    ease: 'easeOut'
+                  }}
+                  className="absolute inset-0 flex items-center justify-center pointer-events-none"
+                >
+                  <div className="text-center">
+                    <motion.h1
+                      className="text-[#0F0] font-mono font-bold select-none"
+                      style={{
+                        fontSize: 'clamp(3rem, 10vw, 8rem)',
+                        textShadow: `
+                          0 0 10px #0F0,
+                          0 0 20px #0F0,
+                          0 0 30px #0F0,
+                          0 0 40px #0A0,
+                          0 0 70px #0A0,
+                          0 0 80px #0A0,
+                          0 0 100px #0A0,
+                          0 0 150px #0A0
+                        `,
+                        letterSpacing: '0.2em'
+                      }}
+                      initial={{ y: 20 }}
+                      animate={{
+                        y: [20, -10, 0],
+                        textShadow: [
+                          `0 0 10px #0F0, 0 0 20px #0F0, 0 0 30px #0F0, 0 0 40px #0A0, 0 0 70px #0A0, 0 0 80px #0A0, 0 0 100px #0A0, 0 0 150px #0A0`,
+                          `0 0 20px #0F0, 0 0 30px #0F0, 0 0 40px #0F0, 0 0 50px #0A0, 0 0 80px #0A0, 0 0 90px #0A0, 0 0 120px #0A0, 0 0 180px #0A0`,
+                          `0 0 10px #0F0, 0 0 20px #0F0, 0 0 30px #0F0, 0 0 40px #0A0, 0 0 70px #0A0, 0 0 80px #0A0, 0 0 100px #0A0, 0 0 150px #0A0`
+                        ]
+                      }}
+                      transition={{
+                        duration: 2,
+                        repeat: Infinity,
+                        repeatType: 'reverse',
+                        ease: 'easeInOut'
+                      }}
+                    >
+                      REUBENOS
+                    </motion.h1>
+
+                    <motion.div
+                      initial={{ opacity: 0 }}
+                      animate={{ opacity: [0, 1, 0] }}
+                      transition={{
+                        duration: 1.5,
+                        repeat: Infinity,
+                        repeatDelay: 0.5
+                      }}
+                      className="mt-8 text-[#0F0] font-mono text-xl"
+                      style={{
+                        textShadow: '0 0 5px #0F0, 0 0 10px #0F0'
+                      }}
+                    >
+                      SYSTEM BREACH DETECTED
+                    </motion.div>
+
+                    <motion.div
+                      initial={{ width: 0 }}
+                      animate={{ width: '100%' }}
+                      transition={{
+                        duration: 3,
+                        ease: 'linear'
+                      }}
+                      className="mt-4 h-1 bg-gradient-to-r from-transparent via-[#0F0] to-transparent mx-auto max-w-md"
+                      style={{
+                        boxShadow: '0 0 10px #0F0'
+                      }}
+                    />
+                  </div>
+                </motion.div>
+              )}
+            </AnimatePresence>
+
+            {/* Click to exit hint */}
+            <motion.div
+              initial={{ opacity: 0 }}
+              animate={{ opacity: 1 }}
+              transition={{ delay: 3, duration: 1 }}
+              className="absolute bottom-10 left-1/2 transform -translate-x-1/2 text-[#0F0] font-mono text-sm opacity-50"
+            >
+              Click anywhere to exit the Matrix
+            </motion.div>
+          </motion.div>
+        </>
+      )}
+    </AnimatePresence>
+  )
+}
\ No newline at end of file
diff --git a/app/components/PDFViewer.tsx b/app/components/PDFViewer.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..1b05ca0c9f872f5dfbb66a50e746a295ec452a97
--- /dev/null
+++ b/app/components/PDFViewer.tsx
@@ -0,0 +1,143 @@
+'use client'
+
+import React, { useState } from 'react'
+import dynamic from 'next/dynamic'
+import { MagnifyingGlassPlus, MagnifyingGlassMinus, ArrowLeft, ArrowRight } from '@phosphor-icons/react'
+
+// Dynamically import react-pdf with no SSR
+const Document = dynamic(
+  () => import('react-pdf').then((mod) => mod.Document),
+  { ssr: false }
+)
+const Page = dynamic(
+  () => import('react-pdf').then((mod) => mod.Page),
+  { ssr: false }
+)
+
+// Configure PDF.js worker
+if (typeof window !== 'undefined') {
+  import('react-pdf').then((pdfjs) => {
+    pdfjs.pdfjs.GlobalWorkerOptions.workerSrc = `//unpkg.com/pdfjs-dist@${pdfjs.pdfjs.version}/build/pdf.worker.min.mjs`
+  })
+}
+
+interface PDFViewerProps {
+  url: string
+  scale: number
+  onZoomIn: () => void
+  onZoomOut: () => void
+}
+
+export function PDFViewer({ url, scale, onZoomIn, onZoomOut }: PDFViewerProps) {
+  const [numPages, setNumPages] = useState<number | null>(null)
+  const [pageNumber, setPageNumber] = useState(1)
+  const [error, setError] = useState<string | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+
+  const onDocumentLoadSuccess = ({ numPages }: { numPages: number }) => {
+    setNumPages(numPages)
+    setPageNumber(1)
+    setError(null)
+    setIsLoading(false)
+  }
+
+  const changePage = (offset: number) => {
+    setPageNumber(prevPageNumber => {
+      const newPageNumber = prevPageNumber + offset
+      if (newPageNumber < 1 || newPageNumber > (numPages || 1)) {
+        return prevPageNumber
+      }
+      return newPageNumber
+    })
+  }
+
+  if (!url) {
+    return <div className="flex items-center justify-center h-full text-gray-500">No PDF to display</div>
+  }
+
+  return (
+    <div className="flex flex-col h-full">
+      <div className="flex items-center gap-2 p-3 border-b border-gray-200 bg-gray-50">
+        <button
+          onClick={onZoomOut}
+          className="p-2 hover:bg-gray-200 rounded-lg transition-colors"
+          title="Zoom Out"
+        >
+          <MagnifyingGlassMinus className="h-5 w-5" />
+        </button>
+        <span className="text-sm text-gray-600 min-w-[60px] text-center">{Math.round(scale * 100)}%</span>
+        <button
+          onClick={onZoomIn}
+          className="p-2 hover:bg-gray-200 rounded-lg transition-colors"
+          title="Zoom In"
+        >
+          <MagnifyingGlassPlus className="h-5 w-5" />
+        </button>
+        {numPages && (
+          <>
+            <div className="mx-4 h-6 w-px bg-gray-300" />
+            <button
+              onClick={() => changePage(-1)}
+              disabled={pageNumber <= 1}
+              className="p-2 hover:bg-gray-200 rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+              title="Previous Page"
+            >
+              <ArrowLeft className="h-5 w-5" />
+            </button>
+            <span className="text-sm text-gray-600 min-w-[80px] text-center">
+              Page {pageNumber} of {numPages}
+            </span>
+            <button
+              onClick={() => changePage(1)}
+              disabled={pageNumber >= numPages}
+              className="p-2 hover:bg-gray-200 rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
+              title="Next Page"
+            >
+              <ArrowRight className="h-5 w-5" />
+            </button>
+          </>
+        )}
+      </div>
+      <div className="flex-1 overflow-auto p-4 bg-gray-50">
+        {typeof window !== 'undefined' && url && (
+          <Document
+            file={url}
+            onLoadSuccess={onDocumentLoadSuccess}
+            onLoadError={(err) => {
+              console.warn('PDF load error:', err)
+              setError('Unable to load PDF. The file might be corrupted or in an unsupported format.')
+              setIsLoading(false)
+            }}
+            loading={
+              <div className="flex items-center justify-center h-full">
+                <div className="text-gray-600">Loading PDF...</div>
+              </div>
+            }
+            error={
+              <div className="flex flex-col items-center justify-center h-full">
+                <div className="text-red-500 mb-2">Failed to load PDF</div>
+                <div className="text-sm text-gray-600">{error || 'The file might be corrupted or in an unsupported format.'}</div>
+              </div>
+            }
+            className="flex justify-center"
+          >
+            {!isLoading && !error && (
+              <Page
+                pageNumber={pageNumber}
+                scale={scale}
+                renderTextLayer={false}
+                renderAnnotationLayer={false}
+                className="shadow-lg bg-white"
+                loading={
+                  <div className="flex items-center justify-center h-96 bg-white shadow-lg">
+                    <div className="text-gray-400">Loading page...</div>
+                  </div>
+                }
+              />
+            )}
+          </Document>
+        )}
+      </div>
+    </div>
+  )
+}
\ No newline at end of file
diff --git a/app/components/SpotlightSearch.tsx b/app/components/SpotlightSearch.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..76716b88186bd82fc48c9f4aa35da0eba8130a6a
--- /dev/null
+++ b/app/components/SpotlightSearch.tsx
@@ -0,0 +1,182 @@
+'use client'
+
+import React, { useState, useRef, useEffect } from 'react'
+import { MagnifyingGlass, X } from '@phosphor-icons/react'
+import { motion, AnimatePresence } from 'framer-motion'
+
+interface SpotlightSearchProps {
+  isOpen: boolean
+  onClose: () => void
+  onOpenApp: (appId: string) => void
+}
+
+interface SearchResult {
+  id: string
+  name: string
+  type: 'app' | 'file' | 'setting'
+  icon?: React.ReactNode
+}
+
+export function SpotlightSearch({ isOpen, onClose, onOpenApp }: SpotlightSearchProps) {
+  const [query, setQuery] = useState('')
+  const [results, setResults] = useState<SearchResult[]>([])
+  const inputRef = useRef<HTMLInputElement>(null)
+
+  const apps: SearchResult[] = [
+    { id: 'files', name: 'Files', type: 'app' },
+    { id: 'calendar', name: 'Calendar', type: 'app' },
+    { id: 'clock', name: 'Clock', type: 'app' },
+    { id: 'browser', name: 'Web Browser', type: 'app' },
+    { id: 'gemini', name: 'Gemini Chat', type: 'app' },
+    { id: 'terminal', name: 'Terminal', type: 'app' },
+    { id: 'vscode', name: 'VS Code', type: 'app' },
+  ]
+
+  const files: SearchResult[] = [
+    { id: 'document', name: 'Document.pdf', type: 'file' },
+    { id: 'resume', name: 'Resume.docx', type: 'file' },
+    { id: 'budget', name: 'Budget.xlsx', type: 'file' },
+    { id: 'presentation', name: 'Presentation.pptx', type: 'file' },
+  ]
+
+  const settings: SearchResult[] = [
+    { id: 'wallpaper', name: 'Change Wallpaper', type: 'setting' },
+    { id: 'theme', name: 'Dark Mode', type: 'setting' },
+    { id: 'display', name: 'Display Settings', type: 'setting' },
+  ]
+
+  const allItems = [...apps, ...files, ...settings]
+
+  useEffect(() => {
+    if (isOpen) {
+      setQuery('')
+      setResults([])
+      setTimeout(() => inputRef.current?.focus(), 100)
+    }
+  }, [isOpen])
+
+  useEffect(() => {
+    if (query.trim() === '') {
+      setResults([])
+      return
+    }
+
+    const filtered = allItems.filter(item =>
+      item.name.toLowerCase().includes(query.toLowerCase())
+    )
+    setResults(filtered.slice(0, 8))
+  }, [query])
+
+  const handleSelect = (result: SearchResult) => {
+    if (result.type === 'app') {
+      onOpenApp(result.id)
+    }
+    onClose()
+    setQuery('')
+  }
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    if (e.key === 'Escape') {
+      onClose()
+    } else if (e.key === 'Enter' && results.length > 0) {
+      handleSelect(results[0])
+    }
+  }
+
+  return (
+    <AnimatePresence>
+      {isOpen && (
+        <>
+          {/* Backdrop */}
+          <motion.div
+            initial={{ opacity: 0 }}
+            animate={{ opacity: 1 }}
+            exit={{ opacity: 0 }}
+            className="fixed inset-0 bg-black/20 z-[60]"
+            onClick={onClose}
+          />
+
+          {/* Search Box */}
+          <motion.div
+            initial={{ opacity: 0, scale: 0.95, y: -20 }}
+            animate={{ opacity: 1, scale: 1, y: 0 }}
+            exit={{ opacity: 0, scale: 0.95, y: -20 }}
+            transition={{ duration: 0.15, ease: 'easeOut' }}
+            className="fixed top-[20%] left-1/2 -translate-x-1/2 w-[600px] max-w-[90%] glass rounded-xl shadow-2xl z-[70]"
+          >
+            <div className="flex items-center px-4 py-3 gap-3 border-b border-gray-200/20">
+              <MagnifyingGlass size={24} weight="regular" className="text-gray-600" />
+              <input
+                ref={inputRef}
+                type="text"
+                value={query}
+                onChange={(e) => setQuery(e.target.value)}
+                onKeyDown={handleKeyDown}
+                className="flex-1 bg-transparent text-xl focus:outline-none text-gray-800 placeholder-gray-400"
+                placeholder="Spotlight Search"
+                autoComplete="off"
+                spellCheck={false}
+              />
+              <button
+                onClick={onClose}
+                className="text-gray-500 hover:text-gray-700 transition-colors"
+              >
+                <X size={20} weight="regular" />
+              </button>
+            </div>
+
+            {/* Results */}
+            {results.length > 0 && (
+              <div className="max-h-96 overflow-y-auto p-2">
+                {results.map((result, index) => (
+                  <div
+                    key={result.id}
+                    onClick={() => handleSelect(result)}
+                    className={`flex items-center px-3 py-2.5 hover:bg-blue-500 hover:text-white rounded-lg cursor-pointer transition-colors ${
+                      index === 0 ? 'bg-blue-500/10' : ''
+                    }`}
+                  >
+                    <div className="flex-1 flex flex-col">
+                      <span className="font-medium">{result.name}</span>
+                      <span className="text-xs opacity-70 capitalize">{result.type}</span>
+                    </div>
+                    {result.type === 'app' && (
+                      <span className="text-xs opacity-50">⌘ Enter</span>
+                    )}
+                  </div>
+                ))}
+              </div>
+            )}
+
+            {/* No results */}
+            {query.trim() !== '' && results.length === 0 && (
+              <div className="p-4 text-center text-gray-500">
+                No results found for "{query}"
+              </div>
+            )}
+
+            {/* Quick Actions (when no query) */}
+            {query === '' && (
+              <div className="p-4">
+                <div className="text-xs font-semibold text-gray-500 uppercase tracking-wider mb-2">
+                  Suggestions
+                </div>
+                <div className="grid grid-cols-2 gap-2">
+                  {apps.slice(0, 4).map(app => (
+                    <div
+                      key={app.id}
+                      onClick={() => handleSelect(app)}
+                      className="flex items-center px-3 py-2 hover:bg-gray-100 rounded-lg cursor-pointer transition-colors"
+                    >
+                      <span className="text-sm">{app.name}</span>
+                    </div>
+                  ))}
+                </div>
+              </div>
+            )}
+          </motion.div>
+        </>
+      )}
+    </AnimatePresence>
+  )
+}
\ No newline at end of file
diff --git a/app/components/Terminal.tsx b/app/components/Terminal.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..476c3d16ac4b9a740505cd04b5ed90cceb36f69c
--- /dev/null
+++ b/app/components/Terminal.tsx
@@ -0,0 +1,223 @@
+'use client'
+
+import React, { useState, useRef, useEffect } from 'react'
+import Window from './Window'
+
+interface TerminalProps {
+  onClose: () => void
+}
+
+interface FileSystem {
+  [key: string]: string[]
+}
+
+export function Terminal({ onClose }: TerminalProps) {
+  const [history, setHistory] = useState<string[]>([
+    'Last login: ' + new Date().toLocaleString() + ' on ttys000'
+  ])
+  const [currentInput, setCurrentInput] = useState('')
+  const [currentPath, setCurrentPath] = useState('~')
+  const inputRef = useRef<HTMLInputElement>(null)
+  const outputRef = useRef<HTMLDivElement>(null)
+
+  const fileSystem: FileSystem = {
+    '~': ['Desktop', 'Documents', 'Downloads', 'Pictures', 'Music', 'Videos'],
+    'Desktop': ['screenshot.png', 'notes.txt', 'project'],
+    'Documents': ['resume.pdf', 'budget.xlsx', 'report.docx'],
+    'Downloads': ['installer.dmg', 'image.jpg', 'archive.zip'],
+    'Pictures': ['vacation.jpg', 'family.png'],
+    'Music': ['song.mp3', 'playlist.m3u'],
+    'Videos': ['tutorial.mp4', 'presentation.mov'],
+    'project': ['index.html', 'style.css', 'script.js', 'README.md']
+  }
+
+  useEffect(() => {
+    if (outputRef.current) {
+      outputRef.current.scrollTop = outputRef.current.scrollHeight
+    }
+  }, [history])
+
+  const handleCommand = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === 'Enter') {
+      const cmd = currentInput.trim()
+      const newHistory = [...history]
+
+      // Add command to history
+      newHistory.push(`guest@studyos:${currentPath} $ ${cmd}`)
+
+      // Process command
+      const args = cmd.split(' ')
+      const command = args[0].toLowerCase()
+
+      switch (command) {
+        case 'help':
+          newHistory.push('Available commands:')
+          newHistory.push('  help     - Show this help message')
+          newHistory.push('  ls       - List directory contents')
+          newHistory.push('  cd       - Change directory')
+          newHistory.push('  pwd      - Print working directory')
+          newHistory.push('  clear    - Clear terminal')
+          newHistory.push('  date     - Show current date and time')
+          newHistory.push('  whoami   - Display current user')
+          newHistory.push('  echo     - Display message')
+          newHistory.push('  cat      - Display file contents')
+          newHistory.push('  mkdir    - Create directory')
+          newHistory.push('  touch    - Create file')
+          newHistory.push('  rm       - Remove file')
+          newHistory.push('  open     - Open application')
+          break
+
+        case 'ls':
+          const files = fileSystem[currentPath] || []
+          if (files.length > 0) {
+            const fileList = files.map(f => {
+              const isDir = fileSystem[f] !== undefined
+              return isDir ?
+                `\x1b[34m${f}/\x1b[0m` : // Blue for directories
+                f
+            }).join('  ')
+            newHistory.push(fileList)
+          } else {
+            newHistory.push('Directory is empty')
+          }
+          break
+
+        case 'cd':
+          if (args[1] === '..') {
+            setCurrentPath('~')
+          } else if (args[1] === '~' || !args[1]) {
+            setCurrentPath('~')
+          } else if (fileSystem[args[1]]) {
+            setCurrentPath(args[1])
+          } else {
+            newHistory.push(`cd: no such file or directory: ${args[1]}`)
+          }
+          break
+
+        case 'pwd':
+          newHistory.push(currentPath === '~' ? '/home/guest' : `/home/guest/${currentPath}`)
+          break
+
+        case 'clear':
+          setHistory(['Last login: ' + new Date().toLocaleString() + ' on ttys000'])
+          setCurrentInput('')
+          return
+
+        case 'date':
+          newHistory.push(new Date().toString())
+          break
+
+        case 'whoami':
+          newHistory.push('guest')
+          break
+
+        case 'echo':
+          newHistory.push(args.slice(1).join(' '))
+          break
+
+        case 'cat':
+          if (args[1]) {
+            const files = fileSystem[currentPath] || []
+            if (files.includes(args[1])) {
+              newHistory.push(`Contents of ${args[1]}:`)
+              newHistory.push('(This is a simulated file content)')
+            } else {
+              newHistory.push(`cat: ${args[1]}: No such file`)
+            }
+          } else {
+            newHistory.push('Usage: cat <filename>')
+          }
+          break
+
+        case 'mkdir':
+          if (args[1]) {
+            newHistory.push(`Directory '${args[1]}' created`)
+          } else {
+            newHistory.push('Usage: mkdir <dirname>')
+          }
+          break
+
+        case 'touch':
+          if (args[1]) {
+            newHistory.push(`File '${args[1]}' created`)
+          } else {
+            newHistory.push('Usage: touch <filename>')
+          }
+          break
+
+        case 'rm':
+          if (args[1]) {
+            newHistory.push(`File '${args[1]}' removed`)
+          } else {
+            newHistory.push('Usage: rm <filename>')
+          }
+          break
+
+        case 'open':
+          if (args[1]) {
+            newHistory.push(`Opening ${args[1]}...`)
+          } else {
+            newHistory.push('Usage: open <application>')
+          }
+          break
+
+        case '':
+          break
+
+        default:
+          newHistory.push(`zsh: command not found: ${command}`)
+      }
+
+      setHistory(newHistory)
+      setCurrentInput('')
+    }
+  }
+
+  return (
+    <Window
+      id="terminal"
+      title="Terminal — zsh — 80×24"
+      isOpen={true}
+      onClose={onClose}
+      width={600}
+      height={400}
+      x={120}
+      y={120}
+      darkMode={true}
+      className="terminal-window"
+    >
+      <div
+        className="flex-1 bg-[#1e1e1e] p-2 font-mono text-sm text-white overflow-auto"
+        ref={outputRef}
+        onClick={() => inputRef.current?.focus()}
+      >
+        {history.map((line, index) => (
+          <div
+            key={index}
+            className="whitespace-pre-wrap"
+            dangerouslySetInnerHTML={{
+              __html: line
+                .replace(/\x1b\[34m/g, '<span style="color: #4FC3F7;">')
+                .replace(/\x1b\[0m/g, '</span>')
+                .replace(/guest@studyos/g, '<span style="color: #4CAF50;">guest@studyos</span>')
+            }}
+          />
+        ))}
+        <div className="flex">
+          <span className="text-green-400 mr-2">guest@studyos:{currentPath} $</span>
+          <input
+            ref={inputRef}
+            type="text"
+            value={currentInput}
+            onChange={(e) => setCurrentInput(e.target.value)}
+            onKeyDown={handleCommand}
+            className="flex-1 bg-transparent border-none outline-none text-white"
+            autoFocus
+            autoComplete="off"
+            spellCheck={false}
+          />
+        </div>
+      </div>
+    </Window>
+  )
+}
\ No newline at end of file
diff --git a/app/components/TopBar.tsx b/app/components/TopBar.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..22c9b799be3f612ba308b916cb5014f68e3914f3
--- /dev/null
+++ b/app/components/TopBar.tsx
@@ -0,0 +1,122 @@
+'use client'
+
+import React, { useState, useEffect } from 'react'
+import {
+  SpeakerHigh,
+  WifiHigh,
+  BatteryFull,
+  MagnifyingGlass,
+  Desktop,
+  CirclesFour
+} from '@phosphor-icons/react'
+import { motion, AnimatePresence } from 'framer-motion'
+
+interface TopBarProps {
+  onPowerAction?: () => void
+  activeAppName?: string
+  onAboutClick?: () => void
+}
+
+export function TopBar({ onPowerAction, activeAppName = 'Finder', onAboutClick }: TopBarProps) {
+  const [appleMenuOpen, setAppleMenuOpen] = useState(false)
+  const [currentTime, setCurrentTime] = useState('')
+
+  useEffect(() => {
+    const updateTime = () => {
+      const now = new Date()
+      const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+      const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+
+      const timeString = now.toLocaleTimeString('en-US', {
+        hour: 'numeric',
+        minute: '2-digit',
+        hour12: true
+      })
+      const dateString = `${days[now.getDay()]} ${now.getDate()} ${months[now.getMonth()]}`
+      setCurrentTime(`${dateString}  ${timeString}`)
+    }
+
+    updateTime()
+    const interval = setInterval(updateTime, 1000)
+    return () => clearInterval(interval)
+  }, [])
+
+  return (
+    <div className="fixed top-0 left-0 right-0 h-8 glass flex items-center justify-between px-4 text-sm z-50 shadow-sm">
+      <div className="flex items-center space-x-4">
+        <button
+          onClick={() => setAppleMenuOpen(!appleMenuOpen)}
+          className="font-bold text-lg hover:text-blue-600 transition-colors relative"
+        >
+          <CirclesFour size={20} weight="fill" className="text-blue-600" />
+        </button>
+        <span className="font-bold text-gray-800">Reuben OS</span>
+        <span className="text-gray-600 text-xs ml-2">{activeAppName}</span>
+      </div>
+
+      <div className="flex items-center space-x-4">
+        <BatteryFull size={16} weight="fill" className="text-gray-700" />
+        <WifiHigh size={16} weight="fill" className="text-gray-700" />
+        <MagnifyingGlass size={16} weight="regular" className="text-gray-700" />
+        <div className="font-medium text-gray-800">{currentTime}</div>
+      </div>
+
+      <AnimatePresence>
+        {appleMenuOpen && (
+          <>
+            <div
+              className="fixed inset-0 z-[55]"
+              onClick={() => setAppleMenuOpen(false)}
+            />
+            <motion.div
+              initial={{ opacity: 0, y: -5 }}
+              animate={{ opacity: 1, y: 0 }}
+              exit={{ opacity: 0, y: -5 }}
+              transition={{ duration: 0.15 }}
+              className="absolute top-8 left-2 w-48 glass rounded-lg shadow-xl flex flex-col py-1 z-[60] text-sm"
+            >
+              <button
+                onClick={() => {
+                  if (onAboutClick) onAboutClick()
+                  setAppleMenuOpen(false)
+                }}
+                className="text-left px-4 py-1 hover:bg-blue-500 hover:text-white transition-colors text-gray-800">
+                About Reuben OS
+              </button>
+              <div className="h-px bg-gray-300 my-1 mx-2" />
+              <button className="text-left px-4 py-1 hover:bg-blue-500 hover:text-white transition-colors text-gray-800">
+                System Settings...
+              </button>
+              <div className="h-px bg-gray-300 my-1 mx-2" />
+              <button className="text-left px-4 py-1 hover:bg-blue-500 hover:text-white transition-colors text-gray-800">
+                Sleep
+              </button>
+              <button className="text-left px-4 py-1 hover:bg-blue-500 hover:text-white transition-colors text-gray-800">
+                Restart...
+              </button>
+              <button
+                onClick={() => {
+                  if (onPowerAction) onPowerAction()
+                  setAppleMenuOpen(false)
+                }}
+                className="text-left px-4 py-1 hover:bg-blue-500 hover:text-white transition-colors text-gray-800"
+              >
+                Shut Down...
+              </button>
+              <div className="h-px bg-gray-300 my-1 mx-2" />
+              <button
+                onClick={() => {
+                  if (onPowerAction) onPowerAction()
+                  setAppleMenuOpen(false)
+                }}
+                className="text-left px-4 py-1 hover:bg-blue-500 hover:text-white transition-colors text-gray-800"
+              >
+                Log Out...
+              </button>
+            </motion.div>
+          </>
+        )}
+      </AnimatePresence>
+    </div>
+  )
+}
\ No newline at end of file
diff --git a/app/components/VSCodeEditor.tsx b/app/components/VSCodeEditor.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..0d8ffd94fe628d8f8a108ab9996f1c28b6633c8e
--- /dev/null
+++ b/app/components/VSCodeEditor.tsx
@@ -0,0 +1,458 @@
+'use client'
+
+import React, { useState, useRef, useEffect } from 'react'
+import Window from './Window'
+import Editor from '@monaco-editor/react'
+import {
+  Code,
+  Play,
+  FileHtml,
+  FileCss,
+  FileJs,
+  Download,
+  Upload,
+  FloppyDisk,
+  Eye,
+  EyeSlash,
+  ArrowsOutSimple,
+  ArrowsInSimple,
+  X
+} from '@phosphor-icons/react'
+
+interface VSCodeEditorProps {
+  onClose: () => void
+  userSession?: string
+}
+
+interface Tab {
+  id: string
+  name: string
+  language: string
+  content: string
+}
+
+export function VSCodeEditor({ onClose, userSession }: VSCodeEditorProps) {
+  const [activeTab, setActiveTab] = useState('html')
+  const [showPreview, setShowPreview] = useState(true)
+  const [isFullscreen, setIsFullscreen] = useState(false)
+  const [isSaving, setIsSaving] = useState(false)
+  const previewRef = useRef<HTMLIFrameElement>(null)
+
+  // Generate unique session ID if not provided
+  const sessionId = userSession || `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+
+  // Function to get icon for each tab
+  const getTabIcon = (tabId: string) => {
+    switch (tabId) {
+      case 'html':
+        return <FileHtml size={16} weight="fill" className="text-orange-500" />
+      case 'css':
+        return <FileCss size={16} weight="fill" className="text-blue-500" />
+      case 'js':
+        return <FileJs size={16} weight="fill" className="text-yellow-500" />
+      default:
+        return <Code size={16} weight="fill" className="text-gray-500" />
+    }
+  }
+
+  const [tabs, setTabs] = useState<Tab[]>([
+    {
+      id: 'html',
+      name: 'index.html',
+      language: 'html',
+      content: `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>My Awesome Page</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+    <div class="container">
+        <h1>Welcome to Reuben OS Editor!</h1>
+        <p>Start coding and see your changes live!</p>
+        <button onclick="showMessage()">Click Me!</button>
+        <div id="output"></div>
+    </div>
+    <script src="script.js"></script>
+</body>
+</html>`
+    },
+    {
+      id: 'css',
+      name: 'style.css',
+      language: 'css',
+      content: `* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.container {
+    background: rgba(255, 255, 255, 0.95);
+    padding: 40px;
+    border-radius: 20px;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+    text-align: center;
+    max-width: 500px;
+}
+
+h1 {
+    color: #333;
+    margin-bottom: 20px;
+    font-size: 2.5em;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+}
+
+p {
+    color: #666;
+    margin-bottom: 30px;
+    font-size: 1.1em;
+}
+
+button {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border: none;
+    padding: 12px 30px;
+    border-radius: 50px;
+    font-size: 16px;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);
+}
+
+button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 6px 20px rgba(102, 126, 234, 0.6);
+}
+
+#output {
+    margin-top: 20px;
+    padding: 15px;
+    background: #f7f7f7;
+    border-radius: 10px;
+    min-height: 50px;
+    font-family: 'Courier New', monospace;
+}`
+    },
+    {
+      id: 'js',
+      name: 'script.js',
+      language: 'javascript',
+      content: `// Welcome to Reuben OS Code Editor!
+
+function showMessage() {
+    const messages = [
+        "Hello from Reuben OS! 🚀",
+        "You're doing great! 💪",
+        "Keep coding! 🎉",
+        "Awesome work! ⭐",
+        "Reuben OS is amazing! 🌟"
+    ];
+
+    const randomMessage = messages[Math.floor(Math.random() * messages.length)];
+    const output = document.getElementById('output');
+
+    output.innerHTML = \`
+        <strong>Message:</strong> \${randomMessage}<br>
+        <small>Generated at: \${new Date().toLocaleTimeString()}</small>
+    \`;
+
+    // Add animation
+    output.style.opacity = '0';
+    setTimeout(() => {
+        output.style.transition = 'opacity 0.5s ease';
+        output.style.opacity = '1';
+    }, 10);
+}
+
+// Log to console when page loads
+console.log('Reuben OS Editor initialized!');
+console.log('Session ID:', '\${sessionId}');`
+    }
+  ])
+
+  // Load saved code from localStorage based on session
+  useEffect(() => {
+    const savedCode = localStorage.getItem(`vscode_${sessionId}`)
+    if (savedCode) {
+      try {
+        const parsed = JSON.parse(savedCode)
+        setTabs(parsed)
+      } catch (e) {
+        console.error('Failed to load saved code')
+      }
+    }
+  }, [sessionId])
+
+  // Save code to localStorage
+  useEffect(() => {
+    if (tabs.length > 0) {
+      localStorage.setItem(`vscode_${sessionId}`, JSON.stringify(tabs))
+    }
+  }, [tabs, sessionId])
+
+  // Update preview when code changes
+  useEffect(() => {
+    if (previewRef.current && showPreview) {
+      updatePreview()
+    }
+  }, [tabs, showPreview])
+
+  const updatePreview = () => {
+    if (!previewRef.current) return
+
+    const htmlTab = tabs.find(t => t.id === 'html')
+    const cssTab = tabs.find(t => t.id === 'css')
+    const jsTab = tabs.find(t => t.id === 'js')
+
+    const previewContent = `
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <style>${cssTab?.content || ''}</style>
+      </head>
+      <body>
+        ${htmlTab?.content.replace(/<link.*?>/g, '').replace(/<script.*?src=.*?><\/script>/g, '') || ''}
+        <script>
+          const sessionId = '${sessionId}';
+          ${jsTab?.content || ''}
+        </script>
+      </body>
+      </html>
+    `
+
+    const blob = new Blob([previewContent], { type: 'text/html' })
+    const url = URL.createObjectURL(blob)
+    previewRef.current.src = url
+  }
+
+  const handleEditorChange = (value: string | undefined) => {
+    if (!value) return
+
+    setTabs(prev => prev.map(tab =>
+      tab.id === activeTab
+        ? { ...tab, content: value }
+        : tab
+    ))
+  }
+
+  const downloadCode = () => {
+    const htmlTab = tabs.find(t => t.id === 'html')
+    const cssTab = tabs.find(t => t.id === 'css')
+    const jsTab = tabs.find(t => t.id === 'js')
+
+    const fullHTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>My Reuben OS Project</title>
+    <style>
+${cssTab?.content || ''}
+    </style>
+</head>
+<body>
+${htmlTab?.content.replace(/<.*?html.*?>|<.*?head.*?>|<.*?body.*?>|<\/.*?html.*?>|<\/.*?head.*?>|<\/.*?body.*?>/gi, '').replace(/<link.*?>/g, '').replace(/<script.*?src=.*?><\/script>/g, '') || ''}
+    <script>
+${jsTab?.content || ''}
+    </script>
+</body>
+</html>`
+
+    const blob = new Blob([fullHTML], { type: 'text/html' })
+    const url = URL.createObjectURL(blob)
+    const a = document.createElement('a')
+    a.href = url
+    a.download = `webos-project-${sessionId}.html`
+    a.click()
+    URL.revokeObjectURL(url)
+  }
+
+  const saveToMCP = async () => {
+    setIsSaving(true)
+    try {
+      const response = await fetch('/api/code/save', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          sessionId,
+          code: tabs,
+          timestamp: Date.now()
+        })
+      })
+
+      if (response.ok) {
+        const result = await response.json()
+        console.log('Code saved successfully!', result)
+
+        // Show success message
+        const successDiv = document.createElement('div')
+        successDiv.className = 'fixed bottom-4 right-4 bg-green-600 text-white px-4 py-2 rounded-lg shadow-lg z-[200]'
+        successDiv.textContent = `Saved to: data/vscode_sessions/${sessionId}`
+        document.body.appendChild(successDiv)
+
+        setTimeout(() => {
+          successDiv.remove()
+        }, 3000)
+
+        // Also save to localStorage
+        localStorage.setItem(`vscode_${sessionId}`, JSON.stringify(tabs))
+      }
+    } catch (error) {
+      console.error('Failed to save code:', error)
+
+      // Show error message
+      const errorDiv = document.createElement('div')
+      errorDiv.className = 'fixed bottom-4 right-4 bg-red-600 text-white px-4 py-2 rounded-lg shadow-lg z-[200]'
+      errorDiv.textContent = 'Failed to save code'
+      document.body.appendChild(errorDiv)
+
+      setTimeout(() => {
+        errorDiv.remove()
+      }, 3000)
+    }
+    setIsSaving(false)
+  }
+
+  const activeTabContent = tabs.find(t => t.id === activeTab)
+
+  return (
+    <Window
+      id="vscode"
+      title="VS Code - Reuben OS Editor"
+      isOpen={true}
+      onClose={onClose}
+      width={isFullscreen ? window.innerWidth : 1400}
+      height={isFullscreen ? window.innerHeight - 32 : 800}
+      x={isFullscreen ? 0 : 50}
+      y={isFullscreen ? 32 : 50}
+      darkMode={true}
+      className="vscode-window"
+    >
+      <div className="flex flex-col h-full bg-[#1e1e1e]">
+        {/* Editor Header */}
+        <div className="flex items-center justify-between bg-[#2d2d2d] px-4 py-2 border-b border-[#3e3e3e]">
+          <div className="flex items-center gap-2">
+            <Code size={20} weight="bold" className="text-blue-400" />
+            <span className="text-gray-300 text-sm">Session: {sessionId.substring(0, 8)}...</span>
+          </div>
+
+          <div className="flex items-center gap-2">
+            <button
+              onClick={saveToMCP}
+              className="px-3 py-1 bg-green-600 hover:bg-green-700 text-white rounded text-sm flex items-center gap-2"
+              disabled={isSaving}
+            >
+              <FloppyDisk size={16} />
+              {isSaving ? 'Saving...' : 'Save'}
+            </button>
+
+            <button
+              onClick={downloadCode}
+              className="px-3 py-1 bg-blue-600 hover:bg-blue-700 text-white rounded text-sm flex items-center gap-2"
+            >
+              <Download size={16} />
+              Download
+            </button>
+
+            <button
+              onClick={() => setShowPreview(!showPreview)}
+              className="px-3 py-1 bg-gray-600 hover:bg-gray-700 text-white rounded text-sm flex items-center gap-2"
+            >
+              {showPreview ? <EyeSlash size={16} /> : <Eye size={16} />}
+              Preview
+            </button>
+
+            <button
+              onClick={() => setIsFullscreen(!isFullscreen)}
+              className="px-3 py-1 bg-gray-600 hover:bg-gray-700 text-white rounded text-sm flex items-center gap-2"
+            >
+              {isFullscreen ? <ArrowsInSimple size={16} /> : <ArrowsOutSimple size={16} />}
+            </button>
+          </div>
+        </div>
+
+        {/* Main Content */}
+        <div className="flex flex-1 overflow-hidden">
+          {/* Editor Section */}
+          <div className={`flex flex-col ${showPreview ? 'w-1/2' : 'w-full'} border-r border-[#3e3e3e]`}>
+            {/* Tabs */}
+            <div className="flex bg-[#252526] border-b border-[#3e3e3e]">
+              {tabs.map(tab => (
+                <button
+                  key={tab.id}
+                  onClick={() => setActiveTab(tab.id)}
+                  className={`px-4 py-2 text-sm flex items-center gap-2 border-r border-[#3e3e3e] transition-colors ${
+                    activeTab === tab.id
+                      ? 'bg-[#1e1e1e] text-white'
+                      : 'text-gray-400 hover:text-white hover:bg-[#2d2d2d]'
+                  }`}
+                >
+                  {getTabIcon(tab.id)}
+                  {tab.name}
+                </button>
+              ))}
+            </div>
+
+            {/* Monaco Editor */}
+            <div className="flex-1">
+              <Editor
+                height="100%"
+                language={activeTabContent?.language}
+                value={activeTabContent?.content}
+                onChange={handleEditorChange}
+                theme="vs-dark"
+                options={{
+                  minimap: { enabled: false },
+                  fontSize: 14,
+                  wordWrap: 'on',
+                  automaticLayout: true,
+                  scrollBeyondLastLine: false
+                }}
+              />
+            </div>
+          </div>
+
+          {/* Preview Section */}
+          {showPreview && (
+            <div className="flex-1 flex flex-col bg-white">
+              <div className="bg-gray-100 px-4 py-2 border-b border-gray-300 flex items-center justify-between">
+                <div className="flex items-center gap-2">
+                  <Eye size={16} className="text-gray-600" />
+                  <span className="text-sm font-medium">Live Preview</span>
+                </div>
+                <button
+                  onClick={updatePreview}
+                  className="p-1 hover:bg-gray-200 rounded transition-colors"
+                >
+                  <Play size={16} className="text-gray-600" />
+                </button>
+              </div>
+
+              <iframe
+                ref={previewRef}
+                className="flex-1 w-full bg-white"
+                sandbox="allow-scripts"
+                title="Code Preview"
+              />
+            </div>
+          )}
+        </div>
+      </div>
+    </Window>
+  )
+}
\ No newline at end of file
diff --git a/app/components/WebBrowser.tsx b/app/components/WebBrowser.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..ea7273533b76f85a3615804f6e577c1e7f59aa65
--- /dev/null
+++ b/app/components/WebBrowser.tsx
@@ -0,0 +1,277 @@
+'use client'
+
+import React, { useState, useRef } from 'react'
+import { Globe, RefreshCw, ArrowLeft, ArrowRight, Home, Lock, ExternalLink, X, Maximize2, Minimize2 } from 'lucide-react'
+
+interface Tab {
+  id: string
+  url: string
+  title: string
+  isActive: boolean
+}
+
+export default function WebBrowser() {
+  const [tabs, setTabs] = useState<Tab[]>([
+    { id: '1', url: 'https://www.google.com', title: 'Google', isActive: true }
+  ])
+  const [currentUrl, setCurrentUrl] = useState('https://www.google.com')
+  const [inputUrl, setInputUrl] = useState('https://www.google.com')
+  const [isLoading, setIsLoading] = useState(false)
+  const [isFullscreen, setIsFullscreen] = useState(false)
+  const [showBrowser, setShowBrowser] = useState(false)
+  const iframeRef = useRef<HTMLIFrameElement>(null)
+
+  const handleNavigate = (url: string) => {
+    // Ensure URL has protocol
+    let finalUrl = url
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+      finalUrl = 'https://' + url
+    }
+
+    setCurrentUrl(finalUrl)
+    setInputUrl(finalUrl)
+    setIsLoading(true)
+
+    // Update active tab
+    setTabs(prevTabs =>
+      prevTabs.map(tab =>
+        tab.isActive ? { ...tab, url: finalUrl } : tab
+      )
+    )
+  }
+
+  const handleRefresh = () => {
+    if (iframeRef.current) {
+      const currentSrc = iframeRef.current.src
+      iframeRef.current.src = ''
+      setTimeout(() => {
+        if (iframeRef.current) {
+          iframeRef.current.src = currentSrc
+        }
+      }, 10)
+    }
+  }
+
+  const handleBack = () => {
+    // Browser history would be handled by iframe internally
+    window.history.back()
+  }
+
+  const handleForward = () => {
+    window.history.forward()
+  }
+
+  const handleHome = () => {
+    handleNavigate('https://www.google.com')
+  }
+
+  const addNewTab = () => {
+    const newTab: Tab = {
+      id: Date.now().toString(),
+      url: 'https://www.google.com',
+      title: 'New Tab',
+      isActive: true
+    }
+
+    setTabs(prevTabs => [
+      ...prevTabs.map(tab => ({ ...tab, isActive: false })),
+      newTab
+    ])
+    setCurrentUrl(newTab.url)
+    setInputUrl(newTab.url)
+  }
+
+  const switchTab = (tabId: string) => {
+    const tab = tabs.find(t => t.id === tabId)
+    if (tab) {
+      setTabs(prevTabs =>
+        prevTabs.map(t => ({ ...t, isActive: t.id === tabId }))
+      )
+      setCurrentUrl(tab.url)
+      setInputUrl(tab.url)
+    }
+  }
+
+  const closeTab = (tabId: string) => {
+    if (tabs.length === 1) return // Don't close last tab
+
+    const tabIndex = tabs.findIndex(t => t.id === tabId)
+    const wasActive = tabs[tabIndex].isActive
+
+    const newTabs = tabs.filter(t => t.id !== tabId)
+
+    if (wasActive) {
+      const newActiveIndex = tabIndex > 0 ? tabIndex - 1 : 0
+      newTabs[newActiveIndex].isActive = true
+      setCurrentUrl(newTabs[newActiveIndex].url)
+      setInputUrl(newTabs[newActiveIndex].url)
+    }
+
+    setTabs(newTabs)
+  }
+
+  const openInNewWindow = () => {
+    window.open(currentUrl, '_blank')
+  }
+
+  if (!showBrowser) {
+    return (
+      <button
+        onClick={() => setShowBrowser(true)}
+        className="fixed bottom-4 right-4 z-50 px-4 py-2 bg-blue-600 text-white rounded-lg shadow-lg hover:bg-blue-700 transition-colors flex items-center gap-2"
+      >
+        <Globe size={20} />
+        Open Browser
+      </button>
+    )
+  }
+
+  return (
+    <div className={`fixed ${isFullscreen ? 'inset-0 z-[9999]' : 'inset-4 z-40'} bg-white rounded-lg shadow-2xl flex flex-col transition-all duration-300`}>
+      {/* Browser Header */}
+      <div className="bg-gray-100 border-b border-gray-300 rounded-t-lg">
+        {/* Tabs */}
+        <div className="flex items-center bg-gray-200 px-2 py-1 overflow-x-auto">
+          {tabs.map(tab => (
+            <div
+              key={tab.id}
+              className={`flex items-center px-3 py-1.5 mr-1 rounded-t-md cursor-pointer transition-colors ${
+                tab.isActive ? 'bg-white' : 'bg-gray-100 hover:bg-gray-50'
+              }`}
+              onClick={() => switchTab(tab.id)}
+            >
+              <Globe size={14} className="mr-2 text-gray-600" />
+              <span className="text-sm max-w-[150px] truncate">{tab.title}</span>
+              <button
+                onClick={(e) => {
+                  e.stopPropagation()
+                  closeTab(tab.id)
+                }}
+                className="ml-2 p-0.5 hover:bg-gray-200 rounded"
+              >
+                <X size={14} />
+              </button>
+            </div>
+          ))}
+          <button
+            onClick={addNewTab}
+            className="px-2 py-1 text-gray-600 hover:bg-gray-200 rounded"
+          >
+            +
+          </button>
+        </div>
+
+        {/* Navigation Bar */}
+        <div className="flex items-center gap-2 p-2 bg-white">
+          <button
+            onClick={handleBack}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title="Back"
+          >
+            <ArrowLeft size={18} />
+          </button>
+          <button
+            onClick={handleForward}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title="Forward"
+          >
+            <ArrowRight size={18} />
+          </button>
+          <button
+            onClick={handleRefresh}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title="Refresh"
+          >
+            <RefreshCw size={18} className={isLoading ? 'animate-spin' : ''} />
+          </button>
+          <button
+            onClick={handleHome}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title="Home"
+          >
+            <Home size={18} />
+          </button>
+
+          {/* URL Bar */}
+          <div className="flex-1 flex items-center bg-gray-50 rounded-md px-3 py-1.5 border border-gray-300">
+            <Lock size={14} className="text-green-600 mr-2" />
+            <input
+              type="text"
+              value={inputUrl}
+              onChange={(e) => setInputUrl(e.target.value)}
+              onKeyPress={(e) => {
+                if (e.key === 'Enter') {
+                  handleNavigate(inputUrl)
+                }
+              }}
+              className="flex-1 bg-transparent outline-none text-sm"
+              placeholder="Enter URL..."
+            />
+          </div>
+
+          <button
+            onClick={openInNewWindow}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title="Open in New Window"
+          >
+            <ExternalLink size={18} />
+          </button>
+          <button
+            onClick={() => setIsFullscreen(!isFullscreen)}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title={isFullscreen ? 'Exit Fullscreen' : 'Fullscreen'}
+          >
+            {isFullscreen ? <Minimize2 size={18} /> : <Maximize2 size={18} />}
+          </button>
+          <button
+            onClick={() => setShowBrowser(false)}
+            className="p-2 hover:bg-gray-100 rounded transition-colors text-red-600"
+            title="Close Browser"
+          >
+            <X size={18} />
+          </button>
+        </div>
+      </div>
+
+      {/* Browser Content */}
+      <div className="flex-1 relative bg-white">
+        {/* Loading Indicator */}
+        {isLoading && (
+          <div className="absolute top-0 left-0 w-full h-1 bg-blue-600 animate-pulse z-10" />
+        )}
+
+        {/* iframe Content */}
+        <iframe
+          ref={iframeRef}
+          src={currentUrl}
+          className="w-full h-full border-0"
+          onLoad={() => {
+            setIsLoading(false)
+            // Try to get the title from the iframe (may be blocked by CORS)
+            try {
+              const title = iframeRef.current?.contentDocument?.title || 'Web Page'
+              setTabs(prevTabs =>
+                prevTabs.map(tab =>
+                  tab.isActive ? { ...tab, title } : tab
+                )
+              )
+            } catch (e) {
+              // CORS will block this for most external sites
+              console.log('Could not access iframe title due to CORS')
+            }
+          }}
+          sandbox="allow-scripts allow-same-origin allow-forms allow-popups"
+          title="Web Browser"
+        />
+
+        {/* CORS Notice */}
+        <div className="absolute bottom-4 right-4 bg-yellow-100 border border-yellow-400 rounded-lg p-3 max-w-sm">
+          <p className="text-xs text-yellow-800">
+            <strong>Note:</strong> Some websites may not display due to security restrictions (CORS).
+            For full browsing, consider using a proxy service or browser extension.
+          </p>
+        </div>
+      </div>
+    </div>
+  )
+}
\ No newline at end of file
diff --git a/app/components/WebBrowserApp.tsx b/app/components/WebBrowserApp.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..f955aa81ee40de6012a9aa7a4d8fd6df23ef5b00
--- /dev/null
+++ b/app/components/WebBrowserApp.tsx
@@ -0,0 +1,438 @@
+'use client'
+
+import React, { useState, useRef } from 'react'
+import { Globe, RefreshCw, ArrowLeft, ArrowRight, Home, Lock, ExternalLink, AlertTriangle, Shield, X } from 'lucide-react'
+import Window from './Window'
+
+interface Tab {
+  id: string
+  url: string
+  title: string
+  isActive: boolean
+}
+
+interface WebBrowserAppProps {
+  onClose: () => void
+}
+
+export default function WebBrowserApp({ onClose }: WebBrowserAppProps) {
+  const [tabs, setTabs] = useState<Tab[]>([
+    { id: '1', url: 'https://www.google.com/webhp?igu=1', title: 'Google', isActive: true }
+  ])
+  const [currentUrl, setCurrentUrl] = useState('https://www.google.com/webhp?igu=1')
+  const [inputUrl, setInputUrl] = useState('https://www.google.com')
+  const [isLoading, setIsLoading] = useState(false)
+  const [isMaximized, setIsMaximized] = useState(false)
+  const [useProxy, setUseProxy] = useState(false)
+  const [showSettings, setShowSettings] = useState(false)
+  const [showHomePage, setShowHomePage] = useState(true)
+  const iframeRef = useRef<HTMLIFrameElement>(null)
+
+  // List of sites that work well in iframes
+  const iframeFriendlySites = [
+    { name: 'Google', url: 'https://www.google.com/webhp?igu=1' },
+    { name: 'Wikipedia', url: 'https://www.wikipedia.org' },
+    { name: 'MDN Web Docs', url: 'https://developer.mozilla.org' },
+    { name: 'Stack Overflow', url: 'https://stackoverflow.com' },
+    { name: 'GitHub', url: 'https://github.com' },
+    { name: 'DuckDuckGo', url: 'https://duckduckgo.com' }
+  ]
+
+  const getProxiedUrl = (url: string) => {
+    // Use a CORS proxy service - you can replace this with your own proxy
+    if (useProxy) {
+      // Option 1: Use allorigins proxy (free, public) - SLOW but works
+      return `https://api.allorigins.win/raw?url=${encodeURIComponent(url)}`
+
+      // Option 2: Use cors-anywhere (may require your own deployment)
+      // return `https://cors-anywhere.herokuapp.com/${url}`
+
+      // Option 3: Use your own backend proxy endpoint
+      // return `/api/proxy?url=${encodeURIComponent(url)}`
+    }
+    return url
+  }
+
+  const handleNavigate = (url: string) => {
+    // Ensure URL has protocol
+    let finalUrl = url
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+      // Check if it looks like a search query
+      if (!url.includes('.') || url.includes(' ')) {
+        finalUrl = `https://www.google.com/search?q=${encodeURIComponent(url)}&igu=1`
+      } else {
+        finalUrl = 'https://' + url
+      }
+    }
+
+    setShowHomePage(false)
+    const proxiedUrl = getProxiedUrl(finalUrl)
+    setCurrentUrl(proxiedUrl)
+    setInputUrl(finalUrl)
+    setIsLoading(true)
+
+    // Update active tab
+    setTabs(prevTabs =>
+      prevTabs.map(tab =>
+        tab.isActive ? { ...tab, url: finalUrl, title: new URL(finalUrl).hostname } : tab
+      )
+    )
+  }
+
+  const handleRefresh = () => {
+    if (iframeRef.current) {
+      setIsLoading(true)
+      const currentSrc = iframeRef.current.src
+      iframeRef.current.src = ''
+      setTimeout(() => {
+        if (iframeRef.current) {
+          iframeRef.current.src = currentSrc
+        }
+      }, 10)
+    }
+  }
+
+  const handleBack = () => {
+    window.history.back()
+  }
+
+  const handleForward = () => {
+    window.history.forward()
+  }
+
+  const handleHome = () => {
+    setShowHomePage(true)
+    setCurrentUrl('')
+    setInputUrl('')
+  }
+
+  const addNewTab = () => {
+    const newTab: Tab = {
+      id: Date.now().toString(),
+      url: 'https://www.google.com/webhp?igu=1',
+      title: 'New Tab',
+      isActive: true
+    }
+
+    setTabs(prevTabs => [
+      ...prevTabs.map(tab => ({ ...tab, isActive: false })),
+      newTab
+    ])
+    handleNavigate(newTab.url)
+  }
+
+  const switchTab = (tabId: string) => {
+    const tab = tabs.find(t => t.id === tabId)
+    if (tab) {
+      setTabs(prevTabs =>
+        prevTabs.map(t => ({ ...t, isActive: t.id === tabId }))
+      )
+      handleNavigate(tab.url)
+    }
+  }
+
+  const closeTab = (tabId: string, e: React.MouseEvent) => {
+    e.stopPropagation()
+    if (tabs.length === 1) return
+
+    const tabIndex = tabs.findIndex(t => t.id === tabId)
+    const wasActive = tabs[tabIndex].isActive
+
+    const newTabs = tabs.filter(t => t.id !== tabId)
+
+    if (wasActive) {
+      const newActiveIndex = tabIndex > 0 ? tabIndex - 1 : 0
+      newTabs[newActiveIndex].isActive = true
+      handleNavigate(newTabs[newActiveIndex].url)
+    }
+
+    setTabs(newTabs)
+  }
+
+  const openInNewWindow = () => {
+    const activeTab = tabs.find(t => t.isActive)
+    if (activeTab) {
+      window.open(activeTab.url, '_blank')
+    }
+  }
+
+  return (
+    <Window
+      id="browser"
+      title="Web Browser"
+      isOpen={true}
+      onClose={onClose}
+      width={1200}
+      height={700}
+      x={window.innerWidth / 2 - 600}
+      y={window.innerHeight / 2 - 350}
+      className="browser-window"
+    >
+      {/* Browser Header */}
+      <div className="bg-gray-100 border-b border-gray-300">
+        {/* Tabs */}
+        <div className="flex items-center bg-gray-200 px-2 py-1 overflow-x-auto">
+          {tabs.map(tab => (
+            <div
+              key={tab.id}
+              className={`flex items-center px-3 py-1.5 mr-1 rounded-t-md cursor-pointer transition-colors min-w-[150px] max-w-[200px] ${
+                tab.isActive ? 'bg-white' : 'bg-gray-100 hover:bg-gray-50'
+              }`}
+              onClick={() => switchTab(tab.id)}
+            >
+              <Globe size={14} className="mr-2 text-gray-600 flex-shrink-0" />
+              <span className="text-sm truncate flex-1">{tab.title}</span>
+              {tabs.length > 1 && (
+                <button
+                  onClick={(e) => closeTab(tab.id, e)}
+                  className="ml-2 p-0.5 hover:bg-gray-200 rounded flex-shrink-0"
+                >
+                  <X size={14} />
+                </button>
+              )}
+            </div>
+          ))}
+          <button
+            onClick={addNewTab}
+            className="px-2 py-1 text-gray-600 hover:bg-gray-200 rounded"
+          >
+            +
+          </button>
+        </div>
+
+        {/* Navigation Bar */}
+        <div className="flex items-center gap-2 p-2 bg-white">
+          <button
+            onClick={handleBack}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title="Back"
+          >
+            <ArrowLeft size={18} />
+          </button>
+          <button
+            onClick={handleForward}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title="Forward"
+          >
+            <ArrowRight size={18} />
+          </button>
+          <button
+            onClick={handleRefresh}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title="Refresh"
+          >
+            <RefreshCw size={18} className={isLoading ? 'animate-spin' : ''} />
+          </button>
+          <button
+            onClick={handleHome}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title="Home"
+          >
+            <Home size={18} />
+          </button>
+
+          {/* URL Bar */}
+          <div className="flex-1 flex items-center bg-gray-50 rounded-md px-3 py-1.5 border border-gray-300">
+            {useProxy ? (
+              <Shield size={14} className="text-green-600 mr-2" />
+            ) : (
+              <Lock size={14} className="text-gray-400 mr-2" />
+            )}
+            <input
+              type="text"
+              value={inputUrl}
+              onChange={(e) => setInputUrl(e.target.value)}
+              onKeyPress={(e) => {
+                if (e.key === 'Enter') {
+                  handleNavigate(inputUrl)
+                }
+              }}
+              className="flex-1 bg-transparent outline-none text-sm"
+              placeholder="Enter URL or search..."
+            />
+          </div>
+
+          <button
+            onClick={() => setShowSettings(!showSettings)}
+            className={`p-2 rounded transition-colors ${showSettings ? 'bg-blue-100' : 'hover:bg-gray-100'}`}
+            title="Settings"
+          >
+            <Shield size={18} className={useProxy ? 'text-green-600' : 'text-gray-400'} />
+          </button>
+          <button
+            onClick={openInNewWindow}
+            className="p-2 hover:bg-gray-100 rounded transition-colors"
+            title="Open in New Window"
+          >
+            <ExternalLink size={18} />
+          </button>
+        </div>
+
+        {/* Settings Panel */}
+        {showSettings && (
+          <div className="px-4 py-3 bg-blue-50 border-b border-blue-200">
+            <div className="flex items-center justify-between mb-2">
+              <label className="flex items-center gap-2 cursor-pointer">
+                <input
+                  type="checkbox"
+                  checked={useProxy}
+                  onChange={(e) => setUseProxy(e.target.checked)}
+                  className="w-4 h-4"
+                />
+                <span className="text-sm font-medium">Use CORS Proxy</span>
+                <span className="text-xs text-gray-600">(Bypass cross-origin restrictions)</span>
+              </label>
+            </div>
+            <div className="text-xs text-gray-600">
+              <p className="mb-1">• Proxy allows accessing most websites but may affect performance</p>
+              <p>• Some interactive features may not work through proxy</p>
+            </div>
+          </div>
+        )}
+
+        {/* Quick Links */}
+        <div className="px-4 py-2 bg-gray-50 border-b flex items-center gap-2 overflow-x-auto">
+          <span className="text-xs text-gray-600 mr-2">Quick Links:</span>
+          {iframeFriendlySites.map(site => (
+            <button
+              key={site.name}
+              onClick={() => handleNavigate(site.url)}
+              className="px-3 py-1 text-xs bg-white border border-gray-300 rounded hover:bg-blue-50 hover:border-blue-400 transition-colors whitespace-nowrap"
+            >
+              {site.name}
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* Browser Content */}
+      <div className="flex-1 relative bg-white overflow-hidden">
+        {/* Loading Indicator */}
+        {isLoading && !showHomePage && (
+          <div className="absolute top-0 left-0 w-full h-1 bg-blue-600 z-20">
+            <div className="h-full bg-blue-400 animate-pulse" />
+          </div>
+        )}
+
+        {/* Home Page */}
+        {showHomePage ? (
+          <div className="w-full h-full flex flex-col items-center justify-center bg-gradient-to-br from-blue-50 to-purple-50 p-8">
+            <div className="max-w-2xl w-full space-y-8">
+              {/* Browser Logo */}
+              <div className="flex flex-col items-center gap-4">
+                <div className="w-24 h-24 rounded-full bg-gradient-to-br from-blue-500 to-cyan-500 flex items-center justify-center shadow-lg">
+                  <Globe size={48} className="text-white" />
+                </div>
+                <h1 className="text-4xl font-bold text-gray-800">Web Browser</h1>
+                <p className="text-gray-600 text-center">Browse the web with speed and simplicity</p>
+              </div>
+
+              {/* Search Box */}
+              <div className="w-full">
+                <div className="relative">
+                  <input
+                    type="text"
+                    placeholder="Search or enter website address..."
+                    className="w-full px-6 py-4 text-lg rounded-full border-2 border-gray-300 focus:border-blue-500 focus:outline-none shadow-md"
+                    onKeyPress={(e) => {
+                      if (e.key === 'Enter') {
+                        const value = (e.target as HTMLInputElement).value
+                        if (value.trim()) {
+                          handleNavigate(value)
+                        }
+                      }
+                    }}
+                  />
+                  <div className="absolute right-4 top-1/2 -translate-y-1/2 text-gray-400">
+                    Press Enter ↵
+                  </div>
+                </div>
+              </div>
+
+              {/* Quick Access Grid */}
+              <div>
+                <h2 className="text-sm font-medium text-gray-600 mb-3">Quick Access</h2>
+                <div className="grid grid-cols-3 gap-4">
+                  {iframeFriendlySites.map(site => (
+                    <button
+                      key={site.name}
+                      onClick={() => handleNavigate(site.url)}
+                      className="p-4 bg-white rounded-lg shadow hover:shadow-md transition-shadow border border-gray-200 hover:border-blue-400 group"
+                    >
+                      <div className="flex flex-col items-center gap-2">
+                        <div className="w-12 h-12 rounded-full bg-gradient-to-br from-blue-100 to-purple-100 flex items-center justify-center group-hover:from-blue-200 group-hover:to-purple-200 transition-colors">
+                          <Globe size={24} className="text-blue-600" />
+                        </div>
+                        <span className="text-sm font-medium text-gray-700">{site.name}</span>
+                      </div>
+                    </button>
+                  ))}
+                </div>
+              </div>
+
+              {/* Performance Tip */}
+              <div className="bg-blue-100 border border-blue-300 rounded-lg p-4">
+                <div className="flex items-start gap-3">
+                  <Shield size={20} className="text-blue-600 mt-0.5 flex-shrink-0" />
+                  <div className="text-sm">
+                    <p className="text-blue-900 font-medium mb-1">⚡ Fast Direct Access</p>
+                    <p className="text-blue-800">
+                      For best performance, websites are loaded directly without proxy. Some sites may block iframe access due to security policies.
+                    </p>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+        ) : (
+          <>
+            {/* iframe Content */}
+            <iframe
+              ref={iframeRef}
+              src={currentUrl}
+              className="w-full h-full border-0"
+              onLoad={() => {
+                setIsLoading(false)
+                // Try to get the title (may be blocked by CORS)
+                try {
+                  if (iframeRef.current?.contentDocument?.title) {
+                    const title = iframeRef.current.contentDocument.title
+                    setTabs(prevTabs =>
+                      prevTabs.map(tab =>
+                        tab.isActive ? { ...tab, title } : tab
+                      )
+                    )
+                  }
+                } catch (e) {
+                  // Expected for cross-origin content
+                }
+              }}
+              onError={() => {
+                setIsLoading(false)
+              }}
+              sandbox="allow-scripts allow-same-origin allow-forms allow-popups allow-popups-to-escape-sandbox"
+              title="Web Browser"
+            />
+
+            {/* Info Panel - only show if using proxy */}
+            {useProxy && (
+              <div className="absolute bottom-4 right-4 bg-yellow-100 border border-yellow-400 rounded-lg p-3 max-w-sm z-10">
+                <div className="flex items-start gap-2">
+                  <AlertTriangle size={16} className="text-yellow-700 mt-0.5" />
+                  <div>
+                    <p className="text-xs text-yellow-800 font-medium mb-1">
+                      Using Proxy (Slower)
+                    </p>
+                    <p className="text-xs text-yellow-700">
+                      Proxy adds extra latency. Disable in settings for faster loading.
+                    </p>
+                  </div>
+                </div>
+              </div>
+            )}
+          </>
+        )}
+      </div>
+    </Window>
+  )
+}
\ No newline at end of file
diff --git a/app/components/Window.tsx b/app/components/Window.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..56866cd54bebd4c243bf42d69ec7fc89342f37eb
--- /dev/null
+++ b/app/components/Window.tsx
@@ -0,0 +1,132 @@
+'use client';
+
+import React, { ReactNode } from 'react';
+import { Rnd } from 'react-rnd';
+
+interface WindowProps {
+  id: string;
+  title: string;
+  isOpen: boolean;
+  onClose: () => void;
+  onMinimize?: () => void;
+  onMaximize?: () => void;
+  children: ReactNode;
+  width?: number | string;
+  height?: number | string;
+  x?: number;
+  y?: number;
+  resizable?: boolean;
+  className?: string;
+  headerClassName?: string;
+  darkMode?: boolean;
+}
+
+const Window: React.FC<WindowProps> = ({
+  id,
+  title,
+  isOpen,
+  onClose,
+  onMinimize,
+  onMaximize,
+  children,
+  width = 800,
+  height = 600,
+  x = 100,
+  y = 100,
+  resizable = true,
+  className = '',
+  headerClassName = '',
+  darkMode = false,
+}) => {
+  const [isMaximized, setIsMaximized] = React.useState(false);
+  const [previousSize, setPreviousSize] = React.useState({ width, height, x, y });
+  const [currentPosition, setCurrentPosition] = React.useState({ x, y });
+  const [currentSize, setCurrentSize] = React.useState({ width, height });
+
+  if (!isOpen) return null;
+
+  const handleMaximize = () => {
+    if (!onMaximize) return;
+
+    if (!isMaximized) {
+      setPreviousSize({ width, height, x, y });
+      setIsMaximized(true);
+    } else {
+      setIsMaximized(false);
+    }
+    onMaximize();
+  };
+
+  const windowClass = darkMode ? 'bg-gray-900 border-gray-700' : 'bg-[#f5f5f5] border-gray-300/50';
+  const headerClass = darkMode ? 'bg-gray-800 border-gray-700' : 'bg-[#f1f1f1] border-gray-300';
+
+  if (isMaximized) {
+    return (
+      <div
+        className={`fixed inset-0 top-8 z-50 flex flex-col overflow-hidden ${windowClass} ${className}`}
+      >
+        <div
+          className={`h-12 flex items-center px-4 space-x-4 border-b ${headerClass} ${headerClassName}`}
+        >
+          <div className="flex space-x-2">
+            <div className="traffic-light traffic-close" onClick={onClose} />
+            <div className="traffic-light traffic-min" onClick={onMinimize} />
+            <div className="traffic-light traffic-max" onClick={handleMaximize} />
+          </div>
+          <span className="font-semibold text-gray-700 flex-1 text-center pr-16">{title}</span>
+        </div>
+        <div className="flex-1 overflow-auto">{children}</div>
+      </div>
+    );
+  }
+
+  return (
+    <Rnd
+      default={{
+        x: currentPosition.x,
+        y: currentPosition.y,
+        width: typeof currentSize.width === 'number' ? currentSize.width : 800,
+        height: typeof currentSize.height === 'number' ? currentSize.height : 600,
+      }}
+      position={undefined}
+      size={undefined}
+      minWidth={400}
+      minHeight={300}
+      bounds="parent"
+      dragHandleClassName="window-drag-handle"
+      enableResizing={resizable}
+      onDragStop={(e, d) => {
+        setCurrentPosition({ x: d.x, y: d.y });
+      }}
+      onResizeStop={(e, direction, ref, delta, position) => {
+        setCurrentSize({
+          width: ref.offsetWidth,
+          height: ref.offsetHeight,
+        });
+        setCurrentPosition(position);
+      }}
+      className="window-transition"
+      style={{ zIndex: 50 }}
+    >
+      <div
+        className={`h-full rounded-xl shadow-2xl overflow-hidden border ${windowClass} ${className}`}
+      >
+        <div
+          className={`window-drag-handle h-12 flex items-center px-4 space-x-4 border-b cursor-move ${headerClass} ${headerClassName}`}
+        >
+          <div className="flex space-x-2">
+            <div className="traffic-light traffic-close" onClick={onClose} />
+            <div className="traffic-light traffic-min" onClick={onMinimize} />
+            <div className="traffic-light traffic-max" onClick={handleMaximize} />
+          </div>
+          <span className="font-semibold text-gray-700 flex-1 text-center pr-16">{title}</span>
+        </div>
+        <div className="flex-1 overflow-auto bg-white" style={{ height: 'calc(100% - 3rem)' }}>
+          {children}
+        </div>
+      </div>
+    </Rnd>
+  );
+};
+
+export default Window;
\ No newline at end of file
diff --git a/app/gemini/page.tsx b/app/gemini/page.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..80c87444875ffade99d7d2407f8c1bbb8f0d955b
--- /dev/null
+++ b/app/gemini/page.tsx
@@ -0,0 +1,426 @@
+'use client'
+
+import React, { useState, useRef, useEffect } from 'react'
+import { Upload, Mic, MicOff, Send, Image as ImageIcon, FileText, Loader2, X } from 'lucide-react'
+
+interface Message {
+  id: string
+  role: 'user' | 'assistant'
+  content: string
+  type: 'text' | 'image' | 'audio'
+  imageUrl?: string
+  timestamp: Date
+}
+
+export default function GeminiAIApp() {
+  const [messages, setMessages] = useState<Message[]>([])
+  const [inputText, setInputText] = useState('')
+  const [isLoading, setIsLoading] = useState(false)
+  const [isRecording, setIsRecording] = useState(false)
+  const [selectedImage, setSelectedImage] = useState<string | null>(null)
+  const [activeTab, setActiveTab] = useState<'chat' | 'transcribe' | 'image'>('chat')
+  const [apiKey, setApiKey] = useState('')
+  const [showApiKeyInput, setShowApiKeyInput] = useState(true)
+
+  const fileInputRef = useRef<HTMLInputElement>(null)
+  const audioInputRef = useRef<HTMLInputElement>(null)
+  const messagesEndRef = useRef<HTMLDivElement>(null)
+  const mediaRecorderRef = useRef<MediaRecorder | null>(null)
+  const audioChunksRef = useRef<Blob[]>([])
+
+  useEffect(() => {
+    // Check for stored API key
+    const storedKey = localStorage.getItem('gemini_api_key')
+    if (storedKey) {
+      setApiKey(storedKey)
+      setShowApiKeyInput(false)
+    }
+  }, [])
+
+  useEffect(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
+  }, [messages])
+
+  const saveApiKey = () => {
+    if (apiKey.trim()) {
+      localStorage.setItem('gemini_api_key', apiKey)
+      setShowApiKeyInput(false)
+    }
+  }
+
+  const handleSendMessage = async () => {
+    if (!inputText.trim() && !selectedImage) return
+
+    const newMessage: Message = {
+      id: Date.now().toString(),
+      role: 'user',
+      content: inputText || 'Image uploaded',
+      type: selectedImage ? 'image' : 'text',
+      imageUrl: selectedImage || undefined,
+      timestamp: new Date()
+    }
+
+    setMessages(prev => [...prev, newMessage])
+    setInputText('')
+    setSelectedImage(null)
+    setIsLoading(true)
+
+    try {
+      const response = await fetch('/api/gemini/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          message: inputText,
+          imageUrl: selectedImage,
+          apiKey: apiKey,
+          history: messages.slice(-10) // Send last 10 messages for context
+        })
+      })
+
+      const data = await response.json()
+
+      if (data.error) {
+        throw new Error(data.error)
+      }
+
+      const aiMessage: Message = {
+        id: (Date.now() + 1).toString(),
+        role: 'assistant',
+        content: data.response,
+        type: 'text',
+        timestamp: new Date()
+      }
+
+      setMessages(prev => [...prev, aiMessage])
+    } catch (error) {
+      console.error('Error:', error)
+      const errorMessage: Message = {
+        id: (Date.now() + 1).toString(),
+        role: 'assistant',
+        content: `Error: ${error instanceof Error ? error.message : 'Failed to get response'}`,
+        type: 'text',
+        timestamp: new Date()
+      }
+      setMessages(prev => [...prev, errorMessage])
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleImageUpload = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0]
+    if (file) {
+      const reader = new FileReader()
+      reader.onloadend = () => {
+        setSelectedImage(reader.result as string)
+      }
+      reader.readAsDataURL(file)
+    }
+  }
+
+  const startRecording = async () => {
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true })
+      const mediaRecorder = new MediaRecorder(stream)
+      mediaRecorderRef.current = mediaRecorder
+      audioChunksRef.current = []
+
+      mediaRecorder.ondataavailable = (event) => {
+        audioChunksRef.current.push(event.data)
+      }
+
+      mediaRecorder.onstop = async () => {
+        const audioBlob = new Blob(audioChunksRef.current, { type: 'audio/wav' })
+        await transcribeAudio(audioBlob)
+        stream.getTracks().forEach(track => track.stop())
+      }
+
+      mediaRecorder.start()
+      setIsRecording(true)
+    } catch (error) {
+      console.error('Error accessing microphone:', error)
+      alert('Error accessing microphone. Please check permissions.')
+    }
+  }
+
+  const stopRecording = () => {
+    if (mediaRecorderRef.current && isRecording) {
+      mediaRecorderRef.current.stop()
+      setIsRecording(false)
+    }
+  }
+
+  const transcribeAudio = async (audioBlob: Blob) => {
+    setIsLoading(true)
+    const formData = new FormData()
+    formData.append('audio', audioBlob, 'recording.wav')
+    formData.append('apiKey', apiKey)
+
+    try {
+      const response = await fetch('/api/gemini/transcribe', {
+        method: 'POST',
+        body: formData
+      })
+
+      const data = await response.json()
+
+      if (data.error) {
+        throw new Error(data.error)
+      }
+
+      setInputText(data.transcription)
+    } catch (error) {
+      console.error('Transcription error:', error)
+      alert('Failed to transcribe audio')
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleAudioFileUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0]
+    if (file) {
+      await transcribeAudio(file)
+    }
+  }
+
+  return (
+    <div className="min-h-screen bg-gradient-to-br from-purple-50 to-blue-50 p-4">
+      <div className="max-w-6xl mx-auto">
+        <div className="bg-white rounded-2xl shadow-xl overflow-hidden">
+          {/* Header */}
+          <div className="bg-gradient-to-r from-blue-600 to-purple-600 p-6 text-white">
+            <h1 className="text-3xl font-bold mb-2">Gemini AI Assistant</h1>
+            <p className="text-blue-100">Chat, Transcribe, and Analyze Images with AI</p>
+          </div>
+
+          {/* API Key Input */}
+          {showApiKeyInput && (
+            <div className="p-4 bg-yellow-50 border-b border-yellow-200">
+              <div className="flex gap-2">
+                <input
+                  type="password"
+                  placeholder="Enter your Gemini API Key"
+                  value={apiKey}
+                  onChange={(e) => setApiKey(e.target.value)}
+                  className="flex-1 px-4 py-2 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
+                />
+                <button
+                  onClick={saveApiKey}
+                  className="px-6 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors"
+                >
+                  Save Key
+                </button>
+              </div>
+              <p className="text-sm text-gray-600 mt-2">
+                Get your API key from <a href="https://makersuite.google.com/app/apikey" target="_blank" rel="noopener noreferrer" className="text-blue-600 hover:underline">Google AI Studio</a>
+              </p>
+            </div>
+          )}
+
+          {/* Tabs */}
+          <div className="flex border-b border-gray-200">
+            <button
+              onClick={() => setActiveTab('chat')}
+              className={`flex-1 py-3 px-4 font-medium transition-colors ${
+                activeTab === 'chat'
+                  ? 'bg-blue-50 text-blue-600 border-b-2 border-blue-600'
+                  : 'text-gray-600 hover:bg-gray-50'
+              }`}
+            >
+              Chat
+            </button>
+            <button
+              onClick={() => setActiveTab('transcribe')}
+              className={`flex-1 py-3 px-4 font-medium transition-colors ${
+                activeTab === 'transcribe'
+                  ? 'bg-blue-50 text-blue-600 border-b-2 border-blue-600'
+                  : 'text-gray-600 hover:bg-gray-50'
+              }`}
+            >
+              Transcribe
+            </button>
+            <button
+              onClick={() => setActiveTab('image')}
+              className={`flex-1 py-3 px-4 font-medium transition-colors ${
+                activeTab === 'image'
+                  ? 'bg-blue-50 text-blue-600 border-b-2 border-blue-600'
+                  : 'text-gray-600 hover:bg-gray-50'
+              }`}
+            >
+              Image Analysis
+            </button>
+          </div>
+
+          {/* Chat Messages */}
+          <div className="h-[500px] overflow-y-auto p-4 space-y-4">
+            {messages.length === 0 && (
+              <div className="text-center text-gray-500 mt-20">
+                <div className="mb-4">
+                  {activeTab === 'chat' && <FileText size={48} className="mx-auto text-gray-300" />}
+                  {activeTab === 'transcribe' && <Mic size={48} className="mx-auto text-gray-300" />}
+                  {activeTab === 'image' && <ImageIcon size={48} className="mx-auto text-gray-300" />}
+                </div>
+                <p className="text-lg font-medium">
+                  {activeTab === 'chat' && 'Start a conversation with Gemini AI'}
+                  {activeTab === 'transcribe' && 'Record or upload audio to transcribe'}
+                  {activeTab === 'image' && 'Upload an image for AI analysis'}
+                </p>
+              </div>
+            )}
+
+            {messages.map((message) => (
+              <div
+                key={message.id}
+                className={`flex ${message.role === 'user' ? 'justify-end' : 'justify-start'}`}
+              >
+                <div
+                  className={`max-w-[70%] p-4 rounded-2xl ${
+                    message.role === 'user'
+                      ? 'bg-blue-600 text-white'
+                      : 'bg-gray-100 text-gray-800'
+                  }`}
+                >
+                  {message.imageUrl && (
+                    <img
+                      src={message.imageUrl}
+                      alt="Uploaded"
+                      className="mb-2 rounded-lg max-h-64 object-contain"
+                    />
+                  )}
+                  <p className="whitespace-pre-wrap">{message.content}</p>
+                  <p className={`text-xs mt-2 ${
+                    message.role === 'user' ? 'text-blue-100' : 'text-gray-500'
+                  }`}>
+                    {new Date(message.timestamp).toLocaleTimeString()}
+                  </p>
+                </div>
+              </div>
+            ))}
+
+            {isLoading && (
+              <div className="flex justify-start">
+                <div className="bg-gray-100 p-4 rounded-2xl">
+                  <Loader2 className="animate-spin h-5 w-5 text-gray-600" />
+                </div>
+              </div>
+            )}
+
+            <div ref={messagesEndRef} />
+          </div>
+
+          {/* Selected Image Preview */}
+          {selectedImage && (
+            <div className="px-4 pb-2">
+              <div className="relative inline-block">
+                <img
+                  src={selectedImage}
+                  alt="Selected"
+                  className="h-20 rounded-lg border-2 border-blue-500"
+                />
+                <button
+                  onClick={() => setSelectedImage(null)}
+                  className="absolute -top-2 -right-2 bg-red-500 text-white rounded-full p-1 hover:bg-red-600"
+                >
+                  <X size={16} />
+                </button>
+              </div>
+            </div>
+          )}
+
+          {/* Input Area */}
+          <div className="border-t border-gray-200 p-4">
+            <div className="flex gap-2">
+              {/* File Inputs */}
+              <input
+                ref={fileInputRef}
+                type="file"
+                accept="image/*"
+                onChange={handleImageUpload}
+                className="hidden"
+              />
+              <input
+                ref={audioInputRef}
+                type="file"
+                accept="audio/*"
+                onChange={handleAudioFileUpload}
+                className="hidden"
+              />
+
+              {/* Action Buttons */}
+              {activeTab === 'image' && (
+                <button
+                  onClick={() => fileInputRef.current?.click()}
+                  className="p-3 bg-purple-100 text-purple-600 rounded-lg hover:bg-purple-200 transition-colors"
+                  title="Upload Image"
+                >
+                  <ImageIcon size={20} />
+                </button>
+              )}
+
+              {activeTab === 'transcribe' && (
+                <>
+                  <button
+                    onClick={isRecording ? stopRecording : startRecording}
+                    className={`p-3 rounded-lg transition-colors ${
+                      isRecording
+                        ? 'bg-red-100 text-red-600 hover:bg-red-200 animate-pulse'
+                        : 'bg-green-100 text-green-600 hover:bg-green-200'
+                    }`}
+                    title={isRecording ? 'Stop Recording' : 'Start Recording'}
+                  >
+                    {isRecording ? <MicOff size={20} /> : <Mic size={20} />}
+                  </button>
+                  <button
+                    onClick={() => audioInputRef.current?.click()}
+                    className="p-3 bg-blue-100 text-blue-600 rounded-lg hover:bg-blue-200 transition-colors"
+                    title="Upload Audio File"
+                  >
+                    <Upload size={20} />
+                  </button>
+                </>
+              )}
+
+              {/* Text Input */}
+              <input
+                type="text"
+                value={inputText}
+                onChange={(e) => setInputText(e.target.value)}
+                onKeyPress={(e) => e.key === 'Enter' && !e.shiftKey && handleSendMessage()}
+                placeholder={
+                  activeTab === 'chat' ? 'Type your message...' :
+                  activeTab === 'transcribe' ? 'Transcribed text will appear here...' :
+                  'Describe what you want to analyze...'
+                }
+                className="flex-1 px-4 py-3 border border-gray-300 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
+                disabled={isLoading}
+              />
+
+              {/* Send Button */}
+              <button
+                onClick={handleSendMessage}
+                disabled={isLoading || (!inputText.trim() && !selectedImage)}
+                className="px-6 py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors disabled:bg-gray-300 disabled:cursor-not-allowed"
+              >
+                {isLoading ? <Loader2 className="animate-spin h-5 w-5" /> : <Send size={20} />}
+              </button>
+            </div>
+
+            {/* Feature Instructions */}
+            <div className="mt-4 text-sm text-gray-600">
+              {activeTab === 'chat' && (
+                <p>Chat with Gemini AI. Ask questions, get creative responses, or have a conversation.</p>
+              )}
+              {activeTab === 'transcribe' && (
+                <p>Record audio or upload an audio file to transcribe it to text using AI.</p>
+              )}
+              {activeTab === 'image' && (
+                <p>Upload an image to get AI-powered analysis, descriptions, or answers about the image content.</p>
+              )}
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
\ No newline at end of file
diff --git a/app/globals.css b/app/globals.css
index a2dc41ecee5ec435200fe7cba2bde4107f823774..e2ae3d751c96b748a697d0750ec4b54668ccc246 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -1,26 +1,315 @@
 @import "tailwindcss";
+@import "tw-animate-css";
+@import "./styles/theme.css";
 
+/* Tailwind base layer for compatibility */
+@layer base {
+  *,
+  ::after,
+  ::before,
+  ::backdrop,
+  ::file-selector-button {
+    border-color: var(--color-gray-200, currentColor);
+  }
+}
+
+/* Custom variant for dark mode */
+@custom-variant dark (&:is(.dark *));
+
+/* CSS Variables for theming */
 :root {
-  --background: #ffffff;
-  --foreground: #171717;
+  --radius: 0.625rem;
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.145 0 0);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.145 0 0);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.145 0 0);
+  --primary: oklch(0.205 0 0);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.97 0 0);
+  --secondary-foreground: oklch(0.205 0 0);
+  --muted: oklch(0.97 0 0);
+  --muted-foreground: oklch(0.556 0 0);
+  --accent: oklch(0.97 0 0);
+  --accent-foreground: oklch(0.205 0 0);
+  --destructive: oklch(0.577 0.245 27.325);
+  --destructive-foreground: oklch(1 0 0);
+  --border: oklch(0.922 0 0);
+  --input: oklch(0.922 0 0);
+  --ring: oklch(0.708 0 0);
+  --chart-1: oklch(0.646 0.222 41.116);
+  --chart-2: oklch(0.6 0.118 184.704);
+  --chart-3: oklch(0.398 0.07 227.392);
+  --chart-4: oklch(0.828 0.189 84.429);
+  --chart-5: oklch(0.769 0.188 70.08);
+  --sidebar: oklch(0.985 0 0);
+  --sidebar-foreground: oklch(0.145 0 0);
+  --sidebar-primary: oklch(0.205 0 0);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.97 0 0);
+  --sidebar-accent-foreground: oklch(0.205 0 0);
+  --sidebar-border: oklch(0.922 0 0);
+  --sidebar-ring: oklch(0.708 0 0);
+}
+
+.dark {
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.205 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.205 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.922 0 0);
+  --primary-foreground: oklch(0.205 0 0);
+  --secondary: oklch(0.269 0 0);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.269 0 0);
+  --muted-foreground: oklch(0.708 0 0);
+  --accent: oklch(0.269 0 0);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --destructive-foreground: oklch(1 0 0);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: oklch(0.556 0 0);
+  --chart-1: oklch(0.488 0.243 264.376);
+  --chart-2: oklch(0.696 0.17 162.48);
+  --chart-3: oklch(0.769 0.188 70.08);
+  --chart-4: oklch(0.627 0.265 303.9);
+  --chart-5: oklch(0.645 0.246 16.439);
+  --sidebar: oklch(0.205 0 0);
+  --sidebar-foreground: oklch(0.985 0 0);
+  --sidebar-primary: oklch(0.488 0.243 264.376);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.269 0 0);
+  --sidebar-accent-foreground: oklch(0.985 0 0);
+  --sidebar-border: oklch(1 0 0 / 10%);
+  --sidebar-ring: oklch(0.556 0 0);
 }
 
 @theme inline {
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
   --color-background: var(--background);
   --color-foreground: var(--foreground);
-  --font-sans: var(--font-geist-sans);
-  --font-mono: var(--font-geist-mono);
+  --color-card: var(--card);
+  --color-card-foreground: var(--card-foreground);
+  --color-popover: var(--popover);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-primary: var(--primary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-secondary: var(--secondary);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-muted: var(--muted);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-accent: var(--accent);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-destructive: var(--destructive);
+  --color-destructive-foreground: var(--destructive-foreground);
+  --color-border: var(--border);
+  --color-input: var(--input);
+  --color-ring: var(--ring);
+  --color-chart-1: var(--chart-1);
+  --color-chart-2: var(--chart-2);
+  --color-chart-3: var(--chart-3);
+  --color-chart-4: var(--chart-4);
+  --color-chart-5: var(--chart-5);
+  --color-sidebar: var(--sidebar);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-ring: var(--sidebar-ring);
+  --animate-accordion-down: accordion-down 0.2s ease-out;
+  --animate-accordion-up: accordion-up 0.2s ease-out;
+
+  @keyframes accordion-down {
+    from {
+      height: 0;
+    }
+    to {
+      height: var(--radix-accordion-content-height);
+    }
+  }
+
+  @keyframes accordion-up {
+    from {
+      height: var(--radix-accordion-content-height);
+    }
+    to {
+      height: 0;
+    }
+  }
 }
 
-@media (prefers-color-scheme: dark) {
-  :root {
-    --background: #0a0a0a;
-    --foreground: #ededed;
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
   }
+
+  body {
+    @apply bg-background text-foreground;
+    font-family: var(--font-inter, 'Inter'), 'SF Pro Display', -apple-system, BlinkMacSystemFont, 'Ubuntu', ui-sans-serif, system-ui, sans-serif;
+    overflow: hidden;
+    touch-action: none;
+    user-select: none;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+}
+
+/* Sonoma Background */
+.bg-sonoma {
+  background: linear-gradient(135deg, #e0c3fc 0%, #8ec5fc 100%);
+  background-size: cover;
+  background-position: center;
+}
+
+/* Glassmorphism utilities */
+.glass {
+  background: rgba(255, 255, 255, 0.65);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  border: 1px solid rgba(255, 255, 255, 0.3);
+}
+
+.glass-dark {
+  background: rgba(0, 0, 0, 0.5);
+  backdrop-filter: blur(20px);
+  -webkit-backdrop-filter: blur(20px);
+  border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.dock-glass {
+  background: rgba(255, 255, 255, 0.4);
+  backdrop-filter: blur(15px);
+  -webkit-backdrop-filter: blur(15px);
+  border: 1px solid rgba(255, 255, 255, 0.2);
+}
+
+/* App Icon Styles */
+.app-icon {
+  transition: transform 0.2s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+}
+.app-icon:hover {
+  transform: scale(1.2) translateY(-10px);
+}
+.app-icon:active {
+  transform: scale(0.95);
+}
+
+/* Window Animations */
+.window-transition {
+  transition: opacity 0.2s, transform 0.2s;
+}
+.window-hidden {
+  opacity: 0;
+  transform: scale(0.95);
+  pointer-events: none;
+}
+
+/* Traffic Lights */
+.traffic-light {
+  width: 12px;
+  height: 12px;
+  border-radius: 50%;
+  margin-right: 8px;
+  position: relative;
+  cursor: pointer;
+  transition: all 0.2s ease;
+}
+.traffic-close {
+  background-color: #ff5f56;
+  border: 1px solid #e0443e;
+}
+.traffic-min {
+  background-color: #ffbd2e;
+  border: 1px solid #dea123;
+}
+.traffic-max {
+  background-color: #27c93f;
+  border: 1px solid #1aab29;
+}
+
+.traffic-light:hover::after {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-size: 8px;
+  color: rgba(0,0,0,0.5);
+  font-weight: bold;
+}
+.traffic-close:hover::after { content: '×'; }
+.traffic-min:hover::after { content: '−'; }
+.traffic-max:hover::after { content: '+'; }
+
+/* Custom Scrollbar */
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+::-webkit-scrollbar-thumb {
+  background: rgba(0,0,0,0.2);
+  border-radius: 4px;
+}
+::-webkit-scrollbar-thumb:hover {
+  background: rgba(0,0,0,0.3);
 }
 
-body {
-  background: var(--background);
-  color: var(--foreground);
-  font-family: Arial, Helvetica, sans-serif;
+/* Desktop Icon Grid */
+.desktop-icon {
+  @apply flex flex-col items-center gap-1 cursor-pointer transition-all;
 }
+.desktop-icon:hover {
+  transform: scale(1.05);
+}
+.desktop-icon-label {
+  @apply text-xs text-white font-medium px-2 py-0.5 rounded;
+  background: rgba(0,0,0,0.3);
+  text-shadow: 0 1px 2px rgba(0,0,0,0.5);
+}
+
+/* macOS style window */
+.macos-window {
+  @apply rounded-xl shadow-2xl overflow-hidden;
+  background: #f5f5f5;
+  border: 1px solid rgba(0, 0, 0, 0.1);
+}
+
+.macos-window-header {
+  @apply h-10 flex items-center px-4 justify-between;
+  background: #f1f1f1;
+  border-bottom: 1px solid rgba(0, 0, 0, 0.1);
+}
+
+/* Dock styles */
+.dock-container {
+  @apply fixed bottom-2 left-0 right-0 flex justify-center z-50;
+}
+
+.dock-item {
+  @apply relative flex flex-col items-center gap-1;
+}
+
+.dock-dot {
+  @apply w-1 h-1 rounded-full mt-1 opacity-0 transition-opacity;
+  background: rgba(0, 0, 0, 0.5);
+}
+
+.dock-item:hover .dock-dot {
+  @apply opacity-100;
+}
\ No newline at end of file
diff --git a/app/hooks/useKV.ts b/app/hooks/useKV.ts
new file mode 100644
index 0000000000000000000000000000000000000000..33c81b2768d9236b15ca163ea78bb184f73fa86f
--- /dev/null
+++ b/app/hooks/useKV.ts
@@ -0,0 +1,37 @@
+'use client'
+
+import { useState, useEffect } from 'react'
+
+// Custom implementation of useKV hook for key-value storage
+export function useKV<T>(key: string, defaultValue: T): [T, (value: T) => void] {
+  // Initialize state with the default value
+  const [value, setValue] = useState<T>(() => {
+    // Try to get the value from localStorage on initial load
+    if (typeof window !== 'undefined') {
+      try {
+        const storedValue = localStorage.getItem(key)
+        if (storedValue !== null) {
+          return JSON.parse(storedValue)
+        }
+      } catch (error) {
+        console.error(`Error reading from localStorage for key "${key}":`, error)
+      }
+    }
+    return defaultValue
+  })
+
+  // Update localStorage whenever the value changes
+  useEffect(() => {
+    if (typeof window !== 'undefined') {
+      try {
+        localStorage.setItem(key, JSON.stringify(value))
+      } catch (error) {
+        console.error(`Error writing to localStorage for key "${key}":`, error)
+      }
+    }
+  }, [key, value])
+
+  return [value, setValue]
+}
+
+export default useKV
\ No newline at end of file
diff --git a/app/layout.tsx b/app/layout.tsx
index f7fa87eb875260ed98651bc419c8139b5119e554..8a93ebae71f1b851fa73d8777a12af326a7cc7fb 100644
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -1,10 +1,11 @@
 import type { Metadata } from "next";
-import { Geist, Geist_Mono } from "next/font/google";
+import { Inter, Geist_Mono } from "next/font/google";
 import "./globals.css";
 
-const geistSans = Geist({
-  variable: "--font-geist-sans",
+const inter = Inter({
+  variable: "--font-inter",
   subsets: ["latin"],
+  weight: ["300", "400", "500", "600"],
 });
 
 const geistMono = Geist_Mono({
@@ -13,8 +14,8 @@ const geistMono = Geist_Mono({
 });
 
 export const metadata: Metadata = {
-  title: "Create Next App",
-  description: "Generated by create next app",
+  title: "Reuben OS - Advanced Desktop Environment",
+  description: "AI-powered desktop environment with integrated development and execution tools",
 };
 
 export default function RootLayout({
@@ -25,7 +26,7 @@ export default function RootLayout({
   return (
     <html lang="en">
       <body
-        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
+        className={`${inter.variable} ${geistMono.variable} antialiased`}
       >
         {children}
       </body>
diff --git a/app/page.tsx b/app/page.tsx
index 295f8fdf14fcfe6cccaa832133037157521b1890..cbf0d95a65028255e53bdd03067474299de48833 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -1,65 +1,8 @@
-import Image from "next/image";
+'use client'
+
+import React from 'react'
+import { Desktop } from './components/Desktop'
 
 export default function Home() {
-  return (
-    <div className="flex min-h-screen items-center justify-center bg-zinc-50 font-sans dark:bg-black">
-      <main className="flex min-h-screen w-full max-w-3xl flex-col items-center justify-between py-32 px-16 bg-white dark:bg-black sm:items-start">
-        <Image
-          className="dark:invert"
-          src="/next.svg"
-          alt="Next.js logo"
-          width={100}
-          height={20}
-          priority
-        />
-        <div className="flex flex-col items-center gap-6 text-center sm:items-start sm:text-left">
-          <h1 className="max-w-xs text-3xl font-semibold leading-10 tracking-tight text-black dark:text-zinc-50">
-            To get started, edit the page.tsx file.
-          </h1>
-          <p className="max-w-md text-lg leading-8 text-zinc-600 dark:text-zinc-400">
-            Looking for a starting point or more instructions? Head over to{" "}
-            <a
-              href="https://vercel.com/templates?framework=next.js&utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
-              className="font-medium text-zinc-950 dark:text-zinc-50"
-            >
-              Templates
-            </a>{" "}
-            or the{" "}
-            <a
-              href="https://nextjs.org/learn?utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
-              className="font-medium text-zinc-950 dark:text-zinc-50"
-            >
-              Learning
-            </a>{" "}
-            center.
-          </p>
-        </div>
-        <div className="flex flex-col gap-4 text-base font-medium sm:flex-row">
-          <a
-            className="flex h-12 w-full items-center justify-center gap-2 rounded-full bg-foreground px-5 text-background transition-colors hover:bg-[#383838] dark:hover:bg-[#ccc] md:w-[158px]"
-            href="https://vercel.com/new?utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
-            target="_blank"
-            rel="noopener noreferrer"
-          >
-            <Image
-              className="dark:invert"
-              src="/vercel.svg"
-              alt="Vercel logomark"
-              width={16}
-              height={16}
-            />
-            Deploy Now
-          </a>
-          <a
-            className="flex h-12 w-full items-center justify-center rounded-full border border-solid border-black/[.08] px-5 transition-colors hover:border-transparent hover:bg-black/[.04] dark:border-white/[.145] dark:hover:bg-[#1a1a1a] md:w-[158px]"
-            href="https://nextjs.org/docs?utm_source=create-next-app&utm_medium=appdir-template-tw&utm_campaign=create-next-app"
-            target="_blank"
-            rel="noopener noreferrer"
-          >
-            Documentation
-          </a>
-        </div>
-      </main>
-    </div>
-  );
-}
+  return <Desktop />
+}
\ No newline at end of file
diff --git a/app/styles/theme.css b/app/styles/theme.css
new file mode 100644
index 0000000000000000000000000000000000000000..8da23f27d52fe1dfb4f2587b570fbde1432c01b3
--- /dev/null
+++ b/app/styles/theme.css
@@ -0,0 +1,262 @@
+@import "tailwindcss";
+
+@import '@radix-ui/colors/sage-dark.css' layer(base);
+@import '@radix-ui/colors/olive.css' layer(base);
+@import '@radix-ui/colors/olive-dark.css' layer(base);
+@import '@radix-ui/colors/sand.css' layer(base);
+@import '@radix-ui/colors/sand-dark.css' layer(base);
+@import '@radix-ui/colors/red.css' layer(base);
+@import '@radix-ui/colors/red-dark.css' layer(base);
+@import '@radix-ui/colors/ruby.css' layer(base);
+@import '@radix-ui/colors/ruby-dark.css' layer(base);
+@import '@radix-ui/colors/crimson.css' layer(base);
+@import '@radix-ui/colors/crimson-dark.css' layer(base);
+@import '@radix-ui/colors/pink.css' layer(base);
+@import '@radix-ui/colors/pink-dark.css' layer(base);
+@import '@radix-ui/colors/plum.css' layer(base);
+@import '@radix-ui/colors/plum-dark.css' layer(base);
+@import '@radix-ui/colors/purple.css' layer(base);
+@import '@radix-ui/colors/purple-dark.css' layer(base);
+@import '@radix-ui/colors/violet.css' layer(base);
+@import '@radix-ui/colors/violet-dark.css' layer(base);
+@import '@radix-ui/colors/iris.css' layer(base);
+@import '@radix-ui/colors/iris-dark.css' layer(base);
+@import '@radix-ui/colors/indigo.css' layer(base);
+@import '@radix-ui/colors/indigo-dark.css' layer(base);
+@import '@radix-ui/colors/blue.css' layer(base);
+@import '@radix-ui/colors/blue-dark.css' layer(base);
+@import '@radix-ui/colors/cyan.css' layer(base);
+@import '@radix-ui/colors/cyan-dark.css' layer(base);
+@import '@radix-ui/colors/teal.css' layer(base);
+@import '@radix-ui/colors/teal-dark.css' layer(base);
+@import '@radix-ui/colors/jade.css' layer(base);
+@import '@radix-ui/colors/jade-dark.css' layer(base);
+@import '@radix-ui/colors/green.css' layer(base);
+@import '@radix-ui/colors/green-dark.css' layer(base);
+@import '@radix-ui/colors/grass.css' layer(base);
+@import '@radix-ui/colors/grass-dark.css' layer(base);
+@import '@radix-ui/colors/bronze.css' layer(base);
+@import '@radix-ui/colors/bronze-dark.css' layer(base);
+@import '@radix-ui/colors/gold.css' layer(base);
+@import '@radix-ui/colors/gold-dark.css' layer(base);
+@import '@radix-ui/colors/brown.css' layer(base);
+@import '@radix-ui/colors/brown-dark.css' layer(base);
+@import '@radix-ui/colors/orange.css' layer(base);
+@import '@radix-ui/colors/orange-dark.css' layer(base);
+@import '@radix-ui/colors/amber.css' layer(base);
+@import '@radix-ui/colors/amber-dark.css' layer(base);
+@import '@radix-ui/colors/yellow.css' layer(base);
+@import '@radix-ui/colors/yellow-dark.css' layer(base);
+@import '@radix-ui/colors/lime.css' layer(base);
+@import '@radix-ui/colors/lime-dark.css' layer(base);
+@import '@radix-ui/colors/mint.css' layer(base);
+@import '@radix-ui/colors/mint-dark.css' layer(base);
+@import '@radix-ui/colors/sky.css' layer(base);
+@import '@radix-ui/colors/sky-dark.css' layer(base);
+@import '@radix-ui/colors/tomato.css' layer(base);
+@import '@radix-ui/colors/tomato-dark.css' layer(base);
+@import '@radix-ui/colors/gray.css' layer(base);
+@import '@radix-ui/colors/gray-dark.css' layer(base);
+@import '@radix-ui/colors/mauve.css' layer(base);
+@import '@radix-ui/colors/mauve-dark.css' layer(base);
+@import '@radix-ui/colors/slate.css' layer(base);
+@import '@radix-ui/colors/slate-dark.css' layer(base);
+@import '@radix-ui/colors/slate-alpha.css' layer(base);
+@import '@radix-ui/colors/slate-dark-alpha.css' layer(base);
+
+@import 'tailwindcss/theme' layer(theme);
+
+@import 'tailwindcss/preflight' layer(base);
+
+/*
+  The default border color has changed to `currentColor` in Tailwind CSS v4,
+  so we've added these compatibility styles to make sure everything still
+  looks the same as it did with Tailwind CSS v3.
+
+  If we ever want to remove these styles, we need to add an explicit border
+  color utility to any element that depends on these defaults.
+*/
+@layer base {
+  *,
+  ::after,
+  ::before,
+  ::backdrop,
+  ::file-selector-button {
+    border-color: var(--color-gray-200, currentColor);
+  }
+}
+
+@layer base {
+  #spark-app {
+    --tomato-contrast: #fff;
+    --red-contrast: #fff;
+    --ruby-contrast: #fff;
+    --crimson-contrast: #fff;
+    --pink-contrast: #fff;
+    --plum-contrast: #fff;
+    --purple-contrast: #fff;
+    --violet-contrast: #fff;
+    --iris-contrast: #fff;
+    --indigo-contrast: #fff;
+    --blue-contrast: #fff;
+    --cyan-contrast: #fff;
+    --teal-contrast: #fff;
+    --jade-contrast: #fff;
+    --green-contrast: #fff;
+    --grass-contrast: #fff;
+    --bronze-contrast: #fff;
+    --gold-contrast: #fff;
+    --brown-contrast: #fff;
+    --orange-contrast: #fff;
+    --amber-contrast: #000;
+    --yellow-contrast: #000;
+    --lime-contrast: #000;
+    --mint-contrast: #000;
+    --sky-contrast: #000;
+    --gray-contrast: #fff;
+    --mauve-contrast: #fff;
+    --slate-contrast: #fff;
+    --sage-contrast: #fff;
+    --olive-contrast: #fff;
+    --sand-contrast: #fff;
+
+    /**
+   * Spacing scale
+   *
+   * These variables define a spacing scale based on Tailwind's default.
+   * We've introduced a --size-scale variable as a multiplier.
+   * By adjusting this single value, we can proportionally
+   * scale all spacing throughout the entire application.
+   *
+   * https://tailwindcss.com/docs/customizing-spacing#default-spacing-scale
+   */
+    --size-scale: 1;
+    --size-0: 0px;
+    --size-px: 1px;
+    --size-0-5: calc(0.125rem * var(--size-scale));
+    --size-1: calc(0.25rem * var(--size-scale));
+    --size-1-5: calc(0.375rem * var(--size-scale));
+    --size-2: calc(0.5rem * var(--size-scale));
+    --size-2-5: calc(0.625rem * var(--size-scale));
+    --size-3: calc(0.75rem * var(--size-scale));
+    --size-3-5: calc(0.875rem * var(--size-scale));
+    --size-4: calc(1rem * var(--size-scale));
+    --size-5: calc(1.25rem * var(--size-scale));
+    --size-6: calc(1.5rem * var(--size-scale));
+    --size-7: calc(1.75rem * var(--size-scale));
+    --size-8: calc(2rem * var(--size-scale));
+    --size-9: calc(2.25rem * var(--size-scale));
+    --size-10: calc(2.5rem * var(--size-scale));
+    --size-11: calc(2.75rem * var(--size-scale));
+    --size-12: calc(3rem * var(--size-scale));
+    --size-14: calc(3.5rem * var(--size-scale));
+    --size-16: calc(4rem * var(--size-scale));
+    --size-20: calc(5rem * var(--size-scale));
+    --size-24: calc(6rem * var(--size-scale));
+    --size-28: calc(7rem * var(--size-scale));
+    --size-32: calc(8rem * var(--size-scale));
+    --size-36: calc(9rem * var(--size-scale));
+    --size-40: calc(10rem * var(--size-scale));
+    --size-44: calc(11rem * var(--size-scale));
+    --size-48: calc(12rem * var(--size-scale));
+    --size-52: calc(13rem * var(--size-scale));
+    --size-56: calc(14rem * var(--size-scale));
+    --size-60: calc(15rem * var(--size-scale));
+    --size-64: calc(16rem * var(--size-scale));
+    --size-72: calc(18rem * var(--size-scale));
+    --size-80: calc(20rem * var(--size-scale));
+    --size-96: calc(24rem * var(--size-scale));
+
+    /* Border radii */
+    --radius-factor: 1;
+    --radius-sm: calc(2px * var(--radius-factor) * var(--size-scale));
+    --radius-md: calc(6px * var(--radius-factor) * var(--size-scale));
+    --radius-lg: calc(8px * var(--radius-factor) * var(--size-scale));
+    --radius-xl: calc(12px * var(--radius-factor) * var(--size-scale));
+    --radius-2xl: calc(16px * var(--radius-factor) * var(--size-scale));
+    --radius-full: 9999px;
+
+    /* Neutral colors */
+    --color-neutral-1: var(--slate-1);
+    --color-neutral-2: var(--slate-2);
+    --color-neutral-3: var(--slate-3);
+    --color-neutral-4: var(--slate-4);
+    --color-neutral-5: var(--slate-5);
+    --color-neutral-6: var(--slate-6);
+    --color-neutral-7: var(--slate-7);
+    --color-neutral-8: var(--slate-8);
+    --color-neutral-9: var(--slate-9);
+    --color-neutral-10: var(--slate-10);
+    --color-neutral-11: var(--slate-11);
+    --color-neutral-12: var(--slate-12);
+    --color-neutral-a1: var(--slate-a1);
+    --color-neutral-a2: var(--slate-a2);
+    --color-neutral-a3: var(--slate-a3);
+    --color-neutral-a4: var(--slate-a4);
+    --color-neutral-a5: var(--slate-a5);
+    --color-neutral-a6: var(--slate-a6);
+    --color-neutral-a7: var(--slate-a7);
+    --color-neutral-a8: var(--slate-a8);
+    --color-neutral-a9: var(--slate-a9);
+    --color-neutral-a10: var(--slate-a10);
+    --color-neutral-a11: var(--slate-a11);
+    --color-neutral-a12: var(--slate-a12);
+    --color-neutral-contrast: var(--slate-contrast);
+
+    /* Accent colors */
+    --color-accent-1: var(--blue-1);
+    --color-accent-2: var(--blue-2);
+    --color-accent-3: var(--blue-3);
+    --color-accent-4: var(--blue-4);
+    --color-accent-5: var(--blue-5);
+    --color-accent-6: var(--blue-6);
+    --color-accent-7: var(--blue-7);
+    --color-accent-8: var(--blue-8);
+    --color-accent-9: var(--blue-9);
+    --color-accent-10: var(--blue-10);
+    --color-accent-11: var(--blue-11);
+    --color-accent-12: var(--blue-12);
+    --color-accent-contrast: var(--blue-contrast);
+
+    /* Secondary accent colors */
+    --color-accent-secondary-1: var(--violet-1);
+    --color-accent-secondary-2: var(--violet-2);
+    --color-accent-secondary-3: var(--violet-3);
+    --color-accent-secondary-4: var(--violet-4);
+    --color-accent-secondary-5: var(--violet-5);
+    --color-accent-secondary-6: var(--violet-6);
+    --color-accent-secondary-7: var(--violet-7);
+    --color-accent-secondary-8: var(--violet-8);
+    --color-accent-secondary-9: var(--violet-9);
+    --color-accent-secondary-10: var(--violet-10);
+    --color-accent-secondary-11: var(--violet-11);
+    --color-accent-secondary-12: var(--violet-12);
+    --color-accent-secondary-contrast: var(--violet-contrast);
+
+    /* Foreground colors */
+    --color-fg: var(--color-neutral-12);
+    --color-fg-secondary: var(--color-neutral-a11);
+
+    /* Background colors */
+    --color-bg: #ffffff;
+    --color-bg-inset: var(--color-neutral-2);
+    --color-bg-overlay: #ffffff;
+
+    /* Focus ring */
+    --color-focus-ring: var(--color-accent-9);
+
+    /* Fonts */
+    --font-sans-serif: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji",
+      "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+    --font-serif: ui-serif, Georgia, Cambria, "Times New Roman", Times, serif;
+    --font-monospace: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas,
+      "Liberation Mono", "Courier New", monospace;
+    --font-family: var(--font-sans-serif);
+  }
+
+  #spark-app.dark-theme {
+    --color-bg: var(--color-neutral-1);
+    --color-bg-inset: #000000;
+    --color-bg-overlay: var(--color-neutral-3);
+  }
+}
\ No newline at end of file
diff --git a/backend/__pycache__/mcp_server.cpython-311.pyc b/backend/__pycache__/mcp_server.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e32b57a3ffda9c9b84d33db944211f7ccc4f3684
Binary files /dev/null and b/backend/__pycache__/mcp_server.cpython-311.pyc differ
diff --git a/backend/__pycache__/ttt_game.cpython-311.pyc b/backend/__pycache__/ttt_game.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8458d02d1465f8ea250596dd07a06566d1590181
Binary files /dev/null and b/backend/__pycache__/ttt_game.cpython-311.pyc differ
diff --git a/backend/create_certificates.py b/backend/create_certificates.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce0e95bd39cba477c3b4c4c1abbc7b323f91ed0a
--- /dev/null
+++ b/backend/create_certificates.py
@@ -0,0 +1,65 @@
+"""
+Create self-signed SSL certificates for HTTPS server
+"""
+
+from cryptography import x509
+from cryptography.x509.oid import NameOID
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import rsa
+from cryptography.hazmat.primitives import serialization
+from datetime import datetime, timedelta
+import ipaddress
+ 
+# Generate private key
+key = rsa.generate_private_key(
+    public_exponent=65537,
+    key_size=2048,
+)
+
+# Create certificate
+subject = issuer = x509.Name([
+    x509.NameAttribute(NameOID.COUNTRY_NAME, "US"),
+    x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "State"),
+    x509.NameAttribute(NameOID.LOCALITY_NAME, "City"),
+    x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Exam Hub MCP"),
+    x509.NameAttribute(NameOID.COMMON_NAME, "localhost"),
+])
+
+cert = x509.CertificateBuilder().subject_name(
+    subject
+).issuer_name(
+    issuer
+).public_key(
+    key.public_key()
+).serial_number(
+    x509.random_serial_number()
+).not_valid_before(
+    datetime.utcnow()
+).not_valid_after(
+    datetime.utcnow() + timedelta(days=365)
+).add_extension(
+    x509.SubjectAlternativeName([
+        x509.DNSName("localhost"),
+        x509.DNSName("127.0.0.1"),
+        x509.IPAddress(ipaddress.IPv4Address("127.0.0.1")),
+    ]),
+    critical=False,
+).sign(key, hashes.SHA256())
+
+# Write private key
+with open("server.key", "wb") as f:
+    f.write(key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.TraditionalOpenSSL,
+        encryption_algorithm=serialization.NoEncryption()
+    ))
+
+# Write certificate
+with open("server.crt", "wb") as f:
+    f.write(cert.public_bytes(serialization.Encoding.PEM))
+
+print("SSL certificates created successfully!")
+print("   - server.key (private key)")
+print("   - server.crt (certificate)")
+print("\nWARNING: These are self-signed certificates for local testing only.")
+print("Browsers will show security warnings - you can proceed anyway for testing.")
\ No newline at end of file
diff --git a/backend/data/documents/README.txt b/backend/data/documents/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e015d863b0b6da07c9a2a8ff7237e771f37f4ec2
--- /dev/null
+++ b/backend/data/documents/README.txt
@@ -0,0 +1,3 @@
+Welcome to the Exam Document Hub!
+
+This is your document repository for exam materials.
\ No newline at end of file
diff --git a/backend/data/documents/exam_schedule.txt b/backend/data/documents/exam_schedule.txt
new file mode 100644
index 0000000000000000000000000000000000000000..72484d7a37c957e1ed3127b6ebcd912c8560af88
--- /dev/null
+++ b/backend/data/documents/exam_schedule.txt
@@ -0,0 +1,6 @@
+Exam Schedule 2025
+
+February:
+- Math Midterm: Feb 15
+- Physics Final: Feb 20
+- Chemistry Midterm: Feb 18
\ No newline at end of file
diff --git a/backend/data/documents/study_tips.md b/backend/data/documents/study_tips.md
new file mode 100644
index 0000000000000000000000000000000000000000..7d4ecf6f51715f588eddf83e0acc99a6c201a372
--- /dev/null
+++ b/backend/data/documents/study_tips.md
@@ -0,0 +1,7 @@
+# Study Tips
+
+1. Create a study schedule
+2. Review notes regularly
+3. Practice past exams
+4. Form study groups
+5. Get enough sleep
\ No newline at end of file
diff --git a/backend/data/exams/exams.db b/backend/data/exams/exams.db
new file mode 100644
index 0000000000000000000000000000000000000000..fb67d5b2a1dc11dc2610c48c33baeb799501ef52
Binary files /dev/null and b/backend/data/exams/exams.db differ
diff --git a/backend/demo_api.py b/backend/demo_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c1c215d23cbfabdde27033adb94705412f04389
--- /dev/null
+++ b/backend/demo_api.py
@@ -0,0 +1,154 @@
+"""
+Demo REST API for Hackathon
+Wraps MCP tools as HTTP endpoints for easy testing
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, Any, Dict
+import os
+from dotenv import load_dotenv
+ 
+# Import your MCP tools
+from tools.document_tools import register_document_tools
+from tools.calendar_tools import register_calendar_tools
+from tools.ttt_tools import register_ttt_tools
+
+# Load environment variables
+load_dotenv()
+
+app = FastAPI(title="Exam Hub API", version="1.0.0")
+
+# Enable CORS for web UI
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify your domain
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Configuration
+DATA_DIR = os.getenv("DATA_DIR", "./data")
+DOCS_DIR = os.path.join(DATA_DIR, "documents")
+DB_PATH = os.path.join(DATA_DIR, "exams", "exams.db")
+UPLOAD_PASSCODE = os.getenv("UPLOAD_PASSCODE", "exam-hub-secure-2025")
+
+# Create a mock MCP object to register tools
+class MockMCP:
+    def __init__(self):
+        self.tools = {}
+
+    def tool(self):
+        def decorator(func):
+            self.tools[func.__name__] = func
+            return func
+        return decorator
+
+# Register tools
+mock_mcp = MockMCP()
+register_document_tools(mock_mcp, DOCS_DIR, UPLOAD_PASSCODE)
+register_calendar_tools(mock_mcp, DB_PATH)
+register_ttt_tools(mock_mcp)
+
+# API Models
+class ToolRequest(BaseModel):
+    tool_name: str
+    params: Optional[Dict[str, Any]] = {}
+
+# API Endpoints
+@app.get("/")
+def read_root():
+    return {
+        "name": "Exam Hub API",
+        "description": "AI-powered exam calendar and document management",
+        "endpoints": {
+            "/tools": "List available tools",
+            "/execute": "Execute a tool",
+            "/documents": "List all documents",
+            "/exams": "List all exams",
+            "/exams/upcoming": "Get upcoming exams",
+            "/ttt/new": "Start new Tic Tac Toe game",
+            "/ttt/{game_id}/move": "Make a move in TTT game",
+            "/ttt/{game_id}/state": "Get TTT game state",
+            "/ttt/games": "List all TTT games"
+        }
+    }
+
+@app.get("/tools")
+def list_tools():
+    """List all available MCP tools"""
+    return {
+        "tools": list(mock_mcp.tools.keys()),
+        "count": len(mock_mcp.tools)
+    }
+
+@app.post("/execute")
+def execute_tool(request: ToolRequest):
+    """Execute any MCP tool by name"""
+    if request.tool_name not in mock_mcp.tools:
+        raise HTTPException(status_code=404, detail=f"Tool '{request.tool_name}' not found")
+
+    try:
+        result = mock_mcp.tools[request.tool_name](**request.params)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/documents")
+def get_documents():
+    """Quick endpoint to list all documents"""
+    return mock_mcp.tools["list_all_documents"]()
+
+@app.get("/exams")
+def get_exams():
+    """Quick endpoint to get all exams"""
+    return mock_mcp.tools["get_all_exams"]()
+
+@app.get("/exams/upcoming")
+def get_upcoming_exams(days: int = 7):
+    """Get upcoming exams in the next N days"""
+    return mock_mcp.tools["get_upcoming_exams"](days=days)
+
+@app.get("/exams/week")
+def get_week_exams():
+    """Get this week's exams"""
+    return mock_mcp.tools["get_exams_this_week"]()
+
+# Tic Tac Toe Game Endpoints
+@app.post("/ttt/new")
+def create_ttt_game():
+    """Start a new Tic Tac Toe game"""
+    return mock_mcp.tools["ttt_new_game"]()
+
+@app.post("/ttt/{game_id}/move")
+def make_ttt_move(game_id: str, position: int):
+    """Make a move in a TTT game"""
+    return mock_mcp.tools["ttt_make_move"](game_id=game_id, position=position)
+
+@app.get("/ttt/{game_id}/state")
+def get_ttt_state(game_id: str):
+    """Get the current state of a TTT game"""
+    return mock_mcp.tools["ttt_get_game_state"](game_id=game_id)
+
+@app.get("/ttt/games")
+def list_ttt_games():
+    """List all active TTT games"""
+    return mock_mcp.tools["ttt_list_games"]()
+
+@app.post("/ttt/{game_id}/claude-move")
+def make_claude_move(game_id: str):
+    """Make Claude play its move"""
+    return mock_mcp.tools["ttt_claude_move"](game_id=game_id)
+
+@app.get("/ttt/help")
+def get_ttt_help():
+    """Get TTT game help and instructions"""
+    return mock_mcp.tools["ttt_help"]()
+
+if __name__ == "__main__":
+    import uvicorn
+    print("🚀 Starting Exam Hub Demo API on http://localhost:8001")
+    print("📚 Docs available at http://localhost:8001/docs")
+    uvicorn.run(app, host="0.0.0.0", port=8001)
\ No newline at end of file
diff --git a/backend/mcp_server.py b/backend/mcp_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..907f03abbc4f915ee7d41646462d63959dd0bf70
--- /dev/null
+++ b/backend/mcp_server.py
@@ -0,0 +1,137 @@
+"""
+Reuben OS MCP Server
+Provides AI-powered tools for document management, code execution, and desktop environment integration
+"""
+
+from mcp.server.fastmcp import FastMCP
+import os
+from dotenv import load_dotenv
+import logging
+from pathlib import Path
+ 
+# Import tool modules
+from tools.document_tools import register_document_tools
+from tools.calendar_tools import register_calendar_tools
+from tools.ai_study_tools import register_ai_study_tools
+from tools.claude_integration_tools import register_claude_integration_tools
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+# Initialize MCP server
+mcp = FastMCP("Reuben OS")
+
+# Configuration from environment
+DATA_DIR = os.getenv("DATA_DIR", "./data")
+DOCS_DIR = os.path.join(DATA_DIR, "documents")
+DB_PATH = os.path.join(DATA_DIR, "exams", "exams.db")
+UPLOAD_PASSCODE = os.getenv("UPLOAD_PASSCODE", "default-passcode-change-me")
+MCP_PORT = int(os.getenv("MCP_PORT", "8000"))
+
+# Ensure directories exist
+os.makedirs(DOCS_DIR, exist_ok=True)
+os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+
+# Add some sample documents if the directory is empty
+def add_sample_documents():
+    """Add sample documents for testing"""
+    sample_files = [
+        ("README.txt", "Welcome to Reuben OS!\n\nThis is your advanced desktop environment with AI-powered tools and code execution capabilities."),
+        ("study_tips.md", "# Study Tips\n\n1. Create a study schedule\n2. Review notes regularly\n3. Practice past exams\n4. Form study groups\n5. Get enough sleep"),
+        ("exam_schedule.txt", "Exam Schedule 2025\n\nFebruary:\n- Math Midterm: Feb 15\n- Physics Final: Feb 20\n- Chemistry Midterm: Feb 18"),
+    ]
+
+    for filename, content in sample_files:
+        file_path = os.path.join(DOCS_DIR, filename)
+        if not os.path.exists(file_path):
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            logger.info(f"Created sample file: {filename}")
+
+# Initialize sample documents
+add_sample_documents()
+
+# Register all tools
+logger.info(f"Registering document tools with directory: {DOCS_DIR}")
+register_document_tools(mcp, DOCS_DIR, UPLOAD_PASSCODE)
+
+logger.info(f"Registering calendar tools with database: {DB_PATH}")
+register_calendar_tools(mcp, DB_PATH)
+
+logger.info("Registering AI study tools")
+register_ai_study_tools(mcp)
+
+logger.info("Registering Claude integration tools")
+register_claude_integration_tools(mcp, DATA_DIR)
+
+# Add server information tool
+@mcp.tool()
+def get_server_info() -> dict:
+    """Get information about the MCP server and available tools"""
+    return {
+        "name": "Reuben OS MCP Server",
+        "version": "1.0.0",
+        "status": "running",
+        "configuration": {
+            "documents_directory": DOCS_DIR,
+            "database_path": DB_PATH,
+            "port": MCP_PORT
+        },
+        "available_tools": {
+            "document_tools": [
+                "list_all_documents",
+                "get_folder_structure",
+                "search_documents",
+                "extract_pdf_text",
+                "extract_docx_text",
+                "read_text_file",
+                "search_in_document",
+                "get_document_summary",
+                "upload_file (requires passcode)",
+                "create_folder (requires passcode)",
+                "delete_file (requires passcode)"
+            ],
+            "calendar_tools": [
+                "get_all_exams",
+                "get_exams_this_week",
+                "get_exams_next_week",
+                "get_exams_by_month",
+                "find_exam_by_subject",
+                "get_exams_by_date",
+                "get_upcoming_exams",
+                "search_related_documents",
+                "get_study_schedule",
+                "get_exam_statistics"
+            ],
+            "claude_integration_tools": [
+                "save_claude_text",
+                "save_claude_code",
+                "execute_python_code",
+                "execute_python_with_packages",
+                "execute_matplotlib_code",
+                "list_claude_generated_content",
+                "get_code_output"
+            ]
+        },
+        "tips": [
+            "Use 'save_claude_code' to save generated code to Reuben OS",
+            "Use 'execute_python_code' to run Python scripts directly",
+            "Use 'execute_matplotlib_code' for data visualization with matplotlib",
+            "Use 'list_claude_generated_content' to see all saved content",
+            "Upload operations require a passcode for security",
+            "Reuben OS can execute your Python code and save outputs automatically!"
+        ]
+    }
+
+if __name__ == "__main__":
+    # Run the MCP server
+    logger.info(f"Starting Reuben OS MCP Server on port {MCP_PORT}")
+    logger.info(f"Documents directory: {DOCS_DIR}")
+    logger.info(f"Database path: {DB_PATH}")
+
+    # Run with SSE transport for Claude Desktop compatibility
+    mcp.run(transport="sse")
\ No newline at end of file
diff --git a/backend/mcp_server_https.py b/backend/mcp_server_https.py
new file mode 100644
index 0000000000000000000000000000000000000000..4363d853d6471b5bae8815cb825e131b9c70b207
--- /dev/null
+++ b/backend/mcp_server_https.py
@@ -0,0 +1,130 @@
+"""
+Exam Document Hub MCP Server with HTTPS Support
+Provides AI-powered tools for document management and exam calendar
+"""
+
+from mcp.server.fastmcp import FastMCP
+import os
+from dotenv import load_dotenv
+import logging
+from pathlib import Path
+import ssl
+import uvicorn
+ 
+# Import tool modules
+from tools.document_tools import register_document_tools
+from tools.calendar_tools import register_calendar_tools
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+# Initialize MCP server
+mcp = FastMCP("Exam Document Hub")
+
+# Configuration from environment
+DATA_DIR = os.getenv("DATA_DIR", "./data")
+DOCS_DIR = os.path.join(DATA_DIR, "documents")
+DB_PATH = os.path.join(DATA_DIR, "exams", "exams.db")
+UPLOAD_PASSCODE = os.getenv("UPLOAD_PASSCODE", "default-passcode-change-me")
+MCP_PORT = int(os.getenv("MCP_PORT", "8443"))  # Changed to HTTPS port
+
+# Ensure directories exist
+os.makedirs(DOCS_DIR, exist_ok=True)
+os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+
+# Add some sample documents if the directory is empty
+def add_sample_documents():
+    """Add sample documents for testing"""
+    sample_files = [
+        ("README.txt", "Welcome to the Exam Document Hub!\n\nThis is your document repository for exam materials."),
+        ("study_tips.md", "# Study Tips\n\n1. Create a study schedule\n2. Review notes regularly\n3. Practice past exams\n4. Form study groups\n5. Get enough sleep"),
+        ("exam_schedule.txt", "Exam Schedule 2025\n\nFebruary:\n- Math Midterm: Feb 15\n- Physics Final: Feb 20\n- Chemistry Midterm: Feb 18"),
+    ]
+
+    for filename, content in sample_files:
+        file_path = os.path.join(DOCS_DIR, filename)
+        if not os.path.exists(file_path):
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            logger.info(f"Created sample file: {filename}")
+
+# Initialize sample documents
+add_sample_documents()
+
+# Register all tools
+logger.info(f"Registering document tools with directory: {DOCS_DIR}")
+register_document_tools(mcp, DOCS_DIR, UPLOAD_PASSCODE)
+
+logger.info(f"Registering calendar tools with database: {DB_PATH}")
+register_calendar_tools(mcp, DB_PATH)
+
+# Add server information tool
+@mcp.tool()
+def get_server_info() -> dict:
+    """Get information about the MCP server and available tools"""
+    return {
+        "name": "Exam Document Hub MCP Server",
+        "version": "1.0.0",
+        "status": "running",
+        "protocol": "HTTPS",
+        "configuration": {
+            "documents_directory": DOCS_DIR,
+            "database_path": DB_PATH,
+            "port": MCP_PORT
+        },
+        "available_tools": {
+            "document_tools": [
+                "list_all_documents",
+                "get_folder_structure",
+                "search_documents",
+                "extract_pdf_text",
+                "extract_docx_text",
+                "read_text_file",
+                "search_in_document",
+                "get_document_summary",
+                "upload_file (requires passcode)",
+                "create_folder (requires passcode)",
+                "delete_file (requires passcode)"
+            ],
+            "calendar_tools": [
+                "get_all_exams",
+                "get_exams_this_week",
+                "get_exams_next_week",
+                "get_exams_by_month",
+                "find_exam_by_subject",
+                "get_exams_by_date",
+                "get_upcoming_exams",
+                "search_related_documents",
+                "get_study_schedule",
+                "get_exam_statistics"
+            ]
+        },
+        "tips": [
+            "Use 'list_all_documents' to see available files",
+            "Use 'get_upcoming_exams' to check what's coming up",
+            "Use 'search_related_documents' to find study materials for a subject",
+            "Upload operations require a passcode for security"
+        ]
+    }
+
+if __name__ == "__main__":
+    # Run the MCP server with HTTPS
+    logger.info(f"Starting Exam Document Hub MCP Server on HTTPS port {MCP_PORT}")
+    logger.info(f"Documents directory: {DOCS_DIR}")
+    logger.info(f"Database path: {DB_PATH}")
+
+    # For HTTPS, we need to get the app and run it with uvicorn directly
+    app = mcp.get_app()
+
+    # Run with SSL
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=MCP_PORT,
+        ssl_keyfile="server.key",
+        ssl_certfile="server.crt"
+    )
\ No newline at end of file
diff --git a/backend/mcp_server_wrapper.py b/backend/mcp_server_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..40f37ee33cb0a7ad1a574d25b08e9144caeb2d00
--- /dev/null
+++ b/backend/mcp_server_wrapper.py
@@ -0,0 +1,28 @@
+"""
+MCP Server Wrapper for Claude Desktop
+Handles proper startup and error reporting
+"""
+
+import sys
+import os
+import logging
+
+# Set up proper paths
+backend_dir = os.path.dirname(os.path.abspath(__file__))
+root_dir = os.path.dirname(backend_dir)
+sys.path.insert(0, backend_dir)
+ 
+# Change to backend directory for relative imports
+os.chdir(backend_dir)
+
+# Now import and run the MCP server
+try:
+    from mcp_server import mcp
+
+    # Run with stdio transport for Claude Desktop
+    print("Starting Exam Hub MCP Server for Claude Desktop...", file=sys.stderr)
+    mcp.run(transport="stdio")
+
+except Exception as e:
+    print(f"Error starting MCP server: {e}", file=sys.stderr)
+    sys.exit(1)
\ No newline at end of file
diff --git a/backend/server.crt b/backend/server.crt
new file mode 100644
index 0000000000000000000000000000000000000000..165b6234e810a2df79bc60c628fa11b445f0e456
--- /dev/null
+++ b/backend/server.crt
@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDZTCCAk2gAwIBAgIUU3yH+MmgKLaPsTPBgOmCRDQg5V4wDQYJKoZIhvcNAQEL
+BQAwVzELMAkGA1UEBhMCVVMxDjAMBgNVBAgMBVN0YXRlMQ0wCwYDVQQHDARDaXR5
+MRUwEwYDVQQKDAxFeGFtIEh1YiBNQ1AxEjAQBgNVBAMMCWxvY2FsaG9zdDAeFw0y
+NTExMDgxMTQ2MzVaFw0yNjExMDgxMTQ2MzVaMFcxCzAJBgNVBAYTAlVTMQ4wDAYD
+VQQIDAVTdGF0ZTENMAsGA1UEBwwEQ2l0eTEVMBMGA1UECgwMRXhhbSBIdWIgTUNQ
+MRIwEAYDVQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
+AoIBAQCz8KBrzdUaiNEY4RpYnnEwOeejJUmxAR4YJj7P8wfAuw5l/HjryYazMENd
+u6YDCwXVIV0ypbBxvvYFvDctO/hcmZTD4DwrdG6JZmvcgL5siUu+EW1nnFiwg7m/
+snA8oyjjJn3WisCtskq+UHdHk16pavYm8XgRVupeLyFQd4HhjyILfc7EiXB6+eM4
+lp5isn3nuWDY8xtaRR4ey154CK4Eyt4/5nVOF8G4VgVLrip/QRu90dH0gL5tan/P
+xVFcg8C1akbHtwkEbvoMjCeO+8Mvglh4AryfPMQTZbgxxyH4Q4JVV7JdtNBNPEFv
+pR0Nn3UqP8KasNjhl+tUhHj8NZwbAgMBAAGjKTAnMCUGA1UdEQQeMByCCWxvY2Fs
+aG9zdIIJMTI3LjAuMC4xhwR/AAABMA0GCSqGSIb3DQEBCwUAA4IBAQCHvJFkqi7h
+BukNet5eA5/Qdwi5tN0/4yKEbj7lLf7c0uq7Bd/Ps7NmeTyRZg3Ry5Dw9I2+kVAF
+HzgrGldOV8PCvlJf1djX342HDQEGtMmY9qDcUmnyPZtTyV2K+RD0sJYmHD7Z5KYF
+RYJ7UaGc5yW5iJUGVgHChT3pi6k/ErvHr4z5+EhikfQ1lMMwS4P7gqqNwLHsch8n
+kQ0hxUIC3acl8ff5JGPjj3/7lhFgkAp7wrWhhz/y77mCo/afkEfLkGowsZRNSMHZ
+SQGz7O5n/SgwiA4EBqbMoGbbJTUOLGOD005d3jWTu9hsNG7Sz5J1mziDgOiyRU97
+KNpuSX/fONyz
+-----END CERTIFICATE-----
diff --git a/backend/server.key b/backend/server.key
new file mode 100644
index 0000000000000000000000000000000000000000..6b5010e83a3d7e919741a39de4cfab93075f733f
--- /dev/null
+++ b/backend/server.key
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAs/Cga83VGojRGOEaWJ5xMDnnoyVJsQEeGCY+z/MHwLsOZfx4
+68mGszBDXbumAwsF1SFdMqWwcb72Bbw3LTv4XJmUw+A8K3RuiWZr3IC+bIlLvhFt
+Z5xYsIO5v7JwPKMo4yZ91orArbJKvlB3R5NeqWr2JvF4EVbqXi8hUHeB4Y8iC33O
+xIlwevnjOJaeYrJ957lg2PMbWkUeHsteeAiuBMreP+Z1ThfBuFYFS64qf0EbvdHR
+9IC+bWp/z8VRXIPAtWpGx7cJBG76DIwnjvvDL4JYeAK8nzzEE2W4Mcch+EOCVVey
+XbTQTTxBb6UdDZ91Kj/CmrDY4ZfrVIR4/DWcGwIDAQABAoIBAB13qAXPiPkV88wz
+vPlLRTUFHpKAnj9O9As3ZCzw21GsMHDyNilC8PyySC3293pjGTrsglMzgCA4ihip
+WI3fVs5vVkX3mFLzd9Cnhb1wFf83QsCnIPgJShrqD4a9pZTAkYcVfCEgyuoHGyds
+jQQbNbLf8dyxyZxpU+tFo5qGX6482GQatnhF2HkVa3Z3bTflY0mK09i9JvVFgX6v
+8yYZ91mq1AuSs9q7Hls86I1nzaYqZJ+R9iN0L2eU7hYDSS2AiDQCPxx0yxO9moC2
+etZNK+PdDzUSb/CkPHqQct5b9XVCy9rhnbJVUkQ6dgx979p7ug52/1//raImwLqr
+y6qJLW0CgYEA6cvkP/Nk0NDskBkc4SrW+XSUhjEt2cxPDiyMdpElODl/isY2duyZ
+2y7iDEnavfNH/xUt3wMQobrFGounFT3xQ7YlC73Lgme1wA6I07JgYc9ZzD2XmZVY
+WaKFdFwenUmWjJQfFQ+lJx64f7AlSm0PbTvJAMlrGK83E75McCHRWm8CgYEAxQdd
+SsPrzO02TXwG6Ezw2W1PKOEEad4YcJG9GlltRU9mDE0NkeNVxy+U0q4eM4DqlCZw
+H7RzWPerBVTgs7jrJ/YESd7O8wvQRkHHd8PxZp9VbNKny1FyRwAdHXK4lmZS9e3v
+ExE8dDoydb4FUYy9Mf3Grf7zA6UEeZ7da/cmXxUCgYBAwzQE6v0gQt9kwzAWx3Ep
+RLvnuDPFQy0a9ggqx+YRfwvvexyXMM8lwgTn9oVbXMqyxEEip4yx4DS9N7Ye0jvE
+z+3PJNH825GjE+OfEKhWL8PmKaGW76G7oqNpKiNo2nuTkWxSvzS2c3IUHM0XosJF
+NexmBWVfPxn4pBw0a4m8jQKBgDyhKoUiSwJxkH9BhkKfwpG1wGE89QW68VxajI16
+LVThvO5WG7Hj+fZkXvCB4gtJRWY3edNXzRL4i6kFWGwVoE9YtjMhHB/QZ9Pm1AG3
+yyYgK8JkBHxdYMQWdd8k+UZW0HqbMDF24VqGuhZfVfWlUGb8x9GtHYzmj7z5NPvP
+PwCNAoGBAMAXwVP6uvzRvtLH/vMwqrHETIfpmPVShE2AwVhXrquNWafZqdBFLh8G
+UPvwcib6gjehBj0AUdveQdcN4w3sIEEmwoFpYDPZCYKbCuhbEuxIpeUfW+yhy/y+
+c2xkaHuHyNUd1PFY2c2JnAu6HY4ZdpD0hBraBuFUmdJPP+U6C89p
+-----END RSA PRIVATE KEY-----
diff --git a/backend/simple_mcp_test.py b/backend/simple_mcp_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ade3db555bc8a6ab9b11618f90a06c767d070f0
--- /dev/null
+++ b/backend/simple_mcp_test.py
@@ -0,0 +1,25 @@
+"""
+Minimal MCP Server for Testing Claude Desktop Connection
+"""
+
+from mcp.server.fastmcp import FastMCP
+import sys
+
+# Create minimal MCP server
+mcp = FastMCP("Test Server")
+
+@mcp.tool()
+def hello_world():
+    """Simple test tool"""
+    return {"message": "Hello from MCP server!", "status": "working"}
+
+@mcp.tool()
+def get_time():
+    """Get current time"""
+    from datetime import datetime
+    return {"time": datetime.now().isoformat()}
+
+if __name__ == "__main__":
+    # Run with stdio for Claude Desktop
+    print("Starting minimal test MCP server...", file=sys.stderr)
+    mcp.run(transport="stdio")
\ No newline at end of file
diff --git a/backend/tools/__pycache__/ai_study_tools.cpython-311.pyc b/backend/tools/__pycache__/ai_study_tools.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c09552ecc9501ddf6dd85d761909bfddba0abf2c
Binary files /dev/null and b/backend/tools/__pycache__/ai_study_tools.cpython-311.pyc differ
diff --git a/backend/tools/__pycache__/calendar_tools.cpython-311.pyc b/backend/tools/__pycache__/calendar_tools.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a0e831af62bc3cc7329a955d94ee3200cbe42eca
Binary files /dev/null and b/backend/tools/__pycache__/calendar_tools.cpython-311.pyc differ
diff --git a/backend/tools/__pycache__/claude_integration_tools.cpython-311.pyc b/backend/tools/__pycache__/claude_integration_tools.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94ca4a49e62425a344ba284c4071a0793d2d9fff
Binary files /dev/null and b/backend/tools/__pycache__/claude_integration_tools.cpython-311.pyc differ
diff --git a/backend/tools/__pycache__/document_tools.cpython-311.pyc b/backend/tools/__pycache__/document_tools.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..456e84b975b1d6cc5558faa772f0a41beec29003
Binary files /dev/null and b/backend/tools/__pycache__/document_tools.cpython-311.pyc differ
diff --git a/backend/tools/__pycache__/ttt_tools.cpython-311.pyc b/backend/tools/__pycache__/ttt_tools.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..776a716e5abdda5604727b76d818a53e3905fe80
Binary files /dev/null and b/backend/tools/__pycache__/ttt_tools.cpython-311.pyc differ
diff --git a/backend/tools/ai_study_tools.py b/backend/tools/ai_study_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..26369da71d78950eb0dac4feb5fc2c86f0dc5c0f
--- /dev/null
+++ b/backend/tools/ai_study_tools.py
@@ -0,0 +1,290 @@
+"""
+AI-Powered Study Tools for Enhanced Learning
+"""
+import random
+from typing import List, Dict, Any
+import json
+from datetime import datetime, timedelta
+
+def register_ai_study_tools(mcp):
+    """Register AI-enhanced study tools"""
+
+    @mcp.tool()
+    def generate_flashcards(text: str, num_cards: int = 5) -> Dict[str, Any]:
+        """Generate flashcards from study material
+
+        Args:
+            text: Study material text
+            num_cards: Number of flashcards to generate
+        """
+        # Simple implementation - in production, use NLP
+        sentences = text.split('.')
+        flashcards = []
+
+        for i, sentence in enumerate(sentences[:num_cards]):
+            if len(sentence.strip()) > 20:
+                # Create question by removing key term
+                words = sentence.strip().split()
+                if len(words) > 5:
+                    key_word_idx = len(words) // 2
+                    question = ' '.join(words[:key_word_idx] + ['_____'] + words[key_word_idx+1:])
+                    answer = words[key_word_idx]
+
+                    flashcards.append({
+                        "id": i + 1,
+                        "question": question,
+                        "answer": answer,
+                        "difficulty": random.choice(["easy", "medium", "hard"])
+                    })
+
+        return {
+            "status": "success",
+            "flashcards": flashcards,
+            "count": len(flashcards)
+        }
+
+    @mcp.tool()
+    def generate_study_plan(exam_date: str, subjects: List[str], hours_per_day: int = 3) -> Dict[str, Any]:
+        """Generate an optimal study plan for exam preparation
+
+        Args:
+            exam_date: Target exam date (YYYY-MM-DD)
+            subjects: List of subjects to study
+            hours_per_day: Available study hours per day
+        """
+        try:
+            target = datetime.strptime(exam_date, "%Y-%m-%d")
+            today = datetime.now()
+            days_available = (target - today).days
+
+            if days_available <= 0:
+                return {"status": "error", "message": "Exam date must be in the future"}
+
+            # Distribute time across subjects with spaced repetition
+            study_plan = []
+            total_hours = days_available * hours_per_day
+            hours_per_subject = total_hours / len(subjects)
+
+            for day in range(days_available):
+                date = today + timedelta(days=day)
+                daily_schedule = {
+                    "date": date.strftime("%Y-%m-%d"),
+                    "day": date.strftime("%A"),
+                    "sessions": []
+                }
+
+                # Rotate subjects for variety
+                subject_idx = day % len(subjects)
+                primary_subject = subjects[subject_idx]
+
+                # Add review session for previously studied subjects
+                if day > 2:
+                    review_subject = subjects[(subject_idx - 2) % len(subjects)]
+                    daily_schedule["sessions"].append({
+                        "time": "Morning (30 min)",
+                        "subject": review_subject,
+                        "type": "Review",
+                        "focus": "Quick recap of key concepts"
+                    })
+
+                # Main study session
+                daily_schedule["sessions"].append({
+                    "time": f"Main ({hours_per_day - 1} hours)",
+                    "subject": primary_subject,
+                    "type": "Deep Study",
+                    "focus": "New material and practice problems"
+                })
+
+                # Evening review
+                daily_schedule["sessions"].append({
+                    "time": "Evening (30 min)",
+                    "subject": primary_subject,
+                    "type": "Review",
+                    "focus": "Consolidate today's learning"
+                })
+
+                study_plan.append(daily_schedule)
+
+            return {
+                "status": "success",
+                "exam_date": exam_date,
+                "days_until_exam": days_available,
+                "total_study_hours": total_hours,
+                "subjects": subjects,
+                "plan": study_plan[:14]  # Show first 2 weeks
+            }
+
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def generate_practice_questions(subject: str, topic: str, difficulty: str = "medium", count: int = 5) -> Dict[str, Any]:
+        """Generate practice questions for a topic
+
+        Args:
+            subject: Subject name
+            topic: Specific topic
+            difficulty: easy/medium/hard
+            count: Number of questions
+        """
+        # Template questions - in production, use GPT or subject-specific generator
+        question_templates = {
+            "easy": [
+                f"Define {topic} in the context of {subject}.",
+                f"What is the main purpose of {topic}?",
+                f"List three characteristics of {topic}.",
+                f"True or False: {topic} is important in {subject}.",
+                f"Give an example of {topic}."
+            ],
+            "medium": [
+                f"Explain how {topic} relates to other concepts in {subject}.",
+                f"Compare and contrast {topic} with similar concepts.",
+                f"What are the advantages and disadvantages of {topic}?",
+                f"Describe a real-world application of {topic}.",
+                f"How would you apply {topic} to solve a problem?"
+            ],
+            "hard": [
+                f"Critically analyze the role of {topic} in modern {subject}.",
+                f"Design an experiment to test {topic}.",
+                f"What are the theoretical implications of {topic}?",
+                f"How might {topic} evolve in the next decade?",
+                f"Propose an innovative application of {topic}."
+            ]
+        }
+
+        questions = []
+        templates = question_templates.get(difficulty, question_templates["medium"])
+
+        for i in range(min(count, len(templates))):
+            questions.append({
+                "number": i + 1,
+                "question": templates[i],
+                "difficulty": difficulty,
+                "points": {"easy": 2, "medium": 5, "hard": 10}.get(difficulty, 5),
+                "estimated_time": {"easy": 2, "medium": 5, "hard": 10}.get(difficulty, 5)
+            })
+
+        return {
+            "status": "success",
+            "subject": subject,
+            "topic": topic,
+            "difficulty": difficulty,
+            "questions": questions,
+            "total_points": sum(q["points"] for q in questions),
+            "estimated_time_minutes": sum(q["estimated_time"] for q in questions)
+        }
+
+    @mcp.tool()
+    def analyze_study_progress(study_sessions: List[Dict], target_grade: int = 80) -> Dict[str, Any]:
+        """Analyze study progress and predict performance
+
+        Args:
+            study_sessions: List of completed study sessions
+            target_grade: Target grade percentage
+        """
+        if not study_sessions:
+            return {"status": "error", "message": "No study sessions provided"}
+
+        # Calculate metrics
+        total_hours = sum(s.get("hours", 0) for s in study_sessions)
+        subjects_studied = list(set(s.get("subject", "") for s in study_sessions))
+
+        # Simple performance prediction (in production, use ML)
+        base_score = 50
+        hours_bonus = min(total_hours * 2, 30)  # Max 30 points from hours
+        consistency_bonus = min(len(study_sessions) * 1, 20)  # Max 20 points from consistency
+
+        predicted_score = base_score + hours_bonus + consistency_bonus
+
+        recommendations = []
+        if predicted_score < target_grade:
+            gap = target_grade - predicted_score
+            additional_hours = gap / 2  # Rough estimate
+            recommendations.append(f"Study {additional_hours:.1f} more hours to reach target")
+            recommendations.append("Increase study session frequency")
+            recommendations.append("Focus on weak topics")
+        else:
+            recommendations.append("On track to meet target grade!")
+            recommendations.append("Maintain current study pace")
+            recommendations.append("Add practice tests for reinforcement")
+
+        return {
+            "status": "success",
+            "total_study_hours": total_hours,
+            "sessions_completed": len(study_sessions),
+            "subjects_covered": subjects_studied,
+            "predicted_score": min(predicted_score, 100),
+            "target_score": target_grade,
+            "on_track": predicted_score >= target_grade,
+            "recommendations": recommendations
+        }
+
+    @mcp.tool()
+    def create_mind_map(topic: str, subtopics: List[str]) -> Dict[str, Any]:
+        """Create a mind map structure for a topic
+
+        Args:
+            topic: Central topic
+            subtopics: List of related subtopics
+        """
+        mind_map = {
+            "central_topic": topic,
+            "branches": []
+        }
+
+        for subtopic in subtopics:
+            branch = {
+                "name": subtopic,
+                "connections": [],
+                "importance": random.choice(["high", "medium", "low"])
+            }
+
+            # Create some connections
+            for other in subtopics:
+                if other != subtopic and random.random() > 0.7:
+                    branch["connections"].append(other)
+
+            mind_map["branches"].append(branch)
+
+        return {
+            "status": "success",
+            "mind_map": mind_map,
+            "total_nodes": len(subtopics) + 1,
+            "total_connections": sum(len(b["connections"]) for b in mind_map["branches"])
+        }
+
+    @mcp.tool()
+    def generate_summary(text: str, max_sentences: int = 5) -> Dict[str, Any]:
+        """Generate a summary of study material
+
+        Args:
+            text: Text to summarize
+            max_sentences: Maximum sentences in summary
+        """
+        # Simple extractive summarization
+        sentences = [s.strip() for s in text.split('.') if len(s.strip()) > 20]
+
+        if not sentences:
+            return {"status": "error", "message": "No valid sentences to summarize"}
+
+        # Score sentences (simple version - in production use TextRank or similar)
+        scored_sentences = []
+        for sentence in sentences:
+            score = len(sentence.split())  # Simple: longer sentences = more information
+            scored_sentences.append((score, sentence))
+
+        # Sort by score and take top sentences
+        scored_sentences.sort(reverse=True)
+        summary_sentences = [s[1] for s in scored_sentences[:max_sentences]]
+
+        summary = '. '.join(summary_sentences) + '.'
+
+        return {
+            "status": "success",
+            "original_length": len(text),
+            "summary_length": len(summary),
+            "compression_ratio": f"{(1 - len(summary)/len(text)) * 100:.1f}%",
+            "summary": summary
+        }
+
+    return True  # Successfully registered tools
\ No newline at end of file
diff --git a/backend/tools/calendar_tools.py b/backend/tools/calendar_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..86a0ba6acc6eb144a684448d482f92e8a1ba023c
--- /dev/null
+++ b/backend/tools/calendar_tools.py
@@ -0,0 +1,504 @@
+import sqlite3
+import json
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional
+import os
+
+def register_calendar_tools(mcp, db_path: str):
+    """Register all calendar/exam-related MCP tools"""
+
+    # Ensure the database directory exists
+    os.makedirs(os.path.dirname(db_path), exist_ok=True)
+
+    # Initialize database with exam table
+    def init_database():
+        """Initialize the exam database if it doesn't exist"""
+        conn = sqlite3.connect(db_path)
+        conn.row_factory = sqlite3.Row
+        cursor = conn.cursor()
+
+        # Create exams table
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS exams (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                subject TEXT NOT NULL,
+                exam_type TEXT NOT NULL,
+                date DATE NOT NULL,
+                time TEXT,
+                duration INTEGER,
+                location TEXT,
+                professor TEXT,
+                notes TEXT,
+                materials TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        ''')
+
+        # Create study sessions table
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS study_sessions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                exam_id INTEGER,
+                date DATE NOT NULL,
+                start_time TEXT,
+                end_time TEXT,
+                topic TEXT,
+                completed BOOLEAN DEFAULT 0,
+                notes TEXT,
+                FOREIGN KEY (exam_id) REFERENCES exams(id)
+            )
+        ''')
+
+        # Add sample exam data if table is empty
+        cursor.execute("SELECT COUNT(*) FROM exams")
+        if cursor.fetchone()[0] == 0:
+            sample_exams = [
+                ("Mathematics", "Midterm", "2025-02-15", "10:00", 120, "Room 301", "Dr. Smith", "Calculus chapters 1-5", "Calculator, formula sheet"),
+                ("Physics", "Final", "2025-02-20", "14:00", 180, "Hall A", "Prof. Johnson", "Mechanics and thermodynamics", "Scientific calculator"),
+                ("Computer Science", "Quiz", "2025-02-10", "09:00", 60, "Lab 2", "Dr. Chen", "Data structures", "Laptop"),
+                ("Chemistry", "Midterm", "2025-02-18", "13:00", 120, "Room 205", "Dr. Brown", "Organic chemistry", "Periodic table"),
+                ("History", "Essay", "2025-02-25", "11:00", 90, "Room 102", "Prof. Davis", "World War II", "Blue book"),
+                ("Biology", "Lab Exam", "2025-02-22", "15:00", 150, "Bio Lab", "Dr. Wilson", "Cell biology", "Lab coat, goggles"),
+            ]
+
+            for exam in sample_exams:
+                cursor.execute('''
+                    INSERT INTO exams (subject, exam_type, date, time, duration, location, professor, notes, materials)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ''', exam)
+
+        conn.commit()
+        conn.close()
+
+    # Initialize database on startup
+    init_database()
+
+    def get_db_connection():
+        """Helper to connect to the exam database"""
+        conn = sqlite3.connect(db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def format_exam(row) -> Dict[str, Any]:
+        """Format a database row into an exam dictionary"""
+        return {
+            "id": row["id"],
+            "subject": row["subject"],
+            "exam_type": row["exam_type"],
+            "date": row["date"],
+            "time": row["time"],
+            "duration": row["duration"],
+            "location": row["location"],
+            "professor": row["professor"],
+            "notes": row["notes"],
+            "materials": row["materials"],
+            "days_until": calculate_days_until(row["date"])
+        }
+
+    def calculate_days_until(exam_date: str) -> int:
+        """Calculate days until an exam"""
+        exam_datetime = datetime.strptime(exam_date, "%Y-%m-%d")
+        today = datetime.now().date()
+        delta = exam_datetime.date() - today
+        return delta.days
+
+    # READ TOOLS
+
+    @mcp.tool()
+    def get_all_exams() -> Dict[str, Any]:
+        """Get all scheduled exams sorted by date"""
+        try:
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT * FROM exams
+                ORDER BY date, time
+            ''')
+            rows = cursor.fetchall()
+            conn.close()
+
+            exams = [format_exam(row) for row in rows]
+            return {
+                "status": "success",
+                "count": len(exams),
+                "exams": exams
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def get_exams_this_week() -> Dict[str, Any]:
+        """Get exams scheduled for the current week"""
+        try:
+            today = datetime.now().date()
+            start_of_week = today - timedelta(days=today.weekday())
+            end_of_week = start_of_week + timedelta(days=6)
+
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT * FROM exams
+                WHERE date >= ? AND date <= ?
+                ORDER BY date, time
+            ''', (start_of_week.isoformat(), end_of_week.isoformat()))
+            rows = cursor.fetchall()
+            conn.close()
+
+            exams = [format_exam(row) for row in rows]
+            return {
+                "status": "success",
+                "week_start": start_of_week.isoformat(),
+                "week_end": end_of_week.isoformat(),
+                "count": len(exams),
+                "exams": exams
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def get_exams_next_week() -> Dict[str, Any]:
+        """Get exams scheduled for next week"""
+        try:
+            today = datetime.now().date()
+            start_of_next_week = today + timedelta(days=(7 - today.weekday()))
+            end_of_next_week = start_of_next_week + timedelta(days=6)
+
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT * FROM exams
+                WHERE date >= ? AND date <= ?
+                ORDER BY date, time
+            ''', (start_of_next_week.isoformat(), end_of_next_week.isoformat()))
+            rows = cursor.fetchall()
+            conn.close()
+
+            exams = [format_exam(row) for row in rows]
+            return {
+                "status": "success",
+                "week_start": start_of_next_week.isoformat(),
+                "week_end": end_of_next_week.isoformat(),
+                "count": len(exams),
+                "exams": exams
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def get_exams_by_month(year: int, month: int) -> Dict[str, Any]:
+        """Get exams for a specific month
+
+        Args:
+            year: Year (e.g., 2025)
+            month: Month number (1-12)
+        """
+        try:
+            # Calculate month boundaries
+            start_date = datetime(year, month, 1)
+            if month == 12:
+                end_date = datetime(year + 1, 1, 1) - timedelta(days=1)
+            else:
+                end_date = datetime(year, month + 1, 1) - timedelta(days=1)
+
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT * FROM exams
+                WHERE date >= ? AND date <= ?
+                ORDER BY date, time
+            ''', (start_date.date().isoformat(), end_date.date().isoformat()))
+            rows = cursor.fetchall()
+            conn.close()
+
+            exams = [format_exam(row) for row in rows]
+            month_names = ["", "January", "February", "March", "April", "May", "June",
+                          "July", "August", "September", "October", "November", "December"]
+            return {
+                "status": "success",
+                "month": month_names[month],
+                "year": year,
+                "count": len(exams),
+                "exams": exams
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def find_exam_by_subject(subject: str) -> Dict[str, Any]:
+        """Find exams by subject name
+
+        Args:
+            subject: Subject name to search for (partial match supported)
+        """
+        try:
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT * FROM exams
+                WHERE subject LIKE ?
+                ORDER BY date, time
+            ''', (f"%{subject}%",))
+            rows = cursor.fetchall()
+            conn.close()
+
+            exams = [format_exam(row) for row in rows]
+            return {
+                "status": "success",
+                "search_term": subject,
+                "count": len(exams),
+                "exams": exams
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def get_exams_by_date(date: str) -> Dict[str, Any]:
+        """Get exams on a specific date
+
+        Args:
+            date: Date in YYYY-MM-DD format
+        """
+        try:
+            # Validate date format
+            datetime.strptime(date, "%Y-%m-%d")
+
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT * FROM exams
+                WHERE date = ?
+                ORDER BY time
+            ''', (date,))
+            rows = cursor.fetchall()
+            conn.close()
+
+            exams = [format_exam(row) for row in rows]
+            return {
+                "status": "success",
+                "date": date,
+                "count": len(exams),
+                "exams": exams
+            }
+        except ValueError:
+            return {"status": "error", "message": "Invalid date format. Use YYYY-MM-DD"}
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def get_upcoming_exams(days: int = 7) -> Dict[str, Any]:
+        """Get exams in the next N days
+
+        Args:
+            days: Number of days to look ahead (default: 7)
+        """
+        try:
+            today = datetime.now().date()
+            end_date = today + timedelta(days=days)
+
+            conn = get_db_connection()
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT * FROM exams
+                WHERE date >= ? AND date <= ?
+                ORDER BY date, time
+            ''', (today.isoformat(), end_date.isoformat()))
+            rows = cursor.fetchall()
+            conn.close()
+
+            exams = [format_exam(row) for row in rows]
+
+            # Group exams by urgency
+            urgent = [e for e in exams if e["days_until"] <= 3]
+            upcoming = [e for e in exams if 3 < e["days_until"] <= 7]
+            later = [e for e in exams if e["days_until"] > 7]
+
+            return {
+                "status": "success",
+                "from_date": today.isoformat(),
+                "to_date": end_date.isoformat(),
+                "total_count": len(exams),
+                "urgent": urgent,
+                "upcoming": upcoming,
+                "later": later,
+                "all_exams": exams
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def search_related_documents(subject: str, docs_dir: str = None) -> Dict[str, Any]:
+        """Find documents related to an exam subject
+
+        Args:
+            subject: Subject name to search for in document filenames
+            docs_dir: Optional documents directory path
+        """
+        try:
+            if not docs_dir:
+                docs_dir = os.path.join(os.path.dirname(os.path.dirname(db_path)), "documents")
+
+            related_files = []
+            subject_lower = subject.lower()
+
+            if os.path.exists(docs_dir):
+                for root, dirs, filenames in os.walk(docs_dir):
+                    for filename in filenames:
+                        if subject_lower in filename.lower():
+                            file_path = os.path.join(root, filename)
+                            rel_path = os.path.relpath(file_path, docs_dir)
+                            related_files.append({
+                                "name": filename,
+                                "path": rel_path.replace("\\", "/"),
+                                "extension": os.path.splitext(filename)[1]
+                            })
+
+            return {
+                "status": "success",
+                "subject": subject,
+                "document_count": len(related_files),
+                "documents": related_files
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def get_study_schedule(exam_id: Optional[int] = None) -> Dict[str, Any]:
+        """Get study schedule for exams
+
+        Args:
+            exam_id: Optional specific exam ID to get schedule for
+        """
+        try:
+            conn = get_db_connection()
+            cursor = conn.cursor()
+
+            if exam_id:
+                # Get study sessions for specific exam
+                cursor.execute('''
+                    SELECT s.*, e.subject, e.date as exam_date
+                    FROM study_sessions s
+                    JOIN exams e ON s.exam_id = e.id
+                    WHERE s.exam_id = ?
+                    ORDER BY s.date, s.start_time
+                ''', (exam_id,))
+            else:
+                # Get all study sessions
+                cursor.execute('''
+                    SELECT s.*, e.subject, e.date as exam_date
+                    FROM study_sessions s
+                    JOIN exams e ON s.exam_id = e.id
+                    ORDER BY s.date, s.start_time
+                ''')
+
+            rows = cursor.fetchall()
+            conn.close()
+
+            sessions = []
+            for row in rows:
+                sessions.append({
+                    "id": row["id"],
+                    "exam_id": row["exam_id"],
+                    "subject": row["subject"],
+                    "exam_date": row["exam_date"],
+                    "date": row["date"],
+                    "start_time": row["start_time"],
+                    "end_time": row["end_time"],
+                    "topic": row["topic"],
+                    "completed": bool(row["completed"]),
+                    "notes": row["notes"]
+                })
+
+            return {
+                "status": "success",
+                "count": len(sessions),
+                "study_sessions": sessions
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def get_exam_statistics() -> Dict[str, Any]:
+        """Get statistics about upcoming exams"""
+        try:
+            conn = get_db_connection()
+            cursor = conn.cursor()
+
+            # Total exams
+            cursor.execute("SELECT COUNT(*) FROM exams")
+            total_exams = cursor.fetchone()[0]
+
+            # Past exams
+            today = datetime.now().date().isoformat()
+            cursor.execute("SELECT COUNT(*) FROM exams WHERE date < ?", (today,))
+            past_exams = cursor.fetchone()[0]
+
+            # Future exams
+            cursor.execute("SELECT COUNT(*) FROM exams WHERE date >= ?", (today,))
+            future_exams = cursor.fetchone()[0]
+
+            # Exams by type
+            cursor.execute('''
+                SELECT exam_type, COUNT(*) as count
+                FROM exams
+                WHERE date >= ?
+                GROUP BY exam_type
+            ''', (today,))
+            exam_types = {row[0]: row[1] for row in cursor.fetchall()}
+
+            # Exams by subject
+            cursor.execute('''
+                SELECT subject, COUNT(*) as count
+                FROM exams
+                WHERE date >= ?
+                GROUP BY subject
+            ''', (today,))
+            exam_subjects = {row[0]: row[1] for row in cursor.fetchall()}
+
+            # Next exam
+            cursor.execute('''
+                SELECT * FROM exams
+                WHERE date >= ?
+                ORDER BY date, time
+                LIMIT 1
+            ''', (today,))
+            next_exam_row = cursor.fetchone()
+            next_exam = format_exam(next_exam_row) if next_exam_row else None
+
+            conn.close()
+
+            return {
+                "status": "success",
+                "total_exams": total_exams,
+                "past_exams": past_exams,
+                "future_exams": future_exams,
+                "by_type": exam_types,
+                "by_subject": exam_subjects,
+                "next_exam": next_exam
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # WRITE TOOLS (for future expansion - requires passcode)
+
+    @mcp.tool()
+    def add_exam(subject: str, exam_type: str, date: str, time: str = None,
+                 duration: int = None, location: str = None, professor: str = None,
+                 notes: str = None, materials: str = None, passcode: str = None) -> Dict[str, Any]:
+        """Add a new exam to the calendar (requires passcode)
+
+        Args:
+            subject: Subject name
+            exam_type: Type of exam (e.g., "Midterm", "Final", "Quiz")
+            date: Exam date in YYYY-MM-DD format
+            time: Exam time in HH:MM format (optional)
+            duration: Duration in minutes (optional)
+            location: Exam location (optional)
+            professor: Professor name (optional)
+            notes: Additional notes (optional)
+            materials: Required materials (optional)
+            passcode: Admin passcode for write operations
+        """
+        # For now, this requires a passcode (could be same as upload passcode)
+        # You can implement this if needed
+        return {"status": "error", "message": "Write operations not yet enabled"}
\ No newline at end of file
diff --git a/backend/tools/claude_integration_tools.py b/backend/tools/claude_integration_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab714d6c79ff51331198d680af90d6e9465371ec
--- /dev/null
+++ b/backend/tools/claude_integration_tools.py
@@ -0,0 +1,434 @@
+"""
+Claude Integration Tools for Reuben OS
+Provides tools for saving Claude-generated content and executing code
+"""
+
+import os
+import json
+import subprocess
+import tempfile
+import sys
+import traceback
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+def register_claude_integration_tools(mcp, data_dir: str):
+    """Register Claude integration tools with the MCP server"""
+
+    # Create directories for storing generated content
+    claude_content_dir = os.path.join(data_dir, "claude_generated")
+    code_output_dir = os.path.join(data_dir, "code_outputs")
+    os.makedirs(claude_content_dir, exist_ok=True)
+    os.makedirs(code_output_dir, exist_ok=True)
+
+    @mcp.tool()
+    def save_claude_text(content: str, filename: str, category: str = "general") -> Dict[str, Any]:
+        """
+        Save text generated by Claude to the file system
+
+        Args:
+            content: The text content to save
+            filename: Name of the file (without extension)
+            category: Category folder (general, code, documentation, etc.)
+
+        Returns:
+            Dictionary with save status and file path
+        """
+        try:
+            # Create category directory
+            category_dir = os.path.join(claude_content_dir, category)
+            os.makedirs(category_dir, exist_ok=True)
+
+            # Generate unique filename with timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            full_filename = f"{filename}_{timestamp}.txt"
+            file_path = os.path.join(category_dir, full_filename)
+
+            # Save the content
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+
+            logger.info(f"Saved Claude-generated text to {file_path}")
+
+            return {
+                "success": True,
+                "file_path": file_path,
+                "filename": full_filename,
+                "category": category,
+                "size": len(content),
+                "timestamp": timestamp
+            }
+        except Exception as e:
+            logger.error(f"Error saving Claude text: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    @mcp.tool()
+    def save_claude_code(code: str, filename: str, language: str = "python") -> Dict[str, Any]:
+        """
+        Save code generated by Claude to the file system
+
+        Args:
+            code: The code content to save
+            filename: Name of the file (without extension)
+            language: Programming language (python, javascript, html, etc.)
+
+        Returns:
+            Dictionary with save status and file path
+        """
+        try:
+            # Determine file extension based on language
+            extensions = {
+                "python": ".py",
+                "javascript": ".js",
+                "typescript": ".ts",
+                "html": ".html",
+                "css": ".css",
+                "java": ".java",
+                "cpp": ".cpp",
+                "c": ".c",
+                "go": ".go",
+                "rust": ".rs",
+                "ruby": ".rb",
+                "php": ".php",
+                "swift": ".swift",
+                "kotlin": ".kt",
+                "r": ".r",
+                "matlab": ".m",
+                "bash": ".sh",
+                "powershell": ".ps1"
+            }
+
+            ext = extensions.get(language.lower(), ".txt")
+
+            # Create code directory
+            code_dir = os.path.join(claude_content_dir, "code", language)
+            os.makedirs(code_dir, exist_ok=True)
+
+            # Generate unique filename with timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            full_filename = f"{filename}_{timestamp}{ext}"
+            file_path = os.path.join(code_dir, full_filename)
+
+            # Save the code
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(code)
+
+            logger.info(f"Saved Claude-generated code to {file_path}")
+
+            return {
+                "success": True,
+                "file_path": file_path,
+                "filename": full_filename,
+                "language": language,
+                "extension": ext,
+                "size": len(code),
+                "timestamp": timestamp
+            }
+        except Exception as e:
+            logger.error(f"Error saving Claude code: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    @mcp.tool()
+    def execute_python_code(code: str, save_output: bool = True, timeout: int = 30) -> Dict[str, Any]:
+        """
+        Execute Python code and return the output
+
+        Args:
+            code: Python code to execute
+            save_output: Whether to save the output to a file
+            timeout: Maximum execution time in seconds
+
+        Returns:
+            Dictionary with execution results, output, and any errors
+        """
+        try:
+            # Create a temporary Python file
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False, encoding='utf-8') as f:
+                f.write(code)
+                temp_file = f.name
+
+            # Execute the code
+            try:
+                result = subprocess.run(
+                    [sys.executable, temp_file],
+                    capture_output=True,
+                    text=True,
+                    timeout=timeout,
+                    cwd=code_output_dir
+                )
+
+                output = result.stdout
+                error = result.stderr
+                return_code = result.returncode
+
+                # Save output if requested
+                output_file = None
+                if save_output and (output or error):
+                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                    output_filename = f"python_output_{timestamp}.txt"
+                    output_file = os.path.join(code_output_dir, output_filename)
+
+                    with open(output_file, 'w', encoding='utf-8') as f:
+                        f.write("=== Python Execution Output ===\n")
+                        f.write(f"Timestamp: {datetime.now().isoformat()}\n")
+                        f.write(f"Return Code: {return_code}\n\n")
+
+                        if output:
+                            f.write("=== Standard Output ===\n")
+                            f.write(output)
+                            f.write("\n")
+
+                        if error:
+                            f.write("=== Standard Error ===\n")
+                            f.write(error)
+                            f.write("\n")
+
+                        f.write("\n=== Original Code ===\n")
+                        f.write(code)
+
+                logger.info(f"Executed Python code successfully")
+
+                return {
+                    "success": return_code == 0,
+                    "output": output,
+                    "error": error,
+                    "return_code": return_code,
+                    "output_file": output_file,
+                    "execution_time": datetime.now().isoformat()
+                }
+
+            except subprocess.TimeoutExpired:
+                return {
+                    "success": False,
+                    "error": f"Code execution timed out after {timeout} seconds",
+                    "output": "",
+                    "return_code": -1
+                }
+            finally:
+                # Clean up temporary file
+                try:
+                    os.unlink(temp_file)
+                except:
+                    pass
+
+        except Exception as e:
+            logger.error(f"Error executing Python code: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "traceback": traceback.format_exc()
+            }
+
+    @mcp.tool()
+    def execute_python_with_packages(code: str, packages: list = None, save_output: bool = True) -> Dict[str, Any]:
+        """
+        Execute Python code with automatic package installation
+
+        Args:
+            code: Python code to execute
+            packages: List of packages to install (e.g., ['matplotlib', 'numpy'])
+            save_output: Whether to save the output to a file
+
+        Returns:
+            Dictionary with execution results
+        """
+        try:
+            # Install packages if specified
+            if packages:
+                for package in packages:
+                    try:
+                        subprocess.run(
+                            [sys.executable, "-m", "pip", "install", package],
+                            capture_output=True,
+                            text=True,
+                            timeout=60
+                        )
+                        logger.info(f"Installed package: {package}")
+                    except Exception as e:
+                        logger.warning(f"Failed to install package {package}: {e}")
+
+            # Execute the code
+            return execute_python_code(code, save_output)
+
+        except Exception as e:
+            logger.error(f"Error in execute_python_with_packages: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    @mcp.tool()
+    def execute_matplotlib_code(code: str, output_format: str = "png") -> Dict[str, Any]:
+        """
+        Execute Python code that generates matplotlib plots and save the output
+
+        Args:
+            code: Python code that creates matplotlib plots
+            output_format: Output format (png, jpg, svg, pdf)
+
+        Returns:
+            Dictionary with execution results and path to saved plot
+        """
+        try:
+            # Ensure matplotlib is installed
+            try:
+                import matplotlib
+            except ImportError:
+                subprocess.run(
+                    [sys.executable, "-m", "pip", "install", "matplotlib"],
+                    capture_output=True,
+                    timeout=60
+                )
+
+            # Modify code to save the plot
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            plot_filename = f"plot_{timestamp}.{output_format}"
+            plot_path = os.path.join(code_output_dir, "plots", plot_filename)
+            os.makedirs(os.path.dirname(plot_path), exist_ok=True)
+
+            # Add plot saving code
+            modified_code = f"""
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend
+import matplotlib.pyplot as plt
+
+{code}
+
+# Save the current figure
+if plt.get_fignums():  # Check if any figures exist
+    plt.savefig(r'{plot_path}', dpi=150, bbox_inches='tight')
+    print(f'Plot saved to: {plot_path}')
+else:
+    print('No plot was generated')
+"""
+
+            # Execute the modified code
+            result = execute_python_code(modified_code, save_output=True)
+
+            # Check if plot was created
+            if os.path.exists(plot_path):
+                result["plot_path"] = plot_path
+                result["plot_filename"] = plot_filename
+                logger.info(f"Saved matplotlib plot to {plot_path}")
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Error executing matplotlib code: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "traceback": traceback.format_exc()
+            }
+
+    @mcp.tool()
+    def list_claude_generated_content(category: Optional[str] = None) -> Dict[str, Any]:
+        """
+        List all Claude-generated content
+
+        Args:
+            category: Optional category filter (general, code, etc.)
+
+        Returns:
+            Dictionary with list of generated files
+        """
+        try:
+            files = []
+
+            if category:
+                category_path = os.path.join(claude_content_dir, category)
+                if os.path.exists(category_path):
+                    for root, dirs, filenames in os.walk(category_path):
+                        for filename in filenames:
+                            file_path = os.path.join(root, filename)
+                            rel_path = os.path.relpath(file_path, claude_content_dir)
+                            files.append({
+                                "filename": filename,
+                                "path": file_path,
+                                "relative_path": rel_path,
+                                "size": os.path.getsize(file_path),
+                                "modified": datetime.fromtimestamp(os.path.getmtime(file_path)).isoformat()
+                            })
+            else:
+                # List all files
+                for root, dirs, filenames in os.walk(claude_content_dir):
+                    for filename in filenames:
+                        file_path = os.path.join(root, filename)
+                        rel_path = os.path.relpath(file_path, claude_content_dir)
+                        files.append({
+                            "filename": filename,
+                            "path": file_path,
+                            "relative_path": rel_path,
+                            "size": os.path.getsize(file_path),
+                            "modified": datetime.fromtimestamp(os.path.getmtime(file_path)).isoformat()
+                        })
+
+            return {
+                "success": True,
+                "count": len(files),
+                "files": files,
+                "base_directory": claude_content_dir
+            }
+
+        except Exception as e:
+            logger.error(f"Error listing Claude-generated content: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    @mcp.tool()
+    def get_code_output(filename: str) -> Dict[str, Any]:
+        """
+        Retrieve the output of previously executed code
+
+        Args:
+            filename: Name of the output file
+
+        Returns:
+            Dictionary with the output content
+        """
+        try:
+            file_path = os.path.join(code_output_dir, filename)
+
+            if not os.path.exists(file_path):
+                # Try to find in subdirectories
+                for root, dirs, files in os.walk(code_output_dir):
+                    if filename in files:
+                        file_path = os.path.join(root, filename)
+                        break
+
+            if os.path.exists(file_path):
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+
+                return {
+                    "success": True,
+                    "content": content,
+                    "path": file_path,
+                    "size": len(content)
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"Output file not found: {filename}"
+                }
+
+        except Exception as e:
+            logger.error(f"Error retrieving code output: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    logger.info(f"Registered Claude integration tools with content directory: {claude_content_dir}")
\ No newline at end of file
diff --git a/backend/tools/code_tools.py b/backend/tools/code_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..54c5ceef655d969412fd20760190f69d71041d27
--- /dev/null
+++ b/backend/tools/code_tools.py
@@ -0,0 +1,258 @@
+"""
+MCP tools for code editing and preview functionality
+"""
+import json
+import os
+import secrets
+from typing import Dict, List, Optional
+from datetime import datetime
+import base64
+
+# Store code sessions in memory (in production, use a database)
+code_sessions: Dict[str, Dict] = {}
+
+def generate_session_id() -> str:
+    """Generate a unique session ID"""
+    return secrets.token_urlsafe(16)
+
+def save_code_session(session_id: str, html_code: str, css_code: str, js_code: str) -> dict:
+    """
+    Save a code editing session
+
+    Args:
+        session_id: Unique session identifier
+        html_code: HTML code content
+        css_code: CSS code content
+        js_code: JavaScript code content
+
+    Returns:
+        dict with success status and session details
+    """
+    if not session_id:
+        session_id = generate_session_id()
+
+    code_sessions[session_id] = {
+        'html': html_code,
+        'css': css_code,
+        'js': js_code,
+        'timestamp': datetime.now().isoformat(),
+        'session_id': session_id
+    }
+
+    return {
+        'success': True,
+        'session_id': session_id,
+        'message': 'Code saved successfully'
+    }
+
+def get_code_session(session_id: str) -> dict:
+    """
+    Retrieve a code editing session
+
+    Args:
+        session_id: Session ID to retrieve
+
+    Returns:
+        dict with session data or error
+    """
+    if session_id in code_sessions:
+        return {
+            'success': True,
+            'session': code_sessions[session_id]
+        }
+
+    return {
+        'success': False,
+        'error': 'Session not found'
+    }
+
+def list_sessions() -> dict:
+    """
+    List all available code sessions
+
+    Returns:
+        dict with list of sessions
+    """
+    sessions_list = []
+    for session_id, session_data in code_sessions.items():
+        sessions_list.append({
+            'session_id': session_id,
+            'timestamp': session_data.get('timestamp', 'Unknown'),
+            'has_html': bool(session_data.get('html')),
+            'has_css': bool(session_data.get('css')),
+            'has_js': bool(session_data.get('js'))
+        })
+
+    return {
+        'success': True,
+        'sessions': sessions_list,
+        'total': len(sessions_list)
+    }
+
+def generate_preview_html(session_id: str) -> dict:
+    """
+    Generate a complete HTML preview from session code
+
+    Args:
+        session_id: Session ID to generate preview for
+
+    Returns:
+        dict with preview HTML or error
+    """
+    if session_id not in code_sessions:
+        return {
+            'success': False,
+            'error': 'Session not found'
+        }
+
+    session = code_sessions[session_id]
+    html_code = session.get('html', '')
+    css_code = session.get('css', '')
+    js_code = session.get('js', '')
+
+    # Generate complete HTML with embedded CSS and JS
+    preview_html = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Code Preview - {session_id}</title>
+    <style>
+{css_code}
+    </style>
+</head>
+<body>
+{html_code}
+    <script>
+{js_code}
+    </script>
+</body>
+</html>"""
+
+    # Encode as base64 data URL
+    encoded_html = base64.b64encode(preview_html.encode()).decode()
+    data_url = f"data:text/html;base64,{encoded_html}"
+
+    return {
+        'success': True,
+        'session_id': session_id,
+        'preview_html': preview_html,
+        'data_url': data_url
+    }
+
+def validate_code(session_id: str, code_type: str) -> dict:
+    """
+    Validate HTML, CSS, or JavaScript code
+
+    Args:
+        session_id: Session ID
+        code_type: Type of code to validate ('html', 'css', 'js')
+
+    Returns:
+        dict with validation results
+    """
+    if session_id not in code_sessions:
+        return {
+            'success': False,
+            'error': 'Session not found'
+        }
+
+    session = code_sessions[session_id]
+    code = session.get(code_type, '')
+
+    # Basic validation (in production, use proper validators)
+    warnings = []
+    errors = []
+
+    if code_type == 'html':
+        if '<html' not in code.lower() and '<!doctype' not in code.lower():
+            warnings.append('Missing HTML document structure')
+        if '<script>' in code and '</script>' not in code:
+            errors.append('Unclosed script tag')
+
+    elif code_type == 'css':
+        open_braces = code.count('{')
+        close_braces = code.count('}')
+        if open_braces != close_braces:
+            errors.append(f'Mismatched braces: {open_braces} open, {close_braces} close')
+
+    elif code_type == 'js':
+        if 'function' in code:
+            open_braces = code.count('{')
+            close_braces = code.count('}')
+            if open_braces != close_braces:
+                errors.append(f'Mismatched braces: {open_braces} open, {close_braces} close')
+
+    return {
+        'success': True,
+        'session_id': session_id,
+        'code_type': code_type,
+        'valid': len(errors) == 0,
+        'errors': errors,
+        'warnings': warnings
+    }
+
+def share_session(session_id: str) -> dict:
+    """
+    Generate a shareable link for a code session
+
+    Args:
+        session_id: Session ID to share
+
+    Returns:
+        dict with shareable link
+    """
+    if session_id not in code_sessions:
+        return {
+            'success': False,
+            'error': 'Session not found'
+        }
+
+    # Generate a share token
+    share_token = secrets.token_urlsafe(8)
+
+    # Store the share mapping (in production, use a database)
+    session = code_sessions[session_id]
+    session['share_token'] = share_token
+
+    return {
+        'success': True,
+        'session_id': session_id,
+        'share_token': share_token,
+        'share_url': f'/code/share/{share_token}'
+    }
+
+# Clean up old sessions periodically
+def cleanup_old_sessions(max_age_hours: int = 24) -> dict:
+    """
+    Remove sessions older than specified hours
+
+    Args:
+        max_age_hours: Maximum age in hours
+
+    Returns:
+        dict with cleanup results
+    """
+    from datetime import datetime, timedelta
+
+    cutoff_time = datetime.now() - timedelta(hours=max_age_hours)
+    removed_count = 0
+
+    sessions_to_remove = []
+    for session_id, session_data in code_sessions.items():
+        try:
+            timestamp = datetime.fromisoformat(session_data.get('timestamp', ''))
+            if timestamp < cutoff_time:
+                sessions_to_remove.append(session_id)
+        except:
+            continue
+
+    for session_id in sessions_to_remove:
+        del code_sessions[session_id]
+        removed_count += 1
+
+    return {
+        'success': True,
+        'removed_count': removed_count,
+        'remaining_sessions': len(code_sessions)
+    }
\ No newline at end of file
diff --git a/backend/tools/document_tools.py b/backend/tools/document_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1d62fad5e40ab6a0c492b1fa2e7cd46064644fc
--- /dev/null
+++ b/backend/tools/document_tools.py
@@ -0,0 +1,480 @@
+import os
+import base64
+from pathlib import Path
+import json
+from typing import List, Dict, Any, Optional
+import PyPDF2
+from docx import Document as DocxDocument
+import hashlib
+import datetime
+
+def register_document_tools(mcp, docs_dir: str, upload_passcode: str):
+    """Register all document-related MCP tools"""
+
+    # Ensure documents directory exists
+    os.makedirs(docs_dir, exist_ok=True)
+
+    # Helper function to get file metadata
+    def get_file_metadata(file_path: str) -> Dict[str, Any]:
+        """Get metadata for a file"""
+        try:
+            stat = os.stat(file_path)
+            return {
+                "size": stat.st_size,
+                "size_formatted": format_file_size(stat.st_size),
+                "created": datetime.datetime.fromtimestamp(stat.st_ctime).isoformat(),
+                "modified": datetime.datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                "extension": Path(file_path).suffix.lower()
+            }
+        except Exception as e:
+            return {"error": str(e)}
+
+    def format_file_size(size: int) -> str:
+        """Format file size to human-readable format"""
+        for unit in ['B', 'KB', 'MB', 'GB']:
+            if size < 1024.0:
+                return f"{size:.2f} {unit}"
+            size /= 1024.0
+        return f"{size:.2f} TB"
+
+    # READ TOOLS (No passcode required)
+
+    @mcp.tool()
+    def list_all_documents() -> Dict[str, Any]:
+        """List all files in the document repository with their metadata"""
+        files = []
+        try:
+            for root, dirs, filenames in os.walk(docs_dir):
+                for filename in filenames:
+                    file_path = os.path.join(root, filename)
+                    rel_path = os.path.relpath(file_path, docs_dir)
+                    metadata = get_file_metadata(file_path)
+                    files.append({
+                        "name": filename,
+                        "path": rel_path.replace("\\", "/"),
+                        **metadata
+                    })
+            return {
+                "status": "success",
+                "count": len(files),
+                "files": sorted(files, key=lambda x: x.get("modified", ""), reverse=True)
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def get_folder_structure() -> Dict[str, Any]:
+        """Get complete folder structure as a nested tree"""
+        try:
+            def build_tree(path: str, parent_path: str = "") -> Dict[str, Any]:
+                items = []
+                for item in os.listdir(path):
+                    item_path = os.path.join(path, item)
+                    rel_path = os.path.join(parent_path, item)
+                    if os.path.isdir(item_path):
+                        items.append({
+                            "name": item,
+                            "type": "folder",
+                            "path": rel_path.replace("\\", "/"),
+                            "children": build_tree(item_path, rel_path)["items"]
+                        })
+                    else:
+                        metadata = get_file_metadata(item_path)
+                        items.append({
+                            "name": item,
+                            "type": "file",
+                            "path": rel_path.replace("\\", "/"),
+                            **metadata
+                        })
+                return {"items": sorted(items, key=lambda x: (x["type"] != "folder", x["name"]))}
+
+            tree = build_tree(docs_dir)
+            return {
+                "status": "success",
+                "structure": tree["items"]
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def search_documents(query: str, file_type: Optional[str] = None) -> Dict[str, Any]:
+        """Search for documents by name or extension
+
+        Args:
+            query: Search term to match in filenames
+            file_type: Optional file extension filter (e.g., 'pdf', 'docx')
+        """
+        matching_files = []
+        query_lower = query.lower()
+
+        try:
+            for root, dirs, filenames in os.walk(docs_dir):
+                for filename in filenames:
+                    if file_type and not filename.lower().endswith(f".{file_type.lower()}"):
+                        continue
+                    if query_lower in filename.lower():
+                        file_path = os.path.join(root, filename)
+                        rel_path = os.path.relpath(file_path, docs_dir)
+                        metadata = get_file_metadata(file_path)
+                        matching_files.append({
+                            "name": filename,
+                            "path": rel_path.replace("\\", "/"),
+                            **metadata
+                        })
+
+            return {
+                "status": "success",
+                "query": query,
+                "count": len(matching_files),
+                "files": sorted(matching_files, key=lambda x: x["name"])
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def extract_pdf_text(filename: str, max_pages: Optional[int] = None) -> Dict[str, Any]:
+        """Extract text content from a PDF file
+
+        Args:
+            filename: Path to the PDF file (relative to documents directory)
+            max_pages: Maximum number of pages to extract (optional)
+        """
+        try:
+            file_path = os.path.join(docs_dir, filename)
+            if not os.path.exists(file_path):
+                return {"status": "error", "message": f"File not found: {filename}"}
+
+            with open(file_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                num_pages = len(pdf_reader.pages)
+                pages_to_read = min(max_pages or num_pages, num_pages)
+
+                text_content = []
+                for i in range(pages_to_read):
+                    page_text = pdf_reader.pages[i].extract_text()
+                    text_content.append({
+                        "page": i + 1,
+                        "content": page_text
+                    })
+
+                return {
+                    "status": "success",
+                    "filename": filename,
+                    "total_pages": num_pages,
+                    "pages_extracted": pages_to_read,
+                    "text": text_content
+                }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def extract_docx_text(filename: str) -> Dict[str, Any]:
+        """Extract text content from a DOCX file
+
+        Args:
+            filename: Path to the DOCX file (relative to documents directory)
+        """
+        try:
+            file_path = os.path.join(docs_dir, filename)
+            if not os.path.exists(file_path):
+                return {"status": "error", "message": f"File not found: {filename}"}
+
+            doc = DocxDocument(file_path)
+            paragraphs = []
+            for i, para in enumerate(doc.paragraphs):
+                if para.text.strip():
+                    paragraphs.append({
+                        "index": i + 1,
+                        "content": para.text
+                    })
+
+            # Extract tables if any
+            tables = []
+            for i, table in enumerate(doc.tables):
+                table_data = []
+                for row in table.rows:
+                    row_data = [cell.text for cell in row.cells]
+                    table_data.append(row_data)
+                tables.append({
+                    "table_index": i + 1,
+                    "rows": len(table.rows),
+                    "columns": len(table.columns),
+                    "data": table_data
+                })
+
+            return {
+                "status": "success",
+                "filename": filename,
+                "paragraph_count": len(paragraphs),
+                "table_count": len(tables),
+                "paragraphs": paragraphs,
+                "tables": tables
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def read_text_file(filename: str, encoding: str = "utf-8") -> Dict[str, Any]:
+        """Read content from a text file
+
+        Args:
+            filename: Path to the text file (relative to documents directory)
+            encoding: File encoding (default: utf-8)
+        """
+        try:
+            file_path = os.path.join(docs_dir, filename)
+            if not os.path.exists(file_path):
+                return {"status": "error", "message": f"File not found: {filename}"}
+
+            with open(file_path, 'r', encoding=encoding) as file:
+                content = file.read()
+
+            metadata = get_file_metadata(file_path)
+            return {
+                "status": "success",
+                "filename": filename,
+                "content": content,
+                "line_count": len(content.splitlines()),
+                "character_count": len(content),
+                **metadata
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def search_in_document(filename: str, search_query: str, case_sensitive: bool = False) -> Dict[str, Any]:
+        """Search for text within a document
+
+        Args:
+            filename: Path to the document (relative to documents directory)
+            search_query: Text to search for
+            case_sensitive: Whether the search should be case-sensitive
+        """
+        try:
+            file_path = os.path.join(docs_dir, filename)
+            if not os.path.exists(file_path):
+                return {"status": "error", "message": f"File not found: {filename}"}
+
+            ext = Path(file_path).suffix.lower()
+            text = ""
+
+            # Extract text based on file type
+            if ext == '.pdf':
+                result = extract_pdf_text(filename)
+                if result["status"] == "success":
+                    text = "\n".join([page["content"] for page in result["text"]])
+            elif ext in ['.docx', '.doc']:
+                result = extract_docx_text(filename)
+                if result["status"] == "success":
+                    text = "\n".join([para["content"] for para in result["paragraphs"]])
+            elif ext in ['.txt', '.md', '.csv', '.json', '.xml', '.html']:
+                result = read_text_file(filename)
+                if result["status"] == "success":
+                    text = result["content"]
+            else:
+                return {"status": "error", "message": f"Unsupported file type: {ext}"}
+
+            # Search for the query
+            if not case_sensitive:
+                search_text = text.lower()
+                search_term = search_query.lower()
+            else:
+                search_text = text
+                search_term = search_query
+
+            # Find all occurrences
+            lines = search_text.splitlines()
+            matches = []
+            for i, line in enumerate(lines):
+                if search_term in line:
+                    # Get surrounding context
+                    start_line = max(0, i - 1)
+                    end_line = min(len(lines), i + 2)
+                    context = lines[start_line:end_line]
+
+                    matches.append({
+                        "line_number": i + 1,
+                        "line_content": text.splitlines()[i],  # Original text with case
+                        "context": "\n".join(text.splitlines()[start_line:end_line])
+                    })
+
+            return {
+                "status": "success",
+                "filename": filename,
+                "search_query": search_query,
+                "match_count": len(matches),
+                "matches": matches[:20]  # Limit to first 20 matches
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def get_document_summary(filename: str) -> Dict[str, Any]:
+        """Get document metadata and preview
+
+        Args:
+            filename: Path to the document (relative to documents directory)
+        """
+        try:
+            file_path = os.path.join(docs_dir, filename)
+            if not os.path.exists(file_path):
+                return {"status": "error", "message": f"File not found: {filename}"}
+
+            metadata = get_file_metadata(file_path)
+            ext = Path(file_path).suffix.lower()
+
+            preview = ""
+            details = {}
+
+            # Get preview based on file type
+            if ext == '.pdf':
+                result = extract_pdf_text(filename, max_pages=1)
+                if result["status"] == "success":
+                    preview = result["text"][0]["content"][:500] if result["text"] else ""
+                    details["page_count"] = result["total_pages"]
+            elif ext in ['.docx', '.doc']:
+                result = extract_docx_text(filename)
+                if result["status"] == "success" and result["paragraphs"]:
+                    preview = "\n".join([p["content"] for p in result["paragraphs"][:3]])[:500]
+                    details["paragraph_count"] = result["paragraph_count"]
+                    details["table_count"] = result["table_count"]
+            elif ext in ['.txt', '.md', '.csv', '.json', '.xml', '.html']:
+                result = read_text_file(filename)
+                if result["status"] == "success":
+                    preview = result["content"][:500]
+                    details["line_count"] = result["line_count"]
+
+            return {
+                "status": "success",
+                "filename": filename,
+                "file_type": ext[1:] if ext else "unknown",
+                "preview": preview + ("..." if len(preview) == 500 else ""),
+                **metadata,
+                **details
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    # WRITE TOOLS (Passcode required)
+
+    @mcp.tool()
+    def upload_file(filename: str, file_data: str, passcode: str, folder: Optional[str] = None) -> Dict[str, Any]:
+        """Upload a file to the document repository (requires passcode)
+
+        Args:
+            filename: Name for the uploaded file
+            file_data: Base64-encoded file content
+            passcode: Upload passcode for authentication
+            folder: Optional subfolder path (e.g., "exams/2025")
+        """
+        # Validate passcode
+        if passcode != upload_passcode:
+            return {"status": "error", "message": "Invalid passcode"}
+
+        try:
+            # Validate filename
+            if not filename or "/" in filename or "\\" in filename:
+                return {"status": "error", "message": "Invalid filename"}
+
+            # Determine target directory
+            if folder:
+                target_dir = os.path.join(docs_dir, folder)
+                os.makedirs(target_dir, exist_ok=True)
+            else:
+                target_dir = docs_dir
+
+            # Decode base64 data
+            try:
+                file_content = base64.b64decode(file_data)
+            except Exception:
+                return {"status": "error", "message": "Invalid base64 data"}
+
+            # Check file size (max 50MB)
+            if len(file_content) > 50 * 1024 * 1024:
+                return {"status": "error", "message": "File too large (max 50MB)"}
+
+            # Save file
+            file_path = os.path.join(target_dir, filename)
+
+            # Create backup if file exists
+            if os.path.exists(file_path):
+                backup_name = f"{Path(filename).stem}_backup_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}{Path(filename).suffix}"
+                backup_path = os.path.join(target_dir, backup_name)
+                os.rename(file_path, backup_path)
+
+            with open(file_path, 'wb') as f:
+                f.write(file_content)
+
+            # Calculate file hash for verification
+            file_hash = hashlib.md5(file_content).hexdigest()
+
+            return {
+                "status": "success",
+                "message": "File uploaded successfully",
+                "filename": filename,
+                "path": os.path.relpath(file_path, docs_dir).replace("\\", "/"),
+                "size": len(file_content),
+                "size_formatted": format_file_size(len(file_content)),
+                "hash": file_hash
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def create_folder(folder_path: str, passcode: str) -> Dict[str, Any]:
+        """Create a new folder in the document repository (requires passcode)
+
+        Args:
+            folder_path: Path for the new folder (e.g., "exams/2025/midterms")
+            passcode: Upload passcode for authentication
+        """
+        # Validate passcode
+        if passcode != upload_passcode:
+            return {"status": "error", "message": "Invalid passcode"}
+
+        try:
+            full_path = os.path.join(docs_dir, folder_path)
+            os.makedirs(full_path, exist_ok=True)
+
+            return {
+                "status": "success",
+                "message": "Folder created successfully",
+                "path": folder_path
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+    @mcp.tool()
+    def delete_file(filename: str, passcode: str) -> Dict[str, Any]:
+        """Delete a file from the document repository (requires passcode)
+
+        Args:
+            filename: Path to the file to delete (relative to documents directory)
+            passcode: Upload passcode for authentication
+        """
+        # Validate passcode
+        if passcode != upload_passcode:
+            return {"status": "error", "message": "Invalid passcode"}
+
+        try:
+            file_path = os.path.join(docs_dir, filename)
+            if not os.path.exists(file_path):
+                return {"status": "error", "message": f"File not found: {filename}"}
+
+            # Create backup before deletion
+            backup_dir = os.path.join(docs_dir, ".trash")
+            os.makedirs(backup_dir, exist_ok=True)
+
+            backup_name = f"{Path(filename).stem}_deleted_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}{Path(filename).suffix}"
+            backup_path = os.path.join(backup_dir, backup_name)
+
+            os.rename(file_path, backup_path)
+
+            return {
+                "status": "success",
+                "message": "File deleted (moved to trash)",
+                "filename": filename,
+                "backup_path": os.path.relpath(backup_path, docs_dir).replace("\\", "/")
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
\ No newline at end of file
diff --git a/backend/tools/document_tools_fix.py b/backend/tools/document_tools_fix.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a96dabb8564cc066c3aeb326a6bb649bf00f25c
--- /dev/null
+++ b/backend/tools/document_tools_fix.py
@@ -0,0 +1,108 @@
+"""
+Enhanced document upload function with better binary file handling
+"""
+
+import base64
+from typing import Dict, Any, Optional
+import os
+from pathlib import Path
+import datetime
+
+
+def enhanced_upload_file(
+    filename: str,
+    file_data: str,
+    passcode: str,
+    upload_passcode: str,
+    docs_dir: str,
+    folder: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Enhanced upload function with better error handling for binary files
+
+    Args:
+        filename: Name for the uploaded file
+        file_data: Base64-encoded file content
+        passcode: Upload passcode for authentication
+        upload_passcode: System upload passcode
+        docs_dir: Base directory for documents
+        folder: Optional subfolder path
+    """
+    # Validate passcode
+    if passcode != upload_passcode:
+        return {"status": "error", "message": "Invalid passcode"}
+
+    try:
+        # Validate filename
+        if not filename or "/" in filename or "\\" in filename:
+            return {"status": "error", "message": "Invalid filename"}
+
+        # Determine target directory
+        if folder:
+            target_dir = os.path.join(docs_dir, folder)
+            os.makedirs(target_dir, exist_ok=True)
+        else:
+            target_dir = docs_dir
+
+        # Enhanced base64 decoding with padding fix
+        try:
+            # Remove any data URL prefix if present
+            if ',' in file_data:
+                # Handle data URLs like "data:application/pdf;base64,..."
+                file_data = file_data.split(',')[1]
+
+            # Fix base64 padding if needed
+            missing_padding = len(file_data) % 4
+            if missing_padding:
+                file_data += '=' * (4 - missing_padding)
+
+            # Decode base64
+            file_content = base64.b64decode(file_data, validate=True)
+        except Exception as e:
+            return {"status": "error", "message": f"Failed to decode file data: {str(e)}"}
+
+        # Check file size (max 50MB)
+        if len(file_content) > 50 * 1024 * 1024:
+            return {"status": "error", "message": "File too large (max 50MB)"}
+
+        # Validate file type for PDFs and DOCX
+        file_ext = Path(filename).suffix.lower()
+        if file_ext == '.pdf':
+            # Check PDF magic number
+            if not file_content.startswith(b'%PDF'):
+                return {"status": "error", "message": "Invalid PDF file format"}
+        elif file_ext == '.docx':
+            # Check DOCX (ZIP) magic number
+            if not file_content.startswith(b'PK'):
+                return {"status": "error", "message": "Invalid DOCX file format"}
+
+        # Save file
+        file_path = os.path.join(target_dir, filename)
+
+        # Create backup if file exists
+        if os.path.exists(file_path):
+            backup_name = f"{Path(filename).stem}_backup_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}{Path(filename).suffix}"
+            backup_path = os.path.join(target_dir, backup_name)
+            os.rename(file_path, backup_path)
+
+        # Write file in binary mode
+        with open(file_path, 'wb') as f:
+            f.write(file_content)
+
+        # Verify file was written correctly
+        with open(file_path, 'rb') as f:
+            verify_content = f.read()
+            if verify_content != file_content:
+                return {"status": "error", "message": "File verification failed"}
+
+        return {
+            "status": "success",
+            "message": "File uploaded successfully",
+            "filename": filename,
+            "path": os.path.relpath(file_path, docs_dir).replace("\\", "/"),
+            "size": len(file_content),
+            "file_type": file_ext
+        }
+
+    except Exception as e:
+        return {"status": "error", "message": f"Upload failed: {str(e)}"}
\ No newline at end of file
diff --git a/backend/tools/pomodoro_timer.py b/backend/tools/pomodoro_timer.py
new file mode 100644
index 0000000000000000000000000000000000000000..b68a3c2460b99367fd9f4cf113121b101bea0b9a
--- /dev/null
+++ b/backend/tools/pomodoro_timer.py
@@ -0,0 +1,226 @@
+"""
+Pomodoro Timer for Study Sessions
+"""
+
+import time
+from datetime import datetime, timedelta
+from typing import Dict, Any, Optional
+import json
+import os
+
+class PomodoroTimer:
+    def __init__(self, data_dir: str = "./data"):
+        self.sessions_file = os.path.join(data_dir, "pomodoro_sessions.json")
+        self.current_session = None
+        self.load_sessions()
+
+    def load_sessions(self):
+        """Load previous sessions from file"""
+        if os.path.exists(self.sessions_file):
+            with open(self.sessions_file, 'r') as f:
+                self.sessions = json.load(f)
+        else:
+            self.sessions = []
+
+    def save_sessions(self):
+        """Save sessions to file"""
+        with open(self.sessions_file, 'w') as f:
+            json.dump(self.sessions, f, indent=2)
+
+def register_pomodoro_tools(mcp):
+    """Register Pomodoro timer tools"""
+
+    timer = PomodoroTimer()
+
+    @mcp.tool()
+    def start_pomodoro(subject: str, task: str, duration_minutes: int = 25) -> Dict[str, Any]:
+        """Start a Pomodoro study session
+
+        Args:
+            subject: Subject being studied
+            task: Specific task or topic
+            duration_minutes: Session duration (default 25)
+        """
+        session = {
+            "id": len(timer.sessions) + 1,
+            "subject": subject,
+            "task": task,
+            "start_time": datetime.now().isoformat(),
+            "duration_minutes": duration_minutes,
+            "end_time": (datetime.now() + timedelta(minutes=duration_minutes)).isoformat(),
+            "status": "active",
+            "completed": False
+        }
+
+        timer.current_session = session
+        timer.sessions.append(session)
+        timer.save_sessions()
+
+        return {
+            "status": "success",
+            "message": f"Started {duration_minutes}-minute Pomodoro for {subject}",
+            "session": session,
+            "tips": [
+                "Focus on one task only",
+                "Turn off notifications",
+                "Take a 5-minute break after",
+                "Stay hydrated"
+            ]
+        }
+
+    @mcp.tool()
+    def complete_pomodoro(notes: Optional[str] = None) -> Dict[str, Any]:
+        """Complete the current Pomodoro session
+
+        Args:
+            notes: Optional notes about the session
+        """
+        if not timer.current_session:
+            return {"status": "error", "message": "No active Pomodoro session"}
+
+        timer.current_session["completed"] = True
+        timer.current_session["status"] = "completed"
+        timer.current_session["actual_end_time"] = datetime.now().isoformat()
+
+        if notes:
+            timer.current_session["notes"] = notes
+
+        timer.save_sessions()
+
+        # Calculate stats
+        completed_count = sum(1 for s in timer.sessions if s.get("completed"))
+        total_time = sum(s.get("duration_minutes", 0) for s in timer.sessions if s.get("completed"))
+
+        return {
+            "status": "success",
+            "message": "Pomodoro completed! Great work!",
+            "session": timer.current_session,
+            "stats": {
+                "total_sessions": completed_count,
+                "total_focus_time": f"{total_time} minutes",
+                "streak": calculate_streak(timer.sessions)
+            },
+            "next_steps": [
+                "Take a 5-minute break",
+                "Stretch and move around",
+                "Review what you learned",
+                "Plan next session"
+            ]
+        }
+
+    @mcp.tool()
+    def get_pomodoro_stats(days: int = 7) -> Dict[str, Any]:
+        """Get Pomodoro statistics
+
+        Args:
+            days: Number of days to analyze
+        """
+        cutoff_date = datetime.now() - timedelta(days=days)
+        recent_sessions = [
+            s for s in timer.sessions
+            if datetime.fromisoformat(s["start_time"]) > cutoff_date
+        ]
+
+        # Group by subject
+        by_subject = {}
+        for session in recent_sessions:
+            subject = session["subject"]
+            if subject not in by_subject:
+                by_subject[subject] = {
+                    "count": 0,
+                    "total_minutes": 0,
+                    "completed": 0
+                }
+            by_subject[subject]["count"] += 1
+            by_subject[subject]["total_minutes"] += session.get("duration_minutes", 0)
+            if session.get("completed"):
+                by_subject[subject]["completed"] += 1
+
+        # Daily stats
+        by_day = {}
+        for session in recent_sessions:
+            day = datetime.fromisoformat(session["start_time"]).date().isoformat()
+            if day not in by_day:
+                by_day[day] = 0
+            by_day[day] += session.get("duration_minutes", 0)
+
+        return {
+            "status": "success",
+            "period_days": days,
+            "total_sessions": len(recent_sessions),
+            "completed_sessions": sum(1 for s in recent_sessions if s.get("completed")),
+            "total_focus_time": sum(s.get("duration_minutes", 0) for s in recent_sessions),
+            "by_subject": by_subject,
+            "by_day": by_day,
+            "average_per_day": sum(by_day.values()) / max(len(by_day), 1),
+            "most_productive_subject": max(by_subject.items(), key=lambda x: x[1]["total_minutes"])[0] if by_subject else None
+        }
+
+    @mcp.tool()
+    def suggest_break_activity() -> Dict[str, Any]:
+        """Suggest a break activity between Pomodoros"""
+        activities = [
+            {"type": "physical", "activity": "Do 10 jumping jacks", "duration": "1 minute"},
+            {"type": "physical", "activity": "Stretch your arms and neck", "duration": "2 minutes"},
+            {"type": "physical", "activity": "Walk around the room", "duration": "3 minutes"},
+            {"type": "mental", "activity": "Practice deep breathing", "duration": "2 minutes"},
+            {"type": "mental", "activity": "Close your eyes and relax", "duration": "5 minutes"},
+            {"type": "hydration", "activity": "Drink a glass of water", "duration": "1 minute"},
+            {"type": "vision", "activity": "Look at something 20 feet away", "duration": "20 seconds"},
+            {"type": "creative", "activity": "Doodle or sketch", "duration": "5 minutes"},
+        ]
+
+        import random
+        selected = random.choice(activities)
+
+        return {
+            "status": "success",
+            "activity": selected,
+            "benefits": {
+                "physical": "Improves blood circulation and reduces muscle tension",
+                "mental": "Clears your mind and reduces stress",
+                "hydration": "Keeps you hydrated and alert",
+                "vision": "Reduces eye strain from screen time",
+                "creative": "Activates different parts of your brain"
+            }.get(selected["type"], "Helps you recharge"),
+            "next_pomodoro_tips": [
+                "Set a clear goal for the next session",
+                "Remove any new distractions",
+                "Have your materials ready"
+            ]
+        }
+
+def calculate_streak(sessions):
+    """Calculate current study streak in days"""
+    if not sessions:
+        return 0
+
+    # Get unique days with completed sessions
+    study_days = set()
+    for session in sessions:
+        if session.get("completed"):
+            day = datetime.fromisoformat(session["start_time"]).date()
+            study_days.add(day)
+
+    if not study_days:
+        return 0
+
+    # Check for consecutive days
+    sorted_days = sorted(study_days)
+    streak = 1
+    current_streak = 1
+
+    for i in range(1, len(sorted_days)):
+        if (sorted_days[i] - sorted_days[i-1]).days == 1:
+            current_streak += 1
+            streak = max(streak, current_streak)
+        else:
+            current_streak = 1
+
+    # Check if streak is current
+    today = datetime.now().date()
+    yesterday = today - timedelta(days=1)
+    if today not in study_days and yesterday not in study_days:
+        return 0
+
+    return streak
\ No newline at end of file
diff --git a/claude_desktop_config.json b/claude_desktop_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..c5de57e2b14fa1b3a2f733c3cd32f2727cbb0dfe
--- /dev/null
+++ b/claude_desktop_config.json
@@ -0,0 +1,12 @@
+{
+  "mcpServers": {
+    "reuben-os": {
+      "command": "python",
+      "args": ["E:\\mpc-hackathon\\backend\\mcp_server.py"],
+      "env": {
+        "UPLOAD_PASSCODE": "reuben-os-secure-2025",
+        "DATA_DIR": "E:\\mpc-hackathon\\data"
+      }
+    }
+  }
+}
\ No newline at end of file
diff --git a/claude_desktop_test_config.json b/claude_desktop_test_config.json
new file mode 100644
index 0000000000000000000000000000000000000000..ef1c31259c800516c4bf3f5957b27d4150e4e820
--- /dev/null
+++ b/claude_desktop_test_config.json
@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "test-server": {
+      "command": "C:\\Users\\USER\\AppData\\Local\\Microsoft\\WindowsApps\\python.exe",
+      "args": ["E:\\mpc-hackathon\\backend\\simple_mcp_test.py"]
+    }
+  }
+}
\ No newline at end of file
diff --git a/demo_script.py b/demo_script.py
new file mode 100644
index 0000000000000000000000000000000000000000..49f6b13c850c210c4c155e9e13b231b2bc8292b7
--- /dev/null
+++ b/demo_script.py
@@ -0,0 +1,128 @@
+"""
+Automated Demo Script for Hackathon Presentation
+Shows off all features in sequence
+"""
+
+import time
+import requests
+import json
+from datetime import datetime, timedelta
+
+API_URL = "http://localhost:8001"
+
+def print_section(title):
+    """Print a section header"""
+    print("\n" + "="*50)
+    print(f"  {title}")
+    print("="*50)
+    time.sleep(1)
+
+def demo_step(description, endpoint, params=None):
+    """Execute a demo step"""
+    print(f"\n► {description}")
+    time.sleep(1)
+
+    try:
+        if params:
+            response = requests.post(f"{API_URL}{endpoint}", json=params)
+        else:
+            response = requests.get(f"{API_URL}{endpoint}")
+
+        data = response.json()
+        print(f"✓ Response: {json.dumps(data, indent=2)[:200]}...")
+        return data
+    except Exception as e:
+        print(f"✗ Error: {e}")
+        return None
+
+def main():
+    print("\n" + "🎓"*25)
+    print("     EXAM HUB - AI-POWERED STUDY ASSISTANT")
+    print("           MCP Hackathon Demo")
+    print("🎓"*25)
+    time.sleep(2)
+
+    # Section 1: Document Management
+    print_section("1. DOCUMENT MANAGEMENT")
+    demo_step("Listing all documents", "/documents")
+    demo_step("Searching for PDFs", "/execute", {
+        "tool_name": "search_documents",
+        "params": {"query": "exam", "file_type": "pdf"}
+    })
+
+    # Section 2: Exam Calendar
+    print_section("2. EXAM CALENDAR")
+    demo_step("Getting this week's exams", "/exams/week")
+    demo_step("Getting upcoming exams", "/exams/upcoming?days=14")
+
+    # Section 3: AI Study Tools
+    print_section("3. AI-POWERED STUDY TOOLS")
+
+    demo_step("Generating a study plan", "/execute", {
+        "tool_name": "generate_study_plan",
+        "params": {
+            "exam_date": (datetime.now() + timedelta(days=14)).strftime("%Y-%m-%d"),
+            "subjects": ["Mathematics", "Physics", "Chemistry"],
+            "hours_per_day": 3
+        }
+    })
+
+    demo_step("Creating flashcards", "/execute", {
+        "tool_name": "generate_flashcards",
+        "params": {
+            "text": "Photosynthesis is the process by which plants convert light energy into chemical energy. Chlorophyll absorbs light in chloroplasts. Carbon dioxide and water are converted to glucose and oxygen.",
+            "num_cards": 3
+        }
+    })
+
+    demo_step("Generating practice questions", "/execute", {
+        "tool_name": "generate_practice_questions",
+        "params": {
+            "subject": "Biology",
+            "topic": "Cell Division",
+            "difficulty": "medium",
+            "count": 3
+        }
+    })
+
+    # Section 4: Pomodoro Timer
+    print_section("4. POMODORO STUDY TIMER")
+
+    demo_step("Starting a Pomodoro session", "/execute", {
+        "tool_name": "start_pomodoro",
+        "params": {
+            "subject": "Mathematics",
+            "task": "Calculus practice problems",
+            "duration_minutes": 25
+        }
+    })
+
+    demo_step("Getting Pomodoro statistics", "/execute", {
+        "tool_name": "get_pomodoro_stats",
+        "params": {"days": 7}
+    })
+
+    # Section 5: Claude Integration
+    print_section("5. CLAUDE DESKTOP INTEGRATION")
+    print("\n► Claude can now:")
+    print("  • Answer questions about your documents")
+    print("  • Create study schedules automatically")
+    print("  • Generate practice exams")
+    print("  • Track your study progress")
+    print("  • Provide personalized study advice")
+
+    print("\n" + "="*50)
+    print("  Demo Complete! 🎉")
+    print("="*50)
+    print("\nKey Innovations:")
+    print("  ✓ First MCP implementation for education")
+    print("  ✓ Natural language study assistant")
+    print("  ✓ Beautiful Ubuntu-style UI")
+    print("  ✓ 30+ AI-powered tools")
+    print("  ✓ Real-time document analysis")
+
+if __name__ == "__main__":
+    print("\nStarting demo in 3 seconds...")
+    print("Make sure the demo API is running: python backend/demo_api.py")
+    time.sleep(3)
+    main()
\ No newline at end of file
diff --git a/next.config.mjs b/next.config.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..d6035078b75302cbfef06ddd3a517501930a138d
--- /dev/null
+++ b/next.config.mjs
@@ -0,0 +1,10 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  // Empty turbopack config to silence warnings
+  turbopack: {},
+
+  // Transpile specific packages if needed
+  transpilePackages: ['react-pdf'],
+}
+
+export default nextConfig
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index b2013fd6bd9444efb0cc4d6b00ebfd56e802ef81..d328c160eb2462807d0758859142dff2b753e52b 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,9 +8,23 @@
       "name": "mpc-hackathon",
       "version": "0.1.0",
       "dependencies": {
+        "@github/spark": "^0.41.23",
+        "@monaco-editor/react": "^4.7.0",
+        "@phosphor-icons/react": "^2.1.10",
+        "@radix-ui/colors": "^3.0.0",
+        "framer-motion": "^12.23.24",
+        "lucide-react": "^0.553.0",
+        "mammoth": "^1.11.0",
+        "monaco-editor": "^0.54.0",
         "next": "16.0.1",
         "react": "19.2.0",
-        "react-dom": "19.2.0"
+        "react-dom": "19.2.0",
+        "react-draggable": "^4.5.0",
+        "react-error-boundary": "^6.0.0",
+        "react-pdf": "^10.2.0",
+        "react-rnd": "^10.5.2",
+        "tw-animate-css": "^1.4.0",
+        "xlsx": "^0.18.5"
       },
       "devDependencies": {
         "@tailwindcss/postcss": "^4",
@@ -228,6 +242,15 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@babel/runtime": {
+      "version": "7.28.4",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz",
+      "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==",
+      "license": "MIT",
+      "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",
@@ -309,493 +332,678 @@
         "tslib": "^2.4.0"
       }
     },
-    "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.9.0",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz",
-      "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==",
-      "dev": true,
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
+      "cpu": [
+        "ppc64"
+      ],
       "license": "MIT",
-      "dependencies": {
-        "eslint-visitor-keys": "^3.4.3"
-      },
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "peer": true,
       "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": ">=18"
       }
     },
-    "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,
-      "license": "Apache-2.0",
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "peer": true,
       "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
+        "node": ">=18"
       }
     },
-    "node_modules/@eslint-community/regexpp": {
-      "version": "4.12.2",
-      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
-      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
-      "dev": true,
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
+      "cpu": [
+        "arm64"
+      ],
       "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "peer": true,
       "engines": {
-        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+        "node": ">=18"
       }
     },
-    "node_modules/@eslint/config-array": {
-      "version": "0.21.1",
-      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz",
-      "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/object-schema": "^2.1.7",
-        "debug": "^4.3.1",
-        "minimatch": "^3.1.2"
-      },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "peer": true,
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=18"
       }
     },
-    "node_modules/@eslint/config-helpers": {
-      "version": "0.4.2",
-      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
-      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/core": "^0.17.0"
-      },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "peer": true,
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=18"
       }
     },
-    "node_modules/@eslint/core": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
-      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@types/json-schema": "^7.0.15"
-      },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "peer": true,
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=18"
       }
     },
-    "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,
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
+      "cpu": [
+        "arm64"
+      ],
       "license": "MIT",
-      "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"
-      },
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "peer": true,
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
+        "node": ">=18"
       }
     },
-    "node_modules/@eslint/js": {
-      "version": "9.39.1",
-      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.1.tgz",
-      "integrity": "sha512-S26Stp4zCy88tH94QbBv3XCuzRQiZ9yXofEILmglYTh/Ug/a9/umqvgFtYBAo3Lp0nsI/5/qH1CCrbdK3AP1Tw==",
-      "dev": true,
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
+      "cpu": [
+        "x64"
+      ],
       "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "peer": true,
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
-      },
-      "funding": {
-        "url": "https://eslint.org/donate"
+        "node": ">=18"
       }
     },
-    "node_modules/@eslint/object-schema": {
-      "version": "2.1.7",
-      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
-      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
-      "dev": true,
-      "license": "Apache-2.0",
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=18"
       }
     },
-    "node_modules/@eslint/plugin-kit": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
-      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@eslint/core": "^0.17.0",
-        "levn": "^0.4.1"
-      },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
       "engines": {
-        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+        "node": ">=18"
       }
     },
-    "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,
-      "license": "Apache-2.0",
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
       "engines": {
-        "node": ">=18.18.0"
+        "node": ">=18"
       }
     },
-    "node_modules/@humanfs/node": {
-      "version": "0.16.7",
-      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
-      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
-      "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@humanfs/core": "^0.19.1",
-        "@humanwhocodes/retry": "^0.4.0"
-      },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
       "engines": {
-        "node": ">=18.18.0"
+        "node": ">=18"
       }
     },
-    "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,
-      "license": "Apache-2.0",
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true,
       "engines": {
-        "node": ">=12.22"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
+        "node": ">=18"
       }
     },
-    "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,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18.18"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/nzakas"
-      }
-    },
-    "node_modules/@img/colour": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.0.0.tgz",
-      "integrity": "sha512-A5P/LfWGFSl6nsckYtjw9da+19jB8hkJ6ACTGcDfEJ0aE+l2n2El7dsVM7UVHZQ9s2lmYMWlrS21YLy2IR1LUw==",
-      "license": "MIT",
-      "optional": true,
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/@img/sharp-darwin-arm64": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.34.5.tgz",
-      "integrity": "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==",
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
       "cpu": [
-        "arm64"
+        "ppc64"
       ],
-      "license": "Apache-2.0",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "darwin"
+        "linux"
       ],
+      "peer": true,
       "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-darwin-arm64": "1.2.4"
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-darwin-x64": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.34.5.tgz",
-      "integrity": "sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==",
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
       "cpu": [
-        "x64"
+        "riscv64"
       ],
-      "license": "Apache-2.0",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "darwin"
+        "linux"
       ],
+      "peer": true,
       "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-darwin-x64": "1.2.4"
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-libvips-darwin-arm64": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.2.4.tgz",
-      "integrity": "sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==",
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
       "cpu": [
-        "arm64"
+        "s390x"
       ],
-      "license": "LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "darwin"
+        "linux"
       ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peer": true,
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-libvips-darwin-x64": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.2.4.tgz",
-      "integrity": "sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==",
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
       "cpu": [
         "x64"
       ],
-      "license": "LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "darwin"
+        "linux"
       ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peer": true,
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-libvips-linux-arm": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.2.4.tgz",
-      "integrity": "sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==",
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
       "cpu": [
-        "arm"
+        "arm64"
       ],
-      "license": "LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "netbsd"
       ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peer": true,
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-libvips-linux-arm64": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.2.4.tgz",
-      "integrity": "sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==",
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
       "cpu": [
-        "arm64"
+        "x64"
       ],
-      "license": "LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "netbsd"
       ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peer": true,
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-libvips-linux-ppc64": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.2.4.tgz",
-      "integrity": "sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==",
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
       "cpu": [
-        "ppc64"
+        "arm64"
       ],
-      "license": "LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "openbsd"
       ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peer": true,
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-libvips-linux-riscv64": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.2.4.tgz",
-      "integrity": "sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==",
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
       "cpu": [
-        "riscv64"
+        "x64"
       ],
-      "license": "LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "openbsd"
       ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peer": true,
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-libvips-linux-s390x": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.2.4.tgz",
-      "integrity": "sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==",
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
       "cpu": [
-        "s390x"
+        "arm64"
       ],
-      "license": "LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "openharmony"
       ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peer": true,
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-libvips-linux-x64": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.2.4.tgz",
-      "integrity": "sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==",
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
       "cpu": [
         "x64"
       ],
-      "license": "LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "sunos"
       ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peer": true,
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-libvips-linuxmusl-arm64": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.2.4.tgz",
-      "integrity": "sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==",
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
       "cpu": [
         "arm64"
       ],
-      "license": "LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "win32"
       ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peer": true,
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-libvips-linuxmusl-x64": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.2.4.tgz",
-      "integrity": "sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==",
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
       "cpu": [
-        "x64"
+        "ia32"
       ],
-      "license": "LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "win32"
       ],
-      "funding": {
-        "url": "https://opencollective.com/libvips"
+      "peer": true,
+      "engines": {
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-linux-arm": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.34.5.tgz",
-      "integrity": "sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==",
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
       "cpu": [
-        "arm"
+        "x64"
       ],
-      "license": "Apache-2.0",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "win32"
       ],
+      "peer": true,
       "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-arm": "1.2.4"
+        "node": ">=18"
       }
     },
-    "node_modules/@img/sharp-linux-arm64": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.34.5.tgz",
-      "integrity": "sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.9.0",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz",
+      "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
       "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
       },
       "funding": {
-        "url": "https://opencollective.com/libvips"
+        "url": "https://opencollective.com/eslint"
       },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-arm64": "1.2.4"
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
       }
     },
-    "node_modules/@img/sharp-linux-ppc64": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.34.5.tgz",
-      "integrity": "sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==",
-      "cpu": [
-        "ppc64"
-      ],
+    "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,
       "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
       "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
       },
       "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-ppc64": "1.2.4"
+        "url": "https://opencollective.com/eslint"
       }
     },
-    "node_modules/@img/sharp-linux-riscv64": {
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.2",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/config-array": {
+      "version": "0.21.1",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.1.tgz",
+      "integrity": "sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/object-schema": "^2.1.7",
+        "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.4.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
+      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/core": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
+      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "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,
+      "license": "MIT",
+      "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/js": {
+      "version": "9.39.1",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.1.tgz",
+      "integrity": "sha512-S26Stp4zCy88tH94QbBv3XCuzRQiZ9yXofEILmglYTh/Ug/a9/umqvgFtYBAo3Lp0nsI/5/qH1CCrbdK3AP1Tw==",
+      "dev": true,
+      "license": "MIT",
+      "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.7",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
+      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
+      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@github/spark": {
+      "version": "0.41.23",
+      "resolved": "https://registry.npmjs.org/@github/spark/-/spark-0.41.23.tgz",
+      "integrity": "sha512-jC7KNRL/V0wO72Cfp/GgsHT2OsHOzX7AV6IxQM+q39O4DhvRIu9N9E9WTygSCJa6tvXHLDTPSBu5D6pa2PuxZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "octokit": "^5.0.3"
+      },
+      "peerDependencies": {
+        "react": "^19.0.0",
+        "vite": "^6.2.0"
+      }
+    },
+    "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,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.7",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz",
+      "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/core": "^0.19.1",
+        "@humanwhocodes/retry": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "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,
+      "license": "Apache-2.0",
+      "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,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@img/colour": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.0.0.tgz",
+      "integrity": "sha512-A5P/LfWGFSl6nsckYtjw9da+19jB8hkJ6ACTGcDfEJ0aE+l2n2El7dsVM7UVHZQ9s2lmYMWlrS21YLy2IR1LUw==",
+      "license": "MIT",
+      "optional": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@img/sharp-darwin-arm64": {
       "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.34.5.tgz",
-      "integrity": "sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.34.5.tgz",
+      "integrity": "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==",
       "cpu": [
-        "riscv64"
+        "arm64"
       ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
-        "linux"
+        "darwin"
       ],
       "engines": {
         "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
@@ -804,20 +1012,20 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-riscv64": "1.2.4"
+        "@img/sharp-libvips-darwin-arm64": "1.2.4"
       }
     },
-    "node_modules/@img/sharp-linux-s390x": {
+    "node_modules/@img/sharp-darwin-x64": {
       "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.34.5.tgz",
-      "integrity": "sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.34.5.tgz",
+      "integrity": "sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==",
       "cpu": [
-        "s390x"
+        "x64"
       ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
-        "linux"
+        "darwin"
       ],
       "engines": {
         "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
@@ -826,346 +1034,1542 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-s390x": "1.2.4"
+        "@img/sharp-libvips-darwin-x64": "1.2.4"
       }
     },
-    "node_modules/@img/sharp-linux-x64": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.34.5.tgz",
-      "integrity": "sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==",
+    "node_modules/@img/sharp-libvips-darwin-arm64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.2.4.tgz",
+      "integrity": "sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-x64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.2.4.tgz",
+      "integrity": "sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.2.4.tgz",
+      "integrity": "sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.2.4.tgz",
+      "integrity": "sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-ppc64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.2.4.tgz",
+      "integrity": "sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-riscv64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.2.4.tgz",
+      "integrity": "sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-s390x": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.2.4.tgz",
+      "integrity": "sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-x64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.2.4.tgz",
+      "integrity": "sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-arm64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.2.4.tgz",
+      "integrity": "sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-x64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.2.4.tgz",
+      "integrity": "sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.34.5.tgz",
+      "integrity": "sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.34.5.tgz",
+      "integrity": "sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-ppc64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.34.5.tgz",
+      "integrity": "sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-ppc64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-riscv64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.34.5.tgz",
+      "integrity": "sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-riscv64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-s390x": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.34.5.tgz",
+      "integrity": "sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-s390x": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.34.5.tgz",
+      "integrity": "sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-x64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.34.5.tgz",
+      "integrity": "sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-arm64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.34.5.tgz",
+      "integrity": "sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-x64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-wasm32": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.34.5.tgz",
+      "integrity": "sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==",
+      "cpu": [
+        "wasm32"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/runtime": "^1.7.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.34.5.tgz",
+      "integrity": "sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-ia32": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.34.5.tgz",
+      "integrity": "sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.34.5.tgz",
+      "integrity": "sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "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==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@monaco-editor/loader": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@monaco-editor/loader/-/loader-1.6.1.tgz",
+      "integrity": "sha512-w3tEnj9HYEC73wtjdpR089AqkUPskFRcdkxsiSFt3SoUc3OHpmu+leP94CXBm4mHfefmhsdfI0ZQu6qJ0wgtPg==",
+      "license": "MIT",
+      "dependencies": {
+        "state-local": "^1.0.6"
+      }
+    },
+    "node_modules/@monaco-editor/react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@monaco-editor/react/-/react-4.7.0.tgz",
+      "integrity": "sha512-cyzXQCtO47ydzxpQtCGSQGOC8Gk3ZUeBXFAxD+CWXYFo5OqZyZUonFl0DwUlTyAfRHntBfw2p3w4s9R6oe1eCA==",
+      "license": "MIT",
+      "dependencies": {
+        "@monaco-editor/loader": "^1.5.0"
+      },
+      "peerDependencies": {
+        "monaco-editor": ">= 0.25.0 < 1",
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/@napi-rs/canvas": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas/-/canvas-0.1.81.tgz",
+      "integrity": "sha512-ReCjd5SYI/UKx/olaQLC4GtN6wUQGjlgHXs1lvUvWGXfBMR3Fxnik3cL+OxKN5ithNdoU0/GlCrdKcQDFh2XKQ==",
+      "license": "MIT",
+      "optional": true,
+      "workspaces": [
+        "e2e/*"
+      ],
+      "engines": {
+        "node": ">= 10"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas-android-arm64": "0.1.81",
+        "@napi-rs/canvas-darwin-arm64": "0.1.81",
+        "@napi-rs/canvas-darwin-x64": "0.1.81",
+        "@napi-rs/canvas-linux-arm-gnueabihf": "0.1.81",
+        "@napi-rs/canvas-linux-arm64-gnu": "0.1.81",
+        "@napi-rs/canvas-linux-arm64-musl": "0.1.81",
+        "@napi-rs/canvas-linux-riscv64-gnu": "0.1.81",
+        "@napi-rs/canvas-linux-x64-gnu": "0.1.81",
+        "@napi-rs/canvas-linux-x64-musl": "0.1.81",
+        "@napi-rs/canvas-win32-x64-msvc": "0.1.81"
+      }
+    },
+    "node_modules/@napi-rs/canvas-android-arm64": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-android-arm64/-/canvas-android-arm64-0.1.81.tgz",
+      "integrity": "sha512-78Lz+AUi+MsWupyZjXwpwQrp1QCwncPvRZrdvrROcZ9Gq9grP7LfQZiGdR8LKyHIq3OR18mDP+JESGT15V1nXw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-arm64": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-darwin-arm64/-/canvas-darwin-arm64-0.1.81.tgz",
+      "integrity": "sha512-omejuKgHWKDGoh8rsgsyhm/whwxMaryTQjJTd9zD7hiB9/rzcEEJLHnzXWR5ysy4/tTjHaQotE6k2t8eodTLnA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@napi-rs/canvas-darwin-x64": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-darwin-x64/-/canvas-darwin-x64-0.1.81.tgz",
+      "integrity": "sha512-EYfk+co6BElq5DXNH9PBLYDYwc4QsvIVbyrsVHsxVpn4p6Y3/s8MChgC69AGqj3vzZBQ1qx2CRCMtg5cub+XuQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm-gnueabihf": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm-gnueabihf/-/canvas-linux-arm-gnueabihf-0.1.81.tgz",
+      "integrity": "sha512-teh6Q74CyAcH31yLNQGR9MtXSFxlZa5CI6vvNUISI14gWIJWrhOwUAOly+KRe1aztWR0FWTVSPxM4p5y+06aow==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-gnu": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm64-gnu/-/canvas-linux-arm64-gnu-0.1.81.tgz",
+      "integrity": "sha512-AGEopHFYRzJOjxY+2G1RmHPRnuWvO3Qdhq7sIazlSjxb3Z6dZHg7OB/4ZimXaimPjDACm9qWa6t5bn9bhXvkcw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-arm64-musl": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-arm64-musl/-/canvas-linux-arm64-musl-0.1.81.tgz",
+      "integrity": "sha512-Bj3m1cl4GIhsigkdwOxii4g4Ump3/QhNpx85IgAlCCYXpaly6mcsWpuDYEabfIGWOWhDUNBOndaQUPfWK1czOQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-riscv64-gnu": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-riscv64-gnu/-/canvas-linux-riscv64-gnu-0.1.81.tgz",
+      "integrity": "sha512-yg/5NkHykVdwPlD3XObwCa/EswkOwLHswJcI9rHrac+znHsmCSj5AMX/RTU9Z9F6lZTwL60JM2Esit33XhAMiw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-gnu": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-gnu/-/canvas-linux-x64-gnu-0.1.81.tgz",
+      "integrity": "sha512-tPfMpSEBuV5dJSKexO/UZxpOqnYTaNbG8aKa1ek8QsWu+4SJ/foWkaxscra/RUv85vepx6WWDjzBNbNJsTnO0w==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@napi-rs/canvas-linux-x64-musl": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-linux-x64-musl/-/canvas-linux-x64-musl-0.1.81.tgz",
+      "integrity": "sha512-1L0xnYgzqn8Baef+inPvY4dKqdmw3KCBoe0NEDgezuBZN7MA5xElwifoG8609uNdrMtJ9J6QZarsslLRVqri7g==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@napi-rs/canvas-win32-x64-msvc": {
+      "version": "0.1.81",
+      "resolved": "https://registry.npmjs.org/@napi-rs/canvas-win32-x64-msvc/-/canvas-win32-x64-msvc-0.1.81.tgz",
+      "integrity": "sha512-57ryVbhm/z7RE9/UVcS7mrLPdlayLesy+9U0Uf6epCoeSGrs99tfieCcgZWFbIgmByQ1AZnNtFI2N6huqDLlWQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "0.2.12",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
+      "integrity": "sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "^1.4.3",
+        "@emnapi/runtime": "^1.4.3",
+        "@tybys/wasm-util": "^0.10.0"
+      }
+    },
+    "node_modules/@next/env": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/@next/env/-/env-16.0.1.tgz",
+      "integrity": "sha512-LFvlK0TG2L3fEOX77OC35KowL8D7DlFF45C0OvKMC4hy8c/md1RC4UMNDlUGJqfCoCS2VWrZ4dSE6OjaX5+8mw==",
+      "license": "MIT"
+    },
+    "node_modules/@next/eslint-plugin-next": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/@next/eslint-plugin-next/-/eslint-plugin-next-16.0.1.tgz",
+      "integrity": "sha512-g4Cqmv/gyFEXNeVB2HkqDlYKfy+YrlM2k8AVIO/YQVEPfhVruH1VA99uT1zELLnPLIeOnx8IZ6Ddso0asfTIdw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-glob": "3.3.1"
+      }
+    },
+    "node_modules/@next/swc-darwin-arm64": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-16.0.1.tgz",
+      "integrity": "sha512-R0YxRp6/4W7yG1nKbfu41bp3d96a0EalonQXiMe+1H9GTHfKxGNCGFNWUho18avRBPsO8T3RmdWuzmfurlQPbg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@next/swc-darwin-x64": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.0.1.tgz",
+      "integrity": "sha512-kETZBocRux3xITiZtOtVoVvXyQLB7VBxN7L6EPqgI5paZiUlnsgYv4q8diTNYeHmF9EiehydOBo20lTttCbHAg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@next/swc-linux-arm64-gnu": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-16.0.1.tgz",
+      "integrity": "sha512-hWg3BtsxQuSKhfe0LunJoqxjO4NEpBmKkE+P2Sroos7yB//OOX3jD5ISP2wv8QdUwtRehMdwYz6VB50mY6hqAg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@next/swc-linux-arm64-musl": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-16.0.1.tgz",
+      "integrity": "sha512-UPnOvYg+fjAhP3b1iQStcYPWeBFRLrugEyK/lDKGk7kLNua8t5/DvDbAEFotfV1YfcOY6bru76qN9qnjLoyHCQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@next/swc-linux-x64-gnu": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-16.0.1.tgz",
+      "integrity": "sha512-Et81SdWkcRqAJziIgFtsFyJizHoWne4fzJkvjd6V4wEkWTB4MX6J0uByUb0peiJQ4WeAt6GGmMszE5KrXK6WKg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@next/swc-linux-x64-musl": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-16.0.1.tgz",
+      "integrity": "sha512-qBbgYEBRrC1egcG03FZaVfVxrJm8wBl7vr8UFKplnxNRprctdP26xEv9nJ07Ggq4y1adwa0nz2mz83CELY7N6Q==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@next/swc-win32-arm64-msvc": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-16.0.1.tgz",
+      "integrity": "sha512-cPuBjYP6I699/RdbHJonb3BiRNEDm5CKEBuJ6SD8k3oLam2fDRMKAvmrli4QMDgT2ixyRJ0+DTkiODbIQhRkeQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@next/swc-win32-x64-msvc": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-16.0.1.tgz",
+      "integrity": "sha512-XeEUJsE4JYtfrXe/LaJn3z1pD19fK0Q6Er8Qoufi+HqvdO4LEPyCxLUt4rxA+4RfYo6S9gMlmzCMU2F+AatFqQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nolyfill/is-core-module": {
+      "version": "1.0.39",
+      "resolved": "https://registry.npmjs.org/@nolyfill/is-core-module/-/is-core-module-1.0.39.tgz",
+      "integrity": "sha512-nn5ozdjYQpUCZlWGuxcJY/KpxkWQs4DcbMCmKojjyrYDEAGy4Ce19NN4v5MduafTwJlbKc99UA8YhSVqq9yPZA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.4.0"
+      }
+    },
+    "node_modules/@octokit/app": {
+      "version": "16.1.2",
+      "resolved": "https://registry.npmjs.org/@octokit/app/-/app-16.1.2.tgz",
+      "integrity": "sha512-8j7sEpUYVj18dxvh0KWj6W/l6uAiVRBl1JBDVRqH1VHKAO/G5eRVl4yEoYACjakWers1DjUkcCHyJNQK47JqyQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/auth-app": "^8.1.2",
+        "@octokit/auth-unauthenticated": "^7.0.3",
+        "@octokit/core": "^7.0.6",
+        "@octokit/oauth-app": "^8.0.3",
+        "@octokit/plugin-paginate-rest": "^14.0.0",
+        "@octokit/types": "^16.0.0",
+        "@octokit/webhooks": "^14.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/auth-app": {
+      "version": "8.1.2",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-app/-/auth-app-8.1.2.tgz",
+      "integrity": "sha512-db8VO0PqXxfzI6GdjtgEFHY9tzqUql5xMFXYA12juq8TeTgPAuiiP3zid4h50lwlIP457p5+56PnJOgd2GGBuw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/auth-oauth-app": "^9.0.3",
+        "@octokit/auth-oauth-user": "^6.0.2",
+        "@octokit/request": "^10.0.6",
+        "@octokit/request-error": "^7.0.2",
+        "@octokit/types": "^16.0.0",
+        "toad-cache": "^3.7.0",
+        "universal-github-app-jwt": "^2.2.0",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/auth-oauth-app": {
+      "version": "9.0.3",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-oauth-app/-/auth-oauth-app-9.0.3.tgz",
+      "integrity": "sha512-+yoFQquaF8OxJSxTb7rnytBIC2ZLbLqA/yb71I4ZXT9+Slw4TziV9j/kyGhUFRRTF2+7WlnIWsePZCWHs+OGjg==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/auth-oauth-device": "^8.0.3",
+        "@octokit/auth-oauth-user": "^6.0.2",
+        "@octokit/request": "^10.0.6",
+        "@octokit/types": "^16.0.0",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/auth-oauth-device": {
+      "version": "8.0.3",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-oauth-device/-/auth-oauth-device-8.0.3.tgz",
+      "integrity": "sha512-zh2W0mKKMh/VWZhSqlaCzY7qFyrgd9oTWmTmHaXnHNeQRCZr/CXy2jCgHo4e4dJVTiuxP5dLa0YM5p5QVhJHbw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/oauth-methods": "^6.0.2",
+        "@octokit/request": "^10.0.6",
+        "@octokit/types": "^16.0.0",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/auth-oauth-user": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-oauth-user/-/auth-oauth-user-6.0.2.tgz",
+      "integrity": "sha512-qLoPPc6E6GJoz3XeDG/pnDhJpTkODTGG4kY0/Py154i/I003O9NazkrwJwRuzgCalhzyIeWQ+6MDvkUmKXjg/A==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/auth-oauth-device": "^8.0.3",
+        "@octokit/oauth-methods": "^6.0.2",
+        "@octokit/request": "^10.0.6",
+        "@octokit/types": "^16.0.0",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/auth-token": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-6.0.0.tgz",
+      "integrity": "sha512-P4YJBPdPSpWTQ1NU4XYdvHvXJJDxM6YwpS0FZHRgP7YFkdVxsWcpWGy/NVqlAA7PcPCnMacXlRm1y2PFZRWL/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/auth-unauthenticated": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-unauthenticated/-/auth-unauthenticated-7.0.3.tgz",
+      "integrity": "sha512-8Jb1mtUdmBHL7lGmop9mU9ArMRUTRhg8vp0T1VtZ4yd9vEm3zcLwmjQkhNEduKawOOORie61xhtYIhTDN+ZQ3g==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/request-error": "^7.0.2",
+        "@octokit/types": "^16.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/core": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-7.0.6.tgz",
+      "integrity": "sha512-DhGl4xMVFGVIyMwswXeyzdL4uXD5OGILGX5N8Y+f6W7LhC1Ze2poSNrkF/fedpVDHEEZ+PHFW0vL14I+mm8K3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/auth-token": "^6.0.0",
+        "@octokit/graphql": "^9.0.3",
+        "@octokit/request": "^10.0.6",
+        "@octokit/request-error": "^7.0.2",
+        "@octokit/types": "^16.0.0",
+        "before-after-hook": "^4.0.0",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/endpoint": {
+      "version": "11.0.2",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-11.0.2.tgz",
+      "integrity": "sha512-4zCpzP1fWc7QlqunZ5bSEjxc6yLAlRTnDwKtgXfcI/FxxGoqedDG8V2+xJ60bV2kODqcGB+nATdtap/XYq2NZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^16.0.0",
+        "universal-user-agent": "^7.0.2"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/graphql": {
+      "version": "9.0.3",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-9.0.3.tgz",
+      "integrity": "sha512-grAEuupr/C1rALFnXTv6ZQhFuL1D8G5y8CN04RgrO4FIPMrtm+mcZzFG7dcBm+nq+1ppNixu+Jd78aeJOYxlGA==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/request": "^10.0.6",
+        "@octokit/types": "^16.0.0",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/oauth-app": {
+      "version": "8.0.3",
+      "resolved": "https://registry.npmjs.org/@octokit/oauth-app/-/oauth-app-8.0.3.tgz",
+      "integrity": "sha512-jnAjvTsPepyUaMu9e69hYBuozEPgYqP4Z3UnpmvoIzHDpf8EXDGvTY1l1jK0RsZ194oRd+k6Hm13oRU8EoDFwg==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/auth-oauth-app": "^9.0.2",
+        "@octokit/auth-oauth-user": "^6.0.1",
+        "@octokit/auth-unauthenticated": "^7.0.2",
+        "@octokit/core": "^7.0.5",
+        "@octokit/oauth-authorization-url": "^8.0.0",
+        "@octokit/oauth-methods": "^6.0.1",
+        "@types/aws-lambda": "^8.10.83",
+        "universal-user-agent": "^7.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/oauth-authorization-url": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/oauth-authorization-url/-/oauth-authorization-url-8.0.0.tgz",
+      "integrity": "sha512-7QoLPRh/ssEA/HuHBHdVdSgF8xNLz/Bc5m9fZkArJE5bb6NmVkDm3anKxXPmN1zh6b5WKZPRr3697xKT/yM3qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/oauth-methods": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@octokit/oauth-methods/-/oauth-methods-6.0.2.tgz",
+      "integrity": "sha512-HiNOO3MqLxlt5Da5bZbLV8Zarnphi4y9XehrbaFMkcoJ+FL7sMxH/UlUsCVxpddVu4qvNDrBdaTVE2o4ITK8ng==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/oauth-authorization-url": "^8.0.0",
+        "@octokit/request": "^10.0.6",
+        "@octokit/request-error": "^7.0.2",
+        "@octokit/types": "^16.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/openapi-types": {
+      "version": "27.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-27.0.0.tgz",
+      "integrity": "sha512-whrdktVs1h6gtR+09+QsNk2+FO+49j6ga1c55YZudfEG+oKJVvJLQi3zkOm5JjiUXAagWK2tI2kTGKJ2Ys7MGA==",
+      "license": "MIT"
+    },
+    "node_modules/@octokit/openapi-webhooks-types": {
+      "version": "12.0.3",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-webhooks-types/-/openapi-webhooks-types-12.0.3.tgz",
+      "integrity": "sha512-90MF5LVHjBedwoHyJsgmaFhEN1uzXyBDRLEBe7jlTYx/fEhPAk3P3DAJsfZwC54m8hAIryosJOL+UuZHB3K3yA==",
+      "license": "MIT"
+    },
+    "node_modules/@octokit/plugin-paginate-graphql": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-graphql/-/plugin-paginate-graphql-6.0.0.tgz",
+      "integrity": "sha512-crfpnIoFiBtRkvPqOyLOsw12XsveYuY2ieP6uYDosoUegBJpSVxGwut9sxUgFFcll3VTOTqpUf8yGd8x1OmAkQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=6"
+      }
+    },
+    "node_modules/@octokit/plugin-paginate-rest": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-14.0.0.tgz",
+      "integrity": "sha512-fNVRE7ufJiAA3XUrha2omTA39M6IXIc6GIZLvlbsm8QOQCYvpq/LkMNGyFlB1d8hTDzsAXa3OKtybdMAYsV/fw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^16.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=6"
+      }
+    },
+    "node_modules/@octokit/plugin-rest-endpoint-methods": {
+      "version": "17.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-17.0.0.tgz",
+      "integrity": "sha512-B5yCyIlOJFPqUUeiD0cnBJwWJO8lkJs5d8+ze9QDP6SvfiXSz1BF+91+0MeI1d2yxgOhU/O+CvtiZ9jSkHhFAw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^16.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=6"
+      }
+    },
+    "node_modules/@octokit/plugin-retry": {
+      "version": "8.0.3",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-retry/-/plugin-retry-8.0.3.tgz",
+      "integrity": "sha512-vKGx1i3MC0za53IzYBSBXcrhmd+daQDzuZfYDd52X5S0M2otf3kVZTVP8bLA3EkU0lTvd1WEC2OlNNa4G+dohA==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/request-error": "^7.0.2",
+        "@octokit/types": "^16.0.0",
+        "bottleneck": "^2.15.3"
+      },
+      "engines": {
+        "node": ">= 20"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=7"
+      }
+    },
+    "node_modules/@octokit/plugin-throttling": {
+      "version": "11.0.3",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-throttling/-/plugin-throttling-11.0.3.tgz",
+      "integrity": "sha512-34eE0RkFCKycLl2D2kq7W+LovheM/ex3AwZCYN8udpi6bxsyjZidb2McXs69hZhLmJlDqTSP8cH+jSRpiaijBg==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^16.0.0",
+        "bottleneck": "^2.15.3"
+      },
+      "engines": {
+        "node": ">= 20"
+      },
+      "peerDependencies": {
+        "@octokit/core": "^7.0.0"
+      }
+    },
+    "node_modules/@octokit/request": {
+      "version": "10.0.6",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-10.0.6.tgz",
+      "integrity": "sha512-FO+UgZCUu+pPnZAR+iKdUt64kPE7QW7ciqpldaMXaNzixz5Jld8dJ31LAUewk0cfSRkNSRKyqG438ba9c/qDlQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/endpoint": "^11.0.2",
+        "@octokit/request-error": "^7.0.2",
+        "@octokit/types": "^16.0.0",
+        "fast-content-type-parse": "^3.0.0",
+        "universal-user-agent": "^7.0.2"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/request-error": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-7.0.2.tgz",
+      "integrity": "sha512-U8piOROoQQUyExw5c6dTkU3GKxts5/ERRThIauNL7yaRoeXW0q/5bgHWT7JfWBw1UyrbK8ERId2wVkcB32n0uQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/types": "^16.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/types": {
+      "version": "16.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-16.0.0.tgz",
+      "integrity": "sha512-sKq+9r1Mm4efXW1FCk7hFSeJo4QKreL/tTbR0rz/qx/r1Oa2VV83LTA/H/MuCOX7uCIJmQVRKBcbmWoySjAnSg==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/openapi-types": "^27.0.0"
+      }
+    },
+    "node_modules/@octokit/webhooks": {
+      "version": "14.1.3",
+      "resolved": "https://registry.npmjs.org/@octokit/webhooks/-/webhooks-14.1.3.tgz",
+      "integrity": "sha512-gcK4FNaROM9NjA0mvyfXl0KPusk7a1BeA8ITlYEZVQCXF5gcETTd4yhAU0Kjzd8mXwYHppzJBWgdBVpIR9wUcQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/openapi-webhooks-types": "12.0.3",
+        "@octokit/request-error": "^7.0.0",
+        "@octokit/webhooks-methods": "^6.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@octokit/webhooks-methods": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/webhooks-methods/-/webhooks-methods-6.0.0.tgz",
+      "integrity": "sha512-MFlzzoDJVw/GcbfzVC1RLR36QqkTLUf79vLVO3D+xn7r0QgxnFoLZgtrzxiQErAjFUOdH6fas2KeQJ1yr/qaXQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/@phosphor-icons/react": {
+      "version": "2.1.10",
+      "resolved": "https://registry.npmjs.org/@phosphor-icons/react/-/react-2.1.10.tgz",
+      "integrity": "sha512-vt8Tvq8GLjheAZZYa+YG/pW7HDbov8El/MANW8pOAz4eGxrwhnbfrQZq0Cp4q8zBEu8NIhHdnr+r8thnfRSNYA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "peerDependencies": {
+        "react": ">= 16.8",
+        "react-dom": ">= 16.8"
+      }
+    },
+    "node_modules/@radix-ui/colors": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@radix-ui/colors/-/colors-3.0.0.tgz",
+      "integrity": "sha512-FUOsGBkHrYJwCSEtWRCIfQbZG7q1e6DgxCIOe1SUQzDe/7rXXeA47s8yCn6fuTNQAj1Zq4oTFi9Yjp3wzElcxg==",
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.53.1.tgz",
+      "integrity": "sha512-bxZtughE4VNVJlL1RdoSE545kc4JxL7op57KKoi59/gwuU5rV6jLWFXXc8jwgFoT6vtj+ZjO+Z2C5nrY0Cl6wA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "peer": true
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.53.1.tgz",
+      "integrity": "sha512-44a1hreb02cAAfAKmZfXVercPFaDjqXCK+iKeVOlJ9ltvnO6QqsBHgKVPTu+MJHSLLeMEUbeG2qiDYgbFPU48g==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "peer": true
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.53.1.tgz",
+      "integrity": "sha512-usmzIgD0rf1syoOZ2WZvy8YpXK5G1V3btm3QZddoGSa6mOgfXWkkv+642bfUUldomgrbiLQGrPryb7DXLovPWQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "peer": true
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.53.1.tgz",
+      "integrity": "sha512-is3r/k4vig2Gt8mKtTlzzyaSQ+hd87kDxiN3uDSDwggJLUV56Umli6OoL+/YZa/KvtdrdyNfMKHzL/P4siOOmg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "peer": true
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.53.1.tgz",
+      "integrity": "sha512-QJ1ksgp/bDJkZB4daldVmHaEQkG4r8PUXitCOC2WRmRaSaHx5RwPoI3DHVfXKwDkB+Sk6auFI/+JHacTekPRSw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "peer": true
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.53.1.tgz",
+      "integrity": "sha512-J6ma5xgAzvqsnU6a0+jgGX/gvoGokqpkx6zY4cWizRrm0ffhHDpJKQgC8dtDb3+MqfZDIqs64REbfHDMzxLMqQ==",
       "cpu": [
         "x64"
       ],
-      "license": "Apache-2.0",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "freebsd"
       ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linux-x64": "1.2.4"
-      }
+      "peer": true
     },
-    "node_modules/@img/sharp-linuxmusl-arm64": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.34.5.tgz",
-      "integrity": "sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==",
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.53.1.tgz",
+      "integrity": "sha512-JzWRR41o2U3/KMNKRuZNsDUAcAVUYhsPuMlx5RUldw0E4lvSIXFUwejtYz1HJXohUmqs/M6BBJAUBzKXZVddbg==",
       "cpu": [
-        "arm64"
+        "arm"
       ],
-      "license": "Apache-2.0",
+      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linuxmusl-arm64": "1.2.4"
-      }
+      "peer": true
     },
-    "node_modules/@img/sharp-linuxmusl-x64": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.34.5.tgz",
-      "integrity": "sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==",
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.53.1.tgz",
+      "integrity": "sha512-L8kRIrnfMrEoHLHtHn+4uYA52fiLDEDyezgxZtGUTiII/yb04Krq+vk3P2Try+Vya9LeCE9ZHU8CXD6J9EhzHQ==",
       "cpu": [
-        "x64"
+        "arm"
       ],
-      "license": "Apache-2.0",
+      "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      },
-      "optionalDependencies": {
-        "@img/sharp-libvips-linuxmusl-x64": "1.2.4"
-      }
+      "peer": true
     },
-    "node_modules/@img/sharp-wasm32": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.34.5.tgz",
-      "integrity": "sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==",
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.53.1.tgz",
+      "integrity": "sha512-ysAc0MFRV+WtQ8li8hi3EoFi7us6d1UzaS/+Dp7FYZfg3NdDljGMoVyiIp6Ucz7uhlYDBZ/zt6XI0YEZbUO11Q==",
       "cpu": [
-        "wasm32"
+        "arm64"
       ],
-      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
+      "license": "MIT",
       "optional": true,
-      "dependencies": {
-        "@emnapi/runtime": "^1.7.0"
-      },
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
+      "os": [
+        "linux"
+      ],
+      "peer": true
     },
-    "node_modules/@img/sharp-win32-arm64": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.34.5.tgz",
-      "integrity": "sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==",
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.53.1.tgz",
+      "integrity": "sha512-UV6l9MJpDbDZZ/fJvqNcvO1PcivGEf1AvKuTcHoLjVZVFeAMygnamCTDikCVMRnA+qJe+B3pSbgX2+lBMqgBhA==",
       "cpu": [
         "arm64"
       ],
-      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "win32"
+        "linux"
       ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
+      "peer": true
     },
-    "node_modules/@img/sharp-win32-ia32": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.34.5.tgz",
-      "integrity": "sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==",
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.53.1.tgz",
+      "integrity": "sha512-UDUtelEprkA85g95Q+nj3Xf0M4hHa4DiJ+3P3h4BuGliY4NReYYqwlc0Y8ICLjN4+uIgCEvaygYlpf0hUj90Yg==",
       "cpu": [
-        "ia32"
+        "loong64"
       ],
-      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "win32"
+        "linux"
       ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
+      "peer": true
     },
-    "node_modules/@img/sharp-win32-x64": {
-      "version": "0.34.5",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.34.5.tgz",
-      "integrity": "sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==",
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.53.1.tgz",
+      "integrity": "sha512-vrRn+BYhEtNOte/zbc2wAUQReJXxEx2URfTol6OEfY2zFEUK92pkFBSXRylDM7aHi+YqEPJt9/ABYzmcrS4SgQ==",
       "cpu": [
-        "x64"
+        "ppc64"
       ],
-      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "license": "MIT",
       "optional": true,
       "os": [
-        "win32"
+        "linux"
       ],
-      "engines": {
-        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/libvips"
-      }
-    },
-    "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.13",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
-      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/sourcemap-codec": "^1.5.0",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      }
-    },
-    "node_modules/@jridgewell/remapping": {
-      "version": "2.3.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
-      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/gen-mapping": "^0.3.5",
-        "@jridgewell/trace-mapping": "^0.3.24"
-      }
-    },
-    "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==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=6.0.0"
-      }
-    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
-      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@jridgewell/trace-mapping": {
-      "version": "0.3.31",
-      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
-      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@jridgewell/resolve-uri": "^3.1.0",
-        "@jridgewell/sourcemap-codec": "^1.4.14"
-      }
+      "peer": true
     },
-    "node_modules/@napi-rs/wasm-runtime": {
-      "version": "0.2.12",
-      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
-      "integrity": "sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==",
-      "dev": true,
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.53.1.tgz",
+      "integrity": "sha512-gto/1CxHyi4A7YqZZNznQYrVlPSaodOBPKM+6xcDSCMVZN/Fzb4K+AIkNz/1yAYz9h3Ng+e2fY9H6bgawVq17w==",
+      "cpu": [
+        "riscv64"
+      ],
       "license": "MIT",
       "optional": true,
-      "dependencies": {
-        "@emnapi/core": "^1.4.3",
-        "@emnapi/runtime": "^1.4.3",
-        "@tybys/wasm-util": "^0.10.0"
-      }
-    },
-    "node_modules/@next/env": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/@next/env/-/env-16.0.1.tgz",
-      "integrity": "sha512-LFvlK0TG2L3fEOX77OC35KowL8D7DlFF45C0OvKMC4hy8c/md1RC4UMNDlUGJqfCoCS2VWrZ4dSE6OjaX5+8mw==",
-      "license": "MIT"
+      "os": [
+        "linux"
+      ],
+      "peer": true
     },
-    "node_modules/@next/eslint-plugin-next": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/@next/eslint-plugin-next/-/eslint-plugin-next-16.0.1.tgz",
-      "integrity": "sha512-g4Cqmv/gyFEXNeVB2HkqDlYKfy+YrlM2k8AVIO/YQVEPfhVruH1VA99uT1zELLnPLIeOnx8IZ6Ddso0asfTIdw==",
-      "dev": true,
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.53.1.tgz",
+      "integrity": "sha512-KZ6Vx7jAw3aLNjFR8eYVcQVdFa/cvBzDNRFM3z7XhNNunWjA03eUrEwJYPk0G8V7Gs08IThFKcAPS4WY/ybIrQ==",
+      "cpu": [
+        "riscv64"
+      ],
       "license": "MIT",
-      "dependencies": {
-        "fast-glob": "3.3.1"
-      }
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "peer": true
     },
-    "node_modules/@next/swc-darwin-arm64": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-16.0.1.tgz",
-      "integrity": "sha512-R0YxRp6/4W7yG1nKbfu41bp3d96a0EalonQXiMe+1H9GTHfKxGNCGFNWUho18avRBPsO8T3RmdWuzmfurlQPbg==",
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.53.1.tgz",
+      "integrity": "sha512-HvEixy2s/rWNgpwyKpXJcHmE7om1M89hxBTBi9Fs6zVuLU4gOrEMQNbNsN/tBVIMbLyysz/iwNiGtMOpLAOlvA==",
       "cpu": [
-        "arm64"
+        "s390x"
       ],
       "license": "MIT",
       "optional": true,
       "os": [
-        "darwin"
+        "linux"
       ],
-      "engines": {
-        "node": ">= 10"
-      }
+      "peer": true
     },
-    "node_modules/@next/swc-darwin-x64": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.0.1.tgz",
-      "integrity": "sha512-kETZBocRux3xITiZtOtVoVvXyQLB7VBxN7L6EPqgI5paZiUlnsgYv4q8diTNYeHmF9EiehydOBo20lTttCbHAg==",
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.53.1.tgz",
+      "integrity": "sha512-E/n8x2MSjAQgjj9IixO4UeEUeqXLtiA7pyoXCFYLuXpBA/t2hnbIdxHfA7kK9BFsYAoNU4st1rHYdldl8dTqGA==",
       "cpu": [
         "x64"
       ],
       "license": "MIT",
       "optional": true,
       "os": [
-        "darwin"
+        "linux"
       ],
-      "engines": {
-        "node": ">= 10"
-      }
+      "peer": true
     },
-    "node_modules/@next/swc-linux-arm64-gnu": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-16.0.1.tgz",
-      "integrity": "sha512-hWg3BtsxQuSKhfe0LunJoqxjO4NEpBmKkE+P2Sroos7yB//OOX3jD5ISP2wv8QdUwtRehMdwYz6VB50mY6hqAg==",
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.53.1.tgz",
+      "integrity": "sha512-IhJ087PbLOQXCN6Ui/3FUkI9pWNZe/Z7rEIVOzMsOs1/HSAECCvSZ7PkIbkNqL/AZn6WbZvnoVZw/qwqYMo4/w==",
       "cpu": [
-        "arm64"
+        "x64"
       ],
       "license": "MIT",
       "optional": true,
       "os": [
         "linux"
       ],
-      "engines": {
-        "node": ">= 10"
-      }
+      "peer": true
     },
-    "node_modules/@next/swc-linux-arm64-musl": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-16.0.1.tgz",
-      "integrity": "sha512-UPnOvYg+fjAhP3b1iQStcYPWeBFRLrugEyK/lDKGk7kLNua8t5/DvDbAEFotfV1YfcOY6bru76qN9qnjLoyHCQ==",
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.53.1.tgz",
+      "integrity": "sha512-0++oPNgLJHBblreu0SFM7b3mAsBJBTY0Ksrmu9N6ZVrPiTkRgda52mWR7TKhHAsUb9noCjFvAw9l6ZO1yzaVbA==",
       "cpu": [
         "arm64"
       ],
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "openharmony"
       ],
-      "engines": {
-        "node": ">= 10"
-      }
+      "peer": true
     },
-    "node_modules/@next/swc-linux-x64-gnu": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-16.0.1.tgz",
-      "integrity": "sha512-Et81SdWkcRqAJziIgFtsFyJizHoWne4fzJkvjd6V4wEkWTB4MX6J0uByUb0peiJQ4WeAt6GGmMszE5KrXK6WKg==",
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.53.1.tgz",
+      "integrity": "sha512-VJXivz61c5uVdbmitLkDlbcTk9Or43YC2QVLRkqp86QoeFSqI81bNgjhttqhKNMKnQMWnecOCm7lZz4s+WLGpQ==",
       "cpu": [
-        "x64"
+        "arm64"
       ],
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "win32"
       ],
-      "engines": {
-        "node": ">= 10"
-      }
+      "peer": true
     },
-    "node_modules/@next/swc-linux-x64-musl": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-16.0.1.tgz",
-      "integrity": "sha512-qBbgYEBRrC1egcG03FZaVfVxrJm8wBl7vr8UFKplnxNRprctdP26xEv9nJ07Ggq4y1adwa0nz2mz83CELY7N6Q==",
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.53.1.tgz",
+      "integrity": "sha512-NmZPVTUOitCXUH6erJDzTQ/jotYw4CnkMDjCYRxNHVD9bNyfrGoIse684F9okwzKCV4AIHRbUkeTBc9F2OOH5Q==",
       "cpu": [
-        "x64"
+        "ia32"
       ],
       "license": "MIT",
       "optional": true,
       "os": [
-        "linux"
+        "win32"
       ],
-      "engines": {
-        "node": ">= 10"
-      }
+      "peer": true
     },
-    "node_modules/@next/swc-win32-arm64-msvc": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-16.0.1.tgz",
-      "integrity": "sha512-cPuBjYP6I699/RdbHJonb3BiRNEDm5CKEBuJ6SD8k3oLam2fDRMKAvmrli4QMDgT2ixyRJ0+DTkiODbIQhRkeQ==",
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.53.1.tgz",
+      "integrity": "sha512-2SNj7COIdAf6yliSpLdLG8BEsp5lgzRehgfkP0Av8zKfQFKku6JcvbobvHASPJu4f3BFxej5g+HuQPvqPhHvpQ==",
       "cpu": [
-        "arm64"
+        "x64"
       ],
       "license": "MIT",
       "optional": true,
       "os": [
         "win32"
       ],
-      "engines": {
-        "node": ">= 10"
-      }
+      "peer": true
     },
-    "node_modules/@next/swc-win32-x64-msvc": {
-      "version": "16.0.1",
-      "resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-16.0.1.tgz",
-      "integrity": "sha512-XeEUJsE4JYtfrXe/LaJn3z1pD19fK0Q6Er8Qoufi+HqvdO4LEPyCxLUt4rxA+4RfYo6S9gMlmzCMU2F+AatFqQ==",
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.53.1.tgz",
+      "integrity": "sha512-rLarc1Ofcs3DHtgSzFO31pZsCh8g05R2azN1q3fF+H423Co87My0R+tazOEvYVKXSLh8C4LerMK41/K7wlklcg==",
       "cpu": [
         "x64"
       ],
@@ -1174,57 +2578,7 @@
       "os": [
         "win32"
       ],
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@nodelib/fs.scandir": {
-      "version": "2.1.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
-      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.stat": "2.0.5",
-        "run-parallel": "^1.1.9"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.stat": {
-      "version": "2.0.5",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
-      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nodelib/fs.walk": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
-      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "@nodelib/fs.scandir": "2.1.5",
-        "fastq": "^1.6.0"
-      },
-      "engines": {
-        "node": ">= 8"
-      }
-    },
-    "node_modules/@nolyfill/is-core-module": {
-      "version": "1.0.39",
-      "resolved": "https://registry.npmjs.org/@nolyfill/is-core-module/-/is-core-module-1.0.39.tgz",
-      "integrity": "sha512-nn5ozdjYQpUCZlWGuxcJY/KpxkWQs4DcbMCmKojjyrYDEAGy4Ce19NN4v5MduafTwJlbKc99UA8YhSVqq9yPZA==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.4.0"
-      }
+      "peer": true
     },
     "node_modules/@rtsao/scc": {
       "version": "1.1.0",
@@ -1524,11 +2878,16 @@
         "tslib": "^2.4.0"
       }
     },
+    "node_modules/@types/aws-lambda": {
+      "version": "8.10.157",
+      "resolved": "https://registry.npmjs.org/@types/aws-lambda/-/aws-lambda-8.10.157.tgz",
+      "integrity": "sha512-ofjcRCO1N7tMZDSO11u5bFHPDfUFD3Q9YK9g4S4w8UDKuG3CNlw2lNK1sd3Itdo7JORygZmG4h9ZykS8dlXvMA==",
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
       "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/@types/json-schema": {
@@ -1549,7 +2908,7 @@
       "version": "20.19.24",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.24.tgz",
       "integrity": "sha512-FE5u0ezmi6y9OZEzlJfg37mqqf6ZDSF2V/NLjUyGrR9uTZ7Sb9F7bLNZ03S4XVUNRWGA7Ck4c1kK+YnuWjl+DA==",
-      "dev": true,
+      "devOptional": true,
       "license": "MIT",
       "dependencies": {
         "undici-types": "~6.21.0"
@@ -1559,7 +2918,7 @@
       "version": "19.2.2",
       "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.2.tgz",
       "integrity": "sha512-6mDvHUFSjyT2B2yeNx2nUgMxh9LtOWvkhIU3uePn2I2oyNymUAX1NIsdgviM4CH+JSrp2D2hsMvJOkxY+0wNRA==",
-      "dev": true,
+      "devOptional": true,
       "license": "MIT",
       "dependencies": {
         "csstype": "^3.0.2"
@@ -2145,6 +3504,15 @@
         "win32"
       ]
     },
+    "node_modules/@xmldom/xmldom": {
+      "version": "0.8.11",
+      "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.11.tgz",
+      "integrity": "sha512-cQzWCtO6C8TQiYl1ruKNn2U6Ao4o4WBBcbL61yJl84x+j5sOWWFU9X7DpND8XZG3daDppSsigMdfAIl2upQBRw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
     "node_modules/acorn": {
       "version": "8.15.0",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
@@ -2168,6 +3536,15 @@
         "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
+    "node_modules/adler-32": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/adler-32/-/adler-32-1.3.1.tgz",
+      "integrity": "sha512-ynZ4w/nUUv5rrsR8UUGoe1VC9hZj6V5hU9Qw1HlMDJGEJw5S7TfTErWTjMys6M7vr0YWcPqs3qAr4ss0nDfP+A==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/ajv": {
       "version": "6.12.6",
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
@@ -2438,6 +3815,26 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/baseline-browser-mapping": {
       "version": "2.8.25",
       "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.25.tgz",
@@ -2448,6 +3845,24 @@
         "baseline-browser-mapping": "dist/cli.js"
       }
     },
+    "node_modules/before-after-hook": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-4.0.0.tgz",
+      "integrity": "sha512-q6tR3RPqIB1pMiTRMFcZwuG5T8vwp+vUvEG0vuI6B+Rikh5BfPp2fQ82c925FOs+b0lcFQ8CFrL+KbilfZFhOQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/bluebird": {
+      "version": "3.4.7",
+      "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.4.7.tgz",
+      "integrity": "sha512-iD3898SR7sWVRHbiQv+sHUtHnMvC1o3nW5rAcqnq3uOn07DSAppZYUkIGslDz6gXC7HfunPe7YVBgoEJASPcHA==",
+      "license": "MIT"
+    },
+    "node_modules/bottleneck": {
+      "version": "2.19.5",
+      "resolved": "https://registry.npmjs.org/bottleneck/-/bottleneck-2.19.5.tgz",
+      "integrity": "sha512-VHiNCbI1lKdl44tGrhNfU3lup0Tj/ZBMJB5/2ZbNXRCPuRCO7ed2mgcK4r17y+KB2EfuYuRaVlwNbAeaWGSpbw==",
+      "license": "MIT"
+    },
     "node_modules/brace-expansion": {
       "version": "1.1.12",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
@@ -2586,6 +4001,19 @@
       ],
       "license": "CC-BY-4.0"
     },
+    "node_modules/cfb": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cfb/-/cfb-1.2.2.tgz",
+      "integrity": "sha512-KfdUZsSOw19/ObEWasvBP/Ac4reZvAGauZhs6S/gqNhXhI7cKwvlH7ulj+dOEYnca4bm4SGo8C1bTAQvnTjgQA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "adler-32": "~1.3.0",
+        "crc-32": "~1.2.0"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -2609,6 +4037,24 @@
       "integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==",
       "license": "MIT"
     },
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/codepage": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/codepage/-/codepage-1.15.0.tgz",
+      "integrity": "sha512-3g6NUTPd/YtuuGrhMnOMRjFc+LJw/bnMp3+0r/Wcz3IXUuCosKRJvMphm5+Q+bvTVGcJJuRvVLuYba+WojaFaA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/color-convert": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
@@ -2643,6 +4089,24 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+      "license": "MIT"
+    },
+    "node_modules/crc-32": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz",
+      "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==",
+      "license": "Apache-2.0",
+      "bin": {
+        "crc32": "bin/crc32.njs"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -2662,7 +4126,7 @@
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
       "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
-      "dev": true,
+      "devOptional": true,
       "license": "MIT"
     },
     "node_modules/damerau-levenshtein": {
@@ -2787,6 +4251,15 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/detect-libc": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
@@ -2797,6 +4270,12 @@
         "node": ">=8"
       }
     },
+    "node_modules/dingbat-to-unicode": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dingbat-to-unicode/-/dingbat-to-unicode-1.0.1.tgz",
+      "integrity": "sha512-98l0sW87ZT58pU4i61wa2OHwxbiYSbuxsCBozaVnYX2iCnr3bLM3fIes1/ej7h1YdOKuKt/MLs706TVnALA65w==",
+      "license": "BSD-2-Clause"
+    },
     "node_modules/doctrine": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",
@@ -2810,6 +4289,21 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/dompurify": {
+      "version": "3.1.7",
+      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.1.7.tgz",
+      "integrity": "sha512-VaTstWtsneJY8xzy7DekmYWEOZcmzIe3Qb3zPd4STve1OBTa+e+WmS1ITQec1fZYXI3HCsOZZiSMpG6oxoWMWQ==",
+      "license": "(MPL-2.0 OR Apache-2.0)"
+    },
+    "node_modules/duck": {
+      "version": "0.1.12",
+      "resolved": "https://registry.npmjs.org/duck/-/duck-0.1.12.tgz",
+      "integrity": "sha512-wkctla1O6VfP89gQ+J/yDesM0S7B7XLXjKGzXxMDVFg7uEn706niAtyYovKbyq1oT9YwDcly721/iUWoc8MVRg==",
+      "license": "BSD",
+      "dependencies": {
+        "underscore": "^1.13.1"
+      }
+    },
     "node_modules/dunder-proto": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
@@ -3030,6 +4524,48 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/esbuild": {
+      "version": "0.25.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.12",
+        "@esbuild/android-arm": "0.25.12",
+        "@esbuild/android-arm64": "0.25.12",
+        "@esbuild/android-x64": "0.25.12",
+        "@esbuild/darwin-arm64": "0.25.12",
+        "@esbuild/darwin-x64": "0.25.12",
+        "@esbuild/freebsd-arm64": "0.25.12",
+        "@esbuild/freebsd-x64": "0.25.12",
+        "@esbuild/linux-arm": "0.25.12",
+        "@esbuild/linux-arm64": "0.25.12",
+        "@esbuild/linux-ia32": "0.25.12",
+        "@esbuild/linux-loong64": "0.25.12",
+        "@esbuild/linux-mips64el": "0.25.12",
+        "@esbuild/linux-ppc64": "0.25.12",
+        "@esbuild/linux-riscv64": "0.25.12",
+        "@esbuild/linux-s390x": "0.25.12",
+        "@esbuild/linux-x64": "0.25.12",
+        "@esbuild/netbsd-arm64": "0.25.12",
+        "@esbuild/netbsd-x64": "0.25.12",
+        "@esbuild/openbsd-arm64": "0.25.12",
+        "@esbuild/openbsd-x64": "0.25.12",
+        "@esbuild/openharmony-arm64": "0.25.12",
+        "@esbuild/sunos-x64": "0.25.12",
+        "@esbuild/win32-arm64": "0.25.12",
+        "@esbuild/win32-ia32": "0.25.12",
+        "@esbuild/win32-x64": "0.25.12"
+      }
+    },
     "node_modules/escalade": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
@@ -3477,6 +5013,22 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/fast-content-type-parse": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/fast-content-type-parse/-/fast-content-type-parse-3.0.0.tgz",
+      "integrity": "sha512-ZvLdcY8P+N8mGQJahJV5G4U88CSvT1rP8ApL6uETe88MBXrBHAkZlSEySdUlyztF7ccb+Znos3TFqaepHxdhBg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
@@ -3618,6 +5170,57 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/frac": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/frac/-/frac-1.1.2.tgz",
+      "integrity": "sha512-w/XBfkibaTl3YDqASwfDUqkna4Z2p9cFSr1aHDt0WoMTECnRfBOv2WArlZILlqgWlmdIlALXGpM2AOhEk5W3IA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/framer-motion": {
+      "version": "12.23.24",
+      "resolved": "https://registry.npmjs.org/framer-motion/-/framer-motion-12.23.24.tgz",
+      "integrity": "sha512-HMi5HRoRCTou+3fb3h9oTLyJGBxHfW+HnNE25tAXOvVx/IvwMHK0cx7IR4a2ZU6sh3IX1Z+4ts32PcYBOqka8w==",
+      "license": "MIT",
+      "dependencies": {
+        "motion-dom": "^12.23.23",
+        "motion-utils": "^12.23.6",
+        "tslib": "^2.4.0"
+      },
+      "peerDependencies": {
+        "@emotion/is-prop-valid": "*",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@emotion/is-prop-valid": {
+          "optional": true
+        },
+        "react": {
+          "optional": true
+        },
+        "react-dom": {
+          "optional": 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,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "peer": true,
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
     "node_modules/function-bind": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
@@ -3940,6 +5543,12 @@
         "node": ">= 4"
       }
     },
+    "node_modules/immediate": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz",
+      "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==",
+      "license": "MIT"
+    },
     "node_modules/import-fresh": {
       "version": "3.3.1",
       "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
@@ -3967,6 +5576,12 @@
         "node": ">=0.8.19"
       }
     },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
     "node_modules/internal-slot": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz",
@@ -4433,7 +6048,7 @@
       "version": "2.6.1",
       "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.6.1.tgz",
       "integrity": "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==",
-      "dev": true,
+      "devOptional": true,
       "license": "MIT",
       "bin": {
         "jiti": "lib/jiti-cli.mjs"
@@ -4443,7 +6058,6 @@
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
       "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/js-yaml": {
@@ -4522,6 +6136,18 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/jszip": {
+      "version": "3.10.1",
+      "resolved": "https://registry.npmjs.org/jszip/-/jszip-3.10.1.tgz",
+      "integrity": "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==",
+      "license": "(MIT OR GPL-3.0-or-later)",
+      "dependencies": {
+        "lie": "~3.3.0",
+        "pako": "~1.0.2",
+        "readable-stream": "~2.3.6",
+        "setimmediate": "^1.0.5"
+      }
+    },
     "node_modules/keyv": {
       "version": "4.5.4",
       "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
@@ -4566,11 +6192,20 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/lie": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/lie/-/lie-3.3.0.tgz",
+      "integrity": "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "immediate": "~3.0.5"
+      }
+    },
     "node_modules/lightningcss": {
       "version": "1.30.2",
       "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.30.2.tgz",
       "integrity": "sha512-utfs7Pr5uJyyvDETitgsaqSyjCb2qNRAtuqUeWIAKztsOYdcACf2KtARYXg2pSvhkt+9NfoaNY7fxjl6nuMjIQ==",
-      "dev": true,
+      "devOptional": true,
       "license": "MPL-2.0",
       "dependencies": {
         "detect-libc": "^2.0.3"
@@ -4854,7 +6489,6 @@
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
       "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "js-tokens": "^3.0.0 || ^4.0.0"
@@ -4863,6 +6497,17 @@
         "loose-envify": "cli.js"
       }
     },
+    "node_modules/lop": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/lop/-/lop-0.4.2.tgz",
+      "integrity": "sha512-RefILVDQ4DKoRZsJ4Pj22TxE3omDO47yFpkIBoDKzkqPRISs5U1cnAdg/5583YPkWPaLIYHOKRMQSvjFsO26cw==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "duck": "^0.1.12",
+        "option": "~0.2.1",
+        "underscore": "^1.13.1"
+      }
+    },
     "node_modules/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -4873,6 +6518,15 @@
         "yallist": "^3.0.2"
       }
     },
+    "node_modules/lucide-react": {
+      "version": "0.553.0",
+      "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.553.0.tgz",
+      "integrity": "sha512-BRgX5zrWmNy/lkVAe0dXBgd7XQdZ3HTf+Hwe3c9WK6dqgnj9h+hxV+MDncM88xDWlCq27+TKvHGE70ViODNILw==",
+      "license": "ISC",
+      "peerDependencies": {
+        "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
     "node_modules/magic-string": {
       "version": "0.30.21",
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
@@ -4883,6 +6537,69 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/make-cancellable-promise": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/make-cancellable-promise/-/make-cancellable-promise-2.0.0.tgz",
+      "integrity": "sha512-3SEQqTpV9oqVsIWqAcmDuaNeo7yBO3tqPtqGRcKkEo0lrzD3wqbKG9mkxO65KoOgXqj+zH2phJ2LiAsdzlogSw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/wojtekmaj/make-cancellable-promise?sponsor=1"
+      }
+    },
+    "node_modules/make-event-props": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/make-event-props/-/make-event-props-2.0.0.tgz",
+      "integrity": "sha512-G/hncXrl4Qt7mauJEXSg3AcdYzmpkIITTNl5I+rH9sog5Yw0kK6vseJjCaPfOXqOqQuPUP89Rkhfz5kPS8ijtw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/wojtekmaj/make-event-props?sponsor=1"
+      }
+    },
+    "node_modules/mammoth": {
+      "version": "1.11.0",
+      "resolved": "https://registry.npmjs.org/mammoth/-/mammoth-1.11.0.tgz",
+      "integrity": "sha512-BcEqqY/BOwIcI1iR5tqyVlqc3KIaMRa4egSoK83YAVrBf6+yqdAAbtUcFDCWX8Zef8/fgNZ6rl4VUv+vVX8ddQ==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "@xmldom/xmldom": "^0.8.6",
+        "argparse": "~1.0.3",
+        "base64-js": "^1.5.1",
+        "bluebird": "~3.4.0",
+        "dingbat-to-unicode": "^1.0.1",
+        "jszip": "^3.7.1",
+        "lop": "^0.4.2",
+        "path-is-absolute": "^1.0.0",
+        "underscore": "^1.13.1",
+        "xmlbuilder": "^10.0.0"
+      },
+      "bin": {
+        "mammoth": "bin/mammoth"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/mammoth/node_modules/argparse": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+      "license": "MIT",
+      "dependencies": {
+        "sprintf-js": "~1.0.2"
+      }
+    },
+    "node_modules/marked": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-14.0.0.tgz",
+      "integrity": "sha512-uIj4+faQ+MgHgwUW1l2PsPglZLOLOT1uErt06dAPtx2kjteLAkbsd/0FiYg/MGS+i7ZKLb7w2WClxHkzOOuryQ==",
+      "license": "MIT",
+      "bin": {
+        "marked": "bin/marked.js"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
     "node_modules/math-intrinsics": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
@@ -4893,6 +6610,23 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/merge-refs": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-refs/-/merge-refs-2.0.0.tgz",
+      "integrity": "sha512-3+B21mYK2IqUWnd2EivABLT7ueDhb0b8/dGK8LoFQPrU61YITeCMn14F7y7qZafWNZhUEKb24cJdiT5Wxs3prg==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/wojtekmaj/merge-refs?sponsor=1"
+      },
+      "peerDependencies": {
+        "@types/react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/merge2": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
@@ -4940,6 +6674,31 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/monaco-editor": {
+      "version": "0.54.0",
+      "resolved": "https://registry.npmjs.org/monaco-editor/-/monaco-editor-0.54.0.tgz",
+      "integrity": "sha512-hx45SEUoLatgWxHKCmlLJH81xBo0uXP4sRkESUpmDQevfi+e7K1VuiSprK6UpQ8u4zOcKNiH0pMvHvlMWA/4cw==",
+      "license": "MIT",
+      "dependencies": {
+        "dompurify": "3.1.7",
+        "marked": "14.0.0"
+      }
+    },
+    "node_modules/motion-dom": {
+      "version": "12.23.23",
+      "resolved": "https://registry.npmjs.org/motion-dom/-/motion-dom-12.23.23.tgz",
+      "integrity": "sha512-n5yolOs0TQQBRUFImrRfs/+6X4p3Q4n1dUEqt/H58Vx7OW6RF+foWEgmTVDhIWJIMXOuNNL0apKH2S16en9eiA==",
+      "license": "MIT",
+      "dependencies": {
+        "motion-utils": "^12.23.6"
+      }
+    },
+    "node_modules/motion-utils": {
+      "version": "12.23.6",
+      "resolved": "https://registry.npmjs.org/motion-utils/-/motion-utils-12.23.6.tgz",
+      "integrity": "sha512-eAWoPgr4eFEOFfg2WjIsMoqJTW6Z8MTUCgn/GZ3VRpClWBdnbjryiA3ZSNLyxCTmCQx4RmYX6jX1iWHbenUPNQ==",
+      "license": "MIT"
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -5079,7 +6838,6 @@
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
       "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -5198,6 +6956,34 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/octokit": {
+      "version": "5.0.5",
+      "resolved": "https://registry.npmjs.org/octokit/-/octokit-5.0.5.tgz",
+      "integrity": "sha512-4+/OFSqOjoyULo7eN7EA97DE0Xydj/PW5aIckxqQIoFjFwqXKuFCvXUJObyJfBF9Khu4RL/jlDRI9FPaMGfPnw==",
+      "license": "MIT",
+      "dependencies": {
+        "@octokit/app": "^16.1.2",
+        "@octokit/core": "^7.0.6",
+        "@octokit/oauth-app": "^8.0.3",
+        "@octokit/plugin-paginate-graphql": "^6.0.0",
+        "@octokit/plugin-paginate-rest": "^14.0.0",
+        "@octokit/plugin-rest-endpoint-methods": "^17.0.0",
+        "@octokit/plugin-retry": "^8.0.3",
+        "@octokit/plugin-throttling": "^11.0.3",
+        "@octokit/request-error": "^7.0.2",
+        "@octokit/types": "^16.0.0",
+        "@octokit/webhooks": "^14.0.0"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/option": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/option/-/option-0.2.4.tgz",
+      "integrity": "sha512-pkEqbDyl8ou5cpq+VsnQbe/WlEy5qS7xPzMS1U55OCG9KPvwFD46zDbxQIj3egJSFc3D+XhYOPUzz49zQAVy7A==",
+      "license": "BSD-2-Clause"
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -5266,6 +7052,12 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+      "license": "(MIT AND Zlib)"
+    },
     "node_modules/parent-module": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
@@ -5289,6 +7081,15 @@
         "node": ">=8"
       }
     },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/path-key": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
@@ -5306,6 +7107,18 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/pdfjs-dist": {
+      "version": "5.4.296",
+      "resolved": "https://registry.npmjs.org/pdfjs-dist/-/pdfjs-dist-5.4.296.tgz",
+      "integrity": "sha512-DlOzet0HO7OEnmUmB6wWGJrrdvbyJKftI1bhMitK7O2N8W2gc757yyYBbINy9IDafXAV9wmKr9t7xsTaNKRG5Q==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=20.16.0 || >=22.3.0"
+      },
+      "optionalDependencies": {
+        "@napi-rs/canvas": "^0.1.80"
+      }
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -5339,7 +7152,6 @@
       "version": "8.5.6",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
       "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
-      "dev": true,
       "funding": [
         {
           "type": "opencollective",
@@ -5374,11 +7186,16 @@
         "node": ">= 0.8.0"
       }
     },
+    "node_modules/process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "license": "MIT"
+    },
     "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==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "loose-envify": "^1.4.0",
@@ -5417,6 +7234,16 @@
       ],
       "license": "MIT"
     },
+    "node_modules/re-resizable": {
+      "version": "6.11.2",
+      "resolved": "https://registry.npmjs.org/re-resizable/-/re-resizable-6.11.2.tgz",
+      "integrity": "sha512-2xI2P3OHs5qw7K0Ud1aLILK6MQxW50TcO+DetD9eIV58j84TqYeHoZcL9H4GXFXXIh7afhH8mv5iUCXII7OW7A==",
+      "license": "MIT",
+      "peerDependencies": {
+        "react": "^16.13.1 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.13.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
     "node_modules/react": {
       "version": "19.2.0",
       "resolved": "https://registry.npmjs.org/react/-/react-19.2.0.tgz",
@@ -5438,11 +7265,130 @@
         "react": "^19.2.0"
       }
     },
+    "node_modules/react-draggable": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/react-draggable/-/react-draggable-4.5.0.tgz",
+      "integrity": "sha512-VC+HBLEZ0XJxnOxVAZsdRi8rD04Iz3SiiKOoYzamjylUcju/hP9np/aZdLHf/7WOD268WMoNJMvYfB5yAK45cw==",
+      "license": "MIT",
+      "dependencies": {
+        "clsx": "^2.1.1",
+        "prop-types": "^15.8.1"
+      },
+      "peerDependencies": {
+        "react": ">= 16.3.0",
+        "react-dom": ">= 16.3.0"
+      }
+    },
+    "node_modules/react-error-boundary": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/react-error-boundary/-/react-error-boundary-6.0.0.tgz",
+      "integrity": "sha512-gdlJjD7NWr0IfkPlaREN2d9uUZUlksrfOx7SX62VRerwXbMY6ftGCIZua1VG1aXFNOimhISsTq+Owp725b9SiA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.12.5"
+      },
+      "peerDependencies": {
+        "react": ">=16.13.1"
+      }
+    },
     "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==",
-      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/react-pdf": {
+      "version": "10.2.0",
+      "resolved": "https://registry.npmjs.org/react-pdf/-/react-pdf-10.2.0.tgz",
+      "integrity": "sha512-zk0DIL31oCh8cuQycM0SJKfwh4Onz0/Nwi6wTOjgtEjWGUY6eM+/vuzvOP3j70qtEULn7m1JtaeGzud1w5fY2Q==",
+      "license": "MIT",
+      "dependencies": {
+        "clsx": "^2.0.0",
+        "dequal": "^2.0.3",
+        "make-cancellable-promise": "^2.0.0",
+        "make-event-props": "^2.0.0",
+        "merge-refs": "^2.0.0",
+        "pdfjs-dist": "5.4.296",
+        "tiny-invariant": "^1.0.0",
+        "warning": "^4.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/wojtekmaj/react-pdf?sponsor=1"
+      },
+      "peerDependencies": {
+        "@types/react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/react-rnd": {
+      "version": "10.5.2",
+      "resolved": "https://registry.npmjs.org/react-rnd/-/react-rnd-10.5.2.tgz",
+      "integrity": "sha512-0Tm4x7k7pfHf2snewJA8x7Nwgt3LV+58MVEWOVsFjk51eYruFEa6Wy7BNdxt4/lH0wIRsu7Gm3KjSXY2w7YaNw==",
+      "license": "MIT",
+      "dependencies": {
+        "re-resizable": "6.11.2",
+        "react-draggable": "4.4.6",
+        "tslib": "2.6.2"
+      },
+      "peerDependencies": {
+        "react": ">=16.3.0",
+        "react-dom": ">=16.3.0"
+      }
+    },
+    "node_modules/react-rnd/node_modules/clsx": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-1.2.1.tgz",
+      "integrity": "sha512-EcR6r5a8bj6pu3ycsa/E/cKVGuTgZJZdsyUYHOksG/UHIiKfjxzRxYJpyVBwYaQeOvghal9fcc4PidlgzugAQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/react-rnd/node_modules/react-draggable": {
+      "version": "4.4.6",
+      "resolved": "https://registry.npmjs.org/react-draggable/-/react-draggable-4.4.6.tgz",
+      "integrity": "sha512-LtY5Xw1zTPqHkVmtM3X8MUOxNDOUhv/khTgBgrUvwaS064bwVvxT+q5El0uUFNx5IEPKXuRejr7UqLwBIg5pdw==",
+      "license": "MIT",
+      "dependencies": {
+        "clsx": "^1.1.1",
+        "prop-types": "^15.8.1"
+      },
+      "peerDependencies": {
+        "react": ">= 16.3.0",
+        "react-dom": ">= 16.3.0"
+      }
+    },
+    "node_modules/react-rnd/node_modules/tslib": {
+      "version": "2.6.2",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz",
+      "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==",
+      "license": "0BSD"
+    },
+    "node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/readable-stream/node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
       "license": "MIT"
     },
     "node_modules/reflect.getprototypeof": {
@@ -5541,6 +7487,48 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/rollup": {
+      "version": "4.53.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.53.1.tgz",
+      "integrity": "sha512-n2I0V0lN3E9cxxMqBCT3opWOiQBzRN7UG60z/WDKqdX2zHUS/39lezBcsckZFsV6fUTSnfqI7kHf60jDAPGKug==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.53.1",
+        "@rollup/rollup-android-arm64": "4.53.1",
+        "@rollup/rollup-darwin-arm64": "4.53.1",
+        "@rollup/rollup-darwin-x64": "4.53.1",
+        "@rollup/rollup-freebsd-arm64": "4.53.1",
+        "@rollup/rollup-freebsd-x64": "4.53.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.53.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.53.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.53.1",
+        "@rollup/rollup-linux-arm64-musl": "4.53.1",
+        "@rollup/rollup-linux-loong64-gnu": "4.53.1",
+        "@rollup/rollup-linux-ppc64-gnu": "4.53.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.53.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.53.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.53.1",
+        "@rollup/rollup-linux-x64-gnu": "4.53.1",
+        "@rollup/rollup-linux-x64-musl": "4.53.1",
+        "@rollup/rollup-openharmony-arm64": "4.53.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.53.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.53.1",
+        "@rollup/rollup-win32-x64-gnu": "4.53.1",
+        "@rollup/rollup-win32-x64-msvc": "4.53.1",
+        "fsevents": "~2.3.2"
+      }
+    },
     "node_modules/run-parallel": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
@@ -5585,6 +7573,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
     "node_modules/safe-push-apply": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz",
@@ -5685,6 +7679,12 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/setimmediate": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
+      "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==",
+      "license": "MIT"
+    },
     "node_modules/sharp": {
       "version": "0.34.5",
       "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.34.5.tgz",
@@ -5851,6 +7851,24 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/sprintf-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
+      "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/ssf": {
+      "version": "0.11.2",
+      "resolved": "https://registry.npmjs.org/ssf/-/ssf-0.11.2.tgz",
+      "integrity": "sha512-+idbmIXoYET47hH+d7dfm2epdOMUDjqcB4648sTZ+t2JwoyBFL/insLfB/racrDmsKB3diwsDA696pZMieAC5g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "frac": "~1.1.2"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/stable-hash": {
       "version": "0.0.5",
       "resolved": "https://registry.npmjs.org/stable-hash/-/stable-hash-0.0.5.tgz",
@@ -5858,6 +7876,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/state-local": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/state-local/-/state-local-1.0.7.tgz",
+      "integrity": "sha512-HTEHMNieakEnoe33shBYcZ7NX83ACUjCu8c40iOGEZsngj9zRnkqS9j1pqQPXwobB0ZcVTk27REb7COQ0UR59w==",
+      "license": "MIT"
+    },
     "node_modules/stop-iteration-iterator": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz",
@@ -5872,6 +7896,15 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
     "node_modules/string.prototype.includes": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/string.prototype.includes/-/string.prototype.includes-2.0.1.tgz",
@@ -6078,11 +8111,16 @@
         "url": "https://opencollective.com/webpack"
       }
     },
+    "node_modules/tiny-invariant": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz",
+      "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==",
+      "license": "MIT"
+    },
     "node_modules/tinyglobby": {
       "version": "0.2.15",
       "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
       "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "fdir": "^6.5.0",
@@ -6099,7 +8137,6 @@
       "version": "6.5.0",
       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
       "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=12.0.0"
@@ -6117,7 +8154,6 @@
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
       "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=12"
@@ -6139,6 +8175,15 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/toad-cache": {
+      "version": "3.7.0",
+      "resolved": "https://registry.npmjs.org/toad-cache/-/toad-cache-3.7.0.tgz",
+      "integrity": "sha512-/m8M+2BJUpoJdgAHoG+baCwBT+tf2VraSfkBgl0Y00qIWt41DJ8R5B8nsEw0I58YwF5IZH6z24/2TobDKnqSWw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/ts-api-utils": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.1.0.tgz",
@@ -6184,6 +8229,15 @@
       "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
       "license": "0BSD"
     },
+    "node_modules/tw-animate-css": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/tw-animate-css/-/tw-animate-css-1.4.0.tgz",
+      "integrity": "sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/Wombosvideo"
+      }
+    },
     "node_modules/type-check": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
@@ -6332,13 +8386,31 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/underscore": {
+      "version": "1.13.7",
+      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.13.7.tgz",
+      "integrity": "sha512-GMXzWtsc57XAtguZgaQViUOzs0KTkk8ojr3/xAxXLITqf/3EMwxC0inyETfDFjH/Krbhuep0HNbbjI9i/q3F3g==",
+      "license": "MIT"
+    },
     "node_modules/undici-types": {
       "version": "6.21.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
       "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
-      "dev": true,
+      "devOptional": true,
+      "license": "MIT"
+    },
+    "node_modules/universal-github-app-jwt": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/universal-github-app-jwt/-/universal-github-app-jwt-2.2.2.tgz",
+      "integrity": "sha512-dcmbeSrOdTnsjGjUfAlqNDJrhxXizjAz94ija9Qw8YkZ1uu0d+GoZzyH+Jb9tIIqvGsadUfwg+22k5aDqqwzbw==",
       "license": "MIT"
     },
+    "node_modules/universal-user-agent": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-7.0.3.tgz",
+      "integrity": "sha512-TmnEAEAsBJVZM/AADELsK76llnwcf9vMKuPz8JflO1frO8Lchitr0fNaN9d+Ap0BjKtqWqd/J17qeDnXh8CL2A==",
+      "license": "ISC"
+    },
     "node_modules/unrs-resolver": {
       "version": "1.11.1",
       "resolved": "https://registry.npmjs.org/unrs-resolver/-/unrs-resolver-1.11.1.tgz",
@@ -6415,6 +8487,127 @@
         "punycode": "^2.1.0"
       }
     },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT"
+    },
+    "node_modules/vite": {
+      "version": "6.4.1",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
+      "integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
+      "license": "MIT",
+      "peer": true,
+      "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/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/warning": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/warning/-/warning-4.0.3.tgz",
+      "integrity": "sha512-rpJyN222KWIvHJ/F53XSZv0Zl/accqHR8et1kpaMTD/fLCRxtV8iX8czMzY7sVZupTI3zcUTg8eycS2kNF9l6w==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.0.0"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -6520,6 +8713,24 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/wmf": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wmf/-/wmf-1.0.2.tgz",
+      "integrity": "sha512-/p9K7bEh0Dj6WbXg4JG0xvLQmIadrner1bi45VMJTfnbVHsc7yIajZyoSoK60/dtVBs12Fm6WkUI5/3WAVsNMw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/word": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/word/-/word-0.3.0.tgz",
+      "integrity": "sha512-OELeY0Q61OXpdUfTp+oweA/vtLVg5VDOXh+3he3PNzLGG/y0oylSOC1xRVj0+l4vQ3tj/bB1HVHv1ocXkQceFA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
     "node_modules/word-wrap": {
       "version": "1.2.5",
       "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
@@ -6530,6 +8741,36 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/xlsx": {
+      "version": "0.18.5",
+      "resolved": "https://registry.npmjs.org/xlsx/-/xlsx-0.18.5.tgz",
+      "integrity": "sha512-dmg3LCjBPHZnQp5/F/+nnTa+miPJxUXB6vtk42YjBBKayDNagxGEeIdWApkYPOf3Z3pm3k62Knjzp7lMeTEtFQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "adler-32": "~1.3.0",
+        "cfb": "~1.2.1",
+        "codepage": "~1.15.0",
+        "crc-32": "~1.2.1",
+        "ssf": "~0.11.2",
+        "wmf": "~1.0.1",
+        "word": "~0.3.0"
+      },
+      "bin": {
+        "xlsx": "bin/xlsx.njs"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/xmlbuilder": {
+      "version": "10.1.1",
+      "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-10.1.1.tgz",
+      "integrity": "sha512-OyzrcFLL/nb6fMGHbiRDuPup9ljBycsdCypwuyg5AAHvyWzGfChJpCXMG88AGTIMFhGZ9RccFN1e6lhg3hkwKg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
     "node_modules/yallist": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
diff --git a/package.json b/package.json
index b82c80d8b2895838b42c23d8cd9fafce8ea58956..ca47e0f92dc12d47a8e69049f7520893fa488eca 100644
--- a/package.json
+++ b/package.json
@@ -9,18 +9,32 @@
     "lint": "eslint"
   },
   "dependencies": {
+    "@github/spark": "^0.41.23",
+    "@monaco-editor/react": "^4.7.0",
+    "@phosphor-icons/react": "^2.1.10",
+    "@radix-ui/colors": "^3.0.0",
+    "framer-motion": "^12.23.24",
+    "lucide-react": "^0.553.0",
+    "mammoth": "^1.11.0",
+    "monaco-editor": "^0.54.0",
+    "next": "16.0.1",
     "react": "19.2.0",
     "react-dom": "19.2.0",
-    "next": "16.0.1"
+    "react-draggable": "^4.5.0",
+    "react-error-boundary": "^6.0.0",
+    "react-pdf": "^10.2.0",
+    "react-rnd": "^10.5.2",
+    "tw-animate-css": "^1.4.0",
+    "xlsx": "^0.18.5"
   },
   "devDependencies": {
-    "typescript": "^5",
+    "@tailwindcss/postcss": "^4",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
-    "@tailwindcss/postcss": "^4",
-    "tailwindcss": "^4",
     "eslint": "^9",
-    "eslint-config-next": "16.0.1"
+    "eslint-config-next": "16.0.1",
+    "tailwindcss": "^4",
+    "typescript": "^5"
   }
-}
+}
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..92c2d9e2d4e929a59a1a899341474a1d2ff4b1e5
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,6 @@
+fastmcp>=0.2.0
+PyPDF2>=3.0.0
+python-docx>=1.1.0
+python-dotenv>=1.0.0
+python-multipart>=0.0.6
+aiofiles>=23.0.0
\ No newline at end of file
diff --git a/test_claude_desktop.py b/test_claude_desktop.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc95adca4070b8ad7665eff379eb7fcdcd0b6b72
--- /dev/null
+++ b/test_claude_desktop.py
@@ -0,0 +1,132 @@
+"""
+Diagnostic script for Claude Desktop MCP integration
+Run this to check if everything is set up correctly
+"""
+
+import os
+import sys
+import json
+import subprocess
+
+def check_python():
+    """Check Python installation"""
+    print("1. Checking Python installation...")
+    try:
+        result = subprocess.run([sys.executable, "--version"], capture_output=True, text=True)
+        print(f"   [OK] Python found: {result.stdout.strip()}")
+        print(f"   Path: {sys.executable}")
+        return True
+    except Exception as e:
+        print(f"   [FAIL] Python check failed: {e}")
+        return False
+
+def check_dependencies():
+    """Check required packages"""
+    print("\n2. Checking dependencies...")
+    required = ["fastmcp", "PyPDF2", "python-docx", "dotenv"]
+    missing = []
+
+    for package in required:
+        try:
+            __import__(package.replace("-", "_"))
+            print(f"   [OK] {package} installed")
+        except ImportError:
+            print(f"   [FAIL] {package} missing")
+            missing.append(package)
+
+    if missing:
+        print(f"\n   Install missing packages with: pip install {' '.join(missing)}")
+        return False
+    return True
+
+def check_claude_config():
+    """Check Claude Desktop configuration"""
+    print("\n3. Checking Claude Desktop config...")
+    config_path = os.path.expandvars(r"%APPDATA%\Claude\claude_desktop_config.json")
+
+    if not os.path.exists(config_path):
+        print(f"   [FAIL] Config file not found at: {config_path}")
+        return False
+
+    try:
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+
+        if "mcpServers" in config and "exam-hub" in config["mcpServers"]:
+            print(f"   [OK] exam-hub MCP server configured")
+            server_config = config["mcpServers"]["exam-hub"]
+            print(f"   Command: {server_config.get('command', 'Not set')}")
+            print(f"   Args: {server_config.get('args', [])}")
+            return True
+        else:
+            print("   [FAIL] exam-hub MCP server not configured")
+            return False
+    except Exception as e:
+        print(f"   [FAIL] Error reading config: {e}")
+        return False
+
+def check_mcp_server():
+    """Check if MCP server can start"""
+    print("\n4. Testing MCP server...")
+    server_path = r"E:\mpc-hackathon\backend\mcp_server_wrapper.py"
+
+    if not os.path.exists(server_path):
+        print(f"   [FAIL] Server script not found at: {server_path}")
+        return False
+
+    try:
+        # Change to backend directory
+        os.chdir(r"E:\mpc-hackathon\backend")
+
+        # Try importing the module
+        sys.path.insert(0, r"E:\mpc-hackathon\backend")
+        import mcp_server
+        print("   [OK] MCP server module can be imported")
+
+        # Check if data directories exist
+        data_dir = r"E:\mpc-hackathon\data"
+        docs_dir = os.path.join(data_dir, "documents")
+
+        if os.path.exists(docs_dir):
+            print(f"   [OK] Documents directory exists: {docs_dir}")
+        else:
+            print(f"   [WARN] Documents directory missing: {docs_dir}")
+            os.makedirs(docs_dir, exist_ok=True)
+            print(f"   [OK] Created documents directory")
+
+        return True
+    except Exception as e:
+        print(f"   [FAIL] MCP server test failed: {e}")
+        return False
+
+def main():
+    print("=" * 50)
+    print("Claude Desktop MCP Integration Diagnostic")
+    print("=" * 50)
+
+    results = []
+    results.append(check_python())
+    results.append(check_dependencies())
+    results.append(check_claude_config())
+    results.append(check_mcp_server())
+
+    print("\n" + "=" * 50)
+    if all(results):
+        print("[SUCCESS] All checks passed!")
+        print("\nNext steps:")
+        print("1. Restart Claude Desktop completely")
+        print("2. Open a new conversation")
+        print("3. Test with: 'What tools are available from exam-hub?'")
+    else:
+        print("[WARN]️ Some checks failed. Please fix the issues above.")
+        print("\nTroubleshooting:")
+        print("1. Make sure Python is in your PATH")
+        print("2. Install missing dependencies")
+        print("3. Check the config file path")
+        print("4. Ensure all paths are correct")
+
+    print("\n" + "=" * 50)
+    input("Press Enter to exit...")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/test_mcp_client.py b/test_mcp_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..7fcf719943c79f0e731afb734a3f97ce62836013
--- /dev/null
+++ b/test_mcp_client.py
@@ -0,0 +1,66 @@
+"""
+Simple MCP Client Tester
+Tests the MCP server tools directly
+"""
+
+import asyncio
+import httpx
+import json
+
+async def test_mcp_tools():
+    """Test various MCP tools"""
+
+    # The SSE endpoint URL
+    url = "http://localhost:8000/sse"
+
+    print("Testing MCP Server at:", url)
+    print("=" * 50)
+
+    # Test 1: Check if SSE endpoint is accessible
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(url)
+            print(f"✓ SSE Endpoint accessible: {response.status_code}")
+        except Exception as e:
+            print(f"✗ Cannot reach SSE endpoint: {e}")
+            return
+
+    print("\nThe MCP server is running and ready!")
+    print("To fully test the tools, use Claude Desktop with the configuration provided.")
+
+    # Show available endpoints
+    print("\n" + "=" * 50)
+    print("Available MCP Tools:")
+    print("=" * 50)
+
+    tools = [
+        "Document Tools:",
+        "  - list_all_documents()",
+        "  - search_documents(query, file_type)",
+        "  - read_text_file(filename)",
+        "  - extract_pdf_text(filename)",
+        "  - get_document_summary(filename)",
+        "",
+        "Calendar Tools:",
+        "  - get_all_exams()",
+        "  - get_exams_this_week()",
+        "  - get_upcoming_exams(days)",
+        "  - get_exam_statistics()",
+        "",
+        "Server Info:",
+        "  - get_server_info()"
+    ]
+
+    for tool in tools:
+        print(tool)
+
+    print("\n" + "=" * 50)
+    print("Setup Instructions for Claude Desktop:")
+    print("=" * 50)
+    print("1. Open: %APPDATA%\\Claude\\claude_desktop_config.json")
+    print("2. Add the configuration from claude_desktop_config.json")
+    print("3. Restart Claude Desktop")
+    print("4. Test by asking: 'Show me all documents in the exam hub'")
+
+if __name__ == "__main__":
+    asyncio.run(test_mcp_tools())
\ No newline at end of file