TESTING SESSIONS AND QUIZES

IMPLEMENTATION_GUIDE.md

@@ -0,0 +1,211 @@
+# Reuben OS - Stateless Prefix Strategy Implementation Guide
+
+## Overview
+This implementation uses a simple "Stateless Prefix Strategy" to handle session isolation and file management without complex session state management. All files are stored in `/tmp` with a `{SessionID}_{Filename}` pattern.
+
+## Architecture Components
+
+### 1. API Route (`pages/api/mcp-handler.js`)
+- **Location**: `/pages/api/mcp-handler.js`
+- **Purpose**: Handles all file operations with session prefix logic
+- **Key Features**:
+  - Validates session IDs (alphanumeric + hyphens/underscores only)
+  - Prefixes all files with `{sessionId}_` when saving to `/tmp`
+  - Strips prefixes when returning files to frontend
+  - Supports CORS for cross-origin requests
+
+**Endpoints**:
+- `POST /api/mcp-handler` - Save/delete files, deploy quizzes
+- `GET /api/mcp-handler?sessionId=...` - Retrieve files for a session
+
+### 2. MCP Server (`mcp-server.js`)
+- **Location**: `/mcp-server.js`
+- **Purpose**: Bridge between Claude Desktop and Reuben OS
+- **Tools**:
+  1. `manage_files` - Save, retrieve, delete, or clear files
+  2. `deploy_quiz` - Deploy interactive quizzes
+
+### 3. Frontend Components (`frontend-fetch-example.js`)
+- **Location**: `/frontend-fetch-example.js`
+- **Components**:
+  - `SessionManager` - Main component for file management
+  - `FileItem` - Individual file display
+  - `FlutterAppViewer` - Flutter/Dart file viewer
+  - `LaTeXViewer` - LaTeX document viewer
+
+## Complete Workflow
+
+### Step 1: User Opens Reuben OS
+1. Frontend generates a session ID: `session_{timestamp}_{random}`
+2. Session ID is displayed in the UI
+3. Frontend starts polling `/api/mcp-handler?sessionId=...` every 5 seconds
+
+### Step 2: User Copies Session ID
+1. User clicks "Copy ID" button in the UI
+2. Session ID is copied to clipboard
+
+### Step 3: User Provides Session ID to Claude
+```
+User: "My session ID is session_1234567_abc123"
+Claude: "Got it! I'll use this session ID for all file operations."
+```
+
+### Step 4: Claude Saves Files
+Claude uses the `manage_files` tool:
+```javascript
+{
+  sessionId: "session_1234567_abc123",
+  action: "save",
+  fileName: "main.dart",
+  content: "// Flutter code here..."
+}
+```
+
+Backend saves as: `/tmp/session_1234567_abc123_main.dart`
+
+### Step 5: Frontend Retrieves Files
+Frontend polls: `GET /api/mcp-handler?sessionId=session_1234567_abc123`
+
+API response:
+```javascript
+{
+  success: true,
+  sessionId: "session_1234567_abc123",
+  files: [
+    {
+      name: "main.dart",  // Prefix stripped!
+      size: 1234,
+      content: "// Flutter code here...",
+      isQuiz: false
+    }
+  ],
+  count: 1
+}
+```
+
+### Step 6: Quiz Deployment
+Claude deploys a quiz:
+```javascript
+{
+  sessionId: "session_1234567_abc123",
+  quizData: {
+    title: "JavaScript Quiz",
+    questions: [...]
+  }
+}
+```
+
+Backend saves as: `/tmp/session_1234567_abc123_quiz.json`
+Frontend detects `quiz.json` and shows "Launch Quiz" button.
+
+## Testing Instructions
+
+### 1. Start the Next.js Server
+```bash
+npm run dev
+# Server runs on http://localhost:3000
+```
+
+### 2. Test API Directly
+```bash
+# Save a file
+curl -X POST http://localhost:3000/api/mcp-handler \
+  -H "Content-Type: application/json" \
+  -d '{
+    "sessionId": "test123",
+    "action": "save_file",
+    "fileName": "test.txt",
+    "content": "Hello World"
+  }'
+
+# Retrieve files
+curl "http://localhost:3000/api/mcp-handler?sessionId=test123"
+```
+
+### 3. Configure MCP Server in Claude Desktop
+Add to Claude Desktop settings (`claude_desktop_config.json`):
+```json
+{
+  "mcpServers": {
+    "reubenos": {
+      "command": "node",
+      "args": ["path/to/mcp-server.js"],
+      "env": {
+        "REUBENOS_URL": "http://localhost:3000"
+      }
+    }
+  }
+}
+```
+
+### 4. Test with Claude
+1. Open Claude Desktop
+2. Tell Claude your session ID
+3. Ask Claude to save a Flutter app:
+   ```
+   "Save a Flutter counter app to my session: session_test123"
+   ```
+4. Check the frontend - file should appear immediately
+
+## File Types Supported
+
+- **Flutter/Dart**: `.dart` files - Can be opened in Zapp
+- **LaTeX**: `.tex` files - Can be edited in LaTeX Studio
+- **Quizzes**: `quiz.json` - Launches Quiz App
+- **Any text file**: `.js`, `.py`, `.txt`, etc.
+
+## Security Considerations
+
+1. **Session ID Validation**: Only alphanumeric + hyphens/underscores
+2. **Filename Sanitization**: Prevents path traversal attacks
+3. **File Size Limits**: 1MB limit for content retrieval
+4. **Temporary Storage**: Files in `/tmp` are ephemeral
+5. **No Authentication**: Sessions are isolated by ID only
+
+## Deployment on Hugging Face Spaces
+
+1. **Environment**: Hugging Face provides `/tmp` for temporary storage
+2. **Persistence**: `/tmp` is cleared on container restart
+3. **Public Files**: Use `./public/uploads` for permanent storage
+4. **CORS**: API allows all origins (adjust for production)
+
+## Troubleshooting
+
+### Files Not Appearing
+- Check session ID matches exactly
+- Verify API is accessible at configured URL
+- Check browser console for errors
+- Ensure `/tmp` directory exists and is writable
+
+### MCP Connection Issues
+- Verify `REUBENOS_URL` environment variable
+- Check Claude Desktop has MCP server configured
+- Look at MCP server console output for errors
+
+### Quiz Not Launching
+- Ensure quiz.json has correct structure
+- Check frontend detects `isQuiz: true` flag
+- Verify Quiz App route exists
+
+## Example Session
+
+1. **Frontend**: Generates `session_1732255800000_xyz789`
+2. **User**: Copies ID, gives to Claude
+3. **Claude**: Saves `main.dart` using manage_files tool
+4. **Backend**: Stores as `/tmp/session_1732255800000_xyz789_main.dart`
+5. **Frontend**: Polls and displays "main.dart" (prefix stripped)
+6. **User**: Opens file in Zapp runner
+7. **Claude**: Deploys quiz using deploy_quiz tool
+8. **Frontend**: Shows quiz alert, launches Quiz App
+
+## Summary
+
+This implementation provides:
+- Simple, stateless session management
+- Automatic file isolation by session
+- No complex state tracking
+- Easy to debug and maintain
+- Compatible with Hugging Face Spaces constraints
+- Supports multiple file types and applications
+
+The prefix strategy ensures users never see the technical details - they only see clean filenames while the system maintains perfect isolation behind the scenes.

