feat: Complete session management system with automatic session creation

- Automatic session creation on page load
- Session persistence with localStorage
- File upload/download with session isolation
- Document generation (DOCX, PDF, PPT, Excel)
- MCP server for Claude Desktop integration
- Removed code executor components

.claude/settings.local.json

@@ -3,7 +3,24 @@
     "allow": [
       "Bash(dir:*)",
       "Bash(del nul)",
-      "Bash(rm:*)"
+      "Bash(rm:*)",
+      "Bash(find:*)",
+      "Bash(npm run build:*)",
+      "Bash(npm install:*)",
+      "Bash(npm run dev:*)",
+      "Bash(lsof:*)",
+      "Bash(chmod:*)",
+      "Bash(node test-mcp-local.js:*)",
+      "Bash(REUBENOS_URL=http://localhost:3000 node:*)",
+      "Bash(kill:*)",
+      "Bash(node test-document-gen.js:*)",
+      "Bash(git clone:*)",
+      "Bash(cat:*)",
+      "Bash(git rm:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(git push:*)",
+      "Bash(git filter-branch:*)"
     ],
     "deny": [],
     "ask": []

CLAUDE_DESKTOP_SETUP.md

@@ -1,99 +1,256 @@
-# Setting Up MCP with Claude Desktop
+# 🚀 Connect ReubenOS to Claude Desktop via MCP
 
-## Step 1: Find Your Claude Desktop Config File
+Follow these steps to connect your ReubenOS file management system to Claude Desktop:
 
-Open File Explorer and navigate to:
-```
-C:\Users\[YourUsername]\AppData\Roaming\Claude\
+## Prerequisites
+1. Claude Desktop app installed
+2. Node.js 18+ installed
+3. ReubenOS running locally
+
+## Step 1: Install MCP Server Dependencies
+
+```bash
+cd /Users/reubenfernandes/Desktop/Mcp-hackathon-winter25
+npm install @modelcontextprotocol/sdk node-fetch
 ```
 
-Or press `Win+R` and type:
+## Step 2: Start ReubenOS (Your Web App)
+
+Make sure your ReubenOS is running:
+
+```bash
+npm run dev
 ```
-%APPDATA%\Claude
+
+The server should be running at `http://localhost:3000` (or port 3002 if 3000 is busy)
+
+## Step 3: Configure Claude Desktop
+
+### For macOS:
+
+1. **Open your Claude Desktop configuration file:**
+   ```bash
+   open ~/Library/Application\ Support/Claude/claude_desktop_config.json
+   ```
+
+   If it doesn't exist, create it:
+   ```bash
+   mkdir -p ~/Library/Application\ Support/Claude
+   touch ~/Library/Application\ Support/Claude/claude_desktop_config.json
+   ```
+
+2. **Add this configuration:**
+
+```json
+{
+  "mcpServers": {
+    "reubenos": {
+      "command": "node",
+      "args": ["/Users/reubenfernandes/Desktop/Mcp-hackathon-winter25/mcp-server.js"],
+      "env": {
+        "REUBENOS_URL": "http://localhost:3000"
+      }
+    }
+  }
+}
 ```
 
-## Step 2: Edit claude_desktop_config.json
+**Note**: If your ReubenOS is running on port 3002, change the URL to `http://localhost:3002`
+
+### For Windows:
 
-If the file doesn't exist, create it. Add this content:
+1. **Open File Explorer and navigate to:**
+   ```
+   %APPDATA%\Claude\
+   ```
+
+2. **Create or edit `claude_desktop_config.json`:**
 
 ```json
 {
   "mcpServers": {
-    "semsoon": {
-      "command": "python",
-      "args": ["E:\\mpc-hackathon\\backend\\mcp_server.py"],
+    "reubenos": {
+      "command": "node",
+      "args": ["C:\\path\\to\\your\\Mcp-hackathon-winter25\\mcp-server.js"],
       "env": {
-        "UPLOAD_PASSCODE": "semsoon-secure-2025",
-        "DATA_DIR": "E:\\mpc-hackathon\\data"
+        "REUBENOS_URL": "http://localhost:3000"
       }
     }
   }
 }
 ```
 
-## Step 3: Restart Claude Desktop
+## Step 4: Restart Claude Desktop
+
+1. **Completely quit Claude Desktop** (check system tray/menu bar)
+2. **Start Claude Desktop again**
+3. The MCP server should now be connected!
+
+## Step 5: Test the Connection
+
+In a new Claude Desktop conversation, try these commands:
+
+### Create a new session:
+```
+Can you create a new session for me using the reubenos MCP server?
+```
+
+### Generate a document:
+```
+Using reubenos, generate a Word document with a sample report and save it to my session
+```
+
+### List files:
+```
+Using reubenos, show me all files in my session
+```
 
-1. Completely close Claude Desktop (check system tray)
-2. Open Claude Desktop again
-3. The MCP server should start automatically
+## 📝 Available MCP Tools
 
-## Step 4: Test in Claude Desktop
+Once connected, Claude can use these tools:
 
-Open a new conversation and try these:
+| Tool | Description | Example Request |
+|------|-------------|-----------------|
+| **create_session** | Create a new isolated session | "Create a new session for me" |
+| **upload_file** | Upload files to session/public | "Upload this text as notes.txt" |
+| **download_file** | Download files from storage | "Download report.docx from my session" |
+| **list_files** | List all files | "Show all files in public folder" |
+| **generate_document** | Create DOCX, PDF, PPT, Excel | "Generate a PowerPoint about AI" |
+| **process_document** | Read and analyze docs | "Read and analyze sales.xlsx" |
 
-1. **Basic test**: "What MCP servers are available?"
-   - Claude should mention "semsoon"
+## Example Workflows
 
-2. **List documents**: "Using semsoon, show me all available documents"
-   - Should list the sample documents
+### Document Generation Workflow
+```
+You: Create a new session for document management
+Claude: [Creates session and provides key]
 
-3. **Check exams**: "Using semsoon, what exams are scheduled?"
-   - Should show the sample exams
+You: Generate a PowerPoint presentation about our Q4 results
+Claude: [Generates PPT and saves to session]
 
-4. **Read a file**: "Using semsoon, read the study_tips.md file"
-   - Should display the content
+You: Now create an Excel spreadsheet with the financial data
+Claude: [Generates Excel file]
 
-## If It's Not Working
+You: List all my files
+Claude: [Shows all generated documents]
+```
 
-### Check 1: Python Path
-Make sure Python is in your PATH:
-```cmd
-python --version
+### File Sharing Workflow
 ```
+You: Create a session and upload my notes as a public file
+Claude: [Creates session and uploads to public]
 
-If not, use full path in config:
-```json
-"command": "C:\\Python311\\python.exe"
+You: List all public files
+Claude: [Shows all publicly shared files]
+```
+
+## 🔧 Troubleshooting
+
+### Issue: MCP Server Not Connecting
+
+1. **Verify ReubenOS is running:**
+   ```bash
+   curl http://localhost:3000
+   ```
+
+2. **Check Claude Desktop logs:**
+   - macOS: `~/Library/Logs/Claude/`
+   - Windows: `%LOCALAPPDATA%\Claude\logs\`
+
+3. **Verify Node.js version:**
+   ```bash
+   node --version  # Should be 18+
+   ```
+
+### Issue: Permission Denied
+
+Make the MCP server executable:
+```bash
+chmod +x /Users/reubenfernandes/Desktop/Mcp-hackathon-winter25/mcp-server.js
 ```
 
-### Check 2: Dependencies
-```cmd
-pip install fastmcp PyPDF2 python-docx python-dotenv
+### Issue: Port Already in Use
+
+Check which port your app is using:
+```bash
+lsof -i :3000
+lsof -i :3002
 ```
 
-### Check 3: Test Server Manually
-```cmd
-cd E:\mpc-hackathon\backend
-python mcp_server.py
+Update the `REUBENOS_URL` in the config accordingly.
+
+### View Debug Output
+
+In Claude Desktop, you can open Developer Tools:
+- macOS: `Cmd+Option+I`
+- Windows: `Ctrl+Shift+I`
+
+Check the Console tab for any MCP-related errors.
+
+## 🎯 Quick Test
+
+Create this test script as `test-reubenos.sh`:
+
+```bash
+#!/bin/bash
+echo "Testing ReubenOS Connection..."
+
+# Check if server is running
+if curl -s http://localhost:3000 > /dev/null 2>&1; then
+    echo "✅ ReubenOS running on port 3000"
+    PORT=3000
+elif curl -s http://localhost:3002 > /dev/null 2>&1; then
+    echo "✅ ReubenOS running on port 3002"
+    PORT=3002
+else
+    echo "❌ ReubenOS not running. Start with: npm run dev"
+    exit 1
+fi
+
+# Test session creation
+echo -e "\nTesting session creation..."
+response=$(curl -s -X POST http://localhost:$PORT/api/sessions/create \
+  -H "Content-Type: application/json" \
+  -d '{"metadata": {"test": true}}')
+
+if echo "$response" | grep -q "session"; then
+    echo "✅ Session API working!"
+    echo "$response" | python3 -m json.tool
+else
+    echo "❌ Session API not responding correctly"
+fi
+```
+
+Run it:
+```bash
+chmod +x test-reubenos.sh
+./test-reubenos.sh
 ```
-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, in Claude Desktop you'll be able to:
+
+1. ✅ See "reubenos" mentioned when asking about available MCP servers
+2. ✅ Create sessions and get unique session keys
+3. ✅ Generate Word, PDF, PowerPoint, and Excel documents
+4. ✅ Upload and download files
+5. ✅ List files in session and public folders
+6. ✅ Process and analyze documents
+
+## 💡 Pro Tips
 
-## What Success Looks Like
+1. **Keep your session key safe** - It's your access to private files
+2. **Use public folder** for files you want to share
+3. **Sessions auto-expire** after 24 hours of inactivity
+4. **Generate multiple documents** in one session for organization
 
-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)
+## Need More Help?
 
-## Current Server Status
+- Check the [MCP Documentation](https://github.com/anthropics/model-context-protocol)
+- View your API documentation at `http://localhost:3000/mcp-config.json`
+- Check server logs with `npm run dev`
 
-✅ 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!
+**Ready to go!** Your ReubenOS file management system is now accessible through Claude Desktop! 🎉

Empc-hackathonpublicbackground_readme.txt

@@ -1 +0,0 @@
-Please add your background.webp file to the public directory at E:\mpc-hackathon\public\background.webp

RUN_INSTRUCTIONS.md

@@ -0,0 +1,134 @@
+# 🚀 How to Run ReubenOS with Claude Desktop MCP
+
+## Understanding the Architecture
+
+```
+┌─────────────────┐         ┌──────────────┐         ┌─────────────┐
+│  Claude Desktop │ ──MCP──> │  MCP Server  │ ──API─> │  ReubenOS   │
+│   (Auto-starts  │         │(mcp-server.js)│         │  (port 3000) │
+│   MCP server)   │         └──────────────┘         └─────────────┘
+└─────────────────┘
+```
+
+## Step-by-Step Instructions
+
+### 1️⃣ Start ReubenOS (Your Web App)
+
+```bash
+cd /Users/reubenfernandes/Desktop/Mcp-hackathon-winter25
+npm run dev
+```
+
+✅ This starts your web app on `http://localhost:3000`
+✅ You can access the Session Manager at http://localhost:3000
+
+### 2️⃣ Configure Claude Desktop
+
+Create/Edit the config file:
+```bash
+# Open the config file
+open ~/Library/Application\ Support/Claude/claude_desktop_config.json
+```
+
+Add this configuration:
+```json
+{
+  "mcpServers": {
+    "reubenos": {
+      "command": "node",
+      "args": ["/Users/reubenfernandes/Desktop/Mcp-hackathon-winter25/mcp-server.js"],
+      "env": {
+        "REUBENOS_URL": "http://localhost:3000"
+      }
+    }
+  }
+}
+```
+
+### 3️⃣ Restart Claude Desktop
+
+1. Completely quit Claude Desktop (⌘Q or check menu bar)
+2. Start Claude Desktop again
+3. **Claude Desktop will automatically start the MCP server!**
+
+## ⚠️ IMPORTANT: You DON'T manually run mcp-server.js!
+
+The MCP server (`mcp-server.js`) is **automatically started by Claude Desktop** when it reads your config. You only need to:
+1. Run your ReubenOS app (`npm run dev`)
+2. Configure Claude Desktop
+3. Restart Claude Desktop
+
+## Testing Your Setup
+
+### Test 1: Check if ReubenOS is running
+```bash
+curl http://localhost:3000
+```
+
+### Test 2: Test MCP Integration (without Claude Desktop)
+```bash
+cd /Users/reubenfernandes/Desktop/Mcp-hackathon-winter25
+node test-mcp-local.js
+```
+
+### Test 3: In Claude Desktop
+Once configured, in a new Claude Desktop chat, try:
+```
+"Using reubenos, create a new session"
+```
+
+## Troubleshooting
+
+### If port 3000 is busy:
+```bash
+# Check what's using port 3000
+lsof -i :3000
+
+# Kill the process (replace PID with actual process ID)
+kill -9 PID
+
+# Or use a different port
+npm run dev -- --port 3002
+```
+
+Then update your Claude Desktop config:
+```json
+"REUBENOS_URL": "http://localhost:3002"
+```
+
+### If MCP doesn't connect in Claude Desktop:
+
+1. Check Claude Desktop logs:
+   - Open Developer Tools: `Cmd+Option+I`
+   - Check Console for errors
+
+2. Verify config file is valid JSON:
+   ```bash
+   cat ~/Library/Application\ Support/Claude/claude_desktop_config.json | python3 -m json.tool
+   ```
+
+3. Make sure ReubenOS is running:
+   ```bash
+   ps aux | grep "next dev"
+   ```
+
+## Quick Commands
+
+```bash
+# Start everything (run in project directory)
+npm run dev
+
+# Test MCP locally (optional, for debugging)
+node test-mcp-local.js
+
+# Check if services are running
+curl http://localhost:3000  # Should return HTML
+```
+
+## Summary
+
+✅ **You only run ONE server manually**: `npm run dev` (ReubenOS)
+✅ **Claude Desktop runs the MCP server automatically**
+✅ **The MCP server connects to your ReubenOS API**
+
+That's it! Once ReubenOS is running and Claude Desktop is configured, everything works automatically.

SESSION_SYSTEM.md

