Merge pull request #146 from siteboon/cursor-cli

- Updated ClaudeStatus component to accept a provider prop for better flexibility.
- Added CursorLogo component for displaying cursor sessions.
- Modified MainContent to conditionally display session names based on provider.
- Updated Shell component to show session names and summaries based on provider.
- Enhanced Sidebar to handle both Claude and Cursor sessions, including sorting and displaying session icons.
- Introduced new ToolsSettings functionality to manage tools for both Claude and Cursor, including allowed and disallowed commands.
- Implemented fetching and saving of Cursor-specific settings and commands.
- Added UI elements for managing Cursor tools, including permission settings and command lists.

.gitignore

@@ -98,10 +98,31 @@ temp/
 # Local Netlify folder
 .netlify
 
-# Claude specific
+# AI specific
 .claude/
+.cursor/
+.roo/
+.taskmaster/
+.cline/
+.windsurf/
 
 # Database files
 *.db
 *.sqlite
-*.sqlite3 
+*.sqlite3 
+
+logs
+dev-debug.log
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+# OS specific
+
+# Task files
+tasks.json
+tasks/ 

README.md

@@ -4,7 +4,7 @@
 </div>
 
 
-A desktop and mobile UI for [Claude Code](https://docs.anthropic.com/en/docs/claude-code), Anthropic's official CLI for AI-assisted coding. You can use it locally or remotely to view your active projects and sessions in claude code and make changes to them the same way you would do it in claude code CLI. This gives you a proper interface that works everywhere. 
+A desktop and mobile UI for [Claude Code](https://docs.anthropic.com/en/docs/claude-code), and [Cursor CLI](https://docs.cursor.com/en/cli/overview). You can use it locally or remotely to view your active projects and sessions in Claude Code or Cursor and make changes to them from everywhere (mobile or desktop). This gives you a proper interface that works everywhere. Supports models including **Claude Sonnet 4**, **Opus 4.1**, and **GPT-5**
 
 ## Screenshots
 
@@ -25,6 +25,14 @@ A desktop and mobile UI for [Claude Code](https://docs.anthropic.com/en/docs/cla
 <em>Responsive mobile design with touch navigation</em>
 </td>
 </tr>
+<tr>
+<td align="center" colspan="2">
+<h3>CLI Selection</h3>
+<img src="public/screenshots/cli-selection.png" alt="CLI Selection" width="400">
+<br>
+<em>Select between Claude Code and Cursor CLI</em>
+</td>
+</tr>
 </table>
 
 
@@ -34,11 +42,12 @@ A desktop and mobile UI for [Claude Code](https://docs.anthropic.com/en/docs/cla
 ## Features
 
 - **Responsive Design** - Works seamlessly across desktop, tablet, and mobile so you can also use Claude Code from mobile 
-- **Interactive Chat Interface** - Built-in chat interface for seamless communication with Claude Code
-- **Integrated Shell Terminal** - Direct access to Claude Code CLI through built-in shell functionality
+- **Interactive Chat Interface** - Built-in chat interface for seamless communication with Claude Code or Cursor
+- **Integrated Shell Terminal** - Direct access to Claude Code or Cursor CLI through built-in shell functionality
 - **File Explorer** - Interactive file tree with syntax highlighting and live editing
 - **Git Explorer** - View, stage and commit your changes. You can also switch branches 
 - **Session Management** - Resume conversations, manage multiple sessions, and track history
+- **Model Compatibility** - Works with Claude Sonnet 4, Opus 4.1, and GPT-5
 
 
 ## Quick Start
@@ -46,7 +55,8 @@ A desktop and mobile UI for [Claude Code](https://docs.anthropic.com/en/docs/cla
 ### Prerequisites
 
 - [Node.js](https://nodejs.org/) v20 or higher
-- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and configured
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and configured, and/or
+- [Cursor CLI](https://docs.cursor.com/en/cli/overview) installed and configured
 
 ### Installation
 
@@ -108,9 +118,10 @@ The UI automatically discovers Claude Code projects from `~/.claude/projects/` a
 - **Visual Project Browser** - All available projects with metadata and session counts
 - **Project Actions** - Rename, delete, and organize projects
 - **Smart Navigation** - Quick access to recent projects and sessions
+- **MCP support** - Add your own MCP servers through the UI 
 
 #### Chat Interface
-- **Use responsive chat or Claude Code CLI** - You can either use the adapted chat interface or use the shell button to connect to Claude Code CLI. 
+- **Use responsive chat or Claude Code/Cursor CLI** - You can either use the adapted chat interface or use the shell button to connect to your selected CLI. 
 - **Real-time Communication** - Stream responses from Claude with WebSocket connection
 - **Session Management** - Resume previous conversations or start fresh sessions
 - **Message History** - Complete conversation history with timestamps and metadata
@@ -152,7 +163,7 @@ The UI automatically discovers Claude Code projects from `~/.claude/projects/` a
 ### Backend (Node.js + Express)
 - **Express Server** - RESTful API with static file serving
 - **WebSocket Server** - Communication for chats and project refresh
-- **Claude CLI Integration** - Process spawning and management
+- **CLI Integration (Claude Code / Cursor)** - Process spawning and management
 - **Session Management** - JSONL parsing and conversation persistence
 - **File System API** - Exposing file browser for projects
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-ui",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "A web-based UI for Claude Code CLI",
   "type": "module",
   "main": "server/index.js",
@@ -52,6 +52,8 @@
     "react-dropzone": "^14.2.3",
     "react-markdown": "^10.1.0",
     "react-router-dom": "^6.8.1",
+    "sqlite": "^5.1.1",
+    "sqlite3": "^5.1.7",
     "tailwind-merge": "^3.3.1",
     "ws": "^8.14.2",
     "xterm": "^5.3.0",
@@ -68,4 +70,4 @@
     "tailwindcss": "^3.4.0",
     "vite": "^7.0.4"
   }
-}
+}

public/icons/cursor.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Cursor</title><path d="M11.925 24l10.425-6-10.425-6L1.5 18l10.425 6z" fill="url(#lobe-icons-cursorundefined-fill-0)"></path><path d="M22.35 18V6L11.925 0v12l10.425 6z" fill="url(#lobe-icons-cursorundefined-fill-1)"></path><path d="M11.925 0L1.5 6v12l10.425-6V0z" fill="url(#lobe-icons-cursorundefined-fill-2)"></path><path d="M22.35 6L11.925 24V12L22.35 6z" fill="#555"></path><path d="M22.35 6l-10.425 6L1.5 6h20.85z" fill="#000"></path><defs><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-cursorundefined-fill-0" x1="11.925" x2="11.925" y1="12" y2="24"><stop offset=".16" stop-color="#000" stop-opacity=".39"></stop><stop offset=".658" stop-color="#000" stop-opacity=".8"></stop></linearGradient><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-cursorundefined-fill-1" x1="22.35" x2="11.925" y1="6.037" y2="12.15"><stop offset=".182" stop-color="#000" stop-opacity=".31"></stop><stop offset=".715" stop-color="#000" stop-opacity="0"></stop></linearGradient><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-cursorundefined-fill-2" x1="11.925" x2="1.5" y1="0" y2="18"><stop stop-color="#000" stop-opacity=".6"></stop><stop offset=".667" stop-color="#000" stop-opacity=".22"></stop></linearGradient></defs></svg>

server/cursor-cli.js

@@ -0,0 +1,250 @@
+import { spawn } from 'child_process';
+import crossSpawn from 'cross-spawn';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Use cross-spawn on Windows for better command execution
+const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
+
+let activeCursorProcesses = new Map(); // Track active processes by session ID
+
+async function spawnCursor(command, options = {}, ws) {
+  return new Promise(async (resolve, reject) => {
+    const { sessionId, projectPath, cwd, resume, toolsSettings, skipPermissions, model, images } = options;
+    let capturedSessionId = sessionId; // Track session ID throughout the process
+    let sessionCreatedSent = false; // Track if we've already sent session-created event
+    let messageBuffer = ''; // Buffer for accumulating assistant messages
+    
+    // Use tools settings passed from frontend, or defaults
+    const settings = toolsSettings || {
+      allowedShellCommands: [],
+      skipPermissions: false
+    };
+    
+    // Build Cursor CLI command
+    const args = [];
+    
+    // Build flags allowing both resume and prompt together (reply in existing session)
+    // Treat presence of sessionId as intention to resume, regardless of resume flag
+    if (sessionId) {
+      args.push('--resume=' + sessionId);
+    }
+
+    if (command && command.trim()) {
+      // Provide a prompt (works for both new and resumed sessions)
+      args.push('-p', command);
+
+      // Add model flag if specified (only meaningful for new sessions; harmless on resume)
+      if (!sessionId && model) {
+        args.push('--model', model);
+      }
+
+      // Request streaming JSON when we are providing a prompt
+      args.push('--output-format', 'stream-json');
+    }
+    
+    // Add skip permissions flag if enabled
+    if (skipPermissions || settings.skipPermissions) {
+      args.push('-f');
+      console.log('⚠️  Using -f flag (skip permissions)');
+    }
+    
+    // Use cwd (actual project directory) instead of projectPath
+    const workingDir = cwd || projectPath || process.cwd();
+    
+    console.log('Spawning Cursor CLI:', 'cursor-agent', args.join(' '));
+    console.log('Working directory:', workingDir);
+    console.log('Session info - Input sessionId:', sessionId, 'Resume:', resume);
+    
+    const cursorProcess = spawnFunction('cursor-agent', args, {
+      cwd: workingDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env } // Inherit all environment variables
+    });
+    
+    // Store process reference for potential abort
+    const processKey = capturedSessionId || Date.now().toString();
+    activeCursorProcesses.set(processKey, cursorProcess);
+    
+    // Handle stdout (streaming JSON responses)
+    cursorProcess.stdout.on('data', (data) => {
+      const rawOutput = data.toString();
+      console.log('📤 Cursor CLI stdout:', rawOutput);
+      
+      const lines = rawOutput.split('\n').filter(line => line.trim());
+      
+      for (const line of lines) {
+        try {
+          const response = JSON.parse(line);
+          console.log('📄 Parsed JSON response:', response);
+          
+          // Handle different message types
+          switch (response.type) {
+            case 'system':
+              if (response.subtype === 'init') {
+                // Capture session ID
+                if (response.session_id && !capturedSessionId) {
+                  capturedSessionId = response.session_id;
+                  console.log('📝 Captured session ID:', capturedSessionId);
+                  
+                  // Update process key with captured session ID
+                  if (processKey !== capturedSessionId) {
+                    activeCursorProcesses.delete(processKey);
+                    activeCursorProcesses.set(capturedSessionId, cursorProcess);
+                  }
+                  
+                  // Send session-created event only once for new sessions
+                  if (!sessionId && !sessionCreatedSent) {
+                    sessionCreatedSent = true;
+                    ws.send(JSON.stringify({
+                      type: 'session-created',
+                      sessionId: capturedSessionId,
+                      model: response.model,
+                      cwd: response.cwd
+                    }));
+                  }
+                }
+                
+                // Send system info to frontend
+                ws.send(JSON.stringify({
+                  type: 'cursor-system',
+                  data: response
+                }));
+              }
+              break;
+              
+            case 'user':
+              // Forward user message
+              ws.send(JSON.stringify({
+                type: 'cursor-user',
+                data: response
+              }));
+              break;
+              
+            case 'assistant':
+              // Accumulate assistant message chunks
+              if (response.message && response.message.content && response.message.content.length > 0) {
+                const textContent = response.message.content[0].text;
+                messageBuffer += textContent;
+                
+                // Send as Claude-compatible format for frontend
+                ws.send(JSON.stringify({
+                  type: 'claude-response',
+                  data: {
+                    type: 'content_block_delta',
+                    delta: {
+                      type: 'text_delta',
+                      text: textContent
+                    }
+                  }
+                }));
+              }
+              break;
+              
+            case 'result':
+              // Session complete
+              console.log('Cursor session result:', response);
+              
+              // Send final message if we have buffered content
+              if (messageBuffer) {
+                ws.send(JSON.stringify({
+                  type: 'claude-response',
+                  data: {
+                    type: 'content_block_stop'
+                  }
+                }));
+              }
+              
+              // Send completion event
+              ws.send(JSON.stringify({
+                type: 'cursor-result',
+                data: response,
+                success: response.subtype === 'success'
+              }));
+              break;
+              
+            default:
+              // Forward any other message types
+              ws.send(JSON.stringify({
+                type: 'cursor-response',
+                data: response
+              }));
+          }
+        } catch (parseError) {
+          console.log('📄 Non-JSON response:', line);
+          // If not JSON, send as raw text
+          ws.send(JSON.stringify({
+            type: 'cursor-output',
+            data: line
+          }));
+        }
+      }
+    });
+    
+    // Handle stderr
+    cursorProcess.stderr.on('data', (data) => {
+      console.error('Cursor CLI stderr:', data.toString());
+      ws.send(JSON.stringify({
+        type: 'cursor-error',
+        error: data.toString()
+      }));
+    });
+    
+    // Handle process completion
+    cursorProcess.on('close', async (code) => {
+      console.log(`Cursor CLI process exited with code ${code}`);
+      
+      // Clean up process reference
+      const finalSessionId = capturedSessionId || sessionId || processKey;
+      activeCursorProcesses.delete(finalSessionId);
+      
+      ws.send(JSON.stringify({
+        type: 'claude-complete',
+        exitCode: code,
+        isNewSession: !sessionId && !!command // Flag to indicate this was a new session
+      }));
+      
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Cursor CLI exited with code ${code}`));
+      }
+    });
+    
+    // Handle process errors
+    cursorProcess.on('error', (error) => {
+      console.error('Cursor CLI process error:', error);
+      
+      // Clean up process reference on error
+      const finalSessionId = capturedSessionId || sessionId || processKey;
+      activeCursorProcesses.delete(finalSessionId);
+      
+      ws.send(JSON.stringify({
+        type: 'cursor-error',
+        error: error.message
+      }));
+      
+      reject(error);
+    });
+    
+    // Close stdin since Cursor doesn't need interactive input
+    cursorProcess.stdin.end();
+  });
+}
+
+function abortCursorSession(sessionId) {
+  const process = activeCursorProcesses.get(sessionId);
+  if (process) {
+    console.log(`🛑 Aborting Cursor session: ${sessionId}`);
+    process.kill('SIGTERM');
+    activeCursorProcesses.delete(sessionId);
+    return true;
+  }
+  return false;
+}
+
+export {
+  spawnCursor,
+  abortCursorSession
+};

server/index.js

@@ -38,9 +38,11 @@ import mime from 'mime-types';
 
 import { getProjects, getSessions, getSessionMessages, renameProject, deleteSession, deleteProject, addProjectManually, extractProjectDirectory, clearProjectDirectoryCache } from './projects.js';
 import { spawnClaude, abortClaudeSession } from './claude-cli.js';
+import { spawnCursor, abortCursorSession } from './cursor-cli.js';
 import gitRoutes from './routes/git.js';
 import authRoutes from './routes/auth.js';
 import mcpRoutes from './routes/mcp.js';
+import cursorRoutes from './routes/cursor.js';
 import { initializeDatabase } from './database/db.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
 
@@ -175,6 +177,9 @@ app.use('/api/git', authenticateToken, gitRoutes);
 // MCP API Routes (protected)
 app.use('/api/mcp', authenticateToken, mcpRoutes);
 
+// Cursor API Routes (protected)
+app.use('/api/cursor', authenticateToken, cursorRoutes);
+
 // Static files served after API routes
 app.use(express.static(path.join(__dirname, '../dist')));
 
@@ -214,8 +219,22 @@ app.get('/api/projects/:projectName/sessions', authenticateToken, async (req, re
 app.get('/api/projects/:projectName/sessions/:sessionId/messages', authenticateToken, async (req, res) => {
     try {
         const { projectName, sessionId } = req.params;
-        const messages = await getSessionMessages(projectName, sessionId);
-        res.json({ messages });
+        const { limit, offset } = req.query;
+        
+        // Parse limit and offset if provided
+        const parsedLimit = limit ? parseInt(limit, 10) : null;
+        const parsedOffset = offset ? parseInt(offset, 10) : 0;
+        
+        const result = await getSessionMessages(projectName, sessionId, parsedLimit, parsedOffset);
+        
+        // Handle both old and new response formats
+        if (Array.isArray(result)) {
+            // Backward compatibility: no pagination parameters were provided
+            res.json({ messages: result });
+        } else {
+            // New format with pagination info
+            res.json(result);
+        }
     } catch (error) {
         res.status(500).json({ error: error.message });
     }
@@ -460,12 +479,39 @@ function handleChatConnection(ws) {
                 console.log('📁 Project:', data.options?.projectPath || 'Unknown');
                 console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
                 await spawnClaude(data.command, data.options, ws);
+            } else if (data.type === 'cursor-command') {
+                console.log('🖱️ Cursor message:', data.command || '[Continue/Resume]');
+                console.log('📁 Project:', data.options?.cwd || 'Unknown');
+                console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
+                console.log('🤖 Model:', data.options?.model || 'default');
+                await spawnCursor(data.command, data.options, ws);
+            } else if (data.type === 'cursor-resume') {
+                // Backward compatibility: treat as cursor-command with resume and no prompt
+                console.log('🖱️ Cursor resume session (compat):', data.sessionId);
+                await spawnCursor('', {
+                    sessionId: data.sessionId,
+                    resume: true,
+                    cwd: data.options?.cwd
+                }, ws);
             } else if (data.type === 'abort-session') {
                 console.log('🛑 Abort session request:', data.sessionId);
-                const success = abortClaudeSession(data.sessionId);
+                const provider = data.provider || 'claude';
+                const success = provider === 'cursor' 
+                    ? abortCursorSession(data.sessionId)
+                    : abortClaudeSession(data.sessionId);
                 ws.send(JSON.stringify({
                     type: 'session-aborted',
                     sessionId: data.sessionId,
+                    provider,
+                    success
+                }));
+            } else if (data.type === 'cursor-abort') {
+                console.log('🛑 Abort Cursor session:', data.sessionId);
+                const success = abortCursorSession(data.sessionId);
+                ws.send(JSON.stringify({
+                    type: 'session-aborted',
+                    sessionId: data.sessionId,
+                    provider: 'cursor',
                     success
                 }));
             }
@@ -500,14 +546,17 @@ function handleShellConnection(ws) {
                 const projectPath = data.projectPath || process.cwd();
                 const sessionId = data.sessionId;
                 const hasSession = data.hasSession;
+                const provider = data.provider || 'claude';
 
                 console.log('🚀 Starting shell in:', projectPath);
                 console.log('📋 Session info:', hasSession ? `Resume session ${sessionId}` : 'New session');
+                console.log('🤖 Provider:', provider);
 
                 // First send a welcome message
+                const providerName = provider === 'cursor' ? 'Cursor' : 'Claude';
                 const welcomeMsg = hasSession ?
-                    `\x1b[36mResuming Claude session ${sessionId} in: ${projectPath}\x1b[0m\r\n` :
-                    `\x1b[36mStarting new Claude session in: ${projectPath}\x1b[0m\r\n`;
+                    `\x1b[36mResuming ${providerName} session ${sessionId} in: ${projectPath}\x1b[0m\r\n` :
+                    `\x1b[36mStarting new ${providerName} session in: ${projectPath}\x1b[0m\r\n`;
 
                 ws.send(JSON.stringify({
                     type: 'output',
@@ -515,20 +564,38 @@ function handleShellConnection(ws) {
                 }));
 
                 try {
-                    // Prepare the shell command adapted to the platform
+                    // Prepare the shell command adapted to the platform and provider
                     let shellCommand;
-                    if (os.platform() === 'win32') {
-                        if (hasSession && sessionId) {
-                            // Try to resume session, but with fallback to new session if it fails
-                            shellCommand = `Set-Location -Path "${projectPath}"; claude --resume ${sessionId}; if ($LASTEXITCODE -ne 0) { claude }`;
+                    if (provider === 'cursor') {
+                        // Use cursor-agent command
+                        if (os.platform() === 'win32') {
+                            if (hasSession && sessionId) {
+                                shellCommand = `Set-Location -Path "${projectPath}"; cursor-agent --resume="${sessionId}"`;
+                            } else {
+                                shellCommand = `Set-Location -Path "${projectPath}"; cursor-agent`;
+                            }
                         } else {
-                shellCommand = `Set-Location -Path "${projectPath}"; claude`;
+                            if (hasSession && sessionId) {
+                                shellCommand = `cd "${projectPath}" && cursor-agent --resume="${sessionId}"`;
+                            } else {
+                                shellCommand = `cd "${projectPath}" && cursor-agent`;
+                            }
                         }
                     } else {
-                        if (hasSession && sessionId) {
-                            shellCommand = `cd "${projectPath}" && claude --resume ${sessionId} || claude`;
+                        // Use claude command (default)
+                        if (os.platform() === 'win32') {
+                            if (hasSession && sessionId) {
+                                // Try to resume session, but with fallback to new session if it fails
+                                shellCommand = `Set-Location -Path "${projectPath}"; claude --resume ${sessionId}; if ($LASTEXITCODE -ne 0) { claude }`;
+                            } else {
+                                shellCommand = `Set-Location -Path "${projectPath}"; claude`;
+                            }
                         } else {
-                shellCommand = `cd "${projectPath}" && claude`;
+                            if (hasSession && sessionId) {
+                                shellCommand = `cd "${projectPath}" && claude --resume ${sessionId} || claude`;
+                            } else {
+                                shellCommand = `cd "${projectPath}" && claude`;
+                            }
                         }
                     }
 
@@ -1000,7 +1067,7 @@ async function startServer() {
             console.log(`Claude Code UI server running on http://0.0.0.0:${PORT}`);
 
             // Start watching the projects folder for changes
-            await setupProjectsWatcher(); // Re-enabled with better-sqlite3
+            await setupProjectsWatcher(); 
         });
     } catch (error) {
         console.error('❌ Failed to start server:', error);

server/projects.js

@@ -2,6 +2,10 @@ import { promises as fs } from 'fs';
 import fsSync from 'fs';
 import path from 'path';
 import readline from 'readline';
+import crypto from 'crypto';
+import sqlite3 from 'sqlite3';
+import { open } from 'sqlite';
+import os from 'os';
 
 // Cache for extracted project directories
 const projectDirectoryCache = new Map();
@@ -207,6 +211,14 @@ async function getProjects() {
           console.warn(`Could not load sessions for project ${entry.name}:`, e.message);
         }
         
+        // Also fetch Cursor sessions for this project
+        try {
+          project.cursorSessions = await getCursorSessions(actualProjectDir);
+        } catch (e) {
+          console.warn(`Could not load Cursor sessions for project ${entry.name}:`, e.message);
+          project.cursorSessions = [];
+        }
+        
         projects.push(project);
       }
     }
@@ -236,9 +248,17 @@ async function getProjects() {
           fullPath: actualProjectDir,
           isCustomName: !!projectConfig.displayName,
           isManuallyAdded: true,
-          sessions: []
+          sessions: [],
+          cursorSessions: []
         };
       
+      // Try to fetch Cursor sessions for manual projects too
+      try {
+        project.cursorSessions = await getCursorSessions(actualProjectDir);
+      } catch (e) {
+        console.warn(`Could not load Cursor sessions for manual project ${projectName}:`, e.message);
+      }
+      
       projects.push(project);
     }
   }
@@ -385,8 +405,8 @@ async function parseJsonlSessions(filePath) {
   );
 }
 
-// Get messages for a specific session
-async function getSessionMessages(projectName, sessionId) {
+// Get messages for a specific session with pagination support
+async function getSessionMessages(projectName, sessionId, limit = null, offset = 0) {
   const projectDir = path.join(process.env.HOME, '.claude', 'projects', projectName);
   
   try {
@@ -394,7 +414,7 @@ async function getSessionMessages(projectName, sessionId) {
     const jsonlFiles = files.filter(file => file.endsWith('.jsonl'));
     
     if (jsonlFiles.length === 0) {
-      return [];
+      return { messages: [], total: 0, hasMore: false };
     }
     
     const messages = [];
@@ -423,12 +443,34 @@ async function getSessionMessages(projectName, sessionId) {
     }
     
     // Sort messages by timestamp
-    return messages.sort((a, b) => 
+    const sortedMessages = messages.sort((a, b) => 
       new Date(a.timestamp || 0) - new Date(b.timestamp || 0)
     );
+    
+    const total = sortedMessages.length;
+    
+    // If no limit is specified, return all messages (backward compatibility)
+    if (limit === null) {
+      return sortedMessages;
+    }
+    
+    // Apply pagination - for recent messages, we need to slice from the end
+    // offset 0 should give us the most recent messages
+    const startIndex = Math.max(0, total - offset - limit);
+    const endIndex = total - offset;
+    const paginatedMessages = sortedMessages.slice(startIndex, endIndex);
+    const hasMore = startIndex > 0;
+    
+    return {
+      messages: paginatedMessages,
+      total,
+      hasMore,
+      offset,
+      limit
+    };
   } catch (error) {
     console.error(`Error reading messages for session ${sessionId}:`, error);
-    return [];
+    return limit === null ? [] : { messages: [], total: 0, hasMore: false };
   }
 }
 
@@ -593,6 +635,117 @@ async function addProjectManually(projectPath, displayName = null) {
   };
 }
 
+// Fetch Cursor sessions for a given project path
+async function getCursorSessions(projectPath) {
+  try {
+    // Calculate cwdID hash for the project path (Cursor uses MD5 hash)
+    const cwdId = crypto.createHash('md5').update(projectPath).digest('hex');
+    const cursorChatsPath = path.join(os.homedir(), '.cursor', 'chats', cwdId);
+    
+    // Check if the directory exists
+    try {
+      await fs.access(cursorChatsPath);
+    } catch (error) {
+      // No sessions for this project
+      return [];
+    }
+    
+    // List all session directories
+    const sessionDirs = await fs.readdir(cursorChatsPath);
+    const sessions = [];
+    
+    for (const sessionId of sessionDirs) {
+      const sessionPath = path.join(cursorChatsPath, sessionId);
+      const storeDbPath = path.join(sessionPath, 'store.db');
+      
+      try {
+        // Check if store.db exists
+        await fs.access(storeDbPath);
+        
+        // Capture store.db mtime as a reliable fallback timestamp
+        let dbStatMtimeMs = null;
+        try {
+          const stat = await fs.stat(storeDbPath);
+          dbStatMtimeMs = stat.mtimeMs;
+        } catch (_) {}
+
+        // Open SQLite database
+        const db = await open({
+          filename: storeDbPath,
+          driver: sqlite3.Database,
+          mode: sqlite3.OPEN_READONLY
+        });
+        
+        // Get metadata from meta table
+        const metaRows = await db.all(`
+          SELECT key, value FROM meta
+        `);
+        
+        // Parse metadata
+        let metadata = {};
+        for (const row of metaRows) {
+          if (row.value) {
+            try {
+              // Try to decode as hex-encoded JSON
+              const hexMatch = row.value.toString().match(/^[0-9a-fA-F]+$/);
+              if (hexMatch) {
+                const jsonStr = Buffer.from(row.value, 'hex').toString('utf8');
+                metadata[row.key] = JSON.parse(jsonStr);
+              } else {
+                metadata[row.key] = row.value.toString();
+              }
+            } catch (e) {
+              metadata[row.key] = row.value.toString();
+            }
+          }
+        }
+        
+        // Get message count
+        const messageCountResult = await db.get(`
+          SELECT COUNT(*) as count FROM blobs
+        `);
+        
+        await db.close();
+        
+        // Extract session info
+        const sessionName = metadata.title || metadata.sessionTitle || 'Untitled Session';
+        
+        // Determine timestamp - prefer createdAt from metadata, fall back to db file mtime
+        let createdAt = null;
+        if (metadata.createdAt) {
+          createdAt = new Date(metadata.createdAt).toISOString();
+        } else if (dbStatMtimeMs) {
+          createdAt = new Date(dbStatMtimeMs).toISOString();
+        } else {
+          createdAt = new Date().toISOString();
+        }
+        
+        sessions.push({
+          id: sessionId,
+          name: sessionName,
+          createdAt: createdAt,
+          lastActivity: createdAt, // For compatibility with Claude sessions
+          messageCount: messageCountResult.count || 0,
+          projectPath: projectPath
+        });
+        
+      } catch (error) {
+        console.warn(`Could not read Cursor session ${sessionId}:`, error.message);
+      }
+    }
+    
+    // Sort sessions by creation time (newest first)
+    sessions.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
+    
+    // Return only the first 5 sessions for performance
+    return sessions.slice(0, 5);
+    
+  } catch (error) {
+    console.error('Error fetching Cursor sessions:', error);
+    return [];
+  }
+}
+
 
 export {
   getProjects,

server/routes/cursor.js

@@ -0,0 +1,794 @@
+import express from 'express';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawn } from 'child_process';
+import sqlite3 from 'sqlite3';
+import { open } from 'sqlite';
+import crypto from 'crypto';
+
+const router = express.Router();
+
+// GET /api/cursor/config - Read Cursor CLI configuration
+router.get('/config', async (req, res) => {
+  try {
+    const configPath = path.join(os.homedir(), '.cursor', 'cli-config.json');
+    
+    try {
+      const configContent = await fs.readFile(configPath, 'utf8');
+      const config = JSON.parse(configContent);
+      
+      res.json({
+        success: true,
+        config: config,
+        path: configPath
+      });
+    } catch (error) {
+      // Config doesn't exist or is invalid
+      console.log('Cursor config not found or invalid:', error.message);
+      
+      // Return default config
+      res.json({
+        success: true,
+        config: {
+          version: 1,
+          model: {
+            modelId: "gpt-5",
+            displayName: "GPT-5"
+          },
+          permissions: {
+            allow: [],
+            deny: []
+          }
+        },
+        isDefault: true
+      });
+    }
+  } catch (error) {
+    console.error('Error reading Cursor config:', error);
+    res.status(500).json({ 
+      error: 'Failed to read Cursor configuration', 
+      details: error.message 
+    });
+  }
+});
+
+// POST /api/cursor/config - Update Cursor CLI configuration
+router.post('/config', async (req, res) => {
+  try {
+    const { permissions, model } = req.body;
+    const configPath = path.join(os.homedir(), '.cursor', 'cli-config.json');
+    
+    // Read existing config or create default
+    let config = {
+      version: 1,
+      editor: {
+        vimMode: false
+      },
+      hasChangedDefaultModel: false,
+      privacyCache: {
+        ghostMode: false,
+        privacyMode: 3,
+        updatedAt: Date.now()
+      }
+    };
+    
+    try {
+      const existing = await fs.readFile(configPath, 'utf8');
+      config = JSON.parse(existing);
+    } catch (error) {
+      // Config doesn't exist, use defaults
+      console.log('Creating new Cursor config');
+    }
+    
+    // Update permissions if provided
+    if (permissions) {
+      config.permissions = {
+        allow: permissions.allow || [],
+        deny: permissions.deny || []
+      };
+    }
+    
+    // Update model if provided
+    if (model) {
+      config.model = model;
+      config.hasChangedDefaultModel = true;
+    }
+    
+    // Ensure directory exists
+    const configDir = path.dirname(configPath);
+    await fs.mkdir(configDir, { recursive: true });
+    
+    // Write updated config
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
+    
+    res.json({
+      success: true,
+      config: config,
+      message: 'Cursor configuration updated successfully'
+    });
+  } catch (error) {
+    console.error('Error updating Cursor config:', error);
+    res.status(500).json({ 
+      error: 'Failed to update Cursor configuration', 
+      details: error.message 
+    });
+  }
+});
+
+// GET /api/cursor/mcp - Read Cursor MCP servers configuration
+router.get('/mcp', async (req, res) => {
+  try {
+    const mcpPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+    
+    try {
+      const mcpContent = await fs.readFile(mcpPath, 'utf8');
+      const mcpConfig = JSON.parse(mcpContent);
+      
+      // Convert to UI-friendly format
+      const servers = [];
+      if (mcpConfig.mcpServers && typeof mcpConfig.mcpServers === 'object') {
+        for (const [name, config] of Object.entries(mcpConfig.mcpServers)) {
+          const server = {
+            id: name,
+            name: name,
+            type: 'stdio',
+            scope: 'cursor',
+            config: {},
+            raw: config
+          };
+          
+          // Determine transport type and extract config
+          if (config.command) {
+            server.type = 'stdio';
+            server.config.command = config.command;
+            server.config.args = config.args || [];
+            server.config.env = config.env || {};
+          } else if (config.url) {
+            server.type = config.transport || 'http';
+            server.config.url = config.url;
+            server.config.headers = config.headers || {};
+          }
+          
+          servers.push(server);
+        }
+      }
+      
+      res.json({
+        success: true,
+        servers: servers,
+        path: mcpPath
+      });
+    } catch (error) {
+      // MCP config doesn't exist
+      console.log('Cursor MCP config not found:', error.message);
+      res.json({
+        success: true,
+        servers: [],
+        isDefault: true
+      });
+    }
+  } catch (error) {
+    console.error('Error reading Cursor MCP config:', error);
+    res.status(500).json({ 
+      error: 'Failed to read Cursor MCP configuration', 
+      details: error.message 
+    });
+  }
+});
+
+// POST /api/cursor/mcp/add - Add MCP server to Cursor configuration
+router.post('/mcp/add', async (req, res) => {
+  try {
+    const { name, type = 'stdio', command, args = [], url, headers = {}, env = {} } = req.body;
+    const mcpPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+    
+    console.log(`➕ Adding MCP server to Cursor config: ${name}`);
+    
+    // Read existing config or create new
+    let mcpConfig = { mcpServers: {} };
+    
+    try {
+      const existing = await fs.readFile(mcpPath, 'utf8');
+      mcpConfig = JSON.parse(existing);
+      if (!mcpConfig.mcpServers) {
+        mcpConfig.mcpServers = {};
+      }
+    } catch (error) {
+      console.log('Creating new Cursor MCP config');
+    }
+    
+    // Build server config based on type
+    let serverConfig = {};
+    
+    if (type === 'stdio') {
+      serverConfig = {
+        command: command,
+        args: args,
+        env: env
+      };
+    } else if (type === 'http' || type === 'sse') {
+      serverConfig = {
+        url: url,
+        transport: type,
+        headers: headers
+      };
+    }
+    
+    // Add server to config
+    mcpConfig.mcpServers[name] = serverConfig;
+    
+    // Ensure directory exists
+    const mcpDir = path.dirname(mcpPath);
+    await fs.mkdir(mcpDir, { recursive: true });
+    
+    // Write updated config
+    await fs.writeFile(mcpPath, JSON.stringify(mcpConfig, null, 2));
+    
+    res.json({
+      success: true,
+      message: `MCP server "${name}" added to Cursor configuration`,
+      config: mcpConfig
+    });
+  } catch (error) {
+    console.error('Error adding MCP server to Cursor:', error);
+    res.status(500).json({ 
+      error: 'Failed to add MCP server', 
+      details: error.message 
+    });
+  }
+});
+
+// DELETE /api/cursor/mcp/:name - Remove MCP server from Cursor configuration
+router.delete('/mcp/:name', async (req, res) => {
+  try {
+    const { name } = req.params;
+    const mcpPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+    
+    console.log(`🗑️ Removing MCP server from Cursor config: ${name}`);
+    
+    // Read existing config
+    let mcpConfig = { mcpServers: {} };
+    
+    try {
+      const existing = await fs.readFile(mcpPath, 'utf8');
+      mcpConfig = JSON.parse(existing);
+    } catch (error) {
+      return res.status(404).json({ 
+        error: 'Cursor MCP configuration not found' 
+      });
+    }
+    
+    // Check if server exists
+    if (!mcpConfig.mcpServers || !mcpConfig.mcpServers[name]) {
+      return res.status(404).json({ 
+        error: `MCP server "${name}" not found in Cursor configuration` 
+      });
+    }
+    
+    // Remove server from config
+    delete mcpConfig.mcpServers[name];
+    
+    // Write updated config
+    await fs.writeFile(mcpPath, JSON.stringify(mcpConfig, null, 2));
+    
+    res.json({
+      success: true,
+      message: `MCP server "${name}" removed from Cursor configuration`,
+      config: mcpConfig
+    });
+  } catch (error) {
+    console.error('Error removing MCP server from Cursor:', error);
+    res.status(500).json({ 
+      error: 'Failed to remove MCP server', 
+      details: error.message 
+    });
+  }
+});
+
+// POST /api/cursor/mcp/add-json - Add MCP server using JSON format
+router.post('/mcp/add-json', async (req, res) => {
+  try {
+    const { name, jsonConfig } = req.body;
+    const mcpPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+    
+    console.log(`➕ Adding MCP server to Cursor config via JSON: ${name}`);
+    
+    // Validate and parse JSON config
+    let parsedConfig;
+    try {
+      parsedConfig = typeof jsonConfig === 'string' ? JSON.parse(jsonConfig) : jsonConfig;
+    } catch (parseError) {
+      return res.status(400).json({ 
+        error: 'Invalid JSON configuration', 
+        details: parseError.message 
+      });
+    }
+    
+    // Read existing config or create new
+    let mcpConfig = { mcpServers: {} };
+    
+    try {
+      const existing = await fs.readFile(mcpPath, 'utf8');
+      mcpConfig = JSON.parse(existing);
+      if (!mcpConfig.mcpServers) {
+        mcpConfig.mcpServers = {};
+      }
+    } catch (error) {
+      console.log('Creating new Cursor MCP config');
+    }
+    
+    // Add server to config
+    mcpConfig.mcpServers[name] = parsedConfig;
+    
+    // Ensure directory exists
+    const mcpDir = path.dirname(mcpPath);
+    await fs.mkdir(mcpDir, { recursive: true });
+    
+    // Write updated config
+    await fs.writeFile(mcpPath, JSON.stringify(mcpConfig, null, 2));
+    
+    res.json({
+      success: true,
+      message: `MCP server "${name}" added to Cursor configuration via JSON`,
+      config: mcpConfig
+    });
+  } catch (error) {
+    console.error('Error adding MCP server to Cursor via JSON:', error);
+    res.status(500).json({ 
+      error: 'Failed to add MCP server', 
+      details: error.message 
+    });
+  }
+});
+
+// GET /api/cursor/sessions - Get Cursor sessions from SQLite database
+router.get('/sessions', async (req, res) => {
+  try {
+    const { projectPath } = req.query;
+    
+    // Calculate cwdID hash for the project path (Cursor uses MD5 hash)
+    const cwdId = crypto.createHash('md5').update(projectPath || process.cwd()).digest('hex');
+    const cursorChatsPath = path.join(os.homedir(), '.cursor', 'chats', cwdId);
+    
+    
+    // Check if the directory exists
+    try {
+      await fs.access(cursorChatsPath);
+    } catch (error) {
+      // No sessions for this project
+      return res.json({ 
+        success: true, 
+        sessions: [],
+        cwdId: cwdId,
+        path: cursorChatsPath
+      });
+    }
+    
+    // List all session directories
+    const sessionDirs = await fs.readdir(cursorChatsPath);
+    const sessions = [];
+    
+    for (const sessionId of sessionDirs) {
+      const sessionPath = path.join(cursorChatsPath, sessionId);
+      const storeDbPath = path.join(sessionPath, 'store.db');
+      let dbStatMtimeMs = null;
+      
+      try {
+        // Check if store.db exists
+        await fs.access(storeDbPath);
+        
+        // Capture store.db mtime as a reliable fallback timestamp (last activity)
+        try {
+          const stat = await fs.stat(storeDbPath);
+          dbStatMtimeMs = stat.mtimeMs;
+        } catch (_) {}
+
+        // Open SQLite database
+        const db = await open({
+          filename: storeDbPath,
+          driver: sqlite3.Database,
+          mode: sqlite3.OPEN_READONLY
+        });
+        
+        // Get metadata from meta table
+        const metaRows = await db.all(`
+          SELECT key, value FROM meta
+        `);
+        
+        let sessionData = {
+          id: sessionId,
+          name: 'Untitled Session',
+          createdAt: null,
+          mode: null,
+          projectPath: projectPath,
+          lastMessage: null,
+          messageCount: 0
+        };
+        
+        // Parse meta table entries
+        for (const row of metaRows) {
+          if (row.value) {
+            try {
+              // Try to decode as hex-encoded JSON
+              const hexMatch = row.value.toString().match(/^[0-9a-fA-F]+$/);
+              if (hexMatch) {
+                const jsonStr = Buffer.from(row.value, 'hex').toString('utf8');
+                const data = JSON.parse(jsonStr);
+                
+                if (row.key === 'agent') {
+                  sessionData.name = data.name || sessionData.name;
+                  // Normalize createdAt to ISO string in milliseconds
+                  let createdAt = data.createdAt;
+                  if (typeof createdAt === 'number') {
+                    if (createdAt < 1e12) {
+                      createdAt = createdAt * 1000; // seconds -> ms
+                    }
+                    sessionData.createdAt = new Date(createdAt).toISOString();
+                  } else if (typeof createdAt === 'string') {
+                    const n = Number(createdAt);
+                    if (!Number.isNaN(n)) {
+                      const ms = n < 1e12 ? n * 1000 : n;
+                      sessionData.createdAt = new Date(ms).toISOString();
+                    } else {
+                      // Assume it's already an ISO/date string
+                      const d = new Date(createdAt);
+                      sessionData.createdAt = isNaN(d.getTime()) ? null : d.toISOString();
+                    }
+                  } else {
+                    sessionData.createdAt = sessionData.createdAt || null;
+                  }
+                  sessionData.mode = data.mode;
+                  sessionData.agentId = data.agentId;
+                  sessionData.latestRootBlobId = data.latestRootBlobId;
+                }
+              } else {
+                // If not hex, use raw value for simple keys
+                if (row.key === 'name') {
+                  sessionData.name = row.value.toString();
+                }
+              }
+            } catch (e) {
+              console.log(`Could not parse meta value for key ${row.key}:`, e.message);
+            }
+          }
+        }
+        
+        // Get message count from JSON blobs only (actual messages, not DAG structure)
+        try {
+          const blobCount = await db.get(`
+            SELECT COUNT(*) as count 
+            FROM blobs 
+            WHERE substr(data, 1, 1) = X'7B'
+          `);
+          sessionData.messageCount = blobCount.count;
+          
+          // Get the most recent JSON blob for preview (actual message, not DAG structure)
+          const lastBlob = await db.get(`
+            SELECT data FROM blobs 
+            WHERE substr(data, 1, 1) = X'7B'
+            ORDER BY rowid DESC 
+            LIMIT 1
+          `);
+          
+          if (lastBlob && lastBlob.data) {
+            try {
+              // Try to extract readable preview from blob (may contain binary with embedded JSON)
+              const raw = lastBlob.data.toString('utf8');
+              let preview = '';
+              // Attempt direct JSON parse
+              try {
+                const parsed = JSON.parse(raw);
+                if (parsed?.content) {
+                  if (Array.isArray(parsed.content)) {
+                    const firstText = parsed.content.find(p => p?.type === 'text' && p.text)?.text || '';
+                    preview = firstText;
+                  } else if (typeof parsed.content === 'string') {
+                    preview = parsed.content;
+                  }
+                }
+              } catch (_) {}
+              if (!preview) {
+                // Strip non-printable and try to find JSON chunk
+                const cleaned = raw.replace(/[^\x09\x0A\x0D\x20-\x7E]/g, '');
+                const s = cleaned;
+                const start = s.indexOf('{');
+                const end = s.lastIndexOf('}');
+                if (start !== -1 && end > start) {
+                  const jsonStr = s.slice(start, end + 1);
+                  try {
+                    const parsed = JSON.parse(jsonStr);
+                    if (parsed?.content) {
+                      if (Array.isArray(parsed.content)) {
+                        const firstText = parsed.content.find(p => p?.type === 'text' && p.text)?.text || '';
+                        preview = firstText;
+                      } else if (typeof parsed.content === 'string') {
+                        preview = parsed.content;
+                      }
+                    }
+                  } catch (_) {
+                    preview = s;
+                  }
+                } else {
+                  preview = s;
+                }
+              }
+              if (preview && preview.length > 0) {
+                sessionData.lastMessage = preview.substring(0, 100) + (preview.length > 100 ? '...' : '');
+              }
+            } catch (e) {
+              console.log('Could not parse blob data:', e.message);
+            }
+          }
+        } catch (e) {
+          console.log('Could not read blobs:', e.message);
+        }
+        
+        await db.close();
+
+        // Finalize createdAt: use parsed meta value when valid, else fall back to store.db mtime
+        if (!sessionData.createdAt) {
+          if (dbStatMtimeMs && Number.isFinite(dbStatMtimeMs)) {
+            sessionData.createdAt = new Date(dbStatMtimeMs).toISOString();
+          }
+        }
+        
+        sessions.push(sessionData);
+        
+      } catch (error) {
+        console.log(`Could not read session ${sessionId}:`, error.message);
+      }
+    }
+    
+    // Fallback: ensure createdAt is a valid ISO string (use session directory mtime as last resort)
+    for (const s of sessions) {
+      if (!s.createdAt) {
+        try {
+          const sessionDir = path.join(cursorChatsPath, s.id);
+          const st = await fs.stat(sessionDir);
+          s.createdAt = new Date(st.mtimeMs).toISOString();
+        } catch {
+          s.createdAt = new Date().toISOString();
+        }
+      }
+    }
+    // Sort sessions by creation date (newest first)
+    sessions.sort((a, b) => {
+      if (!a.createdAt) return 1;
+      if (!b.createdAt) return -1;
+      return new Date(b.createdAt) - new Date(a.createdAt);
+    });
+    
+    res.json({ 
+      success: true, 
+      sessions: sessions,
+      cwdId: cwdId,
+      path: cursorChatsPath
+    });
+    
+  } catch (error) {
+    console.error('Error reading Cursor sessions:', error);
+    res.status(500).json({ 
+      error: 'Failed to read Cursor sessions', 
+      details: error.message 
+    });
+  }
+});
+
+// GET /api/cursor/sessions/:sessionId - Get specific Cursor session from SQLite
+router.get('/sessions/:sessionId', async (req, res) => {
+  try {
+    const { sessionId } = req.params;
+    const { projectPath } = req.query;
+    
+    // Calculate cwdID hash for the project path
+    const cwdId = crypto.createHash('md5').update(projectPath || process.cwd()).digest('hex');
+    const storeDbPath = path.join(os.homedir(), '.cursor', 'chats', cwdId, sessionId, 'store.db');
+    
+    
+    // Open SQLite database
+    const db = await open({
+      filename: storeDbPath,
+      driver: sqlite3.Database,
+      mode: sqlite3.OPEN_READONLY
+    });
+    
+    // Get all blobs to build the DAG structure
+    const allBlobs = await db.all(`
+      SELECT rowid, id, data FROM blobs
+    `);
+    
+    // Build the DAG structure from parent-child relationships
+    const blobMap = new Map(); // id -> blob data
+    const parentRefs = new Map(); // blob id -> [parent blob ids]
+    const childRefs = new Map(); // blob id -> [child blob ids]
+    const jsonBlobs = []; // Clean JSON messages
+    
+    for (const blob of allBlobs) {
+      blobMap.set(blob.id, blob);
+      
+      // Check if this is a JSON blob (actual message) or protobuf (DAG structure)
+      if (blob.data && blob.data[0] === 0x7B) { // Starts with '{' - JSON blob
+        try {
+          const parsed = JSON.parse(blob.data.toString('utf8'));
+          jsonBlobs.push({ ...blob, parsed });
+        } catch (e) {
+          console.log('Failed to parse JSON blob:', blob.rowid);
+        }
+      } else if (blob.data) { // Protobuf blob - extract parent references
+        const parents = [];
+        let i = 0;
+        
+        // Scan for parent references (0x0A 0x20 followed by 32-byte hash)
+        while (i < blob.data.length - 33) {
+          if (blob.data[i] === 0x0A && blob.data[i+1] === 0x20) {
+            const parentHash = blob.data.slice(i+2, i+34).toString('hex');
+            if (blobMap.has(parentHash)) {
+              parents.push(parentHash);
+            }
+            i += 34;
+          } else {
+            i++;
+          }
+        }
+        
+        if (parents.length > 0) {
+          parentRefs.set(blob.id, parents);
+          // Update child references
+          for (const parentId of parents) {
+            if (!childRefs.has(parentId)) {
+              childRefs.set(parentId, []);
+            }
+            childRefs.get(parentId).push(blob.id);
+          }
+        }
+      }
+    }
+    
+    // Perform topological sort to get chronological order
+    const visited = new Set();
+    const sorted = [];
+    
+    // DFS-based topological sort
+    function visit(nodeId) {
+      if (visited.has(nodeId)) return;
+      visited.add(nodeId);
+      
+      // Visit all parents first (dependencies)
+      const parents = parentRefs.get(nodeId) || [];
+      for (const parentId of parents) {
+        visit(parentId);
+      }
+      
+      // Add this node after all its parents
+      const blob = blobMap.get(nodeId);
+      if (blob) {
+        sorted.push(blob);
+      }
+    }
+    
+    // Start with nodes that have no parents (roots)
+    for (const blob of allBlobs) {
+      if (!parentRefs.has(blob.id)) {
+        visit(blob.id);
+      }
+    }
+    
+    // Visit any remaining nodes (disconnected components)
+    for (const blob of allBlobs) {
+      visit(blob.id);
+    }
+    
+    // Now extract JSON messages in the order they appear in the sorted DAG
+    const messageOrder = new Map(); // JSON blob id -> order index
+    let orderIndex = 0;
+    
+    for (const blob of sorted) {
+      // Check if this blob references any JSON messages
+      if (blob.data && blob.data[0] !== 0x7B) { // Protobuf blob
+        // Look for JSON blob references
+        for (const jsonBlob of jsonBlobs) {
+          try {
+            const jsonIdBytes = Buffer.from(jsonBlob.id, 'hex');
+            if (blob.data.includes(jsonIdBytes)) {
+              if (!messageOrder.has(jsonBlob.id)) {
+                messageOrder.set(jsonBlob.id, orderIndex++);
+              }
+            }
+          } catch (e) {
+            // Skip if can't convert ID
+          }
+        }
+      }
+    }
+    
+    // Sort JSON blobs by their appearance order in the DAG
+    const sortedJsonBlobs = jsonBlobs.sort((a, b) => {
+      const orderA = messageOrder.get(a.id) ?? Number.MAX_SAFE_INTEGER;
+      const orderB = messageOrder.get(b.id) ?? Number.MAX_SAFE_INTEGER;
+      if (orderA !== orderB) return orderA - orderB;
+      // Fallback to rowid if not in order map
+      return a.rowid - b.rowid;
+    });
+    
+    // Use sorted JSON blobs
+    const blobs = sortedJsonBlobs.map((blob, idx) => ({
+      ...blob,
+      sequence_num: idx + 1,
+      original_rowid: blob.rowid
+    }));
+    
+    // Get metadata from meta table
+    const metaRows = await db.all(`
+      SELECT key, value FROM meta
+    `);
+    
+    // Parse metadata
+    let metadata = {};
+    for (const row of metaRows) {
+      if (row.value) {
+        try {
+          // Try to decode as hex-encoded JSON
+          const hexMatch = row.value.toString().match(/^[0-9a-fA-F]+$/);
+          if (hexMatch) {
+            const jsonStr = Buffer.from(row.value, 'hex').toString('utf8');
+            metadata[row.key] = JSON.parse(jsonStr);
+          } else {
+            metadata[row.key] = row.value.toString();
+          }
+        } catch (e) {
+          metadata[row.key] = row.value.toString();
+        }
+      }
+    }
+    
+    // Extract messages from sorted JSON blobs
+    const messages = [];
+    for (const blob of blobs) {
+      try {
+        // We already parsed JSON blobs earlier
+        const parsed = blob.parsed;
+        
+        if (parsed) {
+          // Filter out ONLY system messages at the server level
+          // Check both direct role and nested message.role
+          const role = parsed?.role || parsed?.message?.role;
+          if (role === 'system') {
+            continue; // Skip only system messages
+          }
+          messages.push({ 
+            id: blob.id, 
+            sequence: blob.sequence_num,
+            rowid: blob.original_rowid, 
+            content: parsed 
+          });
+        }
+      } catch (e) {
+        // Skip blobs that cause errors
+        console.log(`Skipping blob ${blob.id}: ${e.message}`);
+      }
+    }
+    
+    await db.close();
+    
+    res.json({ 
+      success: true, 
+      session: {
+        id: sessionId,
+        projectPath: projectPath,
+        messages: messages,
+        metadata: metadata,
+        cwdId: cwdId
+      }
+    });
+    
+  } catch (error) {
+    console.error('Error reading Cursor session:', error);
+    res.status(500).json({ 
+      error: 'Failed to read Cursor session', 
+      details: error.message 
+    });
+  }
+});
+
+export default router;

server/routes/git.js

@@ -56,7 +56,6 @@ router.get('/status', async (req, res) => {
 
   try {
     const projectPath = await getActualProjectPath(project);
-    console.log('Git status for project:', project, '-> path:', projectPath);
     
     // Validate git repository
     await validateGitRepository(projectPath);
@@ -136,13 +135,16 @@ router.get('/diff', async (req, res) => {
              lines.map(line => `+${line}`).join('\n');
     } else {
       // Get diff for tracked files
-      const { stdout } = await execAsync(`git diff HEAD -- "${file}"`, { cwd: projectPath });
-      diff = stdout || '';
+      // First check for unstaged changes (working tree vs index)
+      const { stdout: unstagedDiff } = await execAsync(`git diff -- "${file}"`, { cwd: projectPath });
       
-      // If no unstaged changes, check for staged changes
-      if (!diff) {
+      if (unstagedDiff) {
+        // Show unstaged changes if they exist
+        diff = unstagedDiff;
+      } else {
+        // If no unstaged changes, check for staged changes (index vs HEAD)
         const { stdout: stagedDiff } = await execAsync(`git diff --cached -- "${file}"`, { cwd: projectPath });
-        diff = stagedDiff;
+        diff = stagedDiff || '';
       }
     }
     
@@ -192,7 +194,6 @@ router.get('/branches', async (req, res) => {
 
   try {
     const projectPath = await getActualProjectPath(project);
-    console.log('Git branches for project:', project, '-> path:', projectPath);
     
     // Validate git repository
     await validateGitRepository(projectPath);

src/App.jsx

@@ -31,7 +31,7 @@ import { ThemeProvider } from './contexts/ThemeContext';
 import { AuthProvider } from './contexts/AuthContext';
 import ProtectedRoute from './components/ProtectedRoute';
 import { useVersionCheck } from './hooks/useVersionCheck';
-import { api } from './utils/api';
+import { api, authenticatedFetch } from './utils/api';
 
 
 // Main App component with routing
@@ -192,6 +192,27 @@ function AppContent() {
       const response = await api.projects();
       const data = await response.json();
       
+      // Always fetch Cursor sessions for each project so we can combine views
+      for (let project of data) {
+        try {
+          const url = `/api/cursor/sessions?projectPath=${encodeURIComponent(project.fullPath || project.path)}`;
+          const cursorResponse = await authenticatedFetch(url);
+          if (cursorResponse.ok) {
+            const cursorData = await cursorResponse.json();
+            if (cursorData.success && cursorData.sessions) {
+              project.cursorSessions = cursorData.sessions;
+            } else {
+              project.cursorSessions = [];
+            }
+          } else {
+            project.cursorSessions = [];
+          }
+        } catch (error) {
+          console.error(`Error fetching Cursor sessions for project ${project.name}:`, error);
+          project.cursorSessions = [];
+        }
+      }
+      
       // Optimize to preserve object references when data hasn't changed
       setProjects(prevProjects => {
         // If no previous projects, just set the new data
@@ -210,7 +231,8 @@ function AppContent() {
             newProject.displayName !== prevProject.displayName ||
             newProject.fullPath !== prevProject.fullPath ||
             JSON.stringify(newProject.sessionMeta) !== JSON.stringify(prevProject.sessionMeta) ||
-            JSON.stringify(newProject.sessions) !== JSON.stringify(prevProject.sessions)
+            JSON.stringify(newProject.sessions) !== JSON.stringify(prevProject.sessions) ||
+            JSON.stringify(newProject.cursorSessions) !== JSON.stringify(prevProject.cursorSessions)
           );
         }) || data.length !== prevProjects.length;
         
@@ -236,16 +258,26 @@ function AppContent() {
       const shouldSwitchTab = !selectedSession || selectedSession.id !== sessionId;
       // Find the session across all projects
       for (const project of projects) {
-        const session = project.sessions?.find(s => s.id === sessionId);
+        let session = project.sessions?.find(s => s.id === sessionId);
         if (session) {
           setSelectedProject(project);
-          setSelectedSession(session);
+          setSelectedSession({ ...session, __provider: 'claude' });
           // Only switch to chat tab if we're loading a different session
           if (shouldSwitchTab) {
             setActiveTab('chat');
           }
           return;
         }
+        // Also check Cursor sessions
+        const cSession = project.cursorSessions?.find(s => s.id === sessionId);
+        if (cSession) {
+          setSelectedProject(project);
+          setSelectedSession({ ...cSession, __provider: 'cursor' });
+          if (shouldSwitchTab) {
+            setActiveTab('chat');
+          }
+          return;
+        }
       }
       
       // If session not found, it might be a newly created session
@@ -270,6 +302,15 @@ function AppContent() {
     if (activeTab !== 'git' && activeTab !== 'preview') {
       setActiveTab('chat');
     }
+    
+    // For Cursor sessions, we need to set the session ID differently
+    // since they're persistent and not created by Claude
+    const provider = localStorage.getItem('selected-provider') || 'claude';
+    if (provider === 'cursor') {
+      // Cursor sessions have persistent IDs
+      sessionStorage.setItem('cursorSessionId', session.id);
+    }
+    
     if (isMobile) {
       setSidebarOpen(false);
     }

src/components/ClaudeStatus.jsx

@@ -1,7 +1,7 @@
 import React, { useState, useEffect } from 'react';
 import { cn } from '../lib/utils';
 
-function ClaudeStatus({ status, onAbort, isLoading }) {
+function ClaudeStatus({ status, onAbort, isLoading, provider = 'claude' }) {
   const [elapsedTime, setElapsedTime] = useState(0);
   const [animationPhase, setAnimationPhase] = useState(0);
   const [fakeTokens, setFakeTokens] = useState(0);

src/components/CursorLogo.jsx

@@ -0,0 +1,9 @@
+import React from 'react';
+
+const CursorLogo = ({ className = 'w-5 h-5' }) => {
+  return (
+    <img src="/icons/cursor.svg" alt="Cursor" className={className} />
+  );
+};
+
+export default CursorLogo;

src/components/GitPanel.jsx

@@ -60,14 +60,12 @@ function GitPanel({ selectedProject, isMobile }) {
   const fetchGitStatus = async () => {
     if (!selectedProject) return;
     
-    console.log('Fetching git status for project:', selectedProject.name, 'path:', selectedProject.path);
     
     setIsLoading(true);
     try {
       const response = await authenticatedFetch(`/api/git/status?project=${encodeURIComponent(selectedProject.name)}`);
       const data = await response.json();
       
-      console.log('Git status response:', data);
       
       if (data.error) {
         console.error('Git status error:', data.error);

src/components/MainContent.jsx

@@ -18,6 +18,8 @@ import CodeEditor from './CodeEditor';
 import Shell from './Shell';
 import GitPanel from './GitPanel';
 import ErrorBoundary from './ErrorBoundary';
+import ClaudeLogo from './ClaudeLogo';
+import CursorLogo from './CursorLogo';
 
 function MainContent({ 
   selectedProject, 
@@ -153,35 +155,46 @@ function MainContent({
                 </svg>
               </button>
             )}
-            <div className="min-w-0">
-              {activeTab === 'chat' && selectedSession ? (
-                <div>
-                  <h2 className="text-base sm:text-lg font-semibold text-gray-900 dark:text-white truncate">
-                    {selectedSession.summary}
-                  </h2>
-                  <div className="text-xs text-gray-500 dark:text-gray-400 truncate">
-                    {selectedProject.displayName} <span className="hidden sm:inline">• {selectedSession.id}</span>
-                  </div>
-                </div>
-              ) : activeTab === 'chat' && !selectedSession ? (
-                <div>
-                  <h2 className="text-base sm:text-lg font-semibold text-gray-900 dark:text-white">
-                    New Session
-                  </h2>
-                  <div className="text-xs text-gray-500 dark:text-gray-400 truncate">
-                    {selectedProject.displayName}
-                  </div>
-                </div>
-              ) : (
-                <div>
-                  <h2 className="text-base sm:text-lg font-semibold text-gray-900 dark:text-white">
-                    {activeTab === 'files' ? 'Project Files' : activeTab === 'git' ? 'Source Control' : 'Project'}
-                  </h2>
-                  <div className="text-xs text-gray-500 dark:text-gray-400 truncate">
-                    {selectedProject.displayName}
-                  </div>
+            <div className="min-w-0 flex items-center gap-2">
+              {activeTab === 'chat' && selectedSession && (
+                <div className="w-6 h-6 flex-shrink-0 flex items-center justify-center">
+                  {selectedSession.__provider === 'cursor' ? (
+                    <CursorLogo className="w-5 h-5" />
+                  ) : (
+                    <ClaudeLogo className="w-5 h-5" />
+                  )}
                 </div>
               )}
+              <div className="flex-1 min-w-0">
+                {activeTab === 'chat' && selectedSession ? (
+                  <div>
+                    <h2 className="text-base sm:text-lg font-semibold text-gray-900 dark:text-white truncate">
+                      {selectedSession.__provider === 'cursor' ? (selectedSession.name || 'Untitled Session') : (selectedSession.summary || 'New Session')}
+                    </h2>
+                    <div className="text-xs text-gray-500 dark:text-gray-400 truncate">
+                      {selectedProject.displayName} <span className="hidden sm:inline">• {selectedSession.id}</span>
+                    </div>
+                  </div>
+                ) : activeTab === 'chat' && !selectedSession ? (
+                  <div>
+                    <h2 className="text-base sm:text-lg font-semibold text-gray-900 dark:text-white">
+                      New Session
+                    </h2>
+                    <div className="text-xs text-gray-500 dark:text-gray-400 truncate">
+                      {selectedProject.displayName}
+                    </div>
+                  </div>
+                ) : (
+                  <div>
+                    <h2 className="text-base sm:text-lg font-semibold text-gray-900 dark:text-white">
+                      {activeTab === 'files' ? 'Project Files' : activeTab === 'git' ? 'Source Control' : 'Project'}
+                    </h2>
+                    <div className="text-xs text-gray-500 dark:text-gray-400 truncate">
+                      {selectedProject.displayName}
+                    </div>
+                  </div>
+                )}
+              </div>
             </div>
           </div>
           

src/components/Shell.jsx

@@ -436,6 +436,7 @@ function Shell({ selectedProject, selectedSession, isActive }) {
                 projectPath: selectedProject.fullPath || selectedProject.path,
                 sessionId: selectedSession?.id,
                 hasSession: !!selectedSession,
+                provider: selectedSession?.__provider || 'claude',
                 cols: terminal.current.cols,
                 rows: terminal.current.rows
               };
@@ -530,11 +531,16 @@ function Shell({ selectedProject, selectedSession, isActive }) {
         <div className="flex items-center justify-between">
           <div className="flex items-center space-x-2">
             <div className={`w-2 h-2 rounded-full ${isConnected ? 'bg-green-500' : 'bg-red-500'}`} />
-            {selectedSession && (
-              <span className="text-xs text-blue-300">
-                ({selectedSession.summary.slice(0, 30)}...)
-              </span>
-            )}
+            {selectedSession && (() => {
+              const displaySessionName = selectedSession.__provider === 'cursor'
+                ? (selectedSession.name || 'Untitled Session')
+                : (selectedSession.summary || 'New Session');
+              return (
+                <span className="text-xs text-blue-300">
+                  ({displaySessionName.slice(0, 30)}...)
+                </span>
+              );
+            })()}
             {!selectedSession && (
               <span className="text-xs text-gray-400">(New Session)</span>
             )}
@@ -601,7 +607,12 @@ function Shell({ selectedProject, selectedSession, isActive }) {
               </button>
               <p className="text-gray-400 text-sm mt-3 px-2">
                 {selectedSession ? 
-                  `Resume session: ${selectedSession.summary.slice(0, 50)}...` : 
+                  (() => {
+                    const displaySessionName = selectedSession.__provider === 'cursor'
+                      ? (selectedSession.name || 'Untitled Session')
+                      : (selectedSession.summary || 'New Session');
+                    return `Resume session: ${displaySessionName.slice(0, 50)}...`;
+                  })() : 
                   'Start a new Claude session'
                 }
               </p>

src/components/Sidebar.jsx

@@ -7,6 +7,7 @@ import { Input } from './ui/input';
 import { FolderOpen, Folder, Plus, MessageSquare, Clock, ChevronDown, ChevronRight, Edit3, Check, X, Trash2, Settings, FolderPlus, RefreshCw, Sparkles, Edit2, Star, Search } from 'lucide-react';
 import { cn } from '../lib/utils';
 import ClaudeLogo from './ClaudeLogo';
+import CursorLogo from './CursorLogo.jsx';
 import { api } from '../utils/api';
 
 // Move formatTimeAgo outside component to avoid recreation on every render
@@ -202,9 +203,12 @@ function Sidebar({
 
   // Helper function to get all sessions for a project (initial + additional)
   const getAllSessions = (project) => {
-    const initialSessions = project.sessions || [];
-    const additional = additionalSessions[project.name] || [];
-    return [...initialSessions, ...additional];
+    // Combine Claude and Cursor sessions; Sidebar will display icon per row
+    const claudeSessions = [...(project.sessions || []), ...(additionalSessions[project.name] || [])].map(s => ({ ...s, __provider: 'claude' }));
+    const cursorSessions = (project.cursorSessions || []).map(s => ({ ...s, __provider: 'cursor' }));
+    // Sort by most recent activity/date
+    const normalizeDate = (s) => new Date(s.__provider === 'cursor' ? s.createdAt : s.lastActivity);
+    return [...claudeSessions, ...cursorSessions].sort((a, b) => normalizeDate(b) - normalizeDate(a));
   };
 
   // Helper function to get the last activity date for a project
@@ -979,11 +983,19 @@ function Sidebar({
                         </div>
                       ) : (
                         getAllSessions(project).map((session) => {
+                          // Handle both Claude and Cursor session formats
+                          const isCursorSession = session.__provider === 'cursor';
+                          
                           // Calculate if session is active (within last 10 minutes)
-                          const sessionDate = new Date(session.lastActivity);
+                          const sessionDate = new Date(isCursorSession ? session.createdAt : session.lastActivity);
                           const diffInMinutes = Math.floor((currentTime - sessionDate) / (1000 * 60));
                           const isActive = diffInMinutes < 10;
                           
+                          // Get session display values
+                          const sessionName = isCursorSession ? (session.name || 'Untitled Session') : (session.summary || 'New Session');
+                          const sessionTime = isCursorSession ? session.createdAt : session.lastActivity;
+                          const messageCount = session.messageCount || 0;
+                          
                           return (
                           <div key={session.id} className="group relative">
                             {/* Active session indicator dot */}
@@ -1014,38 +1026,49 @@ function Sidebar({
                                     "w-5 h-5 rounded-md flex items-center justify-center flex-shrink-0",
                                     selectedSession?.id === session.id ? "bg-primary/10" : "bg-muted/50"
                                   )}>
-                                    <MessageSquare className={cn(
-                                      "w-3 h-3",
-                                      selectedSession?.id === session.id ? "text-primary" : "text-muted-foreground"
-                                    )} />
+                                    {isCursorSession ? (
+                                      <CursorLogo className="w-3 h-3" />
+                                    ) : (
+                                      <ClaudeLogo className="w-3 h-3" />
+                                    )}
                                   </div>
                                   <div className="min-w-0 flex-1">
                                     <div className="text-xs font-medium truncate text-foreground">
-                                      {session.summary || 'New Session'}
+                                      {sessionName}
                                     </div>
-                                    <div className="flex items-center gap-1 mt-0.5">
+                                <div className="flex items-center gap-1 mt-0.5">
                                       <Clock className="w-2.5 h-2.5 text-muted-foreground" />
                                       <span className="text-xs text-muted-foreground">
-                                        {formatTimeAgo(session.lastActivity, currentTime)}
+                                        {formatTimeAgo(sessionTime, currentTime)}
                                       </span>
-                                      {session.messageCount > 0 && (
+                                      {messageCount > 0 && (
                                         <Badge variant="secondary" className="text-xs px-1 py-0 ml-auto">
-                                          {session.messageCount}
+                                          {messageCount}
                                         </Badge>
                                       )}
+                                  {/* Provider tiny icon */}
+                                  <span className="ml-1 opacity-70">
+                                    {isCursorSession ? (
+                                      <CursorLogo className="w-3 h-3" />
+                                    ) : (
+                                      <ClaudeLogo className="w-3 h-3" />
+                                    )}
+                                  </span>
                                     </div>
                                   </div>
-                                  {/* Mobile delete button */}
-                                  <button
-                                    className="w-5 h-5 rounded-md bg-red-50 dark:bg-red-900/20 flex items-center justify-center active:scale-95 transition-transform opacity-70 ml-1"
-                                    onClick={(e) => {
-                                      e.stopPropagation();
-                                      deleteSession(project.name, session.id);
-                                    }}
-                                    onTouchEnd={handleTouchClick(() => deleteSession(project.name, session.id))}
-                                  >
-                                    <Trash2 className="w-2.5 h-2.5 text-red-600 dark:text-red-400" />
-                                  </button>
+                                  {/* Mobile delete button - only for Claude sessions */}
+                                  {!isCursorSession && (
+                                    <button
+                                      className="w-5 h-5 rounded-md bg-red-50 dark:bg-red-900/20 flex items-center justify-center active:scale-95 transition-transform opacity-70 ml-1"
+                                      onClick={(e) => {
+                                        e.stopPropagation();
+                                        deleteSession(project.name, session.id);
+                                      }}
+                                      onTouchEnd={handleTouchClick(() => deleteSession(project.name, session.id))}
+                                    >
+                                      <Trash2 className="w-2.5 h-2.5 text-red-600 dark:text-red-400" />
+                                    </button>
+                                  )}
                                 </div>
                               </div>
                             </div>
@@ -1062,26 +1085,39 @@ function Sidebar({
                                 onTouchEnd={handleTouchClick(() => onSessionSelect(session))}
                               >
                                 <div className="flex items-start gap-2 min-w-0 w-full">
-                                  <MessageSquare className="w-3 h-3 text-muted-foreground mt-0.5 flex-shrink-0" />
+                                  {isCursorSession ? (
+                                    <CursorLogo className="w-3 h-3 mt-0.5 flex-shrink-0" />
+                                  ) : (
+                                    <ClaudeLogo className="w-3 h-3 mt-0.5 flex-shrink-0" />
+                                  )}
                                   <div className="min-w-0 flex-1">
                                     <div className="text-xs font-medium truncate text-foreground">
-                                      {session.summary || 'New Session'}
+                                      {sessionName}
                                     </div>
                                     <div className="flex items-center gap-1 mt-0.5">
                                       <Clock className="w-2.5 h-2.5 text-muted-foreground" />
                                       <span className="text-xs text-muted-foreground">
-                                        {formatTimeAgo(session.lastActivity, currentTime)}
+                                        {formatTimeAgo(sessionTime, currentTime)}
                                       </span>
-                                      {session.messageCount > 0 && (
+                                      {messageCount > 0 && (
                                         <Badge variant="secondary" className="text-xs px-1 py-0 ml-auto">
-                                          {session.messageCount}
+                                          {messageCount}
                                         </Badge>
                                       )}
+                                      {/* Provider tiny icon */}
+                                      <span className="ml-1 opacity-70">
+                                        {isCursorSession ? (
+                                          <CursorLogo className="w-3 h-3" />
+                                        ) : (
+                                          <ClaudeLogo className="w-3 h-3" />
+                                        )}
+                                      </span>
                                     </div>
                                   </div>
                                 </div>
                               </Button>
-                              {/* Desktop hover buttons */}
+                              {/* Desktop hover buttons - only for Claude sessions */}
+                              {!isCursorSession && (
                               <div className="absolute right-2 top-1/2 transform -translate-y-1/2 flex items-center gap-1 opacity-0 group-hover:opacity-100 transition-all duration-200">
                                 {editingSession === session.id ? (
                                   <>
@@ -1168,6 +1204,7 @@ function Sidebar({
                                   </>
                                 )}
                               </div>
+                              )}
                             </div>
                           </div>
                           );

src/components/ToolsSettings.jsx

@@ -41,7 +41,16 @@ function ToolsSettings({ isOpen, onClose, projects = [] }) {
   const [mcpToolsLoading, setMcpToolsLoading] = useState({});
   const [activeTab, setActiveTab] = useState('tools');
   const [jsonValidationError, setJsonValidationError] = useState('');
-  // Common tool patterns
+  const [toolsProvider, setToolsProvider] = useState('claude'); // 'claude' or 'cursor'
+  
+  // Cursor-specific states
+  const [cursorAllowedCommands, setCursorAllowedCommands] = useState([]);
+  const [cursorDisallowedCommands, setCursorDisallowedCommands] = useState([]);
+  const [cursorSkipPermissions, setCursorSkipPermissions] = useState(false);
+  const [newCursorCommand, setNewCursorCommand] = useState('');
+  const [newCursorDisallowedCommand, setNewCursorDisallowedCommand] = useState('');
+  const [cursorMcpServers, setCursorMcpServers] = useState([]);
+  // Common tool patterns for Claude
   const commonTools = [
     'Bash(git log:*)',
     'Bash(git diff:*)',
@@ -58,7 +67,45 @@ function ToolsSettings({ isOpen, onClose, projects = [] }) {
     'WebFetch',
     'WebSearch'
   ];
+  
+  // Common shell commands for Cursor
+  const commonCursorCommands = [
+    'Shell(ls)',
+    'Shell(mkdir)',
+    'Shell(cd)',
+    'Shell(cat)',
+    'Shell(echo)',
+    'Shell(git status)',
+    'Shell(git diff)',
+    'Shell(git log)',
+    'Shell(npm install)',
+    'Shell(npm run)',
+    'Shell(python)',
+    'Shell(node)'
+  ];
 
+  // Fetch Cursor MCP servers
+  const fetchCursorMcpServers = async () => {
+    try {
+      const token = localStorage.getItem('auth-token');
+      const response = await fetch('/api/cursor/mcp', {
+        headers: {
+          'Authorization': `Bearer ${token}`,
+          'Content-Type': 'application/json'
+        }
+      });
+      
+      if (response.ok) {
+        const data = await response.json();
+        setCursorMcpServers(data.servers || []);
+      } else {
+        console.error('Failed to fetch Cursor MCP servers');
+      }
+    } catch (error) {
+      console.error('Error fetching Cursor MCP servers:', error);
+    }
+  };
+  
   // MCP API functions
   const fetchMcpServers = async () => {
     try {
@@ -268,7 +315,7 @@ function ToolsSettings({ isOpen, onClose, projects = [] }) {
   const loadSettings = async () => {
     try {
       
-      // Load from localStorage
+      // Load Claude settings from localStorage
       const savedSettings = localStorage.getItem('claude-tools-settings');
       
       if (savedSettings) {
@@ -284,10 +331,27 @@ function ToolsSettings({ isOpen, onClose, projects = [] }) {
         setSkipPermissions(false);
         setProjectSortOrder('name');
       }
+      
+      // Load Cursor settings from localStorage
+      const savedCursorSettings = localStorage.getItem('cursor-tools-settings');
+      
+      if (savedCursorSettings) {
+        const cursorSettings = JSON.parse(savedCursorSettings);
+        setCursorAllowedCommands(cursorSettings.allowedCommands || []);
+        setCursorDisallowedCommands(cursorSettings.disallowedCommands || []);
+        setCursorSkipPermissions(cursorSettings.skipPermissions || false);
+      } else {
+        // Set Cursor defaults
+        setCursorAllowedCommands([]);
+        setCursorDisallowedCommands([]);
+        setCursorSkipPermissions(false);
+      }
 
-      // Load MCP servers and projects from API
+      // Load MCP servers from API
       await fetchMcpServers();
-      await fetchAvailableProjects();
+      
+      // Load Cursor MCP servers
+      await fetchCursorMcpServers();
     } catch (error) {
       console.error('Error loading tool settings:', error);
       // Set defaults on error
@@ -303,7 +367,8 @@ function ToolsSettings({ isOpen, onClose, projects = [] }) {
     setSaveStatus(null);
     
     try {
-      const settings = {
+      // Save Claude settings
+      const claudeSettings = {
         allowedTools,
         disallowedTools,
         skipPermissions,
@@ -311,9 +376,17 @@ function ToolsSettings({ isOpen, onClose, projects = [] }) {
         lastUpdated: new Date().toISOString()
       };
       
+      // Save Cursor settings
+      const cursorSettings = {
+        allowedCommands: cursorAllowedCommands,
+        disallowedCommands: cursorDisallowedCommands,
+        skipPermissions: cursorSkipPermissions,
+        lastUpdated: new Date().toISOString()
+      };
       
       // Save to localStorage
-      localStorage.setItem('claude-tools-settings', JSON.stringify(settings));
+      localStorage.setItem('claude-tools-settings', JSON.stringify(claudeSettings));
+      localStorage.setItem('cursor-tools-settings', JSON.stringify(cursorSettings));
       
       setSaveStatus('success');
       
@@ -636,6 +709,36 @@ function ToolsSettings({ isOpen, onClose, projects = [] }) {
             {activeTab === 'tools' && (
               <div className="space-y-6 md:space-y-8">
             
+            {/* Provider Tabs */}
+            <div className="border-b border-gray-300 dark:border-gray-600">
+              <div className="flex gap-4">
+                <button
+                  onClick={() => setToolsProvider('claude')}
+                  className={`px-4 py-2 text-sm font-medium border-b-2 transition-colors ${
+                    toolsProvider === 'claude'
+                      ? 'border-blue-600 text-blue-600 dark:text-blue-400'
+                      : 'border-transparent text-muted-foreground hover:text-foreground'
+                  }`}
+                >
+                  Claude Tools
+                </button>
+                <button
+                  onClick={() => setToolsProvider('cursor')}
+                  className={`px-4 py-2 text-sm font-medium border-b-2 transition-colors ${
+                    toolsProvider === 'cursor'
+                      ? 'border-purple-600 text-purple-600 dark:text-purple-400'
+                      : 'border-transparent text-muted-foreground hover:text-foreground'
+                  }`}
+                >
+                  Cursor Tools
+                </button>
+              </div>
+            </div>
+            
+            {/* Claude Tools Content */}
+            {toolsProvider === 'claude' && (
+              <div className="space-y-6 md:space-y-8">
+            
             {/* Skip Permissions */}
             <div className="space-y-4">
               <div className="flex items-center gap-3">
@@ -1361,6 +1464,216 @@ function ToolsSettings({ isOpen, onClose, projects = [] }) {
             )}
               </div>
             )}
+            
+            {/* Cursor Tools Content */}
+            {toolsProvider === 'cursor' && (
+              <div className="space-y-6 md:space-y-8">
+                
+                {/* Skip Permissions for Cursor */}
+                <div className="space-y-4">
+                  <div className="flex items-center gap-3">
+                    <AlertTriangle className="w-5 h-5 text-orange-500" />
+                    <h3 className="text-lg font-medium text-foreground">
+                      Cursor Permission Settings
+                    </h3>
+                  </div>
+                  <div className="bg-orange-50 dark:bg-orange-900/20 border border-orange-200 dark:border-orange-800 rounded-lg p-4">
+                    <label className="flex items-center gap-3">
+                      <input
+                        type="checkbox"
+                        checked={cursorSkipPermissions}
+                        onChange={(e) => setCursorSkipPermissions(e.target.checked)}
+                        className="w-4 h-4 text-blue-600 bg-gray-100 border-gray-300 rounded focus:ring-blue-500"
+                      />
+                      <div>
+                        <div className="font-medium text-orange-900 dark:text-orange-100">
+                          Skip permission prompts (use with caution)
+                        </div>
+                        <div className="text-sm text-orange-700 dark:text-orange-300">
+                          Equivalent to -f flag in Cursor CLI
+                        </div>
+                      </div>
+                    </label>
+                  </div>
+                </div>
+
+                {/* Allowed Shell Commands */}
+                <div className="space-y-4">
+                  <div className="flex items-center gap-3">
+                    <Shield className="w-5 h-5 text-green-500" />
+                    <h3 className="text-lg font-medium text-foreground">
+                      Allowed Shell Commands
+                    </h3>
+                  </div>
+                  <p className="text-sm text-muted-foreground">
+                    Shell commands that are automatically allowed without prompting for permission
+                  </p>
+                  
+                  <div className="flex flex-col sm:flex-row gap-2">
+                    <Input
+                      value={newCursorCommand}
+                      onChange={(e) => setNewCursorCommand(e.target.value)}
+                      placeholder='e.g., "Shell(ls)" or "Shell(git status)"'
+                      onKeyPress={(e) => {
+                        if (e.key === 'Enter') {
+                          if (newCursorCommand && !cursorAllowedCommands.includes(newCursorCommand)) {
+                            setCursorAllowedCommands([...cursorAllowedCommands, newCursorCommand]);
+                            setNewCursorCommand('');
+                          }
+                        }
+                      }}
+                      className="flex-1 h-10 touch-manipulation"
+                      style={{ fontSize: '16px' }}
+                    />
+                    <Button
+                      onClick={() => {
+                        if (newCursorCommand && !cursorAllowedCommands.includes(newCursorCommand)) {
+                          setCursorAllowedCommands([...cursorAllowedCommands, newCursorCommand]);
+                          setNewCursorCommand('');
+                        }
+                      }}
+                      disabled={!newCursorCommand}
+                      size="sm"
+                      className="h-10 px-4 touch-manipulation"
+                    >
+                      <Plus className="w-4 h-4 mr-2 sm:mr-0" />
+                      <span className="sm:hidden">Add Command</span>
+                    </Button>
+                  </div>
+
+                  {/* Common commands quick add */}
+                  <div className="space-y-2">
+                    <p className="text-sm font-medium text-gray-700 dark:text-gray-300">
+                      Quick add common commands:
+                    </p>
+                    <div className="grid grid-cols-2 sm:flex sm:flex-wrap gap-2">
+                      {commonCursorCommands.map(cmd => (
+                        <Button
+                          key={cmd}
+                          variant="outline"
+                          size="sm"
+                          onClick={() => {
+                            if (!cursorAllowedCommands.includes(cmd)) {
+                              setCursorAllowedCommands([...cursorAllowedCommands, cmd]);
+                            }
+                          }}
+                          disabled={cursorAllowedCommands.includes(cmd)}
+                          className="text-xs h-8 touch-manipulation truncate"
+                        >
+                          {cmd}
+                        </Button>
+                      ))}
+                    </div>
+                  </div>
+
+                  <div className="space-y-2">
+                    {cursorAllowedCommands.map(cmd => (
+                      <div key={cmd} className="flex items-center justify-between bg-green-50 dark:bg-green-900/20 border border-green-200 dark:border-green-800 rounded-lg p-3">
+                        <span className="font-mono text-sm text-green-800 dark:text-green-200">
+                          {cmd}
+                        </span>
+                        <Button
+                          variant="ghost"
+                          size="sm"
+                          onClick={() => setCursorAllowedCommands(cursorAllowedCommands.filter(c => c !== cmd))}
+                          className="text-green-600 hover:text-green-700 dark:text-green-400 dark:hover:text-green-300"
+                        >
+                          <X className="w-4 h-4" />
+                        </Button>
+                      </div>
+                    ))}
+                    {cursorAllowedCommands.length === 0 && (
+                      <div className="text-center py-8 text-gray-500 dark:text-gray-400">
+                        No allowed shell commands configured
+                      </div>
+                    )}
+                  </div>
+                </div>
+                
+                {/* Disallowed Shell Commands */}
+                <div className="space-y-4">
+                  <div className="flex items-center gap-3">
+                    <Shield className="w-5 h-5 text-red-500" />
+                    <h3 className="text-lg font-medium text-foreground">
+                      Disallowed Shell Commands
+                    </h3>
+                  </div>
+                  <p className="text-sm text-muted-foreground">
+                    Shell commands that should always be denied
+                  </p>
+                  
+                  <div className="flex flex-col sm:flex-row gap-2">
+                    <Input
+                      value={newCursorDisallowedCommand}
+                      onChange={(e) => setNewCursorDisallowedCommand(e.target.value)}
+                      placeholder='e.g., "Shell(rm -rf)" or "Shell(sudo)"'
+                      onKeyPress={(e) => {
+                        if (e.key === 'Enter') {
+                          if (newCursorDisallowedCommand && !cursorDisallowedCommands.includes(newCursorDisallowedCommand)) {
+                            setCursorDisallowedCommands([...cursorDisallowedCommands, newCursorDisallowedCommand]);
+                            setNewCursorDisallowedCommand('');
+                          }
+                        }
+                      }}
+                      className="flex-1 h-10 touch-manipulation"
+                      style={{ fontSize: '16px' }}
+                    />
+                    <Button
+                      onClick={() => {
+                        if (newCursorDisallowedCommand && !cursorDisallowedCommands.includes(newCursorDisallowedCommand)) {
+                          setCursorDisallowedCommands([...cursorDisallowedCommands, newCursorDisallowedCommand]);
+                          setNewCursorDisallowedCommand('');
+                        }
+                      }}
+                      disabled={!newCursorDisallowedCommand}
+                      size="sm"
+                      className="h-10 px-4 touch-manipulation"
+                    >
+                      <Plus className="w-4 h-4 mr-2 sm:mr-0" />
+                      <span className="sm:hidden">Add Command</span>
+                    </Button>
+                  </div>
+
+                  <div className="space-y-2">
+                    {cursorDisallowedCommands.map(cmd => (
+                      <div key={cmd} className="flex items-center justify-between bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded-lg p-3">
+                        <span className="font-mono text-sm text-red-800 dark:text-red-200">
+                          {cmd}
+                        </span>
+                        <Button
+                          variant="ghost"
+                          size="sm"
+                          onClick={() => setCursorDisallowedCommands(cursorDisallowedCommands.filter(c => c !== cmd))}
+                          className="text-red-600 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300"
+                        >
+                          <X className="w-4 h-4" />
+                        </Button>
+                      </div>
+                    ))}
+                    {cursorDisallowedCommands.length === 0 && (
+                      <div className="text-center py-8 text-gray-500 dark:text-gray-400">
+                        No disallowed shell commands configured
+                      </div>
+                    )}
+                  </div>
+                </div>
+
+                {/* Help Section */}
+                <div className="bg-purple-50 dark:bg-purple-900/20 border border-purple-200 dark:border-purple-800 rounded-lg p-4">
+                  <h4 className="font-medium text-purple-900 dark:text-purple-100 mb-2">
+                    Cursor Shell Command Examples:
+                  </h4>
+                  <ul className="text-sm text-purple-800 dark:text-purple-200 space-y-1">
+                    <li><code className="bg-purple-100 dark:bg-purple-800 px-1 rounded">"Shell(ls)"</code> - Allow ls command</li>
+                    <li><code className="bg-purple-100 dark:bg-purple-800 px-1 rounded">"Shell(git status)"</code> - Allow git status command</li>
+                    <li><code className="bg-purple-100 dark:bg-purple-800 px-1 rounded">"Shell(mkdir)"</code> - Allow mkdir command</li>
+                    <li><code className="bg-purple-100 dark:bg-purple-800 px-1 rounded">"-f"</code> flag - Skip all permission prompts (dangerous)</li>
+                  </ul>
+                </div>
+              </div>
+            )}
+              </div>
+            )}
           </div>
         </div>
 

src/utils/api.js

@@ -43,8 +43,16 @@ export const api = {
   projects: () => authenticatedFetch('/api/projects'),
   sessions: (projectName, limit = 5, offset = 0) => 
     authenticatedFetch(`/api/projects/${projectName}/sessions?limit=${limit}&offset=${offset}`),
-  sessionMessages: (projectName, sessionId) =>
-    authenticatedFetch(`/api/projects/${projectName}/sessions/${sessionId}/messages`),
+  sessionMessages: (projectName, sessionId, limit = null, offset = 0) => {
+    const params = new URLSearchParams();
+    if (limit !== null) {
+      params.append('limit', limit);
+      params.append('offset', offset);
+    }
+    const queryString = params.toString();
+    const url = `/api/projects/${projectName}/sessions/${sessionId}/messages${queryString ? `?${queryString}` : ''}`;
+    return authenticatedFetch(url);
+  },
   renameProject: (projectName, displayName) =>
     authenticatedFetch(`/api/projects/${projectName}/rename`, {
       method: 'PUT',

test.html

@@ -0,0 +1 @@
+hello world 5