README.md

@@ -41,6 +41,16 @@ npm run dev
 # Open http://localhost:3000
 ```
 
+### Configuration
+
+To enable Gemini AI features, create a `.env.local` file in the root directory:
+
+```bash
+GEMINI_API_KEY=your_gemini_api_key_here
+```
+
+This key is used for the Gemini Chat and other AI features. The application uses the `gemini-1.5-flash` model by default.
+
 ### Deploy to Hugging Face Spaces
 
 This project is ready for deployment on [Hugging Face Spaces](https://huggingface.co/spaces):

frontend-fetch-example.js

@@ -0,0 +1,462 @@
+// frontend-fetch-example.js
+// Frontend code snippet for Reuben OS to fetch and display session files
+
+// React Component Example for Session Management
+import React, { useState, useEffect, useCallback } from 'react';
+
+// Configuration
+const API_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:3000';
+const POLL_INTERVAL = 5000; // Poll every 5 seconds
+
+// ===== SESSION MANAGER COMPONENT =====
+export function SessionManager() {
+  const [sessionId, setSessionId] = useState('');
+  const [files, setFiles] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [quizDetected, setQuizDetected] = useState(false);
+
+  // Generate a new session ID on component mount
+  useEffect(() => {
+    const generateSessionId = () => {
+      const timestamp = Date.now();
+      const random = Math.random().toString(36).substring(2, 9);
+      return `session_${timestamp}_${random}`;
+    };
+
+    // Check if session ID exists in localStorage, otherwise generate new one
+    const storedSessionId = localStorage.getItem('reubenOSSessionId');
+    if (storedSessionId) {
+      setSessionId(storedSessionId);
+    } else {
+      const newSessionId = generateSessionId();
+      setSessionId(newSessionId);
+      localStorage.setItem('reubenOSSessionId', newSessionId);
+    }
+  }, []);
+
+  // Fetch files for the current session
+  const fetchFiles = useCallback(async () => {
+    if (!sessionId) return;
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch(`${API_URL}/api/mcp-handler?sessionId=${sessionId}`);
+
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+
+      const data = await response.json();
+
+      if (data.success) {
+        setFiles(data.files || []);
+
+        // Check if quiz.json exists
+        const hasQuiz = data.files.some(file => file.name === 'quiz.json');
+        setQuizDetected(hasQuiz);
+      } else {
+        setError(data.error || 'Failed to fetch files');
+      }
+    } catch (err) {
+      console.error('Error fetching files:', err);
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  }, [sessionId]);
+
+  // Set up polling
+  useEffect(() => {
+    if (!sessionId) return;
+
+    // Initial fetch
+    fetchFiles();
+
+    // Set up polling interval
+    const interval = setInterval(fetchFiles, POLL_INTERVAL);
+
+    return () => clearInterval(interval);
+  }, [sessionId, fetchFiles]);
+
+  // Handle manual refresh
+  const handleRefresh = () => {
+    fetchFiles();
+  };
+
+  // Copy session ID to clipboard
+  const copySessionId = () => {
+    navigator.clipboard.writeText(sessionId);
+    alert('Session ID copied to clipboard!');
+  };
+
+  return (
+    <div className="session-manager">
+      <div className="session-header">
+        <h2>Session Manager</h2>
+        <div className="session-info">
+          <span>Session ID: {sessionId}</span>
+          <button onClick={copySessionId}>Copy ID</button>
+        </div>
+        <button onClick={handleRefresh} disabled={loading}>
+          {loading ? 'Loading...' : 'Refresh'}
+        </button>
+      </div>
+
+      {error && (
+        <div className="error-message">
+          Error: {error}
+        </div>
+      )}
+
+      {quizDetected && (
+        <div className="quiz-alert">
+          🎯 Quiz Detected! Click to launch Quiz App
+          <button onClick={() => launchQuizApp(sessionId)}>
+            Launch Quiz
+          </button>
+        </div>
+      )}
+
+      <div className="files-list">
+        <h3>Files ({files.length})</h3>
+        {files.length === 0 ? (
+          <p>No files yet. Use Claude to save files to this session.</p>
+        ) : (
+          <ul>
+            {files.map((file, index) => (
+              <FileItem key={index} file={file} sessionId={sessionId} />
+            ))}
+          </ul>
+        )}
+      </div>
+    </div>
+  );
+}
+
+// ===== FILE ITEM COMPONENT =====
+function FileItem({ file, sessionId }) {
+  const [showContent, setShowContent] = useState(false);
+
+  const handleDownload = () => {
+    // Create a download link
+    const blob = new Blob([file.content || ''], { type: 'text/plain' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = file.name;
+    a.click();
+    URL.revokeObjectURL(url);
+  };
+
+  const getFileIcon = (fileName) => {
+    if (fileName.endsWith('.dart')) return '🎯';
+    if (fileName.endsWith('.tex')) return '📜';
+    if (fileName.endsWith('.json')) return '📋';
+    if (fileName.endsWith('.js') || fileName.endsWith('.ts')) return '📝';
+    if (fileName.endsWith('.py')) return '🐍';
+    return '📄';
+  };
+
+  return (
+    <li className="file-item">
+      <div className="file-header">
+        <span className="file-icon">{getFileIcon(file.name)}</span>
+        <span className="file-name">{file.name}</span>
+        <span className="file-size">({(file.size / 1024).toFixed(2)} KB)</span>
+        <button onClick={() => setShowContent(!showContent)}>
+          {showContent ? 'Hide' : 'Show'}
+        </button>
+        <button onClick={handleDownload}>Download</button>
+      </div>
+
+      {showContent && file.content && (
+        <div className="file-content">
+          <pre>{file.content.substring(0, 500)}</pre>
+          {file.content.length > 500 && <p>... (truncated)</p>}
+        </div>
+      )}
+    </li>
+  );
+}
+
+// ===== QUIZ APP LAUNCHER =====
+function launchQuizApp(sessionId) {
+  // This function would navigate to your Quiz app with the session ID
+  window.location.href = `/apps/quiz?sessionId=${sessionId}`;
+}
+
+// ===== UTILITY FUNCTIONS =====
+
+// Function to save a file from the frontend (for testing)
+export async function saveFile(sessionId, fileName, content) {
+  try {
+    const response = await fetch(`${API_URL}/api/mcp-handler`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        sessionId,
+        action: 'save_file',
+        fileName,
+        content,
+      }),
+    });
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    console.error('Error saving file:', error);
+    throw error;
+  }
+}
+
+// Function to clear all files for a session
+export async function clearSession(sessionId) {
+  try {
+    const response = await fetch(`${API_URL}/api/mcp-handler`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        sessionId,
+        action: 'clear_session',
+        fileName: '',
+        content: '',
+      }),
+    });
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    console.error('Error clearing session:', error);
+    throw error;
+  }
+}
+
+// ===== FLUTTER APP COMPONENT =====
+export function FlutterAppViewer({ sessionId }) {
+  const [dartFiles, setDartFiles] = useState([]);
+
+  useEffect(() => {
+    const fetchDartFiles = async () => {
+      try {
+        const response = await fetch(`${API_URL}/api/mcp-handler?sessionId=${sessionId}`);
+        const data = await response.json();
+
+        if (data.success) {
+          // Filter only .dart files
+          const dartOnly = data.files.filter(f => f.name.endsWith('.dart'));
+          setDartFiles(dartOnly);
+        }
+      } catch (error) {
+        console.error('Error fetching Dart files:', error);
+      }
+    };
+
+    if (sessionId) {
+      fetchDartFiles();
+      const interval = setInterval(fetchDartFiles, POLL_INTERVAL);
+      return () => clearInterval(interval);
+    }
+  }, [sessionId]);
+
+  const openInZapp = (file) => {
+    // Open Dart code in Zapp runner
+    const zappUrl = 'https://zapp.run/';
+    const code = encodeURIComponent(file.content);
+    window.open(`${zappUrl}?code=${code}`, '_blank');
+  };
+
+  return (
+    <div className="flutter-viewer">
+      <h3>Flutter/Dart Files</h3>
+      {dartFiles.map((file, index) => (
+        <div key={index} className="dart-file">
+          <span>{file.name}</span>
+          <button onClick={() => openInZapp(file)}>
+            Open in Zapp
+          </button>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+// ===== LATEX VIEWER COMPONENT =====
+export function LaTeXViewer({ sessionId }) {
+  const [texFiles, setTexFiles] = useState([]);
+
+  useEffect(() => {
+    const fetchTexFiles = async () => {
+      try {
+        const response = await fetch(`${API_URL}/api/mcp-handler?sessionId=${sessionId}`);
+        const data = await response.json();
+
+        if (data.success) {
+          // Filter only .tex files
+          const texOnly = data.files.filter(f => f.name.endsWith('.tex'));
+          setTexFiles(texOnly);
+        }
+      } catch (error) {
+        console.error('Error fetching LaTeX files:', error);
+      }
+    };
+
+    if (sessionId) {
+      fetchTexFiles();
+      const interval = setInterval(fetchTexFiles, POLL_INTERVAL);
+      return () => clearInterval(interval);
+    }
+  }, [sessionId]);
+
+  return (
+    <div className="latex-viewer">
+      <h3>LaTeX Documents</h3>
+      {texFiles.map((file, index) => (
+        <div key={index} className="tex-file">
+          <span>{file.name}</span>
+          <button onClick={() => openInLatexEditor(file)}>
+            Open in Editor
+          </button>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+function openInLatexEditor(file) {
+  // Your LaTeX editor integration
+  window.location.href = `/apps/latex-studio?file=${file.name}`;
+}
+
+// ===== EXAMPLE USAGE IN NEXT.JS PAGE =====
+/*
+// pages/index.js or pages/dashboard.js
+
+import { SessionManager } from '../components/SessionManager';
+
+export default function Dashboard() {
+  return (
+    <div className="dashboard">
+      <h1>Reuben OS - File Manager</h1>
+      <SessionManager />
+    </div>
+  );
+}
+*/
+
+// ===== CSS STYLES (add to your global styles or styled-components) =====
+const styles = `
+.session-manager {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 20px;
+}
+
+.session-header {
+  background: #f5f5f5;
+  padding: 15px;
+  border-radius: 8px;
+  margin-bottom: 20px;
+}
+
+.session-info {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin: 10px 0;
+  font-family: monospace;
+  background: white;
+  padding: 10px;
+  border-radius: 4px;
+}
+
+.error-message {
+  background: #fee;
+  color: #c00;
+  padding: 10px;
+  border-radius: 4px;
+  margin: 10px 0;
+}
+
+.quiz-alert {
+  background: #efe;
+  color: #060;
+  padding: 15px;
+  border-radius: 4px;
+  margin: 10px 0;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.files-list {
+  background: white;
+  padding: 15px;
+  border-radius: 8px;
+  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+.file-item {
+  list-style: none;
+  padding: 10px;
+  border-bottom: 1px solid #eee;
+}
+
+.file-header {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.file-icon {
+  font-size: 20px;
+}
+
+.file-name {
+  flex: 1;
+  font-weight: 500;
+}
+
+.file-size {
+  color: #666;
+  font-size: 0.9em;
+}
+
+.file-content {
+  margin-top: 10px;
+  padding: 10px;
+  background: #f5f5f5;
+  border-radius: 4px;
+  overflow-x: auto;
+}
+
+.file-content pre {
+  margin: 0;
+  font-size: 0.9em;
+  line-height: 1.4;
+}
+
+button {
+  padding: 6px 12px;
+  background: #007bff;
+  color: white;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+}
+
+button:hover {
+  background: #0056b3;
+}
+
+button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+`;

mcp-server.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// mcp-server.js - Simplified MCP Server for Reuben OS with Stateless Prefix Strategy
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -7,17 +8,17 @@ import {
   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';
+const API_ENDPOINT = `${BASE_URL}/api/mcp-handler`;
 
 class ReubenOSMCPServer {
   constructor() {
     this.server = new Server(
       {
-        name: 'reubenos-file-manager',
-        version: '1.0.0',
-        description: 'AI-powered desktop environment with file management and document generation',
+        name: 'reubenos-mcp-server',
+        version: '2.0.0',
+        description: 'Simplified MCP Server for Reuben OS with stateless prefix strategy',
         icon: '🖥️',
       },
       {
@@ -41,356 +42,103 @@ class ReubenOSMCPServer {
     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: 'verify_session',
-          description: 'Verify if a session key is valid and active',
+          name: 'manage_files',
+          description: 'Manage files in Reuben OS - save Flutter/Dart, LaTeX, text, or any code files. Requires sessionId.',
           inputSchema: {
             type: 'object',
             properties: {
               sessionId: {
                 type: 'string',
-                description: 'Session ID to verify (format: session_timestamp_hash)',
+                description: 'Session ID from Reuben OS (required) - get this from the UI',
               },
-              sessionKey: {
-                type: 'string',
-                description: '(Deprecated) Use sessionId instead',
-              },
-            },
-            oneOf: [
-              { required: ['sessionId'] },
-              { required: ['sessionKey'] }
-            ],
-          },
-        },
-        {
-          name: 'upload_file',
-          description: 'Upload a file to session or public folder',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              sessionKey: {
+              action: {
                 type: 'string',
-                description: 'Session ID for authentication (this will be auto-filled if you verified your session)',
+                enum: ['save', 'retrieve', 'delete', 'clear'],
+                description: 'Action to perform',
               },
               fileName: {
                 type: 'string',
-                description: 'Name of the file',
+                description: 'File name (required for save/delete). Examples: main.dart, document.tex, script.js',
               },
               content: {
                 type: 'string',
-                description: 'File content (base64 encoded for binary files)',
-              },
-              isPublic: {
-                type: 'boolean',
-                description: 'Save to public folder',
-                default: false,
+                description: 'File content (required for save action)',
               },
             },
-            required: ['fileName', 'content'],
+            required: ['sessionId', 'action'],
           },
         },
         {
-          name: 'download_file',
-          description: 'Download a file from session or public folder',
+          name: 'deploy_quiz',
+          description: 'Deploy an interactive quiz to Reuben OS. The quiz will be shown in the Quiz App.',
           inputSchema: {
             type: 'object',
             properties: {
-              sessionKey: {
-                type: 'string',
-                description: 'Session ID (not required for public files, auto-filled if you verified your session)',
-              },
-              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 ID (not required for public files, auto-filled if you verified your session)',
-              },
-              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 ID for authentication (this will be auto-filled if you verified your session)',
-              },
-              type: {
-                type: 'string',
-                enum: ['docx', 'pdf', 'ppt', 'excel', 'latex'],
-                description: 'Document type to generate',
-              },
-              fileName: {
+              sessionId: {
                 type: 'string',
-                description: 'Output file name',
+                description: 'Session ID from Reuben OS (required) - get this from the UI',
               },
-              content: {
+              quizData: {
                 type: 'object',
-                description: 'Document content (structure varies by type)',
-              },
-              isPublic: {
-                type: 'boolean',
-                description: 'Save to public folder',
-                default: false,
-              },
-            },
-            required: ['type', 'fileName', 'content'],
-          },
-        },
-        {
-          name: 'process_document',
-          description: 'Read and analyze documents (DOCX, Excel, PDF, etc.)',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              sessionKey: {
-                type: 'string',
-                description: 'Session ID for authentication (this will be auto-filled if you verified your session)',
-              },
-              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: ['fileName'],
-          },
-        },
-        {
-          name: 'create_flutter_app',
-          description: 'Create a new Flutter app with Dart code that can be run in Zapp',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              name: {
-                type: 'string',
-                description: 'Name of the Flutter app (alphanumeric, hyphens, underscores)',
-              },
-              dartCode: {
-                type: 'string',
-                description: 'Complete Dart/Flutter code (typically main.dart content)',
-              },
-              dependencies: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'List of dependencies (e.g., ["http: ^0.13.0", "provider: ^6.0.0"])',
-              },
-              pubspecYaml: {
-                type: 'string',
-                description: 'Complete pubspec.yaml content (optional, will be auto-generated)',
-              },
-            },
-            required: ['name', 'dartCode'],
-          },
-        },
-        {
-          name: 'get_flutter_app',
-          description: 'Retrieve a Flutter app by name',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              name: {
-                type: 'string',
-                description: 'Name of the Flutter app',
-              },
-            },
-            required: ['name'],
-          },
-        },
-        {
-          name: 'list_flutter_apps',
-          description: 'List all available Flutter apps',
-          inputSchema: {
-            type: 'object',
-            properties: {},
-          },
-        },
-        {
-          name: 'update_flutter_app',
-          description: 'Update an existing Flutter app',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              name: {
-                type: 'string',
-                description: 'Name of the Flutter app to update',
-              },
-              dartCode: {
-                type: 'string',
-                description: 'New Dart/Flutter code (optional)',
-              },
-              dependencies: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'New dependencies list (optional)',
-              },
-              pubspecYaml: {
-                type: 'string',
-                description: 'New pubspec.yaml content (optional)',
-              },
-            },
-            required: ['name'],
-          },
-        },
-        {
-          name: 'delete_flutter_app',
-          description: 'Delete a Flutter app',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              name: {
-                type: 'string',
-                description: 'Name of the Flutter app to delete',
-              },
-            },
-            required: ['name'],
-          },
-        },
-        {
-          name: 'create_latex_document',
-          description: 'Create a LaTeX document that can be edited in LaTeX Studio',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              sessionKey: {
-                type: 'string',
-                description: 'Session ID for authentication (auto-filled if session verified)',
-              },
-              fileName: {
-                type: 'string',
-                description: 'Name of the LaTeX file (without .tex extension)',
-              },
-              content: {
-                type: 'string',
-                description: 'LaTeX document content',
-              },
-              isPublic: {
-                type: 'boolean',
-                description: 'Save to public folder',
-                default: false,
-              },
-            },
-            required: ['fileName', 'content'],
-          },
-        },
-        {
-          name: 'get_latex_document',
-          description: 'Retrieve a LaTeX document content',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              sessionKey: {
-                type: 'string',
-                description: 'Session ID for authentication (auto-filled if session verified)',
-              },
-              fileName: {
-                type: 'string',
-                description: 'Name of the LaTeX file',
-              },
-              isPublic: {
-                type: 'boolean',
-                description: 'File is in public folder',
-                default: false,
-              },
-            },
-            required: ['fileName'],
-          },
-        },
-        {
-          name: 'update_latex_document',
-          description: 'Update an existing LaTeX document',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              sessionKey: {
-                type: 'string',
-                description: 'Session ID for authentication (auto-filled if session verified)',
-              },
-              fileName: {
-                type: 'string',
-                description: 'Name of the LaTeX file to update',
-              },
-              content: {
-                type: 'string',
-                description: 'New LaTeX content',
-              },
-              isPublic: {
-                type: 'boolean',
-                description: 'File is in public folder',
-                default: false,
+                description: 'Quiz data object',
+                properties: {
+                  title: {
+                    type: 'string',
+                    description: 'Quiz title',
+                  },
+                  description: {
+                    type: 'string',
+                    description: 'Quiz description',
+                  },
+                  timeLimit: {
+                    type: 'number',
+                    description: 'Time limit in minutes (optional)',
+                  },
+                  questions: {
+                    type: 'array',
+                    description: 'Array of quiz questions',
+                    items: {
+                      type: 'object',
+                      properties: {
+                        id: {
+                          type: 'string',
+                          description: 'Unique question ID',
+                        },
+                        question: {
+                          type: 'string',
+                          description: 'The question text',
+                        },
+                        type: {
+                          type: 'string',
+                          enum: ['multiple-choice', 'true-false', 'short-answer'],
+                          description: 'Question type',
+                        },
+                        options: {
+                          type: 'array',
+                          description: 'Answer options (for multiple-choice)',
+                          items: { type: 'string' },
+                        },
+                        correctAnswer: {
+                          type: ['string', 'number', 'boolean'],
+                          description: 'Correct answer or index',
+                        },
+                        explanation: {
+                          type: 'string',
+                          description: 'Explanation (optional)',
+                        },
+                        points: {
+                          type: 'number',
+                          description: 'Points (default: 1)',
+                        },
+                      },
+                      required: ['id', 'question', 'type', 'correctAnswer'],
+                    },
+                  },
+                },
+                required: ['title', 'questions'],
               },
             },
-            required: ['fileName', 'content'],
-          },
-        },
-        {
-          name: 'compile_latex_to_pdf',
-          description: 'Compile a LaTeX document to PDF',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              sessionKey: {
-                type: 'string',
-                description: 'Session ID for authentication (auto-filled if session verified)',
-              },
-              fileName: {
-                type: 'string',
-                description: 'Name of the LaTeX file to compile',
-              },
-              isPublic: {
-                type: 'boolean',
-                description: 'File is in public folder',
-                default: false,
-              },
-            },
-            required: ['fileName'],
+            required: ['sessionId', 'quizData'],
           },
         },
       ],
@@ -401,38 +149,10 @@ class ReubenOSMCPServer {
 
       try {
         switch (name) {
-          case 'create_session':
-            return await this.createSession(args);
-          case 'verify_session':
-            return await this.verifySession(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);
-          case 'create_flutter_app':
-            return await this.createFlutterApp(args);
-          case 'get_flutter_app':
-            return await this.getFlutterApp(args);
-          case 'list_flutter_apps':
-            return await this.listFlutterApps(args);
-          case 'update_flutter_app':
-            return await this.updateFlutterApp(args);
-          case 'delete_flutter_app':
-            return await this.deleteFlutterApp(args);
-          case 'create_latex_document':
-            return await this.createLatexDocument(args);
-          case 'get_latex_document':
-            return await this.getLatexDocument(args);
-          case 'update_latex_document':
-            return await this.updateLatexDocument(args);
-          case 'compile_latex_to_pdf':
-            return await this.compileLatexToPdf(args);
+          case 'manage_files':
+            return await this.manageFiles(args);
+          case 'deploy_quiz':
+            return await this.deployQuiz(args);
           default:
             throw new Error(`Unknown tool: ${name}`);
         }
@@ -449,445 +169,264 @@ class ReubenOSMCPServer {
     });
   }
 
-  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 verifySession(args) {
-    // Accept either sessionId or sessionKey
-    const sessionId = args.sessionId || args.sessionKey;
-    
-    const response = await fetch(`${BASE_URL}/api/sessions/verify`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ sessionId }),
-    });
-
-    const data = await response.json();
-    
-    if (data.success && data.valid) {
-      // Store the session ID for future use
-      this.sessionId = sessionId;
-      
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✅ Session is VALID!\n\nSession ID: ${sessionId}\n\nYou can now use this session for file operations.`,
-          },
-        ],
-      };
-    } else {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `❌ Session is INVALID or EXPIRED\n\nThe session ID you provided is not recognized by the server. This can happen if:\n- The Hugging Face Space restarted\n- The session expired (24 hours old)\n- The session ID was mistyped\n\nPlease get a new session ID from the ReubenOS Session Manager.`,
-          },
-        ],
-      };
-    }
-  }
-
-  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-id': args.sessionKey || this.sessionId };
-
-    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-id': args.sessionKey || this.sessionId };
-
-    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-id': args.sessionKey || this.sessionId,
-      },
-      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 manageFiles(args) {
+    try {
+      // Validate inputs based on action
+      if (args.action === 'save' && (!args.fileName || args.content === undefined)) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: '❌ Save action requires fileName and content',
+            },
+          ],
+        };
+      }
 