@@ -0,0 +1,230 @@
+# 📁 ReubenOS Session & File System
+
+## 🗂️ Folder Structure
+
+```
+data/
+├── files/          # PRIVATE session folders (requires session key)
+│   ├── session_xxx/
+│   │   ├── session.json
+│   │   ├── document1.docx
+│   │   └── report.pdf
+│   └── session_yyy/
+│       └── ...
+└── public/         # PUBLIC folder (no authentication needed)
+    ├── shared-doc.docx
+    └── public-file.pdf
+```
+
+## 🔐 How It Works
+
+### **Private Sessions (data/files/)**
+- Each user gets a **unique session key** when they create a session
+- Files are stored in `data/files/{session_id}/`
+- **Only users with the correct session key can access their files**
+- Complete isolation between users
+- Example: User A cannot see User B's files
+
+### **Public Folder (data/public/)**
+- **No authentication required** to upload or download
+- Anyone can upload files here
+- Files are shared with everyone
+- Use for: shared resources, public documents, collaboration
+
+## 🔑 Session System
+
+### Creating a Session
+```bash
+POST /api/sessions/create
+Response:
+{
+  "success": true,
+  "session": {
+    "id": "session_1234567890_abc123",
+    "key": "e2d51cc7ab787de753ff574d5972a042...",
+    "createdAt": "2025-11-14T12:00:00.000Z"
+  }
+}
+```
+
+**IMPORTANT**: Save the `key` - you'll need it for all operations!
+
+### Uploading to Private Session
+```bash
+POST /api/sessions/upload
+Headers:
+  x-session-key: YOUR_SESSION_KEY
+Body (form-data):
+  file: [your file]
+  public: false
+```
+
+### Uploading to Public Folder
+```bash
+# Option 1: Via sessions endpoint
+POST /api/sessions/upload
+Body (form-data):
+  file: [your file]
+  public: true
+# NO session key needed!
+
+# Option 2: Direct public endpoint
+POST /api/public/upload
+Body (form-data):
+  file: [your file]
+# NO session key needed!
+```
+
+### Downloading Files
+
+**From Private Session:**
+```bash
+GET /api/sessions/download?file=document.docx
+Headers:
+  x-session-key: YOUR_SESSION_KEY
+```
+
+**From Public Folder:**
+```bash
+GET /api/sessions/download?file=document.docx&public=true
+# NO session key needed!
+```
+
+## 📄 Document Generation
+
+### Generate Document to Private Session
+```bash
+POST /api/documents/generate
+Headers:
+  x-session-key: YOUR_SESSION_KEY
+Body:
+{
+  "type": "docx",
+  "fileName": "my-document",
+  "content": {
+    "title": "My Document",
+    "sections": [
+      {
+        "type": "header",
+        "content": "Header text here"
+      },
+      {
+        "type": "body",
+        "paragraphs": [
+          "Paragraph 1",
+          "Paragraph 2"
+        ]
+      }
+    ]
+  },
+  "isPublic": false
+}
+```
+
+### Generate Document to Public Folder
+Same as above, but set:
+```json
+"isPublic": true
+```
+
+## 🔒 Security Features
+
+1. **Session Isolation**: Each session key gives access ONLY to that session's files
+2. **Cryptographic Keys**: Session keys are 64-character hex strings (256-bit security)
+3. **No Cross-Session Access**: Users cannot access other users' private files
+4. **Public by Choice**: Users explicitly choose to make files public
+5. **Auto-Cleanup**: Old sessions (24+ hours inactive) are automatically deleted
+
+## 📊 Use Cases
+
+### Private Use (Session-based)
+- Personal documents
+- User-specific data
+- Private reports
+- Confidential files
+- Individual workspace
+
+### Public Use (Shared)
+- Collaboration documents
+- Shared resources
+- Templates
+- Public announcements
+- Common files
+
+## 💡 Best Practices
+
+1. **Keep Your Session Key Secure**
+   - Don't share your session key
+   - Store it securely (like a password)
+   - Each user should have their own session
+
+2. **Use Public Folder Wisely**
+   - Only upload files meant to be shared
+   - Don't upload sensitive information
+   - Remember: anyone can download from public
+
+3. **Session Management**
+   - Create a new session for each user
+   - Sessions expire after 24 hours of inactivity
+   - Re-create session if expired
+
+4. **File Naming**
+   - Use descriptive file names
+   - Avoid duplicate names in same folder
+   - Include file extensions
+
+## 🧪 Testing Your Setup
+
+```bash
+# 1. Create a session
+curl -X POST http://localhost:3000/api/sessions/create \
+  -H "Content-Type: application/json" \
+  -d '{"metadata": {"user": "test"}}'
+
+# Save the session key from response!
+
+# 2. Generate a document (private)
+curl -X POST http://localhost:3000/api/documents/generate \
+  -H "Content-Type: application/json" \
+  -H "x-session-key: YOUR_SESSION_KEY" \
+  -d '{
+    "type": "docx",
+    "fileName": "test-doc",
+    "content": {
+      "title": "Test Document",
+      "content": "This is a test document."
+    },
+    "isPublic": false
+  }'
+
+# 3. List your files
+curl http://localhost:3000/api/sessions/files \
+  -H "x-session-key: YOUR_SESSION_KEY"
+
+# 4. Upload to public (no auth needed!)
+curl -X POST http://localhost:3000/api/public/upload \
+  -F "[email protected]"
+```
+
+## ❓ FAQ
+
+**Q: Can I access another user's files?**
+A: No. Each session is completely isolated. You need the exact session key to access a session's files.
+
+**Q: What happens if I lose my session key?**
+A: Your files become inaccessible. Session keys cannot be recovered. Always save your session key securely!
+
+**Q: Can I make a private file public later?**
+A: Yes, download it from your session and re-upload to public folder.
+
+**Q: How long do sessions last?**
+A: Sessions are automatically cleaned up after 24 hours of inactivity.
+
+**Q: Where are files actually stored?**
+A:
+- Private: `data/files/{session_id}/`
+- Public: `data/public/`
+
+---
+
+**Security Note**: Never share your session key. Treat it like a password!

app/api/code/execute/route.ts

@@ -1,186 +0,0 @@
-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 || []
-  })
-}

app/api/code/public/route.ts

@@ -1,85 +0,0 @@
-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 }
-    )
-  }
-}

app/api/code/save/route.ts

@@ -1,130 +0,0 @@
-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 }
-    )
-  }
-}

app/api/documents/generate/route.ts

@@ -0,0 +1,194 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { SessionManager } from '@/lib/sessionManager';
+import { DocumentGenerator } from '@/lib/documentGenerators';
+
+export async function POST(request: NextRequest) {
+  try {
+    const sessionManager = SessionManager.getInstance();
+
+    // Get session key from headers
+    const sessionKey = request.headers.get('x-session-key');
+    if (!sessionKey) {
+      return NextResponse.json(
+        { success: false, error: 'Session key is required' },
+        { status: 401 }
+      );
+    }
+
+    // Validate session
+    const isValid = await sessionManager.validateSession(sessionKey);
+    if (!isValid) {
+      return NextResponse.json(
+        { success: false, error: 'Invalid or expired session key' },
+        { status: 401 }
+      );
+    }
+
+    const body = await request.json();
+    const { type, fileName, content, isPublic = false } = body;
+
+    if (!type || !fileName || !content) {
+      return NextResponse.json(
+        { success: false, error: 'Type, fileName, and content are required' },
+        { status: 400 }
+      );
+    }
+
+    let fileBuffer: Buffer;
+    let finalFileName = fileName;
+
+    try {
+      switch (type.toLowerCase()) {
+        case 'docx':
+        case 'word':
+          fileBuffer = await DocumentGenerator.generateDOCX({
+            title: content.title,
+            content: content.body || content.content || content
+          });
+          if (!finalFileName.endsWith('.docx')) {
+            finalFileName += '.docx';
+          }
+          break;
+
+        case 'pdf':
+          fileBuffer = await DocumentGenerator.generatePDF({
+            title: content.title,
+            content: content.body || content.content || content
+          });
+          if (!finalFileName.endsWith('.pdf')) {
+            finalFileName += '.pdf';
+          }
+          break;
+
+        case 'latex':
+        case 'latex-pdf':
+          fileBuffer = await DocumentGenerator.generateLatexPDF(
+            content.latex || content.body || content.content || content
+          );
+          if (!finalFileName.endsWith('.pdf')) {
+            finalFileName += '.pdf';
+          }
+          break;
+
+        case 'ppt':
+        case 'pptx':
+        case 'powerpoint':
+          const slides = content.slides || [
+            {
+              title: content.title || 'Presentation',
+              content: content.body || content.content || '',
+              bullets: content.bullets
+            }
+          ];
+          fileBuffer = await DocumentGenerator.generatePowerPoint(slides);
+          if (!finalFileName.endsWith('.pptx')) {
+            finalFileName += '.pptx';
+          }
+          break;
+
+        case 'excel':
+        case 'xlsx':
+        case 'spreadsheet':
+          const excelData = content.sheets || {
+            sheets: [{
+              name: content.sheetName || 'Sheet1',
+              data: {
+                headers: content.headers || [],
+                rows: content.rows || []
+              }
+            }]
+          };
+          fileBuffer = await DocumentGenerator.generateExcel(excelData);
+          if (!finalFileName.endsWith('.xlsx')) {
+            finalFileName += '.xlsx';
+          }
+          break;
+
+        default:
+          return NextResponse.json(
+            { success: false, error: `Unsupported document type: ${type}` },
+            { status: 400 }
+          );
+      }
+    } catch (error) {
+      console.error('Error generating document:', error);
+      return NextResponse.json(
+        { success: false, error: `Failed to generate ${type} document: ${error}` },
+        { status: 500 }
+      );
+    }
+
+    // Save the generated file
+    let filePath: string;
+    if (isPublic) {
+      filePath = await sessionManager.saveFileToPublic(finalFileName, fileBuffer);
+    } else {
+      filePath = await sessionManager.saveFileToSession(sessionKey, finalFileName, fileBuffer);
+    }
+
+    return NextResponse.json({
+      success: true,
+      message: `${type.toUpperCase()} document generated successfully`,
+      fileName: finalFileName,
+      size: fileBuffer.length,
+      type: type,
+      isPublic,
+      path: filePath
+    });
+  } catch (error) {
+    console.error('Error in document generation:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to generate document' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET() {
+  return NextResponse.json({
+    message: 'Document generation endpoint',
+    endpoint: '/api/documents/generate',
+    method: 'POST',
+    headers: {
+      'x-session-key': 'Your session key (required)'
+    },
+    body: {
+      type: 'Document type: docx, pdf, latex, ppt, excel',
+      fileName: 'Output file name',
+      isPublic: 'true/false - whether to save in public folder',
+      content: {
+        description: 'Content structure varies by type',
+        examples: {
+          docx: {
+            title: 'Document Title',
+            content: 'Document content with markdown formatting'
+          },
+          pdf: {
+            title: 'PDF Title',
+            content: 'PDF content with markdown formatting'
+          },
+          powerpoint: {
+            slides: [
+              {
+                title: 'Slide 1',
+                content: 'Content',
+                bullets: ['Point 1', 'Point 2']
+              }
+            ]
+          },
+          excel: {
+            sheets: [
+              {
+                name: 'Sheet1',
+                data: {
+                  headers: ['Column 1', 'Column 2'],
+                  rows: [['Data 1', 'Data 2']]
+                }
+              }
+            ]
+          }
+        }
+      }
+    }
+  });
+}

app/api/documents/process/route.ts

@@ -0,0 +1,216 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { SessionManager } from '@/lib/sessionManager';
+import mammoth from 'mammoth';
+import ExcelJS from 'exceljs';
+import fs from 'fs/promises';
+import path from 'path';
+
+export async function POST(request: NextRequest) {
+  try {
+    const sessionManager = SessionManager.getInstance();
+
+    // Get session key from headers
+    const sessionKey = request.headers.get('x-session-key');
+    if (!sessionKey) {
+      return NextResponse.json(
+        { success: false, error: 'Session key is required' },
+        { status: 401 }
+      );
+    }
+
+    // Validate session
+    const isValid = await sessionManager.validateSession(sessionKey);
+    if (!isValid) {
+      return NextResponse.json(
+        { success: false, error: 'Invalid or expired session key' },
+        { status: 401 }
+      );
+    }
+
+    const body = await request.json();
+    const { fileName, isPublic = false, operation = 'read' } = body;
+
+    if (!fileName) {
+      return NextResponse.json(
+        { success: false, error: 'File name is required' },
+        { status: 400 }
+      );
+    }
+
+    // Get file buffer
+    let fileBuffer: Buffer;
+    try {
+      if (isPublic) {
+        fileBuffer = await sessionManager.getFileFromPublic(fileName);
+      } else {
+        fileBuffer = await sessionManager.getFileFromSession(sessionKey, fileName);
+      }
+    } catch (error) {
+      return NextResponse.json(
+        { success: false, error: 'File not found' },
+        { status: 404 }
+      );
+    }
+
+    const ext = fileName.split('.').pop()?.toLowerCase();
+    let content: any = {};
+
+    switch (ext) {
+      case 'docx':
+        // Process Word document
+        try {
+          const result = await mammoth.extractRawText({ buffer: fileBuffer });
+          content = {
+            type: 'docx',
+            text: result.value,
+            messages: result.messages
+          };
+
+          // Also get structured HTML
+          const htmlResult = await mammoth.convertToHtml({ buffer: fileBuffer });
+          content.html = htmlResult.value;
+        } catch (error) {
+          content = {
+            type: 'docx',
+            error: 'Failed to process Word document',
+            details: error
+          };
+        }
+        break;
+
+      case 'xlsx':
+      case 'xls':
+        // Process Excel spreadsheet
+        try {
+          const workbook = new ExcelJS.Workbook();
+          await workbook.xlsx.load(fileBuffer as any);
+
+          const sheets: any[] = [];
+          workbook.eachSheet((worksheet) => {
+            const sheetData: any = {
+              name: worksheet.name,
+              rowCount: worksheet.rowCount,
+              columnCount: worksheet.columnCount,
+              data: []
+            };
+
+            worksheet.eachRow((row, rowNumber) => {
+              const rowData: any[] = [];
+              row.eachCell((cell, colNumber) => {
+                rowData.push({
+                  value: cell.value,
+                  type: cell.type,
+                  formula: cell.formula
+                });
+              });
+              sheetData.data.push(rowData);
+            });
+
+            sheets.push(sheetData);
+          });
+
+          content = {
+            type: 'excel',
+            sheets,
+            sheetCount: sheets.length
+          };
+        } catch (error) {
+          content = {
+            type: 'excel',
+            error: 'Failed to process Excel spreadsheet',
+            details: error
+          };
+        }
+        break;
+
+      case 'pdf':
+        // For PDF, we'll return metadata for now
+        // Full PDF text extraction would require pdf-parse or similar
+        content = {
+          type: 'pdf',
+          fileName,
+          size: fileBuffer.length,
+          message: 'PDF processing requires additional libraries for text extraction'
+        };
+        break;
+
+      case 'pptx':
+      case 'ppt':
+        // PowerPoint processing would require additional libraries
+        content = {
+          type: 'powerpoint',
+          fileName,
+          size: fileBuffer.length,
+          message: 'PowerPoint processing requires additional libraries'
+        };
+        break;
+
+      case 'txt':
+      case 'md':
+      case 'json':
+      case 'csv':
+        // Text-based files
+        content = {
+          type: ext,
+          text: fileBuffer.toString('utf-8')
+        };
+        break;
+
+      default:
+        content = {
+          type: 'unknown',
+          fileName,
+          size: fileBuffer.length,
+          message: 'Unknown file type'
+        };
+    }
+
+    // Perform requested operation
+    if (operation === 'analyze' && content.text) {
+      // Basic text analysis
+      const text = content.text || '';
+      content.analysis = {
+        characterCount: text.length,
+        wordCount: text.split(/\s+/).filter(Boolean).length,
+        lineCount: text.split('\n').length,
+        paragraphCount: text.split('\n\n').filter(Boolean).length
+      };
+    }
+
+    return NextResponse.json({
+      success: true,
+      fileName,
+      operation,
+      content
+    });
+  } catch (error) {
+    console.error('Error processing document:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to process document' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET() {
+  return NextResponse.json({
+    message: 'Document processing endpoint',
+    endpoint: '/api/documents/process',
+    method: 'POST',
+    headers: {
+      'x-session-key': 'Your session key (required)'
+    },
+    body: {
+      fileName: 'Name of the file to process',
+      isPublic: 'true/false - whether file is in public folder',
+      operation: 'Operation to perform: read (default), analyze'
+    },
+    supportedFormats: [
+      'docx - Word documents (text extraction)',
+      'xlsx/xls - Excel spreadsheets (data extraction)',
+      'pdf - PDF files (metadata only)',
+      'pptx/ppt - PowerPoint (metadata only)',
+      'txt/md/json/csv - Text files (full content)'
+    ]
+  });
+}

app/api/public/upload/route.ts

@@ -0,0 +1,58 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { SessionManager } from '@/lib/sessionManager';
+
+export async function POST(request: NextRequest) {
+  try {
+    const sessionManager = SessionManager.getInstance();
+
+    // Get form data
+    const formData = await request.formData();
+    const file = formData.get('file') as File;
+
+    if (!file) {
+      return NextResponse.json(
+        { success: false, error: 'No file provided' },
+        { status: 400 }
+      );
+    }
+
+    // Read file content
+    const bytes = await file.arrayBuffer();
+    const buffer = Buffer.from(bytes);
+
+    // Save to public folder - NO AUTHENTICATION REQUIRED!
+    const filePath = await sessionManager.saveFileToPublic(file.name, buffer);
+
+    return NextResponse.json({
+      success: true,
+      message: 'File uploaded to public folder successfully!',
+      fileName: file.name,
+      size: file.size,
+      type: file.type,
+      isPublic: true,
+      path: filePath,
+      note: 'This file is publicly accessible to everyone'
+    });
+  } catch (error) {
+    console.error('Error uploading public file:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to upload file' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET() {
+  return NextResponse.json({
+    message: 'Public file upload endpoint - NO AUTHENTICATION REQUIRED',
+    endpoint: '/api/public/upload',
+    method: 'POST',
+    headers: {
+      'x-session-key': 'NOT REQUIRED for public uploads'
+    },
+    body: {
+      file: 'File to upload (multipart/form-data)'
+    },
+    note: 'Files uploaded here are accessible to everyone. For private files, use /api/sessions/upload with a session key.'
+  });
+}

app/api/sessions/create/route.ts

@@ -0,0 +1,40 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { SessionManager } from '@/lib/sessionManager';
+
+export async function POST(request: NextRequest) {
+  try {
+    const sessionManager = SessionManager.getInstance();
+    const body = await request.json().catch(() => ({}));
+
+    const session = await sessionManager.createSession(body.metadata);
+
+    return NextResponse.json({
+      success: true,
+      session: {
+        id: session.id,
+        key: session.key,
+        createdAt: session.createdAt,
+        message: 'Session created successfully. Keep your session key secure!'
+      }
+    });
+  } catch (error) {
+    console.error('Error creating session:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to create session' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET() {
+  return NextResponse.json({
+    message: 'Use POST to create a new session',
+    endpoint: '/api/sessions/create',
+    method: 'POST',
+    body: {
+      metadata: {
+        description: 'Optional metadata object'
+      }
+    }
+  });
+}

app/api/sessions/download/route.ts

@@ -0,0 +1,102 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { SessionManager } from '@/lib/sessionManager';
+
+export async function GET(request: NextRequest) {
+  try {
+    const sessionManager = SessionManager.getInstance();
+    const { searchParams } = new URL(request.url);
+    const fileName = searchParams.get('file');
+    const isPublic = searchParams.get('public') === 'true';
+
+    if (!fileName) {
+      return NextResponse.json(
+        { success: false, error: 'File name is required' },
+        { status: 400 }
+      );
+    }
+
+    let fileBuffer: Buffer;
+
+    if (isPublic) {
+      // Get from public folder
+      try {
+        fileBuffer = await sessionManager.getFileFromPublic(fileName);
+      } catch (error) {
+        return NextResponse.json(
+          { success: false, error: 'File not found in public folder' },
+          { status: 404 }
+        );
+      }
+    } else {
+      // Get session key from headers
+      const sessionKey = request.headers.get('x-session-key');
+      if (!sessionKey) {
+        return NextResponse.json(
+          { success: false, error: 'Session key is required for private files' },
+          { status: 401 }
+        );
+      }
+
+      // Validate session
+      const isValid = await sessionManager.validateSession(sessionKey);
+      if (!isValid) {
+        return NextResponse.json(
+          { success: false, error: 'Invalid or expired session key' },
+          { status: 401 }
+        );
+      }
+
+      // Get from session folder
+      try {
+        fileBuffer = await sessionManager.getFileFromSession(sessionKey, fileName);
+      } catch (error) {
+        return NextResponse.json(
+          { success: false, error: 'File not found in session' },
+          { status: 404 }
+        );
+      }
+    }
+
+    // Determine content type based on file extension
+    const ext = fileName.split('.').pop()?.toLowerCase();
+    let contentType = 'application/octet-stream';
+
+    const contentTypes: Record<string, string> = {
+      'pdf': 'application/pdf',
+      'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      'doc': 'application/msword',
+      'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      'xls': 'application/vnd.ms-excel',
+      'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+      'ppt': 'application/vnd.ms-powerpoint',
+      'txt': 'text/plain',
+      'json': 'application/json',
+      'html': 'text/html',
+      'css': 'text/css',
+      'js': 'application/javascript',
+      'png': 'image/png',
+      'jpg': 'image/jpeg',
+      'jpeg': 'image/jpeg',
+      'gif': 'image/gif',
+      'svg': 'image/svg+xml'
+    };
+
+    if (ext && contentTypes[ext]) {
+      contentType = contentTypes[ext];
+    }
+
+    return new NextResponse(fileBuffer as any, {
+      headers: {
+        'Content-Type': contentType,
+        'Content-Disposition': `attachment; filename="${fileName}"`,
+        'Content-Length': fileBuffer.length.toString()
+      }
+    });
+  } catch (error) {
+    console.error('Error downloading file:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to download file' },
+      { status: 500 }
+    );
+  }
+}

app/api/sessions/files/route.ts

@@ -0,0 +1,102 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { SessionManager } from '@/lib/sessionManager';
+import fs from 'fs/promises';
+import path from 'path';
+
+export async function GET(request: NextRequest) {
+  try {
+    const sessionManager = SessionManager.getInstance();
+    const { searchParams } = new URL(request.url);
+    const listPublic = searchParams.get('public') === 'true';
+
+    if (listPublic) {
+      // List public files
+      const publicPath = sessionManager.getPublicPath();
+      try {
+        const files = await fs.readdir(publicPath);
+        const fileDetails = await Promise.all(
+          files.map(async (fileName) => {
+            const filePath = path.join(publicPath, fileName);
+            const stats = await fs.stat(filePath);
+            return {
+              name: fileName,
+              size: stats.size,
+              modified: stats.mtime,
+              created: stats.ctime
+            };
+          })
+        );
+
+        return NextResponse.json({
+          success: true,
+          files: fileDetails,
+          count: fileDetails.length,
+          type: 'public'
+        });
+      } catch (error) {
+        return NextResponse.json({
+          success: true,
+          files: [],
+          count: 0,
+          type: 'public'
+        });
+      }
+    } else {
+      // List session files
+      const sessionKey = request.headers.get('x-session-key');
+      if (!sessionKey) {
+        return NextResponse.json(
+          { success: false, error: 'Session key is required for listing session files' },
+          { status: 401 }
+        );
+      }
+
+      // Validate session
+      const isValid = await sessionManager.validateSession(sessionKey);
+      if (!isValid) {
+        return NextResponse.json(
+          { success: false, error: 'Invalid or expired session key' },
+          { status: 401 }
+        );
+      }
+
+      const files = await sessionManager.listSessionFiles(sessionKey);
+      const sessionPath = await sessionManager.getSessionPath(sessionKey);
+
+      if (!sessionPath) {
+        return NextResponse.json({
+          success: true,
+          files: [],
+          count: 0,
+          type: 'session'
+        });
+      }
+
+      const fileDetails = await Promise.all(
+        files.map(async (fileName) => {
+          const filePath = path.join(sessionPath, fileName);
+          const stats = await fs.stat(filePath);
+          return {
+            name: fileName,
+            size: stats.size,
+            modified: stats.mtime,
+            created: stats.ctime
+          };
+        })
+      );
+
+      return NextResponse.json({
+        success: true,
+        files: fileDetails,
+        count: fileDetails.length,
+        type: 'session'
+      });
+    }
+  } catch (error) {
+    console.error('Error listing files:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to list files' },
+      { status: 500 }
+    );
+  }
+}

app/api/sessions/upload/route.ts

@@ -0,0 +1,87 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { SessionManager } from '@/lib/sessionManager';
+
+export async function POST(request: NextRequest) {
+  try {
+    const sessionManager = SessionManager.getInstance();
+
+    // Get form data
+    const formData = await request.formData();
+    const file = formData.get('file') as File;
+    const isPublic = formData.get('public') === 'true';
+
+    // Get session key from headers
+    const sessionKey = request.headers.get('x-session-key');
+
+    // If uploading to session folder, require session key
+    if (!isPublic) {
+      if (!sessionKey) {
+        return NextResponse.json(
+          { success: false, error: 'Session key is required for private uploads. Use public=true for public uploads.' },
+          { status: 401 }
+        );
+      }
+
+      // Validate session
+      const isValid = await sessionManager.validateSession(sessionKey);
+      if (!isValid) {
+        return NextResponse.json(
+          { success: false, error: 'Invalid or expired session key' },
+          { status: 401 }
+        );
+      }
+    }
+    // Public uploads don't need authentication!
+
+    if (!file) {
+      return NextResponse.json(
+        { success: false, error: 'No file provided' },
+        { status: 400 }
+      );
+    }
+
+    // Read file content
+    const bytes = await file.arrayBuffer();
+    const buffer = Buffer.from(bytes);
+
+    let filePath: string;
+    if (isPublic) {
+      // Save to public folder - no authentication needed
+      filePath = await sessionManager.saveFileToPublic(file.name, buffer);
+    } else {
+      // Save to session folder - requires valid session key
+      filePath = await sessionManager.saveFileToSession(sessionKey!, file.name, buffer);
+    }
+
+    return NextResponse.json({
+      success: true,
+      message: 'File uploaded successfully',
+      fileName: file.name,
+      size: file.size,
+      type: file.type,
+      isPublic,
+      path: filePath
+    });
+  } catch (error) {
+    console.error('Error uploading file:', error);
+    return NextResponse.json(
+      { success: false, error: 'Failed to upload file' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET() {
+  return NextResponse.json({
+    message: 'File upload endpoint',
+    endpoint: '/api/sessions/upload',
+    method: 'POST',
+    headers: {
+      'x-session-key': 'Your session key (required)'
+    },
+    body: {
+      file: 'File to upload (multipart/form-data)',
+      public: 'true/false - whether to save in public folder (optional, default: false)'
+    }
+  });
+}

app/components/CodeExecutor.tsx

@@ -1,306 +0,0 @@
-'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>
-  )
-}

app/components/CodePlayground.tsx

@@ -1,668 +0,0 @@
-'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>
-  )
-}

app/components/Desktop.tsx

@@ -16,11 +16,9 @@ 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'
+import { SessionManagerWindow } from './SessionManagerWindow'
+import { motion, AnimatePresence } from 'framer-motion'
 
 export function Desktop() {
   const [fileManagerOpen, setFileManagerOpen] = useState(true)
@@ -29,12 +27,12 @@ export function Desktop() {
   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 [userSession, setUserSession] = useState<string>('')
+  const [sessionKey, setSessionKey] = useState<string>('')
+  const [sessionInitialized, setSessionInitialized] = useState(false)
   const [currentPath, setCurrentPath] = useState('')
   const [matrixActive, setMatrixActive] = useState(false)
   const [helpModalOpen, setHelpModalOpen] = useState(false)
@@ -43,7 +41,7 @@ export function Desktop() {
   const [backgroundSelectorOpen, setBackgroundSelectorOpen] = useState(false)
   const [currentBackground, setCurrentBackground] = useState('/background.webp')
   const [aboutModalOpen, setAboutModalOpen] = useState(false)
-  const [codeExecutorOpen, setCodeExecutorOpen] = useState(false)
+  const [sessionManagerOpen, setSessionManagerOpen] = useState(false)
 
   const openFileManager = (path: string) => {
     setCurrentPath(path)
@@ -94,28 +92,12 @@ export function Desktop() {
     setTerminalOpen(false)
   }
 
-  const openVSCode = () => {
-    setVscodeOpen(true)
+  const openSessionManager = () => {
+    setSessionManagerOpen(true)
   }
 
-  const closeVSCode = () => {
-    setVscodeOpen(false)
-  }
-
-  const openCodePlayground = () => {
-    setCodePlaygroundOpen(true)
-  }
-
-  const closeCodePlayground = () => {
-    setCodePlaygroundOpen(false)
-  }
-
-  const openCodeExecutor = () => {
-    setCodeExecutorOpen(true)
-  }
-
-  const closeCodeExecutor = () => {
-    setCodeExecutorOpen(false)
+  const closeSessionManager = () => {
+    setSessionManagerOpen(false)
   }
 
   const handleOpenApp = (appId: string) => {
@@ -138,14 +120,8 @@ export function Desktop() {
       case 'terminal':
         openTerminal()
         break
-      case 'vscode':
-        openVSCode()
-        break
-      case 'playground':
-        openCodePlayground()
-        break
-      case 'executor':
-        openCodeExecutor()
+      case 'sessions':
+        openSessionManager()
         break
     }
   }
@@ -206,6 +182,55 @@ export function Desktop() {
     }
   }
 
+  // Initialize session automatically on mount
+  useEffect(() => {
+    const initializeSession = async () => {
+      // Check if session already exists in localStorage
+      const savedSessionId = localStorage.getItem('reubenOS_sessionId')
+      const savedSessionKey = localStorage.getItem('reubenOS_sessionKey')
+
+      if (savedSessionId && savedSessionKey) {
+        // Use existing session
+        setUserSession(savedSessionId)
+        setSessionKey(savedSessionKey)
+        setSessionInitialized(true)
+        console.log('✅ Loaded existing session:', savedSessionId)
+      } else {
+        // Create new session automatically
+        try {
+          const response = await fetch('/api/sessions/create', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              metadata: {
+                createdAt: new Date().toISOString(),
+                autoCreated: true
+              }
+            })
+          })
+
+          const data = await response.json()
+
+          if (data.success) {
+            setUserSession(data.session.id)
+            setSessionKey(data.session.key)
+            setSessionInitialized(true)
+
+            // Save to localStorage
+            localStorage.setItem('reubenOS_sessionId', data.session.id)
+            localStorage.setItem('reubenOS_sessionKey', data.session.key)
+
+            console.log('✅ Auto-created new session:', data.session.id)
+          }
+        } catch (error) {
+          console.error('Failed to create session:', error)
+        }
+      }
+    }
+
+    initializeSession()
+  }, [])
+
   // Keyboard shortcuts
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
@@ -273,7 +298,7 @@ export function Desktop() {
 
       <TopBar onPowerAction={triggerMatrix} onAboutClick={() => setAboutModalOpen(true)} />
 
-      <Dock onOpenFileManager={openFileManager} onOpenCalendar={openCalendar} onOpenClock={openClock} onOpenBrowser={openBrowser} onOpenGeminiChat={openGeminiChat} onOpenVSCode={openVSCode} onOpenCodePlayground={openCodePlayground} />
+      <Dock onOpenFileManager={openFileManager} onOpenCalendar={openCalendar} onOpenClock={openClock} onOpenBrowser={openBrowser} onOpenGeminiChat={openGeminiChat} />
 
       <div className="flex-1">
         {/* Desktop Icons - Positioned in a grid layout */}
@@ -335,28 +360,12 @@ export function Desktop() {
             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 }}
+            id="sessions"
+            label="Sessions"
+            iconType="key"
+            initialPosition={{ x: 220, y: 120 }}
             onClick={() => {}}
-            onDoubleClick={openCodeExecutor}
+            onDoubleClick={openSessionManager}
           />
         </div>
 
@@ -418,35 +427,23 @@ export function Desktop() {
           </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>
-        )}
+        <AnimatePresence>
+          {sessionManagerOpen && sessionInitialized && (
+            <motion.div
+              initial={{ scale: 0.9, opacity: 0 }}
+              animate={{ scale: 1, opacity: 1 }}
+              exit={{ scale: 0.9, opacity: 0 }}
+              transition={{ duration: 0.2, ease: "easeInOut" }}
+            >
+              <SessionManagerWindow
+                onClose={closeSessionManager}
+                sessionId={userSession}
+                sessionKey={sessionKey}
+              />
+            </motion.div>
+          )}
+        </AnimatePresence>
 
-        {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 */}

app/components/Dock.tsx

@@ -9,9 +9,7 @@ import {
   Sparkle,
   Trash,
   FolderOpen,
-  Compass,
-  Code,
-  Lightning
+  Compass
 } from '@phosphor-icons/react'
 
 interface DockProps {
@@ -20,8 +18,6 @@ interface DockProps {
   onOpenClock: () => void
   onOpenBrowser: () => void
   onOpenGeminiChat: () => void
-  onOpenVSCode?: () => void
-  onOpenCodePlayground?: () => void
 }
 
 interface DockItemProps {
@@ -59,9 +55,7 @@ export function Dock({
   onOpenCalendar,
   onOpenClock,
   onOpenBrowser,
-  onOpenGeminiChat,
-  onOpenVSCode,
-  onOpenCodePlayground
+  onOpenGeminiChat
 }: DockProps) {
   const dockItems = [
     {
@@ -118,26 +112,6 @@ export function Dock({
       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: ''
     }
   ]
 

app/components/DraggableDesktopIcon.tsx

@@ -12,7 +12,8 @@ import {
   HardDrives,
   Compass,
   Code,
-  Lightning
+  Lightning,
+  Key
 } from '@phosphor-icons/react'
 
 interface DraggableDesktopIconProps {
@@ -100,6 +101,12 @@ export function DraggableDesktopIcon({
             <Lightning size={32} weight="fill" className="text-white" />
           </div>
         )
+      case 'key':
+        return (
+          <div className="bg-gradient-to-br from-purple-600 to-purple-800 w-full h-full rounded-xl flex items-center justify-center border border-purple-900/30 shadow-inner">
+            <Key size={32} weight="bold" className="text-white" />
+          </div>
+        )
       default:
         return (
           <div className="bg-gray-400 w-full h-full rounded-xl flex items-center justify-center">

app/components/SessionManager.tsx

@@ -0,0 +1,543 @@
+'use client'
+
+import React, { useState, useEffect } from 'react'
+import { motion, AnimatePresence } from 'framer-motion'
+import {
+  Key,
+  Upload,
+  Download,
+  File,
+  Folder,
+  Globe,
+  Lock,
+  Copy,
+  Check,
+  X,
+  Trash,
+  FileText,
+  Table as FileSpreadsheet,
+  Presentation as FilePresentation,
+  FilePdf,
+  Plus,
+  ArrowsClockwise as RefreshCw
+} from '@phosphor-icons/react'
+
+interface Session {
+  id: string
+  key: string
+  createdAt: string
+  message?: string
+}
+
+interface FileItem {
+  name: string
+  size: number
+  modified: string
+  created: string
+}
+
+export function SessionManager() {
+  const [currentSession, setCurrentSession] = useState<Session | null>(null)
+  const [sessionKey, setSessionKey] = useState('')
+  const [files, setFiles] = useState<FileItem[]>([])
+  const [publicFiles, setPublicFiles] = useState<FileItem[]>([])
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [success, setSuccess] = useState<string | null>(null)
+  const [copiedKey, setCopiedKey] = useState(false)
+  const [activeTab, setActiveTab] = useState<'session' | 'public'>('session')
+  const [uploadFile, setUploadFile] = useState<File | null>(null)
+  const [isPublicUpload, setIsPublicUpload] = useState(false)
+
+  // Create new session
+  const createNewSession = async () => {
+    setLoading(true)
+    setError(null)
+    try {
+      const response = await fetch('/api/sessions/create', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ metadata: { createdFrom: 'UI' } })
+      })
+      const data = await response.json()
+
+      if (data.success) {
+        setCurrentSession(data.session)
+        setSessionKey(data.session.key)
+        setSuccess('Session created successfully!')
+        localStorage.setItem('reubenOS_sessionKey', data.session.key)
+        await loadSessionFiles(data.session.key)
+      } else {
+        setError(data.error || 'Failed to create session')
+      }
+    } catch (err) {
+      setError('Failed to create session')
+    }
+    setLoading(false)
+  }
+
+  // Load files for current session
+  const loadSessionFiles = async (key: string) => {
+    try {
+      const response = await fetch('/api/sessions/files', {
+        headers: { 'x-session-key': key }
+      })
+      const data = await response.json()
+
+      if (data.success) {
+        setFiles(data.files || [])
+      }
+    } catch (err) {
+      console.error('Failed to load session files:', err)
+    }
+  }
+
+  // Load public files
+  const loadPublicFiles = async () => {
+    try {
+      const response = await fetch('/api/sessions/files?public=true')
+      const data = await response.json()
+
+      if (data.success) {
+        setPublicFiles(data.files || [])
+      }
+    } catch (err) {
+      console.error('Failed to load public files:', err)
+    }
+  }
+
+  // Handle file upload
+  const handleFileUpload = async () => {
+    if (!uploadFile || !sessionKey) {
+      setError('No file selected or session not active')
+      return
+    }
+
+    setLoading(true)
+    setError(null)
+    const formData = new FormData()
+    formData.append('file', uploadFile)
+    formData.append('public', isPublicUpload.toString())
+
+    try {
+      const response = await fetch('/api/sessions/upload', {
+        method: 'POST',
+        headers: { 'x-session-key': sessionKey },
+        body: formData
+      })
+      const data = await response.json()
+
+      if (data.success) {
+        setSuccess(`File uploaded successfully: ${data.fileName}`)
+        setUploadFile(null)
+        if (isPublicUpload) {
+          await loadPublicFiles()
+        } else {
+          await loadSessionFiles(sessionKey)
+        }
+      } else {
+        setError(data.error || 'Failed to upload file')
+      }
+    } catch (err) {
+      setError('Failed to upload file')
+    }
+    setLoading(false)
+  }
+
+  // Download file
+  const downloadFile = async (fileName: string, isPublic: boolean) => {
+    const url = `/api/sessions/download?file=${encodeURIComponent(fileName)}${isPublic ? '&public=true' : ''}`
+    const headers: HeadersInit = isPublic ? {} : { 'x-session-key': sessionKey }
+
+    try {
+      const response = await fetch(url, { headers })
+      if (response.ok) {
+        const blob = await response.blob()
+        const downloadUrl = window.URL.createObjectURL(blob)
+        const a = document.createElement('a')
+        a.href = downloadUrl
+        a.download = fileName
+        document.body.appendChild(a)
+        a.click()
+        window.URL.revokeObjectURL(downloadUrl)
+        document.body.removeChild(a)
+        setSuccess(`Downloaded: ${fileName}`)
+      } else {
+        setError('Failed to download file')
+      }
+    } catch (err) {
+      setError('Failed to download file')
+    }
+  }
+
+  // Generate document
+  const generateSampleDocument = async (type: string) => {
+    if (!sessionKey) {
+      setError('No active session')
+      return
+    }
+
+    setLoading(true)
+    setError(null)
+
+    const sampleContent: any = {
+      docx: {
+        type: 'docx',
+        fileName: 'sample-document',
+        content: {
+          title: 'Sample Document',
+          content: '# Introduction\n\nThis is a sample document generated by ReubenOS.\n\n## Features\n\n- Session-based isolation\n- Document generation\n- File management\n\n## Conclusion\n\nThank you for using ReubenOS!'
+        }
+      },
+      pdf: {
+        type: 'pdf',
+        fileName: 'sample-report',
+        content: {
+          title: 'Sample PDF Report',
+          content: 'This is a sample PDF report.\n\n# Section 1\n\nLorem ipsum dolor sit amet.\n\n# Section 2\n\nConclusion and summary.'
+        }
+      },
+      ppt: {
+        type: 'ppt',
+        fileName: 'sample-presentation',
+        content: {
+          slides: [
+            { title: 'Welcome', content: 'Welcome to ReubenOS', bullets: ['Feature 1', 'Feature 2'] },
+            { title: 'Overview', content: 'System Overview', bullets: ['Session Management', 'Document Generation'] },
+            { title: 'Thank You', content: 'Questions?' }
+          ]
+        }
+      },
+      excel: {
+        type: 'excel',
+        fileName: 'sample-data',
+        content: {
+          sheets: [{
+            name: 'Sample Data',
+            data: {
+              headers: ['Name', 'Value', 'Status'],
+              rows: [
+                ['Item 1', '100', 'Active'],
+                ['Item 2', '200', 'Pending'],
+                ['Item 3', '150', 'Active']
+              ]
+            }
+          }]
+        }
+      }
+    }
+
+    const documentData = sampleContent[type]
+    if (!documentData) {
+      setError('Invalid document type')
+      setLoading(false)
+      return
+    }
+
+    try {
+      const response = await fetch('/api/documents/generate', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-session-key': sessionKey
+        },
+        body: JSON.stringify({ ...documentData, isPublic: false })
+      })
+      const data = await response.json()
+
+      if (data.success) {
+        setSuccess(`Generated ${type.toUpperCase()}: ${data.fileName}`)
+        await loadSessionFiles(sessionKey)
+      } else {
+        setError(data.error || `Failed to generate ${type}`)
+      }
+    } catch (err) {
+      setError(`Failed to generate ${type}`)
+    }
+    setLoading(false)
+  }
+
+  // Copy session key
+  const copySessionKey = () => {
+    navigator.clipboard.writeText(sessionKey)
+    setCopiedKey(true)
+    setTimeout(() => setCopiedKey(false), 2000)
+  }
+
+  // Get file icon based on extension
+  const getFileIcon = (fileName: string) => {
+    const ext = fileName.split('.').pop()?.toLowerCase()
+    switch (ext) {
+      case 'docx':
+      case 'doc':
+        return <FileText size={20} weight="fill" className="text-blue-500" />
+      case 'xlsx':
+      case 'xls':
+        return <FileSpreadsheet size={20} weight="fill" className="text-green-500" />
+      case 'pptx':
+      case 'ppt':
+        return <FilePresentation size={20} weight="fill" className="text-orange-500" />
+      case 'pdf':
+        return <FilePdf size={20} weight="fill" className="text-red-500" />
+      default:
+        return <File size={20} weight="fill" className="text-gray-500" />
+    }
+  }
+
+  // Load saved session on mount
+  useEffect(() => {
+    const savedKey = localStorage.getItem('reubenOS_sessionKey')
+    if (savedKey) {
+      setSessionKey(savedKey)
+      loadSessionFiles(savedKey)
+    }
+    loadPublicFiles()
+  }, [])
+
+  // Clear messages after 3 seconds
+  useEffect(() => {
+    if (success) {
+      const timer = setTimeout(() => setSuccess(null), 3000)
+      return () => clearTimeout(timer)
+    }
+  }, [success])
+
+  useEffect(() => {
+    if (error) {
+      const timer = setTimeout(() => setError(null), 3000)
+      return () => clearTimeout(timer)
+    }
+  }, [error])
+
+  return (
+    <div className="min-h-screen bg-gradient-to-br from-purple-900/20 via-black to-purple-900/20 p-8">
+      <div className="max-w-6xl mx-auto">
+        <h1 className="text-4xl font-bold text-white mb-8">ReubenOS Session Manager</h1>
+
+        {/* Session Info */}
+        <div className="bg-gray-900/50 backdrop-blur-lg rounded-xl p-6 mb-8 border border-purple-500/20">
+          {currentSession ? (
+            <div>
+              <div className="flex items-center justify-between mb-4">
+                <h2 className="text-xl font-semibold text-white">Active Session</h2>
+                <button
+                  onClick={createNewSession}
+                  className="px-4 py-2 bg-purple-600 text-white rounded-lg hover:bg-purple-700 transition-colors"
+                >
+                  <Plus size={20} className="inline mr-2" />
+                  New Session
+                </button>
+              </div>
+              <div className="space-y-2">
+                <div className="flex items-center gap-2">
+                  <Key size={20} className="text-purple-400" />
+                  <span className="text-gray-400">Session Key:</span>
+                  <code className="text-xs text-purple-300 bg-black/30 px-2 py-1 rounded">
+                    {sessionKey.substring(0, 20)}...
+                  </code>
+                  <button
+                    onClick={copySessionKey}
+                    className="p-1 hover:bg-white/10 rounded transition-colors"
+                  >
+                    {copiedKey ? (
+                      <Check size={16} className="text-green-400" />
+                    ) : (
+                      <Copy size={16} className="text-gray-400" />
+                    )}
+                  </button>
+                </div>
+                <div className="flex items-center gap-2">
+                  <span className="text-gray-400">Created:</span>
+                  <span className="text-white">{new Date(currentSession.createdAt).toLocaleString()}</span>
+                </div>
+              </div>
+            </div>
+          ) : (
+            <div className="text-center py-8">
+              <Key size={48} className="text-gray-600 mx-auto mb-4" />
+              <p className="text-gray-400 mb-4">No active session</p>
+              <button
+                onClick={createNewSession}
+                disabled={loading}
+                className="px-6 py-3 bg-purple-600 text-white rounded-lg hover:bg-purple-700 transition-colors disabled:opacity-50"
+              >
+                {loading ? 'Creating...' : 'Create New Session'}
+              </button>
+            </div>
+          )}
+        </div>
+
+        {/* File Upload */}
+        {currentSession && (
+          <div className="bg-gray-900/50 backdrop-blur-lg rounded-xl p-6 mb-8 border border-purple-500/20">
+            <h3 className="text-lg font-semibold text-white mb-4">Upload File</h3>
+            <div className="flex gap-4">
+              <input
+                type="file"
+                onChange={(e) => setUploadFile(e.target.files?.[0] || null)}
+                className="flex-1 text-white file:mr-4 file:py-2 file:px-4 file:rounded-lg file:border-0 file:bg-purple-600 file:text-white hover:file:bg-purple-700"
+              />
+              <label className="flex items-center gap-2 text-white">
+                <input
+                  type="checkbox"
+                  checked={isPublicUpload}
+                  onChange={(e) => setIsPublicUpload(e.target.checked)}
+                  className="rounded"
+                />
+                Public
+              </label>
+              <button
+                onClick={handleFileUpload}
+                disabled={!uploadFile || loading}
+                className="px-4 py-2 bg-purple-600 text-white rounded-lg hover:bg-purple-700 transition-colors disabled:opacity-50"
+              >
+                <Upload size={20} className="inline mr-2" />
+                Upload
+              </button>
+            </div>
+          </div>
+        )}
+
+        {/* Document Generation */}
+        {currentSession && (
+          <div className="bg-gray-900/50 backdrop-blur-lg rounded-xl p-6 mb-8 border border-purple-500/20">
+            <h3 className="text-lg font-semibold text-white mb-4">Generate Documents</h3>
+            <div className="grid grid-cols-4 gap-4">
+              <button
+                onClick={() => generateSampleDocument('docx')}
+                disabled={loading}
+                className="p-4 bg-blue-600/20 border border-blue-500/30 rounded-lg hover:bg-blue-600/30 transition-colors disabled:opacity-50"
+              >
+                <FileText size={32} className="text-blue-400 mx-auto mb-2" />
+                <span className="text-white text-sm">Word Doc</span>
+              </button>
+              <button
+                onClick={() => generateSampleDocument('pdf')}
+                disabled={loading}
+                className="p-4 bg-red-600/20 border border-red-500/30 rounded-lg hover:bg-red-600/30 transition-colors disabled:opacity-50"
+              >
+                <FilePdf size={32} className="text-red-400 mx-auto mb-2" />
+                <span className="text-white text-sm">PDF</span>
+              </button>
+              <button
+                onClick={() => generateSampleDocument('ppt')}
+                disabled={loading}
+                className="p-4 bg-orange-600/20 border border-orange-500/30 rounded-lg hover:bg-orange-600/30 transition-colors disabled:opacity-50"
+              >
+                <FilePresentation size={32} className="text-orange-400 mx-auto mb-2" />
+                <span className="text-white text-sm">PowerPoint</span>
+              </button>
+              <button
+                onClick={() => generateSampleDocument('excel')}
+                disabled={loading}
+                className="p-4 bg-green-600/20 border border-green-500/30 rounded-lg hover:bg-green-600/30 transition-colors disabled:opacity-50"
+              >
+                <FileSpreadsheet size={32} className="text-green-400 mx-auto mb-2" />
+                <span className="text-white text-sm">Excel</span>
+              </button>
+            </div>
+          </div>
+        )}
+
+        {/* Files List */}
+        <div className="bg-gray-900/50 backdrop-blur-lg rounded-xl p-6 border border-purple-500/20">
+          {/* Tabs */}
+          <div className="flex gap-4 mb-6">
+            <button
+              onClick={() => setActiveTab('session')}
+              className={`px-4 py-2 rounded-lg transition-colors flex items-center gap-2 ${
+                activeTab === 'session'
+                  ? 'bg-purple-600 text-white'
+                  : 'bg-gray-800 text-gray-400 hover:bg-gray-700'
+              }`}
+            >
+              <Lock size={20} />
+              Session Files ({files.length})
+            </button>
+            <button
+              onClick={() => setActiveTab('public')}
+              className={`px-4 py-2 rounded-lg transition-colors flex items-center gap-2 ${
+                activeTab === 'public'
+                  ? 'bg-purple-600 text-white'
+                  : 'bg-gray-800 text-gray-400 hover:bg-gray-700'
+              }`}
+            >
+              <Globe size={20} />
+              Public Files ({publicFiles.length})
+            </button>
+            <button
+              onClick={() => {
+                if (activeTab === 'session' && sessionKey) {
+                  loadSessionFiles(sessionKey)
+                } else {
+                  loadPublicFiles()
+                }
+              }}
+              className="ml-auto p-2 bg-gray-800 text-gray-400 rounded-lg hover:bg-gray-700 transition-colors"
+            >
+              <RefreshCw size={20} />
+            </button>
+          </div>
+
+          {/* File List */}
+          <div className="space-y-2">
+            {(activeTab === 'session' ? files : publicFiles).map((file) => (
+              <div
+                key={file.name}
+                className="flex items-center justify-between p-3 bg-gray-800/50 rounded-lg hover:bg-gray-800/70 transition-colors"
+              >
+                <div className="flex items-center gap-3">
+                  {getFileIcon(file.name)}
+                  <div>
+                    <p className="text-white font-medium">{file.name}</p>
+                    <p className="text-gray-400 text-sm">
+                      {(file.size / 1024).toFixed(2)} KB • Modified: {new Date(file.modified).toLocaleDateString()}
+                    </p>
+                  </div>
+                </div>
+                <button
+                  onClick={() => downloadFile(file.name, activeTab === 'public')}
+                  className="p-2 bg-purple-600/20 text-purple-400 rounded-lg hover:bg-purple-600/30 transition-colors"
+                >
+                  <Download size={20} />
+                </button>
+              </div>
+            ))}
+            {(activeTab === 'session' ? files : publicFiles).length === 0 && (
+              <div className="text-center py-8">
+                <Folder size={48} className="text-gray-600 mx-auto mb-4" />
+                <p className="text-gray-400">No files in {activeTab === 'session' ? 'session' : 'public'} folder</p>
+              </div>
+            )}
+          </div>
+        </div>
+
+        {/* Messages */}
+        <AnimatePresence>
+          {success && (
+            <motion.div
+              initial={{ opacity: 0, y: 50 }}
+              animate={{ opacity: 1, y: 0 }}
+              exit={{ opacity: 0, y: 50 }}
+              className="fixed bottom-8 right-8 px-6 py-3 bg-green-600 text-white rounded-lg shadow-lg"
+            >
+              <Check size={20} className="inline mr-2" />
+              {success}
+            </motion.div>
+          )}
+          {error && (
+            <motion.div
+              initial={{ opacity: 0, y: 50 }}
+              animate={{ opacity: 1, y: 0 }}
+              exit={{ opacity: 0, y: 50 }}
+              className="fixed bottom-8 right-8 px-6 py-3 bg-red-600 text-white rounded-lg shadow-lg"
+            >
+              <X size={20} className="inline mr-2" />
+              {error}
+            </motion.div>
+          )}
+        </AnimatePresence>
+      </div>
+    </div>
+  )
+}

app/components/SessionManagerWindow.tsx

@@ -0,0 +1,602 @@
+'use client'
+
+import React, { useState, useEffect, useRef } from 'react'
+import Draggable from 'react-draggable'
+import { motion, AnimatePresence } from 'framer-motion'
+import {
+  Key,
+  Upload,
+  Download,
+  File,
+  Folder,
+  Globe,
+  Lock,
+  Copy,
+  Check,
+  X,
+  Trash,
+  FileText,
+  Table as FileSpreadsheet,
+  Presentation as FilePresentation,
+  FilePdf,
+  Plus,
+  ArrowsClockwise as RefreshCw,
+  Minus,
+  Square,
+  XCircle
+} from '@phosphor-icons/react'
+
+interface Session {
+  id: string
+  key: string
+  createdAt: string
+  message?: string
+}
+
+interface FileItem {
+  name: string
+  size: number
+  modified: string
+  created: string
+}
+
+interface SessionManagerWindowProps {
+  onClose: () => void
+  sessionId: string
+  sessionKey: string
+}
+
+export function SessionManagerWindow({ onClose, sessionId, sessionKey: initialSessionKey }: SessionManagerWindowProps) {
+  const [isMaximized, setIsMaximized] = useState(false)
+  const [sessionKey] = useState(initialSessionKey)
+  const [files, setFiles] = useState<FileItem[]>([])
+  const [publicFiles, setPublicFiles] = useState<FileItem[]>([])
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [success, setSuccess] = useState<string | null>(null)
+  const [copiedKey, setCopiedKey] = useState(false)
+  const [copiedId, setCopiedId] = useState(false)
+  const [activeTab, setActiveTab] = useState<'session' | 'public'>('session')
+  const [uploadFile, setUploadFile] = useState<File | null>(null)
+  const [isPublicUpload, setIsPublicUpload] = useState(false)
+  const nodeRef = useRef(null)
+
+  // Session is automatically created - no manual creation needed!
+
+  // Load files for current session
+  const loadSessionFiles = async (key: string) => {
+    try {
+      const response = await fetch('/api/sessions/files', {
+        headers: { 'x-session-key': key }
+      })
+      const data = await response.json()
+
+      if (data.success) {
+        setFiles(data.files || [])
+      }
+    } catch (err) {
+      console.error('Failed to load session files:', err)
+    }
+  }
+
+  // Load public files
+  const loadPublicFiles = async () => {
+    try {
+      const response = await fetch('/api/sessions/files?public=true')
+      const data = await response.json()
+
+      if (data.success) {
+        setPublicFiles(data.files || [])
+      }
+    } catch (err) {
+      console.error('Failed to load public files:', err)
+    }
+  }
+
+  // Handle file upload
+  const handleFileUpload = async () => {
+    if (!uploadFile || !sessionKey) {
+      setError('No file selected or session not active')
+      return
+    }
+
+    setLoading(true)
+    setError(null)
+    const formData = new FormData()
+    formData.append('file', uploadFile)
+    formData.append('public', isPublicUpload.toString())
+
+    try {
+      const response = await fetch('/api/sessions/upload', {
+        method: 'POST',
+        headers: { 'x-session-key': sessionKey },
+        body: formData
+      })
+      const data = await response.json()
+
+      if (data.success) {
+        setSuccess(`File uploaded successfully: ${data.fileName}`)
+        setUploadFile(null)
+        if (isPublicUpload) {
+          await loadPublicFiles()
+        } else {
+          await loadSessionFiles(sessionKey)
+        }
+      } else {
+        setError(data.error || 'Failed to upload file')
+      }
+    } catch (err) {
+      setError('Failed to upload file')
+    }
+    setLoading(false)
+  }
+
+  // Download file
+  const downloadFile = async (fileName: string, isPublic: boolean) => {
+    const url = `/api/sessions/download?file=${encodeURIComponent(fileName)}${isPublic ? '&public=true' : ''}`
+    const headers: HeadersInit = isPublic ? {} : { 'x-session-key': sessionKey }
+
+    try {
+      const response = await fetch(url, { headers })
+      if (response.ok) {
+        const blob = await response.blob()
+        const downloadUrl = window.URL.createObjectURL(blob)
+        const a = document.createElement('a')
+        a.href = downloadUrl
+        a.download = fileName
+        document.body.appendChild(a)
+        a.click()
+        window.URL.revokeObjectURL(downloadUrl)
+        document.body.removeChild(a)
+        setSuccess(`Downloaded: ${fileName}`)
+      } else {
+        setError('Failed to download file')
+      }
+    } catch (err) {
+      setError('Failed to download file')
+    }
+  }
+
+  // Generate document
+  const generateSampleDocument = async (type: string) => {
+    if (!sessionKey) {
+      setError('No active session')
+      return
+    }
+
+    setLoading(true)
+    setError(null)
+
+    const sampleContent: any = {
+      docx: {
+        type: 'docx',
+        fileName: 'sample-document',
+        content: {
+          title: 'Sample Document',
+          content: '# Introduction\n\nThis is a sample document generated by ReubenOS.\n\n## Features\n\n- Session-based isolation\n- Document generation\n- File management\n\n## Conclusion\n\nThank you for using ReubenOS!'
+        }
+      },
+      pdf: {
+        type: 'pdf',
+        fileName: 'sample-report',
+        content: {
+          title: 'Sample PDF Report',
+          content: 'This is a sample PDF report.\n\n# Section 1\n\nLorem ipsum dolor sit amet.\n\n# Section 2\n\nConclusion and summary.'
+        }
+      },
+      ppt: {
+        type: 'ppt',
+        fileName: 'sample-presentation',
+        content: {
+          slides: [
+            { title: 'Welcome', content: 'Welcome to ReubenOS', bullets: ['Feature 1', 'Feature 2'] },
+            { title: 'Overview', content: 'System Overview', bullets: ['Session Management', 'Document Generation'] },
+            { title: 'Thank You', content: 'Questions?' }
+          ]
+        }
+      },
+      excel: {
+        type: 'excel',
+        fileName: 'sample-data',
+        content: {
+          sheets: [{
+            name: 'Sample Data',
+            data: {
+              headers: ['Name', 'Value', 'Status'],
+              rows: [
+                ['Item 1', '100', 'Active'],
+                ['Item 2', '200', 'Pending'],
+                ['Item 3', '150', 'Active']
+              ]
+            }
+          }]
+        }
+      }
+    }
+
+    const documentData = sampleContent[type]
+    if (!documentData) {
+      setError('Invalid document type')
+      setLoading(false)
+      return
+    }
+
+    try {
+      const response = await fetch('/api/documents/generate', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-session-key': sessionKey
+        },
+        body: JSON.stringify({ ...documentData, isPublic: false })
+      })
+      const data = await response.json()
+
+      if (data.success) {
+        setSuccess(`Generated ${type.toUpperCase()}: ${data.fileName}`)
+        await loadSessionFiles(sessionKey)
+      } else {
+        setError(data.error || `Failed to generate ${type}`)
+      }
+    } catch (err) {
+      setError(`Failed to generate ${type}`)
+    }
+    setLoading(false)
+  }
+
+  // Copy session key
+  const copySessionKey = () => {
+    navigator.clipboard.writeText(sessionKey)
+    setCopiedKey(true)
+    setTimeout(() => setCopiedKey(false), 2000)
+  }
+
+  // Get file icon based on extension
+  const getFileIcon = (fileName: string) => {
+    const ext = fileName.split('.').pop()?.toLowerCase()
+    switch (ext) {
+      case 'docx':
+      case 'doc':
+        return <FileText size={20} weight="fill" className="text-blue-500" />
+      case 'xlsx':
+      case 'xls':
+        return <FileSpreadsheet size={20} weight="fill" className="text-green-500" />
+      case 'pptx':
+      case 'ppt':
+        return <FilePresentation size={20} weight="fill" className="text-orange-500" />
+      case 'pdf':
+        return <FilePdf size={20} weight="fill" className="text-red-500" />
+      default:
+        return <File size={20} weight="fill" className="text-gray-500" />
+    }
+  }
+
+  // Load files on mount and handle Escape key
+  useEffect(() => {
+    // Load files for the current session
+    if (sessionKey) {
+      loadSessionFiles(sessionKey)
+    }
+    loadPublicFiles()
+
+    // Handle Escape key to close window
+    const handleEscape = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') {
+        onClose()
+      }
+    }
+    window.addEventListener('keydown', handleEscape)
+    return () => window.removeEventListener('keydown', handleEscape)
+  }, [onClose, sessionKey])
+
+  // Clear messages after 3 seconds
+  useEffect(() => {
+    if (success) {
+      const timer = setTimeout(() => setSuccess(null), 3000)
+      return () => clearTimeout(timer)
+    }
+  }, [success])
+
+  useEffect(() => {
+    if (error) {
+      const timer = setTimeout(() => setError(null), 3000)
+      return () => clearTimeout(timer)
+    }
+  }, [error])
+
+  return (
+    <Draggable
+      handle=".window-header"
+      defaultPosition={{ x: 100, y: 100 }}
+      disabled={isMaximized}
+      nodeRef={nodeRef}
+    >
+      <div
+        ref={nodeRef}
+        className={`bg-gray-900/95 backdrop-blur-xl rounded-xl shadow-2xl border border-purple-500/30 overflow-hidden ${
+          isMaximized ? 'fixed inset-4' : 'w-[900px]'
+        }`}
+        style={{ zIndex: 1000 }}
+      >
+        {/* Window Header */}
+        <div className="window-header bg-gradient-to-r from-purple-600/20 to-purple-800/20 p-3 flex items-center justify-between border-b border-purple-500/20 cursor-move">
+          <div className="flex items-center gap-2">
+            <Key size={20} className="text-purple-400" />
+            <span className="text-white font-semibold">Session Manager</span>
+          </div>
+          <div className="flex items-center gap-1">
+            <button
+              onClick={(e) => {
+                e.stopPropagation();
+                setIsMaximized(false);
+              }}
+              className="w-7 h-7 flex items-center justify-center hover:bg-yellow-500/20 rounded-md transition-colors group"
+              title="Minimize"
+            >
+              <Minus size={14} className="text-yellow-400 group-hover:text-yellow-300" />
+            </button>
+            <button
+              onClick={(e) => {
+                e.stopPropagation();
+                setIsMaximized(!isMaximized);
+              }}
+              className="w-7 h-7 flex items-center justify-center hover:bg-green-500/20 rounded-md transition-colors group"
+              title={isMaximized ? "Restore" : "Maximize"}
+            >
+              <Square size={14} className="text-green-400 group-hover:text-green-300" />
+            </button>
+            <button
+              onClick={(e) => {
+                e.stopPropagation();
+                onClose();
+              }}
+              className="w-7 h-7 flex items-center justify-center hover:bg-red-500/30 rounded-md transition-colors group"
+              title="Close Window"
+            >
+              <X size={14} className="text-red-400 group-hover:text-red-300" />
+            </button>
+          </div>
+        </div>
+
+        {/* Window Content */}
+        <div className={`p-6 ${isMaximized ? 'h-[calc(100%-50px)] overflow-auto' : 'h-[600px] overflow-auto'}`}>
+          {/* Session Info */}
+          <div className="mb-6">
+            <div>
+              <div className="flex items-center justify-between mb-4">
+                <h2 className="text-xl font-semibold text-white">Active Session</h2>
+              </div>
+              <div className="space-y-3">
+                <div className="bg-black/30 rounded-lg p-3 border border-purple-500/30">
+                  <div className="flex items-center justify-between mb-2">
+                    <span className="text-gray-400 text-sm">Session Key:</span>
+                    <button
+                      onClick={copySessionKey}
+                      className="flex items-center gap-2 px-3 py-1 bg-purple-600/20 hover:bg-purple-600/30 rounded-lg transition-colors"
+                    >
+                      {copiedKey ? (
+                        <>
+                          <Check size={16} className="text-green-400" />
+                          <span className="text-green-400 text-sm">Copied!</span>
+                        </>
+                      ) : (
+                        <>
+                          <Copy size={16} className="text-purple-400" />
+                          <span className="text-purple-400 text-sm">Copy Full Key</span>
+                        </>
+                      )}
+                    </button>
+                  </div>
+                  <div className="flex items-center gap-2">
+                    <input
+                      type="text"
+                      value={sessionKey}
+                      readOnly
+                      onClick={(e) => e.currentTarget.select()}
+                      className="flex-1 bg-black/50 text-purple-300 text-xs px-2 py-1 rounded border border-purple-500/20 font-mono"
+                    />
+                  </div>
+                </div>
+                <div className="bg-black/30 rounded-lg p-3 border border-purple-500/30">
+                  <div className="flex items-center justify-between">
+                    <div className="flex items-center gap-2">
+                      <span className="text-gray-400 text-sm">Session ID:</span>
+                      <span className="text-white font-mono text-xs bg-black/50 px-2 py-1 rounded">{sessionId}</span>
+                    </div>
+                    <button
+                      onClick={() => {
+                        navigator.clipboard.writeText(sessionId);
+                        setCopiedId(true);
+                        setTimeout(() => setCopiedId(false), 2000);
+                      }}
+                      className="flex items-center gap-1 px-2 py-1 bg-purple-600/20 hover:bg-purple-600/30 rounded transition-colors"
+                    >
+                      {copiedId ? (
+                        <>
+                          <Check size={14} className="text-green-400" />
+                          <span className="text-green-400 text-xs">Copied!</span>
+                        </>
+                      ) : (
+                        <>
+                          <Copy size={14} className="text-purple-400" />
+                          <span className="text-purple-400 text-xs">Copy ID</span>
+                        </>
+                      )}
+                    </button>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+
+          {/* File Upload */}
+          <div className="mb-6">
+            <h3 className="text-lg font-semibold text-white mb-4">Upload File</h3>
+            <div className="flex gap-4">
+              <input
+                type="file"
+                onChange={(e) => setUploadFile(e.target.files?.[0] || null)}
+                className="flex-1 text-white file:mr-4 file:py-2 file:px-4 file:rounded-lg file:border-0 file:bg-purple-600 file:text-white hover:file:bg-purple-700"
+              />
+              <label className="flex items-center gap-2 text-white">
+                <input
+                  type="checkbox"
+                  checked={isPublicUpload}
+                  onChange={(e) => setIsPublicUpload(e.target.checked)}
+                  className="rounded"
+                />
+                Public
+              </label>
+              <button
+                onClick={handleFileUpload}
+                disabled={!uploadFile || loading}
+                className="px-4 py-2 bg-purple-600 text-white rounded-lg hover:bg-purple-700 transition-colors disabled:opacity-50"
+              >
+                <Upload size={20} className="inline mr-2" />
+                Upload
+              </button>
+            </div>
+          </div>
+
+          {/* Document Generation */}
+          <div className="mb-6">
+            <h3 className="text-lg font-semibold text-white mb-4">Generate Documents</h3>
+            <div className="grid grid-cols-4 gap-4">
+              <button
+                onClick={() => generateSampleDocument('docx')}
+                disabled={loading}
+                className="p-4 bg-blue-600/20 border border-blue-500/30 rounded-lg hover:bg-blue-600/30 transition-colors disabled:opacity-50"
+              >
+                <FileText size={32} className="text-blue-400 mx-auto mb-2" />
+                <span className="text-white text-sm">Word Doc</span>
+              </button>
+              <button
+                onClick={() => generateSampleDocument('pdf')}
+                disabled={loading}
+                className="p-4 bg-red-600/20 border border-red-500/30 rounded-lg hover:bg-red-600/30 transition-colors disabled:opacity-50"
+              >
+                <FilePdf size={32} className="text-red-400 mx-auto mb-2" />
+                <span className="text-white text-sm">PDF</span>
+              </button>
+              <button
+                onClick={() => generateSampleDocument('ppt')}
+                disabled={loading}
+                className="p-4 bg-orange-600/20 border border-orange-500/30 rounded-lg hover:bg-orange-600/30 transition-colors disabled:opacity-50"
+              >
+                <FilePresentation size={32} className="text-orange-400 mx-auto mb-2" />
+                <span className="text-white text-sm">PowerPoint</span>
+              </button>
+              <button
+                onClick={() => generateSampleDocument('excel')}
+                disabled={loading}
+                className="p-4 bg-green-600/20 border border-green-500/30 rounded-lg hover:bg-green-600/30 transition-colors disabled:opacity-50"
+              >
+                <FileSpreadsheet size={32} className="text-green-400 mx-auto mb-2" />
+                <span className="text-white text-sm">Excel</span>
+              </button>
+            </div>
+          </div>
+
+          {/* Files List */}
+          <div>
+            {/* Tabs */}
+            <div className="flex gap-4 mb-4">
+              <button
+                onClick={() => setActiveTab('session')}
+                className={`px-4 py-2 rounded-lg transition-colors flex items-center gap-2 ${
+                  activeTab === 'session'
+                    ? 'bg-purple-600 text-white'
+                    : 'bg-gray-800 text-gray-400 hover:bg-gray-700'
+                }`}
+              >
+                <Lock size={20} />
+                Session Files ({files.length})
+              </button>
+              <button
+                onClick={() => setActiveTab('public')}
+                className={`px-4 py-2 rounded-lg transition-colors flex items-center gap-2 ${
+                  activeTab === 'public'
+                    ? 'bg-purple-600 text-white'
+                    : 'bg-gray-800 text-gray-400 hover:bg-gray-700'
+                }`}
+              >
+                <Globe size={20} />
+                Public Files ({publicFiles.length})
+              </button>
+              <button
+                onClick={() => {
+                  if (activeTab === 'session' && sessionKey) {
+                    loadSessionFiles(sessionKey)
+                  } else {
+                    loadPublicFiles()
+                  }
+                }}
+                className="ml-auto p-2 bg-gray-800 text-gray-400 rounded-lg hover:bg-gray-700 transition-colors"
+              >
+                <RefreshCw size={20} />
+              </button>
+            </div>
+
+            {/* File List */}
+            <div className="space-y-2">
+              {(activeTab === 'session' ? files : publicFiles).map((file) => (
+                <div
+                  key={file.name}
+                  className="flex items-center justify-between p-3 bg-gray-800/50 rounded-lg hover:bg-gray-800/70 transition-colors"
+                >
+                  <div className="flex items-center gap-3">
+                    {getFileIcon(file.name)}
+                    <div>
+                      <p className="text-white font-medium">{file.name}</p>
+                      <p className="text-gray-400 text-sm">
+                        {(file.size / 1024).toFixed(2)} KB • {new Date(file.modified).toLocaleDateString()}
+                      </p>
+                    </div>
+                  </div>
+                  <button
+                    onClick={() => downloadFile(file.name, activeTab === 'public')}
+                    className="p-2 bg-purple-600/20 text-purple-400 rounded-lg hover:bg-purple-600/30 transition-colors"
+                  >
+                    <Download size={20} />
+                  </button>
+                </div>
+              ))}
+              {(activeTab === 'session' ? files : publicFiles).length === 0 && (
+                <div className="text-center py-8">
+                  <Folder size={48} className="text-gray-600 mx-auto mb-4" />
+                  <p className="text-gray-400">No files in {activeTab === 'session' ? 'session' : 'public'} folder</p>
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+
+        {/* Messages */}
+        <AnimatePresence>
+          {success && (
+            <motion.div
+              initial={{ opacity: 0, y: 50 }}
+              animate={{ opacity: 1, y: 0 }}
+              exit={{ opacity: 0, y: 50 }}
+              className="absolute bottom-4 right-4 px-4 py-2 bg-green-600 text-white rounded-lg shadow-lg"
+            >
+              <Check size={16} className="inline mr-2" />
+              {success}
+            </motion.div>
+          )}
+          {error && (
+            <motion.div
+              initial={{ opacity: 0, y: 50 }}
+              animate={{ opacity: 1, y: 0 }}
+              exit={{ opacity: 0, y: 50 }}
+              className="absolute bottom-4 right-4 px-4 py-2 bg-red-600 text-white rounded-lg shadow-lg"
+            >
+              <X size={16} className="inline mr-2" />
+              {error}
+            </motion.div>
+          )}
+        </AnimatePresence>
+      </div>
+    </Draggable>
+  )
+}

app/components/VSCodeEditor.tsx

@@ -1,458 +0,0 @@
-'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>
-  )
-}

app/sessions/page.tsx

@@ -0,0 +1,5 @@
+import { SessionManager } from '../components/SessionManager'
+
+export default function SessionsPage() {
+  return <SessionManager />
+}

lib/documentGenerators.ts

@@ -0,0 +1,380 @@
+import { Document, Packer, Paragraph, TextRun, HeadingLevel, AlignmentType, Table, TableRow, TableCell, WidthType } from 'docx';
+import PDFDocument from 'pdfkit';
+import ExcelJS from 'exceljs';
+// @ts-ignore
+import officegen from 'officegen';
+import fs from 'fs';
+import path from 'path';
+
+export interface DocumentContent {
+  title?: string;
+  content: string | any[];
+  metadata?: Record<string, any>;
+}
+
+export interface TableData {
+  headers: string[];
+  rows: string[][];
+}
+
+export interface SlideContent {
+  title: string;
+  content: string | string[];
+  bullets?: string[];
+}
+
+export class DocumentGenerator {
+  // Generate DOCX file
+  static async generateDOCX(content: DocumentContent): Promise<Buffer> {
+    const doc = new Document({
+      sections: [{
+        properties: {},
+        children: this.parseContentToParagraphs(content.content, content.title)
+      }]
+    });
+
+    return await Packer.toBuffer(doc);
+  }
+
+  private static parseContentToParagraphs(content: string | any, title?: string): Paragraph[] {
+    const paragraphs: Paragraph[] = [];
+
+    // Add title if provided
+    if (title) {
+      paragraphs.push(new Paragraph({
+        text: title,
+        heading: HeadingLevel.HEADING_1,
+        spacing: { after: 200 }
+      }));
+    }
+
+    // Handle complex nested structures (like the letter example)
+    if (typeof content === 'object' && content !== null) {
+      // Check if it has sections array
+      if (content.sections && Array.isArray(content.sections)) {
+        for (const section of content.sections) {
+          if (section.content) {
+            // Add section content
+            if (typeof section.content === 'string') {
+              const lines = section.content.split('\n');
+              for (const line of lines) {
+                if (line.trim()) {
+                  paragraphs.push(new Paragraph({
+                    children: [new TextRun(line)],
+                    spacing: { after: 100 }
+                  }));
+                }
+              }
+            }
+          }
+
+          // Handle paragraphs array in section
+          if (section.paragraphs && Array.isArray(section.paragraphs)) {
+            for (const para of section.paragraphs) {
+              paragraphs.push(new Paragraph({
+                children: [new TextRun(para)],
+                spacing: { after: 100 }
+              }));
+            }
+          }
+        }
+        return paragraphs;
+      }
+
+      // Handle direct content field
+      if (content.content) {
+        return this.parseContentToParagraphs(content.content, title);
+      }
+    }
+
+    if (typeof content === 'string') {
+      const lines = content.split('\n');
+      for (const line of lines) {
+        if (line.startsWith('# ')) {
+          // H1 heading
+          paragraphs.push(new Paragraph({
+            text: line.substring(2),
+            heading: HeadingLevel.HEADING_1
+          }));
+        } else if (line.startsWith('## ')) {
+          // H2 heading
+          paragraphs.push(new Paragraph({
+            text: line.substring(3),
+            heading: HeadingLevel.HEADING_2
+          }));
+        } else if (line.startsWith('### ')) {
+          // H3 heading
+          paragraphs.push(new Paragraph({
+            text: line.substring(4),
+            heading: HeadingLevel.HEADING_3
+          }));
+        } else if (line.startsWith('- ') || line.startsWith('* ')) {
+          // Bullet point
+          paragraphs.push(new Paragraph({
+            text: line.substring(2),
+            bullet: {
+              level: 0
+            }
+          }));
+        } else if (line.startsWith('1. ') || /^\d+\. /.test(line)) {
+          // Numbered list
+          paragraphs.push(new Paragraph({
+            text: line.replace(/^\d+\. /, ''),
+            numbering: {
+              reference: "default-numbering",
+              level: 0
+            }
+          }));
+        } else {
+          // Regular paragraph
+          paragraphs.push(new Paragraph({
+            children: [new TextRun(line)]
+          }));
+        }
+      }
+    } else if (Array.isArray(content)) {
+      for (const item of content) {
+        if (typeof item === 'string') {
+          paragraphs.push(new Paragraph({
+            children: [new TextRun(item)]
+          }));
+        } else if (item.type === 'heading') {
+          paragraphs.push(new Paragraph({
+            text: item.text,
+            heading: item.level || HeadingLevel.HEADING_1
+          }));
+        } else if (item.type === 'paragraph') {
+          paragraphs.push(new Paragraph({
+            children: [new TextRun(item.text)]
+          }));
+        } else if (item.type === 'bullet') {
+          paragraphs.push(new Paragraph({
+            text: item.text,
+            bullet: {
+              level: item.level || 0
+            }
+          }));
+        }
+      }
+    }
+
+    return paragraphs;
+  }
+
+  // Generate PDF file
+  static async generatePDF(content: DocumentContent): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      const doc = new PDFDocument();
+      const buffers: Buffer[] = [];
+
+      doc.on('data', buffers.push.bind(buffers));
+      doc.on('end', () => {
+        const pdfData = Buffer.concat(buffers);
+        resolve(pdfData);
+      });
+      doc.on('error', reject);
+
+      // Add title if provided
+      if (content.title) {
+        doc.fontSize(20).text(content.title, { align: 'center' });
+        doc.moveDown();
+      }
+
+      // Add content
+      if (typeof content.content === 'string') {
+        const lines = content.content.split('\n');
+        for (const line of lines) {
+          if (line.startsWith('# ')) {
+            doc.fontSize(18).text(line.substring(2));
+          } else if (line.startsWith('## ')) {
+            doc.fontSize(16).text(line.substring(3));
+          } else if (line.startsWith('### ')) {
+            doc.fontSize(14).text(line.substring(4));
+          } else if (line.startsWith('- ') || line.startsWith('* ')) {
+            doc.fontSize(12).text(`• ${line.substring(2)}`, { indent: 20 });
+          } else {
+            doc.fontSize(12).text(line);
+          }
+          doc.moveDown(0.5);
+        }
+      }
+
+      doc.end();
+    });
+  }
+
+  // Generate PowerPoint file
+  static async generatePowerPoint(slides: SlideContent[]): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      const pptx = officegen('pptx');
+      const buffers: Buffer[] = [];
+
+      pptx.on('data', (data: Buffer) => buffers.push(data));
+      pptx.on('end', () => {
+        const pptData = Buffer.concat(buffers);
+        resolve(pptData);
+      });
+      pptx.on('error', reject);
+
+      // Add title slide
+      if (slides.length > 0 && slides[0].title) {
+        const titleSlide = pptx.makeNewSlide();
+        titleSlide.title = slides[0].title;
+        if (slides[0].content) {
+          titleSlide.addText(slides[0].content.toString(), {
+            x: 'c',
+            y: 'c',
+            cx: '80%',
+            cy: '30%',
+            font_size: 18
+          });
+        }
+      }
+
+      // Add content slides
+      for (let i = 1; i < slides.length; i++) {
+        const slide = pptx.makeNewSlide();
+        slide.title = slides[i].title;
+
+        if (slides[i].bullets && slides[i].bullets!.length > 0) {
+          // Add bullet points
+          const bullets = slides[i].bullets!.map(bullet => ({
+            text: bullet,
+            options: { font_size: 14 }
+          }));
+          slide.addText(bullets, {
+            x: 0.5,
+            y: 1.5,
+            cx: '90%',
+            cy: '70%'
+          });
+        } else if (slides[i].content) {
+          // Add regular content
+          slide.addText(slides[i].content.toString(), {
+            x: 0.5,
+            y: 1.5,
+            cx: '90%',
+            cy: '70%',
+            font_size: 14
+          });
+        }
+      }
+
+      pptx.generate();
+    });
+  }
+
+  // Generate Excel file
+  static async generateExcel(data: { sheets: { name: string; data: TableData }[] }): Promise<Buffer> {
+    const workbook = new ExcelJS.Workbook();
+
+    workbook.creator = 'ReubenOS';
+    workbook.created = new Date();
+    workbook.modified = new Date();
+
+    for (const sheetData of data.sheets) {
+      const worksheet = workbook.addWorksheet(sheetData.name);
+
+      // Add headers
+      worksheet.addRow(sheetData.data.headers);
+
+      // Style headers
+      worksheet.getRow(1).font = { bold: true };
+      worksheet.getRow(1).fill = {
+        type: 'pattern',
+        pattern: 'solid',
+        fgColor: { argb: 'FFE0E0E0' }
+      };
+
+      // Add data rows
+      for (const row of sheetData.data.rows) {
+        worksheet.addRow(row);
+      }
+
+      // Auto-fit columns
+      worksheet.columns.forEach((column) => {
+        let maxLength = 0;
+        if (column && column.eachCell) {
+          column.eachCell({ includeEmpty: true }, (cell) => {
+            const length = cell.value ? cell.value.toString().length : 10;
+            if (length > maxLength) {
+              maxLength = length;
+            }
+          });
+          column.width = maxLength + 2;
+        }
+      });
+
+      // Add borders to all cells with data
+      const rowCount = worksheet.rowCount;
+      const colCount = worksheet.columnCount;
+      for (let row = 1; row <= rowCount; row++) {
+        for (let col = 1; col <= colCount; col++) {
+          const cell = worksheet.getCell(row, col);
+          cell.border = {
+            top: { style: 'thin' },
+            left: { style: 'thin' },
+            bottom: { style: 'thin' },
+            right: { style: 'thin' }
+          };
+        }
+      }
+    }
+
+    const buffer = await workbook.xlsx.writeBuffer();
+    return Buffer.from(buffer);
+  }
+
+  // Generate LaTeX and compile to PDF (requires latex installation)
+  static async generateLatexPDF(latexContent: string): Promise<Buffer> {
+    // For now, we'll use PDFKit as LaTeX compilation requires external tools
+    // In production, you'd use node-latex or similar with a LaTeX installation
+    return this.generatePDF({
+      content: this.convertLatexToPlainText(latexContent)
+    });
+  }
+
+  private static convertLatexToPlainText(latex: string): string {
+    // Basic LaTeX to plain text conversion
+    return latex
+      .replace(/\\documentclass{.*?}/g, '')
+      .replace(/\\usepackage{.*?}/g, '')
+      .replace(/\\begin{document}/g, '')
+      .replace(/\\end{document}/g, '')
+      .replace(/\\section{(.*?)}/g, '# $1')
+      .replace(/\\subsection{(.*?)}/g, '## $1')
+      .replace(/\\subsubsection{(.*?)}/g, '### $1')
+      .replace(/\\textbf{(.*?)}/g, '**$1**')
+      .replace(/\\textit{(.*?)}/g, '*$1*')
+      .replace(/\\item/g, '- ')
+      .replace(/\\begin{itemize}/g, '')
+      .replace(/\\end{itemize}/g, '')
+      .replace(/\\begin{enumerate}/g, '')
+      .replace(/\\end{enumerate}/g, '')
+      .replace(/\$/g, '')
+      .replace(/\\/g, '\n')
+      .trim();
+  }
+
+  // Convert markdown to structured content for document generation
+  static parseMarkdown(markdown: string): any[] {
+    const lines = markdown.split('\n');
+    const content = [];
+
+    for (const line of lines) {
+      if (line.startsWith('# ')) {
+        content.push({ type: 'heading', text: line.substring(2), level: HeadingLevel.HEADING_1 });
+      } else if (line.startsWith('## ')) {
+        content.push({ type: 'heading', text: line.substring(3), level: HeadingLevel.HEADING_2 });
+      } else if (line.startsWith('### ')) {
+        content.push({ type: 'heading', text: line.substring(4), level: HeadingLevel.HEADING_3 });
+      } else if (line.startsWith('- ') || line.startsWith('* ')) {
+        content.push({ type: 'bullet', text: line.substring(2) });
+      } else if (line.trim() !== '') {
+        content.push({ type: 'paragraph', text: line });
+      }
+    }
+
+    return content;
+  }
+}

lib/sessionManager.ts

@@ -0,0 +1,207 @@
+import crypto from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+
+export interface Session {
+  id: string;
+  key: string;
+  createdAt: Date;
+  lastAccessed: Date;
+  metadata?: Record<string, any>;
+}
+
+export class SessionManager {
+  private static instance: SessionManager;
+  private sessions: Map<string, Session> = new Map();
+  private sessionDir: string;
+  private publicDir: string;
+
+  private constructor() {
+    this.sessionDir = path.join(process.cwd(), 'data', 'files');
+    this.publicDir = path.join(process.cwd(), 'data', 'public');
+    this.initializeDirectories();
+  }
+
+  static getInstance(): SessionManager {
+    if (!SessionManager.instance) {
+      SessionManager.instance = new SessionManager();
+    }
+    return SessionManager.instance;
+  }
+
+  private async initializeDirectories() {
+    try {
+      await fs.mkdir(this.sessionDir, { recursive: true });
+      await fs.mkdir(this.publicDir, { recursive: true });
+    } catch (error) {
+      console.error('Error initializing directories:', error);
+    }
+  }
+
+  generateSessionKey(): string {
+    return crypto.randomBytes(32).toString('hex');
+  }
+
+  async createSession(metadata?: Record<string, any>): Promise<Session> {
+    const sessionId = `session_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
+    const sessionKey = this.generateSessionKey();
+
+    const session: Session = {
+      id: sessionId,
+      key: sessionKey,
+      createdAt: new Date(),
+      lastAccessed: new Date(),
+      metadata
+    };
+
+    this.sessions.set(sessionKey, session);
+
+    // Create session directory
+    const sessionPath = path.join(this.sessionDir, sessionId);
+    await fs.mkdir(sessionPath, { recursive: true });
+
+    // Save session metadata
+    await fs.writeFile(
+      path.join(sessionPath, 'session.json'),
+      JSON.stringify(session, null, 2)
+    );
+
+    return session;
+  }
+
+  async validateSession(sessionKey: string): Promise<boolean> {
+    if (this.sessions.has(sessionKey)) {
+      const session = this.sessions.get(sessionKey)!;
+      session.lastAccessed = new Date();
+      return true;
+    }
+
+    // Check if session exists on disk
+    try {
+      const sessionsOnDisk = await fs.readdir(this.sessionDir);
+      for (const sessionId of sessionsOnDisk) {
+        const sessionPath = path.join(this.sessionDir, sessionId, 'session.json');
+        try {
+          const sessionData = await fs.readFile(sessionPath, 'utf-8');
+          const session = JSON.parse(sessionData) as Session;
+          if (session.key === sessionKey) {
+            session.lastAccessed = new Date();
+            this.sessions.set(sessionKey, session);
+            return true;
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+    } catch (error) {
+      console.error('Error validating session:', error);
+    }
+
+    return false;
+  }
+
+  async getSession(sessionKey: string): Promise<Session | null> {
+    if (await this.validateSession(sessionKey)) {
+      return this.sessions.get(sessionKey) || null;
+    }
+    return null;
+  }
+
+  async getSessionPath(sessionKey: string): Promise<string | null> {
+    const session = await this.getSession(sessionKey);
+    if (session) {
+      return path.join(this.sessionDir, session.id);
+    }
+    return null;
+  }
+
+  getPublicPath(): string {
+    return this.publicDir;
+  }
+
+  async listSessionFiles(sessionKey: string): Promise<string[]> {
+    const sessionPath = await this.getSessionPath(sessionKey);
+    if (!sessionPath) {
+      throw new Error('Invalid session key');
+    }
+
+    try {
+      const files = await fs.readdir(sessionPath);
+      return files.filter(file => file !== 'session.json');
+    } catch (error) {
+      console.error('Error listing session files:', error);
+      return [];
+    }
+  }
+
+  async saveFileToSession(sessionKey: string, fileName: string, content: Buffer | string): Promise<string> {
+    const sessionPath = await this.getSessionPath(sessionKey);
+    if (!sessionPath) {
+      throw new Error('Invalid session key');
+    }
+
+    const filePath = path.join(sessionPath, fileName);
+    await fs.writeFile(filePath, content);
+    return filePath;
+  }
+
+  async getFileFromSession(sessionKey: string, fileName: string): Promise<Buffer> {
+    const sessionPath = await this.getSessionPath(sessionKey);
+    if (!sessionPath) {
+      throw new Error('Invalid session key');
+    }
+
+    const filePath = path.join(sessionPath, fileName);
+    return await fs.readFile(filePath);
+  }
+
+  async saveFileToPublic(fileName: string, content: Buffer | string): Promise<string> {
+    const filePath = path.join(this.publicDir, fileName);
+    await fs.writeFile(filePath, content);
+    return filePath;
+  }
+
+  async getFileFromPublic(fileName: string): Promise<Buffer> {
+    const filePath = path.join(this.publicDir, fileName);
+    return await fs.readFile(filePath);
+  }
+
+  async deleteSession(sessionKey: string): Promise<boolean> {
+    const sessionPath = await this.getSessionPath(sessionKey);
+    if (!sessionPath) {
+      return false;
+    }
+
+    try {
+      await fs.rm(sessionPath, { recursive: true, force: true });
+      this.sessions.delete(sessionKey);
+      return true;
+    } catch (error) {
+      console.error('Error deleting session:', error);
+      return false;
+    }
+  }
+
+  // Clean up old sessions (older than 24 hours)
+  async cleanupOldSessions(): Promise<void> {
+    const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
+
+    try {
+      const sessionsOnDisk = await fs.readdir(this.sessionDir);
+      for (const sessionId of sessionsOnDisk) {
+        const sessionPath = path.join(this.sessionDir, sessionId, 'session.json');
+        try {
+          const sessionData = await fs.readFile(sessionPath, 'utf-8');
+          const session = JSON.parse(sessionData) as Session;
+          if (new Date(session.lastAccessed) < oneDayAgo) {
+            await fs.rm(path.join(this.sessionDir, sessionId), { recursive: true, force: true });
+          }
+        } catch (error) {
+          continue;
+        }
+      }
+    } catch (error) {
+      console.error('Error cleaning up old sessions:', error);
+    }
+  }
+}

mcp-config.json

@@ -0,0 +1,234 @@
+{
+  "name": "ReubenOS File Manager",
+  "description": "MCP integration for ReubenOS file management with session-based isolation",
+  "version": "1.0.0",
+  "baseUrl": "http://localhost:3000",
+  "tools": [
+    {
+      "name": "createSession",
+      "description": "Create a new isolated session with a unique key",
+      "endpoint": "/api/sessions/create",
+      "method": "POST",
+      "parameters": {
+        "metadata": {
+          "type": "object",
+          "description": "Optional metadata for the session",
+          "optional": true
+        }
+      },
+      "returns": {
+        "id": "Session ID",
+        "key": "Session key (required for all operations)",
+        "createdAt": "Creation timestamp"
+      }
+    },
+    {
+      "name": "uploadFile",
+      "description": "Upload a file to session or public folder",
+      "endpoint": "/api/sessions/upload",
+      "method": "POST",
+      "headers": {
+        "x-session-key": "required"
+      },
+      "parameters": {
+        "file": {
+          "type": "file",
+          "description": "File to upload",
+          "required": true
+        },
+        "public": {
+          "type": "boolean",
+          "description": "Save to public folder (default: false)",
+          "optional": true
+        }
+      }
+    },
+    {
+      "name": "downloadFile",
+      "description": "Download a file from session or public folder",
+      "endpoint": "/api/sessions/download",
+      "method": "GET",
+      "headers": {
+        "x-session-key": "required for private files"
+      },
+      "parameters": {
+        "file": {
+          "type": "string",
+          "description": "File name to download",
+          "required": true
+        },
+        "public": {
+          "type": "boolean",
+          "description": "Download from public folder",
+          "optional": true
+        }
+      }
+    },
+    {
+      "name": "listFiles",
+      "description": "List files in session or public folder",
+      "endpoint": "/api/sessions/files",
+      "method": "GET",
+      "headers": {
+        "x-session-key": "required for session files"
+      },
+      "parameters": {
+        "public": {
+          "type": "boolean",
+          "description": "List public files",
+          "optional": true
+        }
+      }
+    },
+    {
+      "name": "generateDocument",
+      "description": "Generate DOCX, PDF, PowerPoint, or Excel documents",
+      "endpoint": "/api/documents/generate",
+      "method": "POST",
+      "headers": {
+        "x-session-key": "required"
+      },
+      "parameters": {
+        "type": {
+          "type": "string",
+          "description": "Document type: docx, pdf, latex, ppt, excel",
+          "required": true
+        },
+        "fileName": {
+          "type": "string",
+          "description": "Output file name",
+          "required": true
+        },
+        "content": {
+          "type": "object",
+          "description": "Document content (structure varies by type)",
+          "required": true
+        },
+        "isPublic": {
+          "type": "boolean",
+          "description": "Save to public folder",
+          "optional": true
+        }
+      },
+      "examples": {
+        "docx": {
+          "type": "docx",
+          "fileName": "report",
+          "content": {
+            "title": "Monthly Report",
+            "content": "# Executive Summary\\n\\nThis is the report content..."
+          }
+        },
+        "powerpoint": {
+          "type": "ppt",
+          "fileName": "presentation",
+          "content": {
+            "slides": [
+              {
+                "title": "Introduction",
+                "content": "Welcome to our presentation",
+                "bullets": ["Point 1", "Point 2", "Point 3"]
+              },
+              {
+                "title": "Main Content",
+                "content": "Detailed information here"
+              }
+            ]
+          }
+        },
+        "excel": {
+          "type": "excel",
+          "fileName": "data",
+          "content": {
+            "sheets": [
+              {
+                "name": "Sales Data",
+                "data": {
+                  "headers": ["Product", "Q1", "Q2", "Q3", "Q4"],
+                  "rows": [
+                    ["Product A", "100", "150", "200", "180"],
+                    ["Product B", "80", "90", "110", "120"]
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      }
+    },
+    {
+      "name": "processDocument",
+      "description": "Read and analyze documents (DOCX, Excel, PDF, etc.)",
+      "endpoint": "/api/documents/process",
+      "method": "POST",
+      "headers": {
+        "x-session-key": "required"
+      },
+      "parameters": {
+        "fileName": {
+          "type": "string",
+          "description": "File name to process",
+          "required": true
+        },
+        "isPublic": {
+          "type": "boolean",
+          "description": "File is in public folder",
+          "optional": true
+        },
+        "operation": {
+          "type": "string",
+          "description": "Operation: read, analyze",
+          "optional": true
+        }
+      }
+    }
+  ],
+  "sessionManagement": {
+    "description": "Each user gets a unique session key that provides isolated file storage",
+    "important": [
+      "Session keys must be kept secure and not shared between users",
+      "Files in session folders are private and only accessible with the session key",
+      "Public folder is shared across all users",
+      "Sessions expire after 24 hours of inactivity"
+    ]
+  },
+  "documentTypes": {
+    "supported": [
+      {
+        "type": "DOCX",
+        "description": "Microsoft Word documents",
+        "capabilities": ["generate", "read", "analyze"]
+      },
+      {
+        "type": "PDF",
+        "description": "Portable Document Format",
+        "capabilities": ["generate", "read_metadata"]
+      },
+      {
+        "type": "PowerPoint",
+        "description": "Presentation slides",
+        "capabilities": ["generate", "read_metadata"]
+      },
+      {
+        "type": "Excel",
+        "description": "Spreadsheets with formulas",
+        "capabilities": ["generate", "read", "analyze"]
+      },
+      {
+        "type": "LaTeX",
+        "description": "LaTeX to PDF conversion",
+        "capabilities": ["generate"]
+      }
+    ]
+  },
+  "usage": {
+    "workflow": [
+      "1. Create a session to get a unique session key",
+      "2. Use the session key in x-session-key header for all operations",
+      "3. Generate or upload documents to your session",
+      "4. Process and analyze documents as needed",
+      "5. Download generated documents",
+      "6. Share files publicly if needed"
+    ]
+  }
+}

mcp-server.js

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import fetch from 'node-fetch';
+import { FormData, Blob } from 'node-fetch';
+
+const BASE_URL = process.env.REUBENOS_URL || 'http://localhost:3000';
+
+class ReubenOSMCPServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'reubenos-file-manager',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupToolHandlers();
+
+    // Error handling
+    this.server.onerror = (error) => console.error('[MCP Error]', error);
+    process.on('SIGINT', async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'create_session',
+          description: 'Create a new isolated session with a unique key',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              metadata: {
+                type: 'object',
+                description: 'Optional metadata for the session',
+              },
+            },
+          },
+        },
+        {
+          name: 'upload_file',
+          description: 'Upload a file to session or public folder',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              sessionKey: {
+                type: 'string',
+                description: 'Session key for authentication',
+              },
+              fileName: {
+                type: 'string',
+                description: 'Name of the file',
+              },
+              content: {
+                type: 'string',
+                description: 'File content (base64 encoded for binary files)',
+              },
+              isPublic: {
+                type: 'boolean',
+                description: 'Save to public folder',
+                default: false,
+              },
+            },
+            required: ['sessionKey', 'fileName', 'content'],
+          },
+        },
+        {
+          name: 'download_file',
+          description: 'Download a file from session or public folder',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              sessionKey: {
+                type: 'string',
+                description: 'Session key (not required for public files)',
+              },
+              fileName: {
+                type: 'string',
+                description: 'Name of the file to download',
+              },
+              isPublic: {
+                type: 'boolean',
+                description: 'Download from public folder',
+                default: false,
+              },
+            },
+            required: ['fileName'],
+          },
+        },
+        {
+          name: 'list_files',
+          description: 'List files in session or public folder',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              sessionKey: {
+                type: 'string',
+                description: 'Session key (not required for public files)',
+              },
+              isPublic: {
+                type: 'boolean',
+                description: 'List public files',
+                default: false,
+              },
+            },
+          },
+        },
+        {
+          name: 'generate_document',
+          description: 'Generate DOCX, PDF, PowerPoint, or Excel documents',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              sessionKey: {
+                type: 'string',
+                description: 'Session key for authentication',
+              },
+              type: {
+                type: 'string',
+                enum: ['docx', 'pdf', 'ppt', 'excel', 'latex'],
+                description: 'Document type to generate',
+              },
+              fileName: {
+                type: 'string',
+                description: 'Output file name',
+              },
+              content: {
+                type: 'object',
+                description: 'Document content (structure varies by type)',
+              },
+              isPublic: {
+                type: 'boolean',
+                description: 'Save to public folder',
+                default: false,
+              },
+            },
+            required: ['sessionKey', 'type', 'fileName', 'content'],
+          },
+        },
+        {
+          name: 'process_document',
+          description: 'Read and analyze documents (DOCX, Excel, PDF, etc.)',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              sessionKey: {
+                type: 'string',
+                description: 'Session key for authentication',
+              },
+              fileName: {
+                type: 'string',
+                description: 'File name to process',
+              },
+              isPublic: {
+                type: 'boolean',
+                description: 'File is in public folder',
+                default: false,
+              },
+              operation: {
+                type: 'string',
+                enum: ['read', 'analyze'],
+                description: 'Operation to perform',
+                default: 'read',
+              },
+            },
+            required: ['sessionKey', 'fileName'],
+          },
+        },
+      ],
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        switch (name) {
+          case 'create_session':
+            return await this.createSession(args);
+          case 'upload_file':
+            return await this.uploadFile(args);
+          case 'download_file':
+            return await this.downloadFile(args);
+          case 'list_files':
+            return await this.listFiles(args);
+          case 'generate_document':
+            return await this.generateDocument(args);
+          case 'process_document':
+            return await this.processDocument(args);
+          default:
+            throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${error.message}`,
+            },
+          ],
+        };
+      }
+    });
+  }
+
+  async createSession(args) {
+    const response = await fetch(`${BASE_URL}/api/sessions/create`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ metadata: args.metadata || {} }),
+    });
+
+    const data = await response.json();
+    return {
+      content: [
+        {
+          type: 'text',
+          text: data.success
+            ? `Session created successfully!\nSession ID: ${data.session.id}\nSession Key: ${data.session.key}\n\nIMPORTANT: Save this session key securely. You'll need it for all file operations.`
+            : `Failed to create session: ${data.error}`,
+        },
+      ],
+    };
+  }
+
+  async uploadFile(args) {
+    const formData = new FormData();
+    const buffer = Buffer.from(args.content, args.content.includes('base64,') ? 'base64' : 'utf8');
+    formData.append('file', new Blob([buffer]), args.fileName);
+    formData.append('public', args.isPublic ? 'true' : 'false');
+
+    // Use public endpoint if public, sessions endpoint if private
+    const endpoint = args.isPublic
+      ? `${BASE_URL}/api/public/upload`
+      : `${BASE_URL}/api/sessions/upload`;
+
+    const headers = args.isPublic
+      ? {}
+      : { 'x-session-key': args.sessionKey };
+
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      body: formData,
+    });
+
+    const data = await response.json();
+    return {
+      content: [
+        {
+          type: 'text',
+          text: data.success
+            ? `File uploaded successfully!\nFile: ${data.fileName}\nSize: ${data.size} bytes\nLocation: ${data.isPublic ? 'Public (data/public/)' : 'Private Session (data/files/)'}\n${args.isPublic ? 'Note: This file is accessible to everyone!' : 'Note: This file is private and only accessible with your session key.'}`
+            : `Failed to upload file: ${data.error}`,
+        },
+      ],
+    };
+  }
+
+  async downloadFile(args) {
+    const url = `${BASE_URL}/api/sessions/download?file=${encodeURIComponent(args.fileName)}${
+      args.isPublic ? '&public=true' : ''
+    }`;
+    const headers = args.isPublic ? {} : { 'x-session-key': args.sessionKey };
+
+    const response = await fetch(url, { headers });
+
+    if (response.ok) {
+      const buffer = await response.buffer();
+      const base64 = buffer.toString('base64');
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `File downloaded successfully!\nFile: ${args.fileName}\nSize: ${buffer.length} bytes\nContent (base64): ${base64.substring(0, 100)}...`,
+          },
+        ],
+      };
+    } else {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Failed to download file: ${response.statusText}`,
+          },
+        ],
+      };
+    }
+  }
+
+  async listFiles(args) {
+    const url = `${BASE_URL}/api/sessions/files${args.isPublic ? '?public=true' : ''}`;
+    const headers = args.isPublic ? {} : { 'x-session-key': args.sessionKey };
+
+    const response = await fetch(url, { headers });
+    const data = await response.json();
+
+    if (data.success) {
+      const fileList = data.files
+        .map((f) => `- ${f.name} (${(f.size / 1024).toFixed(2)} KB)`)
+        .join('\n');
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Files in ${data.type} folder (${data.count} files):\n${fileList || 'No files found'}`,
+          },
+        ],
+      };
+    } else {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Failed to list files: ${data.error}`,
+          },
+        ],
+      };
+    }
+  }
+
+  async generateDocument(args) {
+    const response = await fetch(`${BASE_URL}/api/documents/generate`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-session-key': args.sessionKey,
+      },
+      body: JSON.stringify({
+        type: args.type,
+        fileName: args.fileName,
+        content: args.content,
+        isPublic: args.isPublic || false,
+      }),
+    });
+
+    const data = await response.json();
+    return {
+      content: [
+        {
+          type: 'text',
+          text: data.success
+            ? `Document generated successfully!\nType: ${data.type.toUpperCase()}\nFile: ${data.fileName}\nSize: ${data.size} bytes\nLocation: ${data.isPublic ? 'Public' : 'Session'} folder`
+            : `Failed to generate document: ${data.error}`,
+        },
+      ],
+    };
+  }
+
+  async processDocument(args) {
+    const response = await fetch(`${BASE_URL}/api/documents/process`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-session-key': args.sessionKey,
+      },
+      body: JSON.stringify({
+        fileName: args.fileName,
+        isPublic: args.isPublic || false,
+        operation: args.operation || 'read',
+      }),
+    });
+
+    const data = await response.json();
+    return {
+      content: [
+        {
+          type: 'text',
+          text: data.success
+            ? `Document processed:\nFile: ${data.fileName}\nType: ${data.content.type}\nContent: ${JSON.stringify(data.content, null, 2)}`
+            : `Failed to process document: ${data.error}`,
+        },
+      ],
+    };
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('ReubenOS MCP Server running...');
+  }
+}
+
+const server = new ReubenOSMCPServer();
+server.run();

package-mcp.json

@@ -0,0 +1,17 @@
+{
+  "name": "reubenos-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for ReubenOS file management system",
+  "type": "module",
+  "main": "mcp-server.js",
+  "scripts": {
+    "start": "node mcp-server.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "node-fetch": "^3.3.2"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package.json

@@ -2,34 +2,48 @@
   "name": "mpc-hackathon",
   "version": "0.1.0",
   "private": true,
+  "type": "module",
   "scripts": {
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
-    "lint": "eslint"
+    "lint": "eslint",
+    "mcp": "node mcp-server.js",
+    "test-mcp": "node mcp-server.js test"
   },
   "dependencies": {
     "@github/spark": "^0.41.23",
+    "@modelcontextprotocol/sdk": "^1.22.0",
     "@monaco-editor/react": "^4.7.0",
     "@phosphor-icons/react": "^2.1.10",
     "@radix-ui/colors": "^3.0.0",
+    "docx": "^9.5.1",
+    "exceljs": "^4.4.0",
     "framer-motion": "^12.23.24",
+    "html-pdf-node": "^1.0.8",
+    "latex": "^0.0.1",
     "lucide-react": "^0.553.0",
     "mammoth": "^1.11.0",
     "monaco-editor": "^0.54.0",
     "next": "16.0.1",
+    "node-fetch": "^3.3.2",
+    "officegen": "^0.6.5",
+    "pdfkit": "^0.17.2",
+    "puppeteer-core": "^24.30.0",
     "react": "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",
+    "sharp": "^0.34.5",
     "tw-animate-css": "^1.4.0",
     "xlsx": "^0.18.5"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
     "@types/node": "^20",
+    "@types/pdfkit": "^0.17.3",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "eslint": "^9",

start-all.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+echo "🚀 Starting ReubenOS Complete System"
+echo "===================================="
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Check if port 3000 is available
+if lsof -Pi :3000 -sTCP:LISTEN -t >/dev/null ; then
+    echo -e "${YELLOW}⚠️  Port 3000 is in use. ReubenOS will use port 3002${NC}"
+    PORT=3002
+else
+    PORT=3000
+fi
+
+# Start ReubenOS in background
+echo -e "${BLUE}Starting ReubenOS on port $PORT...${NC}"
+npm run dev &
+WEBAPP_PID=$!
+echo "ReubenOS PID: $WEBAPP_PID"
+
+# Wait for ReubenOS to start
+echo "Waiting for ReubenOS to start..."
+sleep 5
+
+# Test if ReubenOS is running
+if curl -s http://localhost:$PORT > /dev/null; then
+    echo -e "${GREEN}✅ ReubenOS is running on http://localhost:$PORT${NC}"
+else
+    echo -e "${YELLOW}⚠️  ReubenOS might still be starting...${NC}"
+fi
+
+echo ""
+echo -e "${GREEN}================================${NC}"
+echo -e "${GREEN}✅ ReubenOS System Ready!${NC}"
+echo -e "${GREEN}================================${NC}"
+echo ""
+echo "📋 What's Running:"
+echo "  1. ReubenOS Web App: http://localhost:$PORT"
+echo "  2. Session Manager: Available on desktop"
+echo ""
+echo "🔌 To Connect Claude Desktop:"
+echo "  1. The MCP server will be started automatically by Claude Desktop"
+echo "  2. Just add this to your claude_desktop_config.json:"
+echo ""
+echo '  {'
+echo '    "mcpServers": {'
+echo '      "reubenos": {'
+echo '        "command": "node",'
+echo "        \"args\": [\"$(pwd)/mcp-server.js\"],"
+echo '        "env": {'
+echo "          \"REUBENOS_URL\": \"http://localhost:$PORT\""
+echo '        }'
+echo '      }'
+echo '    }'
+echo '  }'
+echo ""
+echo "📌 To stop everything: Press Ctrl+C"
+echo ""
+
+# Keep script running and handle cleanup
+trap "echo 'Shutting down...'; kill $WEBAPP_PID 2>/dev/null; exit" INT TERM
+
+# Wait for background process
+wait $WEBAPP_PID

test-document-gen.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+// Test complex document generation
+import fetch from 'node-fetch';
+
+const BASE_URL = 'http://localhost:3000';
+
+async function testComplexDocument() {
+  console.log('🧪 Testing Complex Document Generation\n');
+
+  // 1. Create session
+  console.log('1️⃣ Creating session...');
+  const sessionResp = await fetch(`${BASE_URL}/api/sessions/create`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ metadata: { test: true } })
+  });
+  const sessionData = await sessionResp.json();
+  console.log(`✅ Session created: ${sessionData.session.id}`);
+  console.log(`   Key: ${sessionData.session.key.substring(0, 20)}...\n`);
+
+  const sessionKey = sessionData.session.key;
+
+  // 2. Generate document with complex structure (like the letter)
+  console.log('2️⃣ Generating complex document (Letter)...');
+  const complexContent = {
+    type: 'docx',
+    fileName: 'test-letter',
+    content: {
+      sections: [
+        {
+          type: 'header',
+          content: 'John Doe\nFlat 101, Shar & Sorai Apartment\nVarde Valaulikar Road, Margao, Goa\[email protected]\n\nDate: November 14, 2025'
+        },
+        {
+          type: 'recipient',
+          content: 'To,\nThe Secretary\nShar & Sorai Apartment Building\nVarde Valaulikar Road\nMargao, Goa - 403601'
+        },
+        {
+          type: 'subject',
+          content: 'Subject: Water Leakage Issue on 1st Floor'
+        },
+        {
+          type: 'body',
+          paragraphs: [
+            'Dear Sir/Madam,',
+            'I hope this letter finds you in good health. I am writing to bring to your attention a serious water leakage problem on the 1st floor.',
+            'The leakage has been noticed since the past few days, and it appears to be coming from the ceiling. This issue poses a risk of structural damage.',
+            'I request immediate inspection and necessary repairs. Please arrange for maintenance personnel to assess the situation.',
+            'Thank you for your prompt attention to this urgent matter.'
+          ]
+        },
+        {
+          type: 'closing',
+          content: 'Yours sincerely,\n\nJohn Doe\nFlat 101'
+        }
+      ],
+      document_type: 'letter'
+    },
+    isPublic: true,
+    sessionKey
+  };
+
+  const docResp = await fetch(`${BASE_URL}/api/documents/generate`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-session-key': sessionKey
+    },
+    body: JSON.stringify(complexContent)
+  });
+
+  const docData = await docResp.json();
+  console.log(`${docData.success ? '✅' : '❌'} Document generation:`);
+  console.log(`   File: ${docData.fileName}`);
+  console.log(`   Size: ${docData.size} bytes`);
+  console.log(`   Location: ${docData.isPublic ? 'Public' : 'Session'} folder\n`);
+
+  // 3. List public files
+  console.log('3️⃣ Listing public files...');
+  const filesResp = await fetch(`${BASE_URL}/api/sessions/files?public=true`);
+  const filesData = await filesResp.json();
+  console.log(`✅ Found ${filesData.count} public files:`);
+  filesData.files.forEach(file => {
+    console.log(`   - ${file.name} (${(file.size / 1024).toFixed(2)} KB)`);
+  });
+
+  console.log('\n' + '='.repeat(50));
+  console.log('✅ Test completed! Check data/public/ for the generated file.');
+}
+
+testComplexDocument().catch(console.error);

test-mcp-local.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+// Test script to verify MCP server can connect to ReubenOS
+import fetch from 'node-fetch';
+
+const BASE_URL = process.env.REUBENOS_URL || 'http://localhost:3000';
+
+console.log('🧪 Testing ReubenOS MCP Integration\n');
+console.log(`Testing against: ${BASE_URL}`);
+console.log('=' .repeat(50));
+
+async function testConnection() {
+  try {
+    // Test 1: Check if ReubenOS is running
+    console.log('\n1️⃣ Testing ReubenOS connection...');
+    try {
+      const response = await fetch(BASE_URL);
+      console.log('✅ ReubenOS is running!');
+    } catch (error) {
+      console.log('❌ ReubenOS is not running. Start it with: npm run dev');
+      return false;
+    }
+
+    // Test 2: Create a session
+    console.log('\n2️⃣ Testing session creation...');
+    const createResponse = await fetch(`${BASE_URL}/api/sessions/create`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ metadata: { test: true } })
+    });
+
+    const sessionData = await createResponse.json();
+    if (sessionData.success) {
+      console.log('✅ Session created successfully!');
+      console.log(`   Session ID: ${sessionData.session.id}`);
+      console.log(`   Session Key: ${sessionData.session.key.substring(0, 20)}...`);
+
+      // Test 3: List files
+      console.log('\n3️⃣ Testing file listing...');
+      const filesResponse = await fetch(`${BASE_URL}/api/sessions/files`, {
+        headers: { 'x-session-key': sessionData.session.key }
+      });
+
+      const filesData = await filesResponse.json();
+      if (filesData.success) {
+        console.log('✅ File listing works!');
+        console.log(`   Files in session: ${filesData.count}`);
+      }
+
+      // Test 4: Generate a document
+      console.log('\n4️⃣ Testing document generation...');
+      const docResponse = await fetch(`${BASE_URL}/api/documents/generate`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-session-key': sessionData.session.key
+        },
+        body: JSON.stringify({
+          type: 'docx',
+          fileName: 'test-document',
+          content: {
+            title: 'Test Document',
+            content: 'This is a test document generated via MCP.'
+          }
+        })
+      });
+
+      const docData = await docResponse.json();
+      if (docData.success) {
+        console.log('✅ Document generation works!');
+        console.log(`   Generated: ${docData.fileName}`);
+      }
+
+      return sessionData.session.key;
+    } else {
+      console.log('❌ Failed to create session:', sessionData.error);
+      return false;
+    }
+  } catch (error) {
+    console.log('❌ Error during testing:', error.message);
+    return false;
+  }
+}
+
+// Run tests
+testConnection().then(sessionKey => {
+  console.log('\n' + '=' .repeat(50));
+  if (sessionKey) {
+    console.log('✅ All tests passed! MCP integration is working.');
+    console.log('\n📋 Next Steps:');
+    console.log('1. Add the configuration to Claude Desktop');
+    console.log('2. Restart Claude Desktop');
+    console.log('3. Test with: "Using reubenos, create a new session"');
+    console.log('\n🔑 Test Session Key (for manual testing):');
+    console.log(sessionKey);
+  } else {
+    console.log('❌ Some tests failed. Please check the errors above.');
+  }
+  console.log('=' .repeat(50));
+});