-  async processDocument(args) {
-    const response = await fetch(`${BASE_URL}/api/documents/process`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-session-id': args.sessionKey || this.sessionId,
-      },
-      body: JSON.stringify({
-        fileName: args.fileName,
-        isPublic: args.isPublic || false,
-        operation: args.operation || 'read',
-      }),
-    });
+      if (args.action === 'delete' && !args.fileName) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: '❌ Delete action requires fileName',
+            },
+          ],
+        };
+      }
 
-    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}`,
-        },
-      ],
-    };
-  }
+      // Handle different actions
+      switch (args.action) {
+        case 'save': {
+          const response = await fetch(API_ENDPOINT, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              sessionId: args.sessionId,
+              action: 'save_file',
+              fileName: args.fileName,
+              content: args.content,
+            }),
+          });
+
+          const data = await response.json();
+
+          if (response.ok && data.success) {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `✅ File saved successfully!\n\n📄 File: ${args.fileName}\n🔑 Session: ${args.sessionId}\n\n✨ File is now available in Reuben OS`,
+                },
+              ],
+            };
+          } else {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `❌ Failed to save file: ${data.error || 'Unknown error'}`,
+                },
+              ],
+            };
+          }
+        }
 
-  async createFlutterApp(args) {
-    const response = await fetch(`${BASE_URL}/api/flutter/create`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        name: args.name,
-        dartCode: args.dartCode,
-        dependencies: args.dependencies || [],
-        pubspecYaml: args.pubspecYaml,
-      }),
-    });
+        case 'retrieve': {
+          const response = await fetch(`${API_ENDPOINT}?sessionId=${args.sessionId}`, {
+            method: 'GET',
+            headers: { 'Content-Type': 'application/json' },
+          });
+
+          const data = await response.json();
+
+          if (response.ok && data.success) {
+            const fileList = data.files
+              .map(f => `📄 ${f.name} (${(f.size / 1024).toFixed(2)} KB)${f.isQuiz ? ' [QUIZ]' : ''}`)
+              .join('\n');
+
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `📁 Files for session ${args.sessionId}:\n\n${fileList || 'No files found'}\n\nTotal: ${data.count} file(s)`,
+                },
+              ],
+            };
+          } else {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `❌ Failed to retrieve files: ${data.error || 'Unknown error'}`,
+                },
+              ],
+            };
+          }
+        }
 
-    const data = await response.json();
-    return {
-      content: [
-        {
-          type: 'text',
-          text: data.success
-            ? `✅ Flutter app "${data.appName}" created successfully!\n\n📱 App Details:\n- Name: ${data.appName}\n- Dependencies: ${data.dependencies?.length || 0}\n- File: ${data.fileName}\n\n🎯 Next Steps:\n1. Open ReubenOS File Manager\n2. Navigate to flutter_apps folder\n3. Double-click "${data.appName}" to open in Zapp runner\n4. Copy the code and paste into Zapp's lib/main.dart\n5. Add dependencies to pubspec.yaml\n6. Click Run in Zapp!\n\n🚀 Your Flutter app is ready to test!`
-            : `❌ Failed to create Flutter app: ${data.error}`,
-        },
-      ],
-    };
-  }
+        case 'delete': {
+          const response = await fetch(API_ENDPOINT, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              sessionId: args.sessionId,
+              action: 'delete_file',
+              fileName: args.fileName,
+              content: '',
+            }),
+          });
+
+          const data = await response.json();
+
+          if (response.ok && data.success) {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `✅ File '${args.fileName}' deleted successfully from session ${args.sessionId}`,
+                },
+              ],
+            };
+          } else {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `❌ Failed to delete file: ${data.error || 'File not found'}`,
+                },
+              ],
+            };
+          }
+        }
 
-  async getFlutterApp(args) {
-    const response = await fetch(`${BASE_URL}/api/flutter/get?name=${encodeURIComponent(args.name)}`);
-    const data = await response.json();
+        case 'clear': {
+          const response = await fetch(API_ENDPOINT, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              sessionId: args.sessionId,
+              action: 'clear_session',
+              fileName: '',
+              content: '',
+            }),
+          });
+
+          const data = await response.json();
+
+          if (response.ok && data.success) {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `✅ All files cleared for session ${args.sessionId}\n\n🗑️ Deleted ${data.deletedCount || 0} file(s)`,
+                },
+              ],
+            };
+          } else {
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `❌ Failed to clear session: ${data.error || 'Unknown error'}`,
+                },
+              ],
+            };
+          }
+        }
 
-    if (data.success) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Flutter App: ${data.appData.name}\n\nDart Code:\n${data.appData.dartCode}\n\nDependencies:\n${data.appData.dependencies?.join('\n') || 'None'}\n\nCreated: ${data.appData.metadata?.created || 'Unknown'}`,
-          },
-        ],
-      };
-    } else {
+        default:
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `❌ Unknown action: ${args.action}`,
+              },
+            ],
+          };
+      }
+    } catch (error) {
+      console.error('manage_files error:', error);
       return {
         content: [
           {
             type: 'text',
-            text: `Failed to get Flutter app: ${data.error}`,
+            text: `❌ Error: ${error.message}`,
           },
         ],
       };
     }
   }
 
-  async listFlutterApps(args) {
-    const response = await fetch(`${BASE_URL}/api/flutter/list`);
-    const data = await response.json();
+  async deployQuiz(args) {
+    try {
+      // Validate quiz data
+      if (!args.quizData.questions || args.quizData.questions.length === 0) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: '❌ Quiz must have at least one question',
+            },
+          ],
+        };
+      }
 
-    if (data.success) {
-      const appList = data.apps
-        .map((app) => `📱 ${app.name} (${app.dependenciesCount} deps) - Created: ${new Date(app.created).toLocaleDateString()}`)
-        .join('\n');
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Flutter Apps (${data.count} total):\n\n${appList || 'No Flutter apps found'}`,
-          },
-        ],
-      };
-    } else {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Failed to list Flutter apps: ${data.error}`,
-          },
-        ],
+      // Add metadata to quiz
+      const fullQuizData = {
+        ...args.quizData,
+        createdAt: new Date().toISOString(),
+        sessionId: args.sessionId,
+        version: '1.0',
       };
-    }
-  }
-
-  async updateFlutterApp(args) {
-    const response = await fetch(`${BASE_URL}/api/flutter/update`, {
-      method: 'PUT',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        name: args.name,
-        dartCode: args.dartCode,
-        dependencies: args.dependencies,
-        pubspecYaml: args.pubspecYaml,
-      }),
-    });
-
-    const data = await response.json();
-    return {
-      content: [
-        {
-          type: 'text',
-          text: data.success
-            ? `✅ Flutter app "${data.appName}" updated successfully!`
-            : `❌ Failed to update Flutter app: ${data.error}`,
-        },
-      ],
-    };
-  }
-
-  async deleteFlutterApp(args) {
-    const response = await fetch(`${BASE_URL}/api/flutter/delete?name=${encodeURIComponent(args.name)}`, {
-      method: 'DELETE',
-    });
-
-    const data = await response.json();
-    return {
-      content: [
-        {
-          type: 'text',
-          text: data.success
-            ? `✅ Flutter app "${args.name}" deleted successfully!`
-            : `❌ Failed to delete Flutter app: ${data.error}`,
-        },
-      ],
-    };
-  }
-
-  async createLatexDocument(args) {
-    const response = await fetch(`${BASE_URL}/api/latex/save`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-session-id': args.sessionKey || this.sessionId,
-      },
-      body: JSON.stringify({
-        fileName: args.fileName.endsWith('.tex') ? args.fileName : `${args.fileName}.tex`,
-        content: args.content,
-        isPublic: args.isPublic || false,
-      }),
-    });
 
-    const data = await response.json();
-    return {
-      content: [
-        {
-          type: 'text',
-          text: data.success
-            ? `✅ LaTeX document created successfully!\n\n📄 Document: ${data.fileName}\n📂 Location: ${args.isPublic ? 'Public' : 'Session'} folder\n\n🎯 Next Steps:\n1. Open ReubenOS File Manager\n2. Navigate to ${args.isPublic ? 'Public' : 'My Files'}\n3. Double-click "${data.fileName}" to open in LaTeX Studio\n4. Edit and compile your document\n\n✨ Your LaTeX document is ready!`
-            : `❌ Failed to create LaTeX document: ${data.error}`,
-        },
-      ],
-    };
-  }
+      // Save quiz as quiz.json
+      const response = await fetch(API_ENDPOINT, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          sessionId: args.sessionId,
+          action: 'deploy_quiz',
+          fileName: 'quiz.json',
+          content: JSON.stringify(fullQuizData, null, 2),
+        }),
+      });
 
-  async getLatexDocument(args) {
-    // First download the file to get its content
-    const url = `${BASE_URL}/api/sessions/download?file=${encodeURIComponent(args.fileName)}${
-      args.isPublic ? '&public=true' : ''
-    }`;
-    const headers = args.isPublic ? {} : { 'x-session-id': args.sessionKey || this.sessionId };
+      const data = await response.json();
 
-    const response = await fetch(url, { headers });
+      if (response.ok && data.success) {
+        const totalPoints = args.quizData.questions.reduce((sum, q) => sum + (q.points || 1), 0);
 
-    if (response.ok) {
-      const content = await response.text();
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `LaTeX Document: ${args.fileName}\n\n${content}`,
-          },
-        ],
-      };
-    } else {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `✅ Quiz deployed successfully!\n\n📝 Quiz: ${args.quizData.title}\n📊 Questions: ${args.quizData.questions.length}\n⏱️ Time Limit: ${args.quizData.timeLimit || 'No limit'} minutes\n🎯 Total Points: ${totalPoints}\n🔑 Session: ${args.sessionId}\n\n🚀 The quiz is now available in Reuben OS Quiz App!`,
+            },
+          ],
+        };
+      } else {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `❌ Failed to deploy quiz: ${data.error || 'Unknown error'}`,
+            },
+          ],
+        };
+      }
+    } catch (error) {
+      console.error('deploy_quiz error:', error);
       return {
         content: [
           {
             type: 'text',
-            text: `Failed to get LaTeX document: ${response.statusText}`,
+            text: `❌ Error deploying quiz: ${error.message}`,
           },
         ],
       };
     }
   }
 
-  async updateLatexDocument(args) {
-    const response = await fetch(`${BASE_URL}/api/latex/save`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-session-id': args.sessionKey || this.sessionId,
-      },
-      body: JSON.stringify({
-        fileName: args.fileName.endsWith('.tex') ? args.fileName : `${args.fileName}.tex`,
-        content: args.content,
-        isPublic: args.isPublic || false,
-      }),
-    });
-
-    const data = await response.json();
-    return {
-      content: [
-        {
-          type: 'text',
-          text: data.success
-            ? `✅ LaTeX document "${args.fileName}" updated successfully!`
-            : `❌ Failed to update LaTeX document: ${data.error}`,
-        },
-      ],
-    };
-  }
-
-  async compileLatexToPdf(args) {
-    const response = await fetch(`${BASE_URL}/api/latex/compile`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-session-id': args.sessionKey || this.sessionId,
-      },
-      body: JSON.stringify({
-        fileName: args.fileName.endsWith('.tex') ? args.fileName : `${args.fileName}.tex`,
-        isPublic: args.isPublic || false,
-      }),
-    });
-
-    const data = await response.json();
-    return {
-      content: [
-        {
-          type: 'text',
-          text: data.success
-            ? `✅ LaTeX compiled to PDF successfully!\n\n📄 PDF File: ${data.pdfFileName}\n📂 Location: ${args.isPublic ? 'Public' : 'Session'} folder\n\n✨ Your PDF is ready for download!`
-            : `❌ Failed to compile LaTeX: ${data.error}`,
-        },
-      ],
-    };
-  }
-
   async run() {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);

pages/api/mcp-handler.js

@@ -0,0 +1,205 @@
+// pages/api/mcp-handler.js
+import fs from 'fs/promises';
+import path from 'path';
+
+// Ensure /tmp directory exists
+async function ensureTmpDirectory() {
+  const tmpPath = '/tmp';
+  try {
+    await fs.access(tmpPath);
+  } catch {
+    await fs.mkdir(tmpPath, { recursive: true });
+  }
+}
+
+// Validate session ID format (alphanumeric and underscores only)
+function isValidSessionId(sessionId) {
+  return sessionId && /^[a-zA-Z0-9_-]+$/.test(sessionId);
+}
+
+// Sanitize filename to prevent path traversal
+function sanitizeFileName(fileName) {
+  return fileName.replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+
+export default async function handler(req, res) {
+  // Enable CORS for all origins (adjust as needed for production)
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+  if (req.method === 'OPTIONS') {
+    return res.status(200).end();
+  }
+
+  try {
+    await ensureTmpDirectory();
+
+    if (req.method === 'POST') {
+      // Handle file save/quiz deployment
+      const { sessionId, action, fileName, content } = req.body;
+
+      // Validate session ID
+      if (!isValidSessionId(sessionId)) {
+        return res.status(400).json({
+          success: false,
+          error: 'Invalid or missing sessionId'
+        });
+      }
+
+      // Validate required fields
+      if (!action || !fileName || content === undefined) {
+        return res.status(400).json({
+          success: false,
+          error: 'Missing required fields: action, fileName, or content'
+        });
+      }
+
+      const sanitizedFileName = sanitizeFileName(fileName);
+      const prefixedFileName = `${sessionId}_${sanitizedFileName}`;
+      const filePath = path.join('/tmp', prefixedFileName);
+
+      try {
+        // Handle different actions
+        switch (action) {
+          case 'save_file':
+          case 'deploy_quiz':
+            // Write content to file
+            await fs.writeFile(filePath, content, 'utf8');
+
+            return res.status(200).json({
+              success: true,
+              message: `File saved successfully`,
+              fileName: sanitizedFileName,
+              prefixedFileName: prefixedFileName,
+              action: action
+            });
+
+          case 'delete_file':
+            // Delete specific file
+            try {
+              await fs.unlink(filePath);
+              return res.status(200).json({
+                success: true,
+                message: `File deleted successfully`,
+                fileName: sanitizedFileName
+              });
+            } catch (err) {
+              return res.status(404).json({
+                success: false,
+                error: 'File not found'
+              });
+            }
+
+          case 'clear_session':
+            // Clear all files for this session
+            const files = await fs.readdir('/tmp');
+            const sessionFiles = files.filter(f => f.startsWith(`${sessionId}_`));
+
+            for (const file of sessionFiles) {
+              await fs.unlink(path.join('/tmp', file));
+            }
+
+            return res.status(200).json({
+              success: true,
+              message: `Cleared ${sessionFiles.length} files for session`,
+              deletedCount: sessionFiles.length
+            });
+
+          default:
+            return res.status(400).json({
+              success: false,
+              error: `Unknown action: ${action}`
+            });
+        }
+      } catch (error) {
+        console.error('File operation error:', error);
+        return res.status(500).json({
+          success: false,
+          error: `Failed to ${action}: ${error.message}`
+        });
+      }
+
+    } else if (req.method === 'GET') {
+      // Handle file retrieval
+      const { sessionId } = req.query;
+
+      // Validate session ID
+      if (!isValidSessionId(sessionId)) {
+        return res.status(400).json({
+          success: false,
+          error: 'Invalid or missing sessionId'
+        });
+      }
+
+      try {
+        // Read all files from /tmp
+        const allFiles = await fs.readdir('/tmp');
+
+        // Filter files for this session
+        const sessionPrefix = `${sessionId}_`;
+        const sessionFiles = allFiles.filter(f => f.startsWith(sessionPrefix));
+
+        // Build file list with content
+        const fileList = await Promise.all(
+          sessionFiles.map(async (file) => {
+            const filePath = path.join('/tmp', file);
+            const stats = await fs.stat(filePath);
+
+            // Strip session prefix from filename
+            const cleanFileName = file.substring(sessionPrefix.length);
+
+            // Read file content (with size limit to prevent memory issues)
+            let content = null;
+            if (stats.size < 1024 * 1024) { // 1MB limit for content retrieval
+              try {
+                content = await fs.readFile(filePath, 'utf8');
+              } catch (err) {
+                console.error(`Error reading file ${file}:`, err);
+              }
+            }
+
+            return {
+              name: cleanFileName,
+              prefixedName: file,
+              size: stats.size,
+              modified: stats.mtime,
+              isQuiz: cleanFileName === 'quiz.json',
+              content: content
+            };
+          })
+        );
+
+        // Sort by modification time (newest first)
+        fileList.sort((a, b) => new Date(b.modified) - new Date(a.modified));
+
+        return res.status(200).json({
+          success: true,
+          sessionId: sessionId,
+          files: fileList,
+          count: fileList.length
+        });
+
+      } catch (error) {
+        console.error('Error reading files:', error);
+        return res.status(500).json({
+          success: false,
+          error: `Failed to retrieve files: ${error.message}`
+        });
+      }
+
+    } else {
+      return res.status(405).json({
+        success: false,
+        error: 'Method not allowed'
+      });
+    }
+
+  } catch (error) {
+    console.error('Unexpected error:', error);
+    return res.status(500).json({
+      success: false,
+      error: `Server error: ${error.message}`
+    });
+  }
+}