+
Powered by OPACTOR
+
+
+
+
+
+
## What is Claudable?
@@ -21,7 +27,7 @@ This open-source project empowers you to build and deploy professional web appli
How to start? Simply login to Claude Code (or Cursor CLI), start Claudable, and describe what you want to build. That's it. There is no additional subscription cost for app builder.
## Features
-
+
- **Powerful Agent Performance**: Leverage the full power of Claude Code and Cursor CLI Agent capabilities with native MCP support
- **Natural Language to Code**: Simply describe what you want to build, and Claudable generates production-ready Next.js code
@@ -33,23 +39,81 @@ How to start? Simply login to Claude Code (or Cursor CLI), start Claudable, and
- **Supabase Database**: Connect production PostgreSQL with authentication ready to use
- **Automated Error Detection**: Detect errors in your app and fix them automatically
-## Technology Stack
-**AI Cooding Agent:**
-- **[Claude Code](https://docs.anthropic.com/en/docs/claude-code/setup)**: Advanced AI coding agent. We strongly recommend you to use Claude Code for the best experience.
+## Demo Examples
+
+### Codex CLI Example
+
+
+### Qwen Code Example
+
+
+## Supported AI Coding Agents
+
+Claudable supports multiple AI coding agents, giving you the flexibility to choose the best tool for your needs:
+
+- **Claude Code** - Anthropic's advanced AI coding agent
+- **Codex CLI** - OpenAI's lightweight coding agent
+- **Cursor CLI** - Powerful multi-model AI agent
+- **Gemini CLI** - Google's open-source AI agent
+- **Qwen Code** - Alibaba's open-source coding CLI
+
+### Claude Code (Recommended)
+**[Claude Code](https://docs.anthropic.com/en/docs/claude-code/setup)** - Anthropic's advanced AI coding agent with Claude Opus 4.1
+- **Features**: Deep codebase awareness, MCP support, Unix philosophy, direct terminal integration
+- **Context**: Native 256K tokens
+- **Pricing**: Included with ChatGPT Plus/Pro/Team/Edu/Enterprise plans
+- **Installation**:
```bash
- # Install
npm install -g @anthropic-ai/claude-code
- # Login
claude # then > /login
```
-- **[Cursor CLI](https://docs.cursor.com/en/cli/overview)**: Intelligent coding agent for complex coding tasks. It's little bit slower than Claude Code, but it's more powerful.
+
+### Codex CLI
+**[Codex CLI](https://github.com/openai/codex)** - OpenAI's lightweight coding agent with GPT-5 support
+- **Features**: High reasoning capabilities, local execution, multiple operating modes (interactive, auto-edit, full-auto)
+- **Context**: Varies by model
+- **Pricing**: Included with ChatGPT Plus/Pro/Business/Edu/Enterprise plans
+- **Installation**:
+ ```bash
+ npm install -g @openai/codex
+ codex # login with ChatGPT account
+ ```
+
+### Cursor CLI
+**[Cursor CLI](https://cursor.com/en/cli)** - Powerful AI agent with access to cutting-edge models
+- **Features**: Multi-model support (Anthropic, OpenAI, Gemini), MCP integration, AGENTS.md support
+- **Context**: Model dependent
+- **Pricing**: Free tier available, Pro plans for advanced features
+- **Installation**:
```bash
- # Install
curl https://cursor.com/install -fsS | bash
- # Login
cursor-agent login
```
+### Gemini CLI
+**[Gemini CLI](https://developers.google.com/gemini-code-assist/docs/gemini-cli)** - Google's open-source AI agent with Gemini 2.5 Pro
+- **Features**: 1M token context window, Google Search grounding, MCP support, extensible architecture
+- **Context**: 1M tokens (with free tier: 60 req/min, 1000 req/day)
+- **Pricing**: Free with Google account, paid tiers for higher limits
+- **Installation**:
+ ```bash
+ npm install -g @google/gemini-cli
+ gemini # follow authentication flow
+ ```
+
+### Qwen Code
+**[Qwen Code](https://github.com/QwenLM/qwen-code)** - Alibaba's open-source CLI for Qwen3-Coder models
+- **Features**: 256K-1M token context, multiple model sizes (0.5B to 480B), Apache 2.0 license
+- **Context**: 256K native, 1M with extrapolation
+- **Pricing**: Completely free and open-source
+- **Installation**:
+ ```bash
+ npm install -g @qwen-code/qwen-code@latest
+ qwen --version
+ ```
+
+## Technology Stack
+
**Database & Deployment:**
- **[Supabase](https://supabase.com/)**: Connect production-ready PostgreSQL database directly to your project.
- **[Vercel](https://vercel.com/)**: Publish your work immediately with one-click deployment
@@ -208,20 +272,22 @@ If you encounter the error: `Error output dangerously skip permissions cannot be
- Anon Key: Public key for client-side
- Service Role Key: Secret key for server-side
-## Design Comparison
-*Same prompt, different results*
-
-### Claudable
-
+## License
-[View Claudable Live Demo →](https://claudable-preview.vercel.app/)
+MIT License.
-### Lovable
-
+## Upcoming Features
+These features are in development and will be opened soon.
+- **New CLI Agents** - Trust us, you're going to LOVE this!
+- **Checkpoints for Chat** - Save and restore conversation/codebase states
+- **Advanced MCP Integration** - Native integration with MCP
+- **Enhanced Agent System** - Subagents, AGENTS.md integration
+- **Website Cloning** - You can start a project from a reference URL.
+- Various bug fixes and community PR merges
-[View Lovable Live Demo →](https://preview--goal-track-studio.lovable.app/)
+We're working hard to deliver the features you've been asking for. Stay tuned!
-## License
+## Star History
-MIT License.
\ No newline at end of file
+[](https://www.star-history.com/#opactorai/Claudable&Date)
diff --git a/apps/api/MCP_README.md b/apps/api/MCP_README.md
new file mode 100644
index 00000000..8515e67f
--- /dev/null
+++ b/apps/api/MCP_README.md
@@ -0,0 +1,284 @@
+# MCP (Model Context Protocol) Implementation
+
+## Overview
+
+This implementation provides a production-ready MCP server management system for Claudable. It supports:
+
+- **stdio Transport**: Execute MCP servers as local processes
+- **SSE Transport**: Connect to remote MCP servers via HTTP/SSE
+- **Dynamic Tool Discovery**: Automatically discover and expose tools from managed servers
+- **Claudable MCP Proxy**: Act as an MCP server that proxies tools from other servers
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ Claudable MCP Server │
+│ (Acts as unified MCP interface) │
+└─────────────────────────────────────────────────────────┘
+ │
+ ┌───────────────┴───────────────┐
+ │ │
+┌───────▼────────┐ ┌──────▼─────────┐
+│ MCP Manager │ │ Database │
+│ (Lifecycle) │ │ (Config) │
+└───────┬────────┘ └────────────────┘
+ │
+ ┌────┴─────┐
+ │ │
+┌──▼───┐ ┌──▼───┐
+│stdio │ │ SSE │
+│Server│ │Server│
+└──────┘ └──────┘
+```
+
+## Components
+
+### 1. Database Model (`app/models/mcp_servers.py`)
+- Stores MCP server configurations per project
+- Tracks server status, tools, and connection details
+- Supports both stdio and SSE transports
+
+### 2. MCP Manager (`app/services/mcp/manager.py`)
+- Manages server lifecycle (start/stop)
+- Handles tool discovery
+- Proxies tool calls to appropriate servers
+- Supports both stdio and SSE transports
+
+### 3. Claudable MCP Server (`app/services/mcp/server.py`)
+- Acts as an MCP server for Claude Desktop
+- Exposes management tools (list, start, stop servers)
+- Proxies tools from managed MCP servers
+- Provides unified interface to all tools
+
+### 4. API Endpoints (`app/api/projects/mcp.py`)
+- REST API for managing MCP servers
+- CRUD operations with validation
+- Start/stop server controls
+- Tool discovery endpoints
+
+### 5. Frontend Components
+- `GlobalMCPConfig.tsx`: Global MCP server management UI
+- `MCPServersTab.tsx`: Project-specific MCP server controls
+
+## API Endpoints
+
+### List MCP Servers
+```
+GET /api/projects/{project_id}/mcp
+```
+
+### Create MCP Server
+```
+POST /api/projects/{project_id}/mcp
+Content-Type: application/json
+
+{
+ "name": "memory-server",
+ "transport": "stdio",
+ "command": "npx",
+ "args": ["-y", "@modelcontextprotocol/server-memory"],
+ "env": {},
+ "scope": "project",
+ "is_active": false
+}
+```
+
+### Start MCP Server
+```
+POST /api/projects/{project_id}/mcp/{server_id}/start
+```
+
+### Stop MCP Server
+```
+POST /api/projects/{project_id}/mcp/{server_id}/stop
+```
+
+### Get Server Tools
+```
+GET /api/projects/{project_id}/mcp/{server_id}/tools
+```
+
+## Configuration
+
+### stdio Transport Example
+```json
+{
+ "name": "memory-server",
+ "transport": "stdio",
+ "command": "npx",
+ "args": ["-y", "@modelcontextprotocol/server-memory"],
+ "env": {
+ "NODE_ENV": "production"
+ }
+}
+```
+
+### SSE Transport Example
+```json
+{
+ "name": "remote-mcp",
+ "transport": "sse",
+ "url": "https://mcp-server.example.com/sse",
+ "env": {
+ "API_KEY": "your-api-key"
+ }
+}
+```
+
+## Security Features
+
+### Input Validation
+- Server names validated for special characters
+- Command whitelist (node, python, python3, npx, uvx)
+- URL validation for SSE transport
+- Field length limits enforced
+
+### Error Handling
+- Comprehensive try-catch blocks
+- Detailed logging with context
+- User-friendly error messages
+- Automatic cleanup on failures
+
+### Process Management
+- Graceful shutdown with timeout
+- Force kill as fallback
+- Proper resource cleanup
+- Process monitoring
+
+## Logging
+
+All MCP operations are logged with context:
+```
+[MCP] Starting MCP server: memory-server
+[MCP] MCP server memory-server started with 3 tools
+[MCP] Stopping MCP server: memory-server
+```
+
+Use `logger.info()`, `logger.warning()`, `logger.error()` for proper log levels.
+
+## Production Deployment
+
+### 1. Environment Variables
+No specific environment variables required, but ensure:
+- Database connection is configured
+- Proper logging level set
+- Resource limits configured
+
+### 2. Database Migration
+The `mcp_servers` table will be created automatically on startup.
+
+### 3. Security Considerations
+- **Command Execution**: Only whitelisted commands are allowed
+- **Process Isolation**: Each MCP server runs in isolated process
+- **Resource Limits**: Consider setting ulimits for spawned processes
+- **Network Access**: SSE servers should use HTTPS in production
+- **Environment Variables**: Sensitive env vars should be encrypted at rest
+
+### 4. Monitoring
+Monitor these metrics:
+- Number of running MCP servers
+- Failed server starts
+- Tool call latency
+- Process memory usage
+
+### 5. Scaling
+- MCP manager is singleton per API instance
+- For multi-instance deployments, consider:
+ - Shared state via Redis
+ - Process affinity for server management
+ - Load balancer sticky sessions
+
+## Claude Desktop Integration
+
+To use Claudable as an MCP server in Claude Desktop:
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+```json
+{
+ "mcpServers": {
+ "claudable": {
+ "command": "python",
+ "args": ["-m", "app.services.mcp.server"],
+ "env": {}
+ }
+ }
+}
+```
+
+This exposes:
+- `claudable_list_mcp_servers`: List all managed servers
+- `claudable_start_mcp_server`: Start a server by name
+- `claudable_stop_mcp_server`: Stop a server by name
+- All tools from running MCP servers (prefixed with server name)
+
+## Development
+
+### Running Tests
+```bash
+# Start API server
+npm run dev:api
+
+# Test MCP server creation
+curl -X POST http://localhost:8080/api/projects/{project_id}/mcp \
+ -H "Content-Type: application/json" \
+ -d '{"name":"test","transport":"stdio","command":"npx","args":["-y","@modelcontextprotocol/server-memory"]}'
+
+# Start the server
+curl -X POST http://localhost:8080/api/projects/{project_id}/mcp/{server_id}/start
+
+# Get tools
+curl http://localhost:8080/api/projects/{project_id}/mcp/{server_id}/tools
+```
+
+### Debugging
+Enable debug logging in `manager.py` and `server.py`:
+```python
+logger.setLevel(logging.DEBUG)
+```
+
+## Troubleshooting
+
+### Server Fails to Start
+- Check command is in whitelist
+- Verify command exists in PATH
+- Check environment variables
+- Review server logs for errors
+
+### Tools Not Discovered
+- Ensure server supports MCP protocol
+- Check JSON-RPC communication
+- Verify timeout settings (increase if needed)
+- Check server stdout for errors
+
+### SSE Connection Issues
+- Verify URL is accessible
+- Check network connectivity
+- Ensure SSL certificates valid
+- Review server logs
+
+## Future Enhancements
+
+1. **Health Checks**: Periodic ping to verify server availability
+2. **Auto-Restart**: Restart failed servers automatically
+3. **Resource Limits**: CPU/memory limits per server
+4. **Tool Caching**: Cache tool metadata for performance
+5. **Metrics**: Prometheus metrics for monitoring
+6. **Multi-tenancy**: User-level MCP servers
+7. **Tool Aliases**: Rename tools to avoid conflicts
+8. **Rate Limiting**: Prevent tool abuse
+
+## Contributing
+
+When adding new MCP features:
+1. Update database models if needed
+2. Add validation to Pydantic models
+3. Implement in manager with error handling
+4. Add API endpoints with proper status codes
+5. Update frontend components
+6. Add tests
+7. Update this README
+
+## License
+
+See project LICENSE file.
\ No newline at end of file
diff --git a/apps/api/SWAGGER_README.md b/apps/api/SWAGGER_README.md
new file mode 100644
index 00000000..9fe95f0e
--- /dev/null
+++ b/apps/api/SWAGGER_README.md
@@ -0,0 +1,70 @@
+# Swagger/OpenAPI Documentation
+
+The API now has fully functional Swagger/OpenAPI documentation with interactive testing capabilities.
+
+## Access Points
+
+When the API server is running on port 8000, you can access:
+
+- **Swagger UI**: http://localhost:8000/docs
+ - Interactive API documentation
+ - Test endpoints directly from the browser
+ - View request/response schemas
+
+- **ReDoc**: http://localhost:8000/redoc
+ - Clean, readable API documentation
+ - Better for sharing with external developers
+
+- **OpenAPI JSON**: http://localhost:8000/openapi.json
+ - Raw OpenAPI schema
+ - Can be imported into Postman or other API tools
+
+## Features Implemented
+
+1. **Enhanced API Metadata**
+ - Title, description, and version info
+ - Server URLs configured
+ - External documentation links
+
+2. **Detailed Endpoint Documentation**
+ - Summary and descriptions for each endpoint
+ - Response codes and descriptions
+ - Request/response model schemas
+ - Organized by tags (projects, chat, health, etc.)
+
+3. **Security Schemes**
+ - JWT Bearer token authentication configured
+ - Ready for API key authentication if needed
+
+## Testing the API
+
+1. Start the API server:
+ ```bash
+ python -m uvicorn app.main:app --port 8000
+ ```
+
+2. Open your browser and navigate to:
+ - http://localhost:8000/docs for Swagger UI
+ - http://localhost:8000/redoc for ReDoc
+
+3. You can test endpoints directly from Swagger UI:
+ - Click on any endpoint
+ - Click "Try it out"
+ - Fill in parameters if needed
+ - Click "Execute"
+
+## Files Modified
+
+- `app/main.py` - Added OpenAPI configuration
+- `app/api/openapi_docs.py` - Created comprehensive OpenAPI configuration
+- `app/api/projects/crud.py` - Added detailed endpoint annotations
+- `requirements.txt` - Updated to include fastapi[all]
+- `app/core/config.py` - Fixed Pydantic configuration issue
+
+## Known Issues Fixed
+
+- ✅ Recursive OpenAPI generation issue resolved
+- ✅ Pydantic validation error in config.py fixed
+- ✅ SDK import compatibility issues handled
+
+The documentation will automatically update as you add or modify endpoints!
\ No newline at end of file
diff --git a/apps/api/app/api/assets.py b/apps/api/app/api/assets.py
index ebf14305..a4c07005 100644
--- a/apps/api/app/api/assets.py
+++ b/apps/api/app/api/assets.py
@@ -28,6 +28,27 @@ async def upload_logo(project_id: str, body: LogoRequest, db: Session = Depends(
return {"path": f"assets/logo.png"}
+@router.get("/{project_id}/{filename}")
+async def get_image(project_id: str, filename: str, db: Session = Depends(get_db)):
+ """Get an image file from project assets directory"""
+ from fastapi.responses import FileResponse
+
+ # Verify project exists
+ row = db.get(ProjectModel, project_id)
+ if not row:
+ raise HTTPException(status_code=404, detail="Project not found")
+
+ # Build file path
+ file_path = os.path.join(settings.projects_root, project_id, "assets", filename)
+
+ # Check if file exists
+ if not os.path.exists(file_path):
+ raise HTTPException(status_code=404, detail="Image not found")
+
+ # Return the image file
+ return FileResponse(file_path)
+
+
@router.post("/{project_id}/upload")
async def upload_image(project_id: str, file: UploadFile = File(...), db: Session = Depends(get_db)):
"""Upload an image file to project assets directory"""
diff --git a/apps/api/app/api/chat/__init__.py b/apps/api/app/api/chat/__init__.py
index e73b0cee..632c04c3 100644
--- a/apps/api/app/api/chat/__init__.py
+++ b/apps/api/app/api/chat/__init__.py
@@ -8,6 +8,8 @@
from .messages import router as messages_router
from .act import router as act_router
from .cli_preferences import router as cli_router
+from .conversations import router as conversations_router
+from .tokens import router as tokens_router
# Create main chat router (prefix will be added in main.py)
@@ -17,4 +19,6 @@
router.include_router(websocket_router, tags=["chat"])
router.include_router(messages_router, tags=["chat"])
router.include_router(act_router, tags=["chat"])
-router.include_router(cli_router, tags=["chat"])
\ No newline at end of file
+router.include_router(cli_router, tags=["chat"])
+router.include_router(conversations_router, tags=["chat"])
+router.include_router(tokens_router, tags=["chat", "tokens"])
diff --git a/apps/api/app/api/chat/act.py b/apps/api/app/api/chat/act.py
index 7ea61cb9..3a4e22a4 100644
--- a/apps/api/app/api/chat/act.py
+++ b/apps/api/app/api/chat/act.py
@@ -10,16 +10,44 @@
from sqlalchemy.orm import Session
from pydantic import BaseModel
+import os
+
from app.api.deps import get_db
+from app.core.config import settings
from app.models.projects import Project
from app.models.messages import Message
from app.models.sessions import Session as ChatSession
from app.models.commits import Commit
from app.models.user_requests import UserRequest
-from app.services.cli.unified_manager import UnifiedCLIManager, CLIType
+from app.services.cli.unified_manager import UnifiedCLIManager
+from app.services.cli.base import CLIType
+from app.services.cli.process_manager import terminate_project_processes
from app.services.git_ops import commit_all
from app.core.websocket.manager import manager
from app.core.terminal_ui import ui
+def build_project_info(project: Project, db: Session) -> dict:
+ """Ensure project has a usable repo path and collect runtime info."""
+ repo_path = project.repo_path
+
+ if not repo_path or not os.path.exists(repo_path):
+ inferred_path = os.path.join(settings.projects_root, project.id, "repo")
+ if os.path.exists(inferred_path):
+ project.repo_path = inferred_path
+ db.commit()
+ repo_path = inferred_path
+ else:
+ raise HTTPException(
+ status_code=409,
+ detail="Project repository is not initialized yet. Please wait for project setup to complete."
+ )
+
+ return {
+ 'id': project.id,
+ 'repo_path': repo_path,
+ 'preferred_cli': project.preferred_cli or "claude",
+ 'fallback_enabled': project.fallback_enabled if project.fallback_enabled is not None else True,
+ 'selected_model': project.selected_model
+ }
router = APIRouter()
@@ -27,7 +55,9 @@
class ImageAttachment(BaseModel):
name: str
- base64_data: str
+ # Either base64_data or path must be provided
+ base64_data: Optional[str] = None
+ path: Optional[str] = None # Absolute path to image file
mime_type: str = "image/jpeg"
@@ -80,13 +110,7 @@ async def execute_act_instruction(
db.commit()
# Extract project info to avoid DetachedInstanceError in background task
- project_info = {
- 'id': project.id,
- 'repo_path': project.repo_path,
- 'preferred_cli': project.preferred_cli or "claude",
- 'fallback_enabled': project.fallback_enabled if project.fallback_enabled is not None else True,
- 'selected_model': project.selected_model
- }
+ project_info = build_project_info(project, db)
# Execute the task
return await execute_act_task(
@@ -156,11 +180,14 @@ async def execute_chat_task(
db=db
)
+ # Qwen Coder does not support images yet; drop them to prevent errors
+ safe_images = [] if cli_preference == CLIType.QWEN else images
+
result = await cli_manager.execute_instruction(
instruction=instruction,
cli_type=cli_preference,
fallback_enabled=project_fallback_enabled,
- images=images,
+ images=safe_images,
model=project_selected_model,
is_initial_prompt=is_initial_prompt
)
@@ -288,7 +315,11 @@ async def execute_act_task(
# Update session status to running
session.status = "running"
-
+
+ project = db.query(Project).filter(Project.id == project_id).first()
+ if project:
+ project.status = "running"
+
# ★ NEW: Update UserRequest status to started
if request_id:
user_request = db.query(UserRequest).filter(UserRequest.id == request_id).first()
@@ -298,6 +329,15 @@ async def execute_act_task(
user_request.model_used = project_selected_model
db.commit()
+
+ if project:
+ await manager.broadcast_to_project(project_id, {
+ "type": "project_status",
+ "data": {
+ "status": "running",
+ "message": instruction[:80] or 'Working...'
+ }
+ })
# Send act_start event to trigger loading indicator
await manager.broadcast_to_project(project_id, {
@@ -318,11 +358,14 @@ async def execute_act_task(
db=db
)
+ # Qwen Coder does not support images yet; drop them to prevent errors
+ safe_images = [] if cli_preference == CLIType.QWEN else images
+
result = await cli_manager.execute_instruction(
instruction=instruction,
cli_type=cli_preference,
fallback_enabled=project_fallback_enabled,
- images=images,
+ images=safe_images,
model=project_selected_model,
is_initial_prompt=is_initial_prompt
)
@@ -364,7 +407,18 @@ async def execute_act_task(
# Update session status only (no success message to user)
session.status = "completed"
session.completed_at = datetime.utcnow()
-
+
+ if project:
+ project.status = "active"
+ db.commit()
+ await manager.broadcast_to_project(project_id, {
+ "type": "project_status",
+ "data": {
+ "status": "active",
+ "message": "Project ready"
+ }
+ })
+
# ★ NEW: Mark UserRequest as completed successfully
if request_id:
user_request = db.query(UserRequest).filter(UserRequest.id == request_id).first()
@@ -402,7 +456,7 @@ async def execute_act_task(
session.status = "failed"
session.error = result.get("error") if result else "No CLI available"
session.completed_at = datetime.utcnow()
-
+
# ★ NEW: Mark UserRequest as completed with failure
if request_id:
user_request = db.query(UserRequest).filter(UserRequest.id == request_id).first()
@@ -459,7 +513,11 @@ async def execute_act_task(
session.status = "failed"
session.error = str(e)
session.completed_at = datetime.utcnow()
-
+
+ project = db.query(Project).filter(Project.id == project_id).first()
+ if project:
+ project.status = "active"
+
# ★ NEW: Mark UserRequest as failed due to exception
if request_id:
user_request = db.query(UserRequest).filter(UserRequest.id == request_id).first()
@@ -495,6 +553,38 @@ async def execute_act_task(
})
+@router.post("/{project_id}/stop")
+async def stop_execution(
+ project_id: str,
+ db: Session = Depends(get_db)
+):
+ """Stop the current execution for a project"""
+ try:
+ # Update all active sessions for this project to stopped
+ active_sessions = db.query(ChatSession).filter(
+ ChatSession.project_id == project_id,
+ ChatSession.status.in_(["active", "running"])
+ ).all()
+
+ for session in active_sessions:
+ session.status = "stopped"
+ session.completed_at = datetime.utcnow()
+
+ db.commit()
+
+ # Terminate all CLI processes for this project
+ terminated_count = await terminate_project_processes(project_id)
+ ui.info(f"Terminated {terminated_count} CLI processes for project {project_id}", "Stop")
+
+ return {
+ "message": f"Stopped {len(active_sessions)} active sessions and {terminated_count} processes",
+ "stopped_sessions": len(active_sessions),
+ "terminated_processes": terminated_count
+ }
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
@router.post("/{project_id}/act", response_model=ActResponse)
async def run_act(
project_id: str,
@@ -516,18 +606,79 @@ async def run_act(
fallback_enabled = body.fallback_enabled if body.fallback_enabled is not None else project.fallback_enabled
conversation_id = body.conversation_id or str(uuid.uuid4())
- # Save user instruction as message
+ # 🔍 DEBUG: Log incoming request data
+ print(f"📥 ACT Request - Project: {project_id}")
+ print(f"📥 Instruction: {body.instruction[:100]}...")
+ print(f"📥 Images count: {len(body.images)}")
+ print(f"📥 Images data: {body.images}")
+ for i, img in enumerate(body.images):
+ print(f"📥 Image {i+1}: {img}")
+ if hasattr(img, '__dict__'):
+ print(f"📥 Image {i+1} dict: {img.__dict__}")
+
+ # Extract image paths and build attachments for metadata/WS
+ image_paths = []
+ attachments = []
+ import os as _os
+
+ print(f"🔍 Processing {len(body.images)} images...")
+ for i, img in enumerate(body.images):
+ print(f"🔍 Processing image {i+1}: {img}")
+
+ img_dict = img if isinstance(img, dict) else img.__dict__ if hasattr(img, '__dict__') else {}
+ print(f"🔍 Image {i+1} converted to dict: {img_dict}")
+
+ p = img_dict.get('path')
+ n = img_dict.get('name')
+ print(f"🔍 Image {i+1} - path: {p}, name: {n}")
+
+ if p:
+ print(f"🔍 Adding path to image_paths: {p}")
+ image_paths.append(p)
+ try:
+ fname = _os.path.basename(p)
+ print(f"🔍 Processing path: {p}")
+ print(f"🔍 Extracted filename: {fname}")
+ if fname and fname.strip():
+ attachment = {
+ "name": n or fname,
+ "url": f"/api/assets/{project_id}/{fname}"
+ }
+ print(f"🔍 Created attachment: {attachment}")
+ attachments.append(attachment)
+ else:
+ print(f"❌ Failed to extract filename from: {p}")
+ except Exception as e:
+ print(f"❌ Exception processing path {p}: {e}")
+ pass
+ elif n:
+ print(f"🔍 Adding name to image_paths: {n}")
+ image_paths.append(n)
+ else:
+ print(f"❌ Image {i+1} has neither path nor name!")
+
+ print(f"🔍 Final image_paths: {image_paths}")
+ print(f"🔍 Final attachments: {attachments}")
+
+ # Save user instruction as message (with image paths in content for display)
+ message_content = body.instruction
+ if image_paths:
+ image_refs = [f"Image #{i+1} path: {path}" for i, path in enumerate(image_paths)]
+ message_content = f"{body.instruction}\n\n{chr(10).join(image_refs)}"
+
user_message = Message(
id=str(uuid.uuid4()),
project_id=project_id,
role="user",
message_type="chat",
- content=body.instruction,
+ content=message_content,
metadata_json={
"type": "act_instruction",
"cli_preference": cli_preference.value,
"fallback_enabled": fallback_enabled,
- "has_images": len(body.images) > 0
+ "has_images": len(body.images) > 0,
+ "image_paths": image_paths,
+ "attachments": attachments
},
conversation_id=conversation_id,
created_at=datetime.utcnow()
@@ -572,7 +723,7 @@ async def run_act(
"id": user_message.id,
"role": "user",
"message_type": "chat",
- "content": body.instruction,
+ "content": message_content,
"metadata_json": user_message.metadata_json,
"parent_message_id": None,
"session_id": session.id,
@@ -586,13 +737,7 @@ async def run_act(
ui.error(f"WebSocket failed: {e}", "ACT API")
# Extract project info to avoid DetachedInstanceError in background task
- project_info = {
- 'id': project.id,
- 'repo_path': project.repo_path,
- 'preferred_cli': project.preferred_cli or "claude",
- 'fallback_enabled': project.fallback_enabled if project.fallback_enabled is not None else True,
- 'selected_model': project.selected_model
- }
+ project_info = build_project_info(project, db)
# Add background task
background_tasks.add_task(
@@ -636,18 +781,54 @@ async def run_chat(
fallback_enabled = body.fallback_enabled if body.fallback_enabled is not None else project.fallback_enabled
conversation_id = body.conversation_id or str(uuid.uuid4())
- # Save user instruction as message
+ # Extract image paths and build attachments for metadata/WS
+ image_paths = []
+ attachments = []
+ import os as _os2
+ for img in body.images:
+ img_dict = img if isinstance(img, dict) else img.__dict__ if hasattr(img, '__dict__') else {}
+ p = img_dict.get('path')
+ n = img_dict.get('name')
+ if p:
+ image_paths.append(p)
+ try:
+ fname = _os2.path.basename(p)
+ print(f"🔍 [CHAT] Processing path: {p}")
+ print(f"🔍 [CHAT] Extracted filename: {fname}")
+ if fname and fname.strip():
+ attachment = {
+ "name": n or fname,
+ "url": f"/api/assets/{project_id}/{fname}"
+ }
+ print(f"🔍 [CHAT] Created attachment: {attachment}")
+ attachments.append(attachment)
+ else:
+ print(f"❌ [CHAT] Failed to extract filename from: {p}")
+ except Exception as e:
+ print(f"❌ [CHAT] Exception processing path {p}: {e}")
+ pass
+ elif n:
+ image_paths.append(n)
+
+ # Save user instruction as message (with image paths in content for display)
+ message_content = body.instruction
+ if image_paths:
+ image_refs = [f"Image #{i+1} path: {path}" for i, path in enumerate(image_paths)]
+ message_content = f"{body.instruction}\n\n{chr(10).join(image_refs)}"
+
user_message = Message(
id=str(uuid.uuid4()),
project_id=project_id,
role="user",
message_type="chat",
- content=body.instruction,
+ content=message_content,
metadata_json={
"type": "chat_instruction",
"cli_preference": cli_preference.value,
"fallback_enabled": fallback_enabled,
- "has_images": len(body.images) > 0
+ "has_images": len(body.images) > 0,
+ "image_paths": image_paths,
+ "attachments": attachments
},
conversation_id=conversation_id,
created_at=datetime.utcnow()
@@ -679,7 +860,7 @@ async def run_chat(
"id": user_message.id,
"role": "user",
"message_type": "chat",
- "content": body.instruction,
+ "content": message_content,
"metadata_json": user_message.metadata_json,
"parent_message_id": None,
"session_id": session.id,
@@ -691,14 +872,8 @@ async def run_chat(
except Exception as e:
ui.error(f"WebSocket failed: {e}", "CHAT API")
- # Extract project info to avoid DetachedInstanceError in background task
- project_info = {
- 'id': project.id,
- 'repo_path': project.repo_path,
- 'preferred_cli': project.preferred_cli or "claude",
- 'fallback_enabled': project.fallback_enabled if project.fallback_enabled is not None else True,
- 'selected_model': project.selected_model
- }
+ # Extract project info (with validated repo_path) to avoid DetachedInstanceError
+ project_info = build_project_info(project, db)
# Add background task for chat (same as act but with different event type)
background_tasks.add_task(
@@ -719,4 +894,4 @@ async def run_chat(
conversation_id=conversation_id,
status="running",
message="Chat execution started"
- )
\ No newline at end of file
+ )
diff --git a/apps/api/app/api/chat/cli_preferences.py b/apps/api/app/api/chat/cli_preferences.py
index 2d160d32..6a3ff4b5 100644
--- a/apps/api/app/api/chat/cli_preferences.py
+++ b/apps/api/app/api/chat/cli_preferences.py
@@ -9,7 +9,8 @@
from app.api.deps import get_db
from app.models.projects import Project
-from app.services.cli import UnifiedCLIManager, CLIType
+from app.services.cli import UnifiedCLIManager
+from app.services.cli.base import CLIType
router = APIRouter()
@@ -36,6 +37,9 @@ class CLIStatusResponse(BaseModel):
class AllCLIStatusResponse(BaseModel):
claude: CLIStatusResponse
cursor: CLIStatusResponse
+ codex: CLIStatusResponse
+ qwen: CLIStatusResponse
+ gemini: CLIStatusResponse
preferred_cli: str
@@ -164,28 +168,37 @@ async def get_all_cli_status(project_id: str, db: Session = Depends(get_db)):
if not project:
raise HTTPException(status_code=404, detail="Project not found")
- # For now, return mock status data to avoid CLI manager issues
preferred_cli = getattr(project, 'preferred_cli', 'claude')
-
- # Create mock status responses
- claude_status = CLIStatusResponse(
- cli_type="claude",
- available=True,
- configured=True,
- error=None,
- models=["claude-3.5-sonnet", "claude-3-opus"]
- )
-
- cursor_status = CLIStatusResponse(
- cli_type="cursor",
- available=False,
- configured=False,
- error="Not configured",
- models=[]
+
+ # Build real status for each CLI using UnifiedCLIManager
+ manager = UnifiedCLIManager(
+ project_id=project.id,
+ project_path=project.repo_path,
+ session_id="status_check",
+ conversation_id="status_check",
+ db=db,
)
-
+
+ def to_resp(cli_key: str, status: Dict[str, Any]) -> CLIStatusResponse:
+ return CLIStatusResponse(
+ cli_type=cli_key,
+ available=status.get("available", False),
+ configured=status.get("configured", False),
+ error=status.get("error"),
+ models=status.get("models"),
+ )
+
+ claude_status = await manager.check_cli_status(CLIType.CLAUDE)
+ cursor_status = await manager.check_cli_status(CLIType.CURSOR)
+ codex_status = await manager.check_cli_status(CLIType.CODEX)
+ qwen_status = await manager.check_cli_status(CLIType.QWEN)
+ gemini_status = await manager.check_cli_status(CLIType.GEMINI)
+
return AllCLIStatusResponse(
- claude=claude_status,
- cursor=cursor_status,
- preferred_cli=preferred_cli
- )
\ No newline at end of file
+ claude=to_resp("claude", claude_status),
+ cursor=to_resp("cursor", cursor_status),
+ codex=to_resp("codex", codex_status),
+ qwen=to_resp("qwen", qwen_status),
+ gemini=to_resp("gemini", gemini_status),
+ preferred_cli=preferred_cli,
+ )
diff --git a/apps/api/app/api/chat/conversations.py b/apps/api/app/api/chat/conversations.py
new file mode 100644
index 00000000..2b495714
--- /dev/null
+++ b/apps/api/app/api/chat/conversations.py
@@ -0,0 +1,68 @@
+"""Conversation summary endpoints for chat sidebar."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_db
+from app.models.sessions import Session as ChatSession
+from app.models.messages import Message as MessageModel
+from app.services.chat.conversation_summary import get_conversation_summaries
+
+router = APIRouter()
+
+
+class ConversationPinUpdate(BaseModel):
+ pinned: bool
+
+
+@router.get("/conversations")
+async def list_conversations(search: str = None, db: Session = Depends(get_db)):
+ """Return unified conversation summaries for all projects with optional full-text search."""
+ summaries = get_conversation_summaries(db)
+
+ if not search:
+ return summaries
+
+ search_lower = search.lower()
+ filtered = []
+
+ for summary in summaries:
+ if (summary.get('summary') and search_lower in summary.get('summary', '').lower()) or \
+ (summary.get('first_message') and search_lower in summary.get('first_message', '').lower()) or \
+ (summary.get('project_name') and search_lower in summary.get('project_name', '').lower()):
+ filtered.append(summary)
+ continue
+
+ messages = db.query(MessageModel).filter(
+ MessageModel.project_id == summary.get('project_id'),
+ MessageModel.conversation_id == summary.get('conversation_id')
+ ).all()
+
+ for msg in messages:
+ if msg.content and search_lower in msg.content.lower():
+ filtered.append(summary)
+ break
+
+ return filtered
+
+
+@router.patch("/conversations/{conversation_id}/pin")
+async def update_conversation_pin(
+ conversation_id: str,
+ body: ConversationPinUpdate,
+ db: Session = Depends(get_db),
+):
+ session = db.query(ChatSession).filter(ChatSession.id == conversation_id).one_or_none()
+ if session is None:
+ raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Conversation not found")
+
+ session.pinned = bool(body.pinned)
+ db.add(session)
+ db.commit()
+
+ return {"conversation_id": conversation_id, "pinned": session.pinned}
+
+
+__all__ = ["router"]
diff --git a/apps/api/app/api/chat/tokens.py b/apps/api/app/api/chat/tokens.py
new file mode 100644
index 00000000..fe76a61a
--- /dev/null
+++ b/apps/api/app/api/chat/tokens.py
@@ -0,0 +1,25 @@
+"""Token usage endpoints for conversations."""
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_db
+from app.services.token_tracker import token_tracker
+
+router = APIRouter()
+
+
+@router.get("/{conversation_id}/tokens")
+async def get_conversation_tokens(conversation_id: str, db: Session = Depends(get_db)):
+ """Get real token usage for a conversation"""
+ totals = token_tracker.get_conversation_totals(conversation_id, db)
+ context_size = token_tracker.get_real_context_size(conversation_id, db)
+
+ return {
+ "conversation_id": conversation_id,
+ "input_tokens": totals["input_tokens"],
+ "output_tokens": totals["output_tokens"],
+ "total_tokens": totals["total_tokens"],
+ "context_size": context_size,
+ "total_cost": totals["total_cost"],
+ "sessions": totals["session_count"]
+ }
\ No newline at end of file
diff --git a/apps/api/app/api/claude_conversations.py b/apps/api/app/api/claude_conversations.py
new file mode 100644
index 00000000..ffd6fc30
--- /dev/null
+++ b/apps/api/app/api/claude_conversations.py
@@ -0,0 +1,98 @@
+"""Claude CLI conversation synchronisation endpoints."""
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_db
+from app.models.messages import Message
+from app.services.chat.conversation_summary import get_conversation_summaries
+from app.services.claude.conversation_sync import ClaudeConversationSync
+
+router = APIRouter()
+
+
+@router.post("/claude-conversations/sync")
+async def sync_claude_conversations(
+ force: bool = Query(True, description="Re-import conversations even if they exist"),
+ db: Session = Depends(get_db),
+):
+ """Trigger a sync of Claude CLI logs into the database."""
+ syncer = ClaudeConversationSync(db)
+ result = syncer.sync(force=force)
+ return result
+
+
+@router.get("/claude-conversations")
+async def list_claude_conversations(db: Session = Depends(get_db)):
+ """Return conversations grouped by project for legacy compatibility."""
+ summaries = get_conversation_summaries(db)
+
+ grouped: dict[str, dict] = {}
+ for summary in summaries:
+ project_id = summary["project_id"]
+ project_group = grouped.setdefault(
+ project_id,
+ {
+ "project_id": project_id,
+ "project_name": summary.get("project_name"),
+ "project_path": summary.get("project_path"),
+ "conversations": [],
+ },
+ )
+ project_group["conversations"].append(
+ {
+ "id": summary["conversation_id"],
+ "summary": summary.get("summary"),
+ "first_message": summary.get("first_message"),
+ "timestamp": summary.get("last_message_at"),
+ "cli_type": summary.get("cli_type"),
+ "source": summary.get("source"),
+ }
+ )
+
+ # Sort conversations within each project by timestamp desc
+ for project_data in grouped.values():
+ project_data["conversations"].sort(
+ key=lambda item: item.get("timestamp") or "",
+ reverse=True,
+ )
+
+ # Keep backwards-compatible shape (user = global projects list)
+ return {
+ "user": list(grouped.values()),
+ "project": [],
+ }
+
+
+@router.get("/claude-conversations/{conversation_id}")
+async def get_claude_conversation_detail(
+ conversation_id: str,
+ project_id: str | None = Query(None, description="Project ID owning the conversation"),
+ db: Session = Depends(get_db),
+):
+ """Return the full transcript for a conversation sourced from the database."""
+ query = db.query(Message).filter(Message.conversation_id == conversation_id)
+ if project_id:
+ query = query.filter(Message.project_id == project_id)
+
+ messages = query.order_by(Message.created_at.asc()).all()
+ if not messages:
+ raise HTTPException(status_code=404, detail="Conversation not found")
+
+ return {
+ "conversation_id": conversation_id,
+ "project_id": messages[0].project_id,
+ "messages": [
+ {
+ "id": message.id,
+ "role": message.role,
+ "content": message.content,
+ "metadata_json": message.metadata_json,
+ "created_at": message.created_at.isoformat() if message.created_at else None,
+ "message_type": message.message_type,
+ "cli_source": message.cli_source,
+ }
+ for message in messages
+ ],
+ }
diff --git a/apps/api/app/api/claude_files.py b/apps/api/app/api/claude_files.py
new file mode 100644
index 00000000..f68fbf17
--- /dev/null
+++ b/apps/api/app/api/claude_files.py
@@ -0,0 +1,92 @@
+"""Endpoints for managing Claude CLI agent and command files."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from app.api.deps import get_db # noqa: F401 # Needed for consistency with other modules
+
+router = APIRouter()
+
+CLAUDE_ROOT = Path.home() / ".claude"
+RESOURCE_DIRS = {
+ "agents": CLAUDE_ROOT / "agents",
+ "commands": CLAUDE_ROOT / "commands",
+}
+
+
+class ClaudeFileResponse(BaseModel):
+ name: str
+ path: str
+ absolute_path: str
+ updated_at: float | None = None
+
+
+class ClaudeFileContent(BaseModel):
+ content: str
+
+
+def _resolve_resource_path(resource: Literal["agents", "commands"], filename: str | Path) -> Path:
+ base_dir = RESOURCE_DIRS[resource]
+ target = (base_dir / filename).resolve()
+ if not str(target).startswith(str(base_dir.resolve())):
+ raise HTTPException(status_code=400, detail="Invalid file path")
+ return target
+
+
+def _list_resource(resource: Literal["agents", "commands"]) -> list[ClaudeFileResponse]:
+ base_dir = RESOURCE_DIRS[resource]
+ if not base_dir.exists():
+ return []
+
+ files: list[ClaudeFileResponse] = []
+ for child in sorted(base_dir.iterdir()):
+ # Only include .md files
+ if child.is_file() and child.suffix == '.md':
+ stat = child.stat()
+ files.append(
+ ClaudeFileResponse(
+ name=child.name,
+ path=child.relative_to(base_dir).as_posix(),
+ absolute_path=str(child),
+ updated_at=stat.st_mtime if stat else None,
+ )
+ )
+ return files
+
+
+@router.get("/claude/{resource}", response_model=list[ClaudeFileResponse])
+async def list_claude_files(resource: Literal["agents", "commands"]):
+ """List Claude agent or command files."""
+ return _list_resource(resource)
+
+
+@router.get("/claude/{resource}/{file_path:path}", response_model=ClaudeFileContent)
+async def read_claude_file(resource: Literal["agents", "commands"], file_path: str):
+ target = _resolve_resource_path(resource, file_path)
+ if not target.exists() or not target.is_file():
+ raise HTTPException(status_code=404, detail="File not found")
+ try:
+ return ClaudeFileContent(content=target.read_text(encoding="utf-8"))
+ except UnicodeDecodeError:
+ raise HTTPException(status_code=400, detail="File is not UTF-8 encoded")
+
+
+@router.put("/claude/{resource}/{file_path:path}", response_model=ClaudeFileContent)
+async def update_claude_file(
+ resource: Literal["agents", "commands"],
+ file_path: str,
+ body: ClaudeFileContent,
+):
+ target = _resolve_resource_path(resource, file_path)
+ if not target.exists() or not target.is_file():
+ raise HTTPException(status_code=404, detail="File not found")
+
+ target.write_text(body.content, encoding="utf-8")
+ return body
+
+
+__all__ = ["router"]
diff --git a/apps/api/app/api/github.py b/apps/api/app/api/github.py
index 8c70a81b..129c2491 100644
--- a/apps/api/app/api/github.py
+++ b/apps/api/app/api/github.py
@@ -327,8 +327,9 @@ async def push_github_repository(project_id: str, db: Session = Depends(get_db))
if not repo_path or not os.path.exists(repo_path):
raise HTTPException(status_code=500, detail="Local repository path not found")
- # Branch
- default_branch = connection.service_data.get("default_branch", "main")
+ # Branch: GitHub may return null for default_branch on empty repos.
+ # Normalize to 'main' and persist after first successful push.
+ default_branch = connection.service_data.get("default_branch") or "main"
# Commit any pending changes (optional harmless)
commit_all(repo_path, "Publish from Lovable UI")
@@ -348,6 +349,9 @@ async def push_github_repository(project_id: str, db: Session = Depends(get_db))
"last_push_at": datetime.utcnow().isoformat() + "Z",
"last_pushed_branch": default_branch,
})
+ # Ensure default_branch is set after first push
+ if not data.get("default_branch"):
+ data["default_branch"] = default_branch
svc.service_data = data
db.commit()
except Exception as e:
@@ -370,4 +374,4 @@ async def push_github_repository(project_id: str, db: Session = Depends(get_db))
logger = logging.getLogger(__name__)
logger.warning(f"Failed updating Vercel connection after push: {e}")
- return GitPushResponse(success=True, message="Pushed to GitHub", branch=default_branch)
\ No newline at end of file
+ return GitPushResponse(success=True, message="Pushed to GitHub", branch=default_branch)
diff --git a/apps/api/app/api/openapi_docs.py b/apps/api/app/api/openapi_docs.py
new file mode 100644
index 00000000..9a5f0637
--- /dev/null
+++ b/apps/api/app/api/openapi_docs.py
@@ -0,0 +1,204 @@
+"""
+OpenAPI Documentation and Configuration
+Enhances API routes with detailed descriptions, examples, and tags
+"""
+from typing import Any, Dict
+from fastapi import FastAPI
+
+# Tag descriptions for better organization
+TAGS_METADATA = [
+ {
+ "name": "projects",
+ "description": "Operations for managing projects including creation, updates, and status tracking",
+ },
+ {
+ "name": "chat",
+ "description": "WebSocket and REST endpoints for chat sessions with Claude and other AI models",
+ },
+ {
+ "name": "commits",
+ "description": "Git commit management and tracking",
+ },
+ {
+ "name": "environment",
+ "description": "Environment variable management for projects",
+ },
+ {
+ "name": "assets",
+ "description": "File and asset management within projects",
+ },
+ {
+ "name": "tokens",
+ "description": "Service token management for external integrations",
+ },
+ {
+ "name": "settings",
+ "description": "Application and project settings",
+ },
+ {
+ "name": "github",
+ "description": "GitHub integration endpoints for repositories and authentication",
+ },
+ {
+ "name": "vercel",
+ "description": "Vercel deployment and project management",
+ },
+ {
+ "name": "claude",
+ "description": "Claude conversation and file management",
+ },
+ {
+ "name": "health",
+ "description": "Health check and monitoring endpoints",
+ }
+]
+
+def configure_openapi(app: FastAPI) -> None:
+ """Configure OpenAPI with enhanced documentation"""
+
+ # Update the OpenAPI schema with tags
+ app.openapi_tags = TAGS_METADATA
+
+ # Store original openapi method
+ original_openapi = app.openapi
+
+ # Add custom OpenAPI configuration
+ def custom_openapi() -> Dict[str, Any]:
+ if app.openapi_schema:
+ return app.openapi_schema
+
+ # Call the original openapi method, not the custom one
+ openapi_schema = original_openapi()
+
+ # Add server information
+ openapi_schema["servers"] = [
+ {"url": "http://localhost:8000", "description": "Development server"},
+ {"url": "http://127.0.0.1:8000", "description": "Local server"}
+ ]
+
+ # Add external documentation
+ openapi_schema["externalDocs"] = {
+ "description": "Clovable API Documentation",
+ "url": "https://github.com/your-org/clovable"
+ }
+
+ # Add security schemes if needed
+ if "components" not in openapi_schema:
+ openapi_schema["components"] = {}
+ if "securitySchemes" not in openapi_schema["components"]:
+ openapi_schema["components"]["securitySchemes"] = {}
+
+ openapi_schema["components"]["securitySchemes"]["bearerAuth"] = {
+ "type": "http",
+ "scheme": "bearer",
+ "bearerFormat": "JWT",
+ "description": "JWT token authentication"
+ }
+
+ # Cache the schema
+ app.openapi_schema = openapi_schema
+ return openapi_schema
+
+ app.openapi = custom_openapi
+
+# Response examples for common models
+PROJECT_EXAMPLE = {
+ "id": "my-awesome-project",
+ "name": "My Awesome Project",
+ "description": "A web application built with React and FastAPI",
+ "status": "active",
+ "preview_url": "http://localhost:3000",
+ "created_at": "2024-01-01T00:00:00Z",
+ "last_active_at": "2024-01-01T12:00:00Z",
+ "services": {
+ "github": {"connected": True, "status": "connected"},
+ "vercel": {"connected": False, "status": "disconnected"}
+ },
+ "features": ["Authentication", "Real-time chat", "File upload"],
+ "tech_stack": ["React", "TypeScript", "FastAPI", "PostgreSQL"],
+ "initial_prompt": "Build a modern web application",
+ "preferred_cli": "claude",
+ "selected_model": "claude-3-opus"
+}
+
+MESSAGE_EXAMPLE = {
+ "id": "msg_123",
+ "project_id": "my-awesome-project",
+ "role": "user",
+ "content": "Can you help me add authentication?",
+ "created_at": "2024-01-01T12:00:00Z",
+ "metadata": {
+ "model": "claude-3-opus",
+ "tokens": 150
+ }
+}
+
+def get_operation_metadata(path: str, method: str) -> Dict[str, Any]:
+ """Get enhanced operation metadata for specific endpoints"""
+
+ operations = {
+ ("/api/projects", "get"): {
+ "summary": "List all projects",
+ "description": "Retrieve a list of all projects with their current status, service connections, and metadata",
+ "responses": {
+ 200: {
+ "description": "List of projects retrieved successfully",
+ "content": {
+ "application/json": {
+ "example": [PROJECT_EXAMPLE]
+ }
+ }
+ }
+ }
+ },
+ ("/api/projects", "post"): {
+ "summary": "Create a new project",
+ "description": "Create a new project with specified configuration. This will initialize the project directory and set up the development environment.",
+ "responses": {
+ 200: {
+ "description": "Project created successfully",
+ "content": {
+ "application/json": {
+ "example": PROJECT_EXAMPLE
+ }
+ }
+ },
+ 409: {
+ "description": "Project with this ID already exists"
+ }
+ }
+ },
+ ("/api/projects/{project_id}", "get"): {
+ "summary": "Get project details",
+ "description": "Retrieve detailed information about a specific project including its configuration, status, and connected services",
+ "responses": {
+ 200: {
+ "description": "Project details retrieved successfully",
+ "content": {
+ "application/json": {
+ "example": PROJECT_EXAMPLE
+ }
+ }
+ },
+ 404: {
+ "description": "Project not found"
+ }
+ }
+ },
+ ("/api/chat/{project_id}", "websocket"): {
+ "summary": "WebSocket chat endpoint",
+ "description": "Establish a WebSocket connection for real-time chat with AI models. Supports streaming responses and tool calls.",
+ "parameters": [
+ {
+ "name": "project_id",
+ "in": "path",
+ "required": True,
+ "schema": {"type": "string"},
+ "description": "The project ID to establish chat session for"
+ }
+ ]
+ }
+ }
+
+ key = (path, method.lower())
+ return operations.get(key, {})
\ No newline at end of file
diff --git a/apps/api/app/api/projects/__init__.py b/apps/api/app/api/projects/__init__.py
index 61ab984e..915ea3e1 100644
--- a/apps/api/app/api/projects/__init__.py
+++ b/apps/api/app/api/projects/__init__.py
@@ -7,6 +7,9 @@
from .crud import router as crud_router
from .preview import router as preview_router
from .system_prompt import router as system_prompt_router
+from .mcp import router as mcp_router
+from .import_ import router as import_router
+from .git import router as git_router
# Create main projects router (prefix will be added in main.py)
@@ -15,4 +18,7 @@
# Include sub-routers without additional prefix
router.include_router(crud_router, tags=["projects"])
router.include_router(preview_router, tags=["projects"])
-router.include_router(system_prompt_router, tags=["projects"])
\ No newline at end of file
+router.include_router(system_prompt_router, tags=["projects"])
+router.include_router(mcp_router, tags=["projects", "mcp"])
+router.include_router(import_router, tags=["projects", "import"])
+router.include_router(git_router, tags=["projects", "git"])
\ No newline at end of file
diff --git a/apps/api/app/api/projects/crud.py b/apps/api/app/api/projects/crud.py
index 78e70708..0f91d2c0 100644
--- a/apps/api/app/api/projects/crud.py
+++ b/apps/api/app/api/projects/crud.py
@@ -18,12 +18,63 @@
from app.models.messages import Message
from app.models.project_services import ProjectServiceConnection
from app.models.sessions import Session as SessionModel
+from app.models.mcp_servers import MCPServer
from app.services.project.initializer import initialize_project
from app.core.websocket.manager import manager as websocket_manager
+from app.services.local_runtime import get_npm_executable
# Project ID validation regex
PROJECT_ID_REGEX = re.compile(r"^[a-z0-9-]{3,}$")
+# Default MCP servers to seed for new projects
+DEFAULT_MCP_SERVERS = [
+ {
+ "name": "Memory Server",
+ "transport": "stdio",
+ "command": "npx",
+ "args": ["-y", "@modelcontextprotocol/server-memory"],
+ "scope": "project",
+ "is_active": False,
+ },
+ {
+ "name": "Fetch MCP",
+ "transport": "stdio",
+ "command": "npx",
+ "args": ["-y", "fetch-mcp"],
+ "scope": "project",
+ "is_active": False,
+ },
+ {
+ "name": "Filesystem Server",
+ "transport": "stdio",
+ "command": "npx",
+ "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
+ "scope": "project",
+ "is_active": False,
+ },
+]
+
+def _seed_default_mcp_servers(db: Session, project_id: str):
+ """Seed default MCP servers for a new project"""
+ try:
+ for server_config in DEFAULT_MCP_SERVERS:
+ server = MCPServer(
+ project_id=project_id,
+ name=server_config["name"],
+ transport=server_config["transport"],
+ command=server_config["command"],
+ args=server_config["args"],
+ scope=server_config["scope"],
+ is_active=server_config["is_active"],
+ status={"running": False}
+ )
+ db.add(server)
+ db.commit()
+ print(f"✓ Seeded {len(DEFAULT_MCP_SERVERS)} default MCP servers for project {project_id}")
+ except Exception as e:
+ print(f"Warning: Failed to seed MCP servers for project {project_id}: {str(e)}")
+ db.rollback()
+
# Pydantic models
class ProjectCreate(BaseModel):
project_id: str = Field(..., pattern=PROJECT_ID_REGEX.pattern)
@@ -48,6 +99,7 @@ class Project(BaseModel):
description: Optional[str] = None
status: str = "idle"
preview_url: Optional[str] = None
+ repo_path: Optional[str] = None
created_at: datetime
last_active_at: Optional[datetime] = None
last_message_at: Optional[datetime] = None
@@ -152,33 +204,45 @@ async def init_project_task():
async def install_dependencies_background(project_id: str, project_path: str):
- """Install dependencies in background"""
+ """Install dependencies in background (npm)"""
try:
import subprocess
import os
-
- # Check if package.json exists
+
package_json_path = os.path.join(project_path, "package.json")
if os.path.exists(package_json_path):
print(f"Installing dependencies for project {project_id}...")
-
- # Run npm install in background
+
+ npm_cmd = get_npm_executable()
process = await asyncio.create_subprocess_exec(
- "npm", "install",
+ npm_cmd, "install",
cwd=project_path,
stdout=asyncio.subprocess.PIPE,
- stderr=asyncio.subprocess.PIPE
+ stderr=asyncio.subprocess.PIPE,
)
stdout, stderr = await process.communicate()
-
+
if process.returncode == 0:
print(f"Dependencies installed successfully for project {project_id}")
else:
- print(f"Failed to install dependencies for project {project_id}: {stderr.decode()}")
+ print(
+ f"Failed to install dependencies for project {project_id}: {stderr.decode()}"
+ )
except Exception as e:
print(f"Error installing dependencies: {e}")
-@router.post("/{project_id}/install-dependencies")
+@router.post(
+ "/{project_id}/install-dependencies",
+ summary="Install dependencies",
+ description="Trigger background installation of project dependencies (npm packages). The installation runs asynchronously and progress is reported via WebSocket.",
+ response_description="Installation status",
+ responses={
+ 200: {"description": "Installation started successfully"},
+ 404: {"description": "Project not found"},
+ 400: {"description": "Project repository path not found"}
+ },
+ tags=["projects"]
+)
async def install_project_dependencies(
project_id: str,
background_tasks: BackgroundTasks,
@@ -200,14 +264,26 @@ async def install_project_dependencies(
return {"message": "Dependency installation started in background", "project_id": project_id}
-@router.get("/health")
+@router.get(
+ "/health",
+ summary="Projects health check",
+ description="Check if the projects router is operational",
+ tags=["health"]
+)
async def projects_health():
"""Simple health check for projects router"""
return {"status": "ok", "router": "projects"}
-@router.get("/", response_model=List[Project])
+@router.get(
+ "/",
+ response_model=List[Project],
+ summary="List all projects",
+ description="Retrieve a complete list of all projects with their current status, service connections, and metadata including features, tech stack, and last activity timestamps.",
+ response_description="List of projects with full details",
+ tags=["projects"]
+)
async def list_projects(db: Session = Depends(get_db)) -> List[Project]:
"""List all projects with their status and last activity"""
@@ -263,6 +339,7 @@ async def list_projects(db: Session = Depends(get_db)) -> List[Project]:
description=ai_info.get('description'),
status=project.status or "idle",
preview_url=project.preview_url,
+ repo_path=project.repo_path,
created_at=project.created_at,
last_active_at=project.last_active_at,
last_message_at=last_message_at,
@@ -278,7 +355,18 @@ async def list_projects(db: Session = Depends(get_db)) -> List[Project]:
return result
-@router.get("/{project_id}", response_model=Project)
+@router.get(
+ "/{project_id}",
+ response_model=Project,
+ summary="Get project details",
+ description="Retrieve detailed information about a specific project including configuration, status, connected services, and AI-generated metadata.",
+ response_description="Project details",
+ responses={
+ 404: {"description": "Project not found"},
+ 500: {"description": "Database error"}
+ },
+ tags=["projects"]
+)
async def get_project(project_id: str, db: Session = Depends(get_db)) -> Project:
"""Get a specific project by ID"""
@@ -303,7 +391,9 @@ async def get_project(project_id: str, db: Session = Depends(get_db)) -> Project
features=ai_info.get('features'),
tech_stack=ai_info.get('tech_stack'),
ai_generated=ai_info.get('ai_generated', False),
- initial_prompt=project.initial_prompt
+ initial_prompt=project.initial_prompt,
+ preferred_cli=project.preferred_cli,
+ selected_model=project.selected_model
)
except HTTPException:
raise
@@ -311,7 +401,20 @@ async def get_project(project_id: str, db: Session = Depends(get_db)) -> Project
raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
-@router.post("/", response_model=Project)
+@router.post(
+ "/",
+ response_model=Project,
+ status_code=201,
+ summary="Create a new project",
+ description="Create a new project with the specified configuration. This initializes the project directory structure and sets up the development environment. The project ID must be lowercase with hyphens only.",
+ response_description="Newly created project",
+ responses={
+ 201: {"description": "Project created successfully"},
+ 409: {"description": "Project with this ID already exists"},
+ 400: {"description": "Invalid project ID format"}
+ },
+ tags=["projects"]
+)
async def create_project(
body: ProjectCreate,
db: Session = Depends(get_db)
@@ -354,7 +457,10 @@ async def create_project(
db.add(project)
db.commit()
db.refresh(project)
-
+
+ # Seed default MCP servers for new project
+ _seed_default_mcp_servers(db, project.id)
+
# Send immediate status update
await websocket_manager.broadcast_to_project(project.id, {
"type": "project_status",
@@ -388,10 +494,21 @@ async def create_project(
)
-@router.put("/{project_id}", response_model=Project)
+@router.put(
+ "/{project_id}",
+ response_model=Project,
+ summary="Update project",
+ description="Update an existing project's name and other configurable properties.",
+ response_description="Updated project details",
+ responses={
+ 200: {"description": "Project updated successfully"},
+ 404: {"description": "Project not found"}
+ },
+ tags=["projects"]
+)
async def update_project(
- project_id: str,
- body: ProjectUpdate,
+ project_id: str,
+ body: ProjectUpdate,
db: Session = Depends(get_db)
) -> Project:
"""Update a project"""
@@ -452,7 +569,17 @@ async def update_project(
)
-@router.delete("/{project_id}")
+@router.delete(
+ "/{project_id}",
+ summary="Delete project",
+ description="Delete a project and all its associated data including messages, sessions, and service connections. This action cannot be undone.",
+ response_description="Confirmation message",
+ responses={
+ 200: {"description": "Project deleted successfully"},
+ 404: {"description": "Project not found"}
+ },
+ tags=["projects"]
+)
async def delete_project(project_id: str, db: Session = Depends(get_db)):
"""Delete a project"""
@@ -484,4 +611,4 @@ async def delete_project(project_id: str, db: Session = Depends(get_db)):
print(f"❌ Error cleaning up project files for {project_id}: {e}")
# Don't fail the whole operation if file cleanup fails
- return {"message": f"Project {project_id} deleted successfully"}
\ No newline at end of file
+ return {"message": f"Project {project_id} deleted successfully"}
diff --git a/apps/api/app/api/projects/git.py b/apps/api/app/api/projects/git.py
new file mode 100644
index 00000000..489744b6
--- /dev/null
+++ b/apps/api/app/api/projects/git.py
@@ -0,0 +1,169 @@
+"""Git operations endpoints for projects."""
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+from typing import Optional
+
+from app.api.deps import get_db
+from app.models.projects import Project as ProjectModel
+from app.services import git_ops
+
+router = APIRouter()
+
+
+class GitCommitRequest(BaseModel):
+ message: str
+
+
+class GitPushRequest(BaseModel):
+ remote: str = "origin"
+ branch: Optional[str] = None
+
+
+class GitPullRequest(BaseModel):
+ remote: str = "origin"
+ branch: Optional[str] = None
+
+
+class GitBranchRequest(BaseModel):
+ branch_name: str
+ checkout: bool = True
+
+
+@router.get("/{project_id}/git/status")
+async def get_git_status(project_id: str, db: Session = Depends(get_db)):
+ """Get git status for a project"""
+ project = db.query(ProjectModel).filter(ProjectModel.id == project_id).first()
+ if not project:
+ raise HTTPException(status_code=404, detail="Project not found")
+
+ if not project.repo_path:
+ raise HTTPException(status_code=400, detail="Project has no repository path")
+
+ try:
+ status = git_ops.get_status(project.repo_path)
+ return status
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/{project_id}/git/branches")
+async def get_git_branches(project_id: str, db: Session = Depends(get_db)):
+ """Get git branches for a project"""
+ project = db.query(ProjectModel).filter(ProjectModel.id == project_id).first()
+ if not project:
+ raise HTTPException(status_code=404, detail="Project not found")
+
+ if not project.repo_path:
+ raise HTTPException(status_code=400, detail="Project has no repository path")
+
+ try:
+ branches = git_ops.get_branches(project.repo_path)
+ return branches
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/{project_id}/git/commit")
+async def commit_changes(
+ project_id: str,
+ request: GitCommitRequest,
+ db: Session = Depends(get_db)
+):
+ """Commit all changes"""
+ project = db.query(ProjectModel).filter(ProjectModel.id == project_id).first()
+ if not project:
+ raise HTTPException(status_code=404, detail="Project not found")
+
+ if not project.repo_path:
+ raise HTTPException(status_code=400, detail="Project has no repository path")
+
+ try:
+ commit_sha = git_ops.commit_all(project.repo_path, request.message)
+ return {"message": "Changes committed successfully", "commit_sha": commit_sha}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/{project_id}/git/push")
+async def push_changes(
+ project_id: str,
+ request: GitPushRequest,
+ db: Session = Depends(get_db)
+):
+ """Push changes to remote"""
+ project = db.query(ProjectModel).filter(ProjectModel.id == project_id).first()
+ if not project:
+ raise HTTPException(status_code=404, detail="Project not found")
+
+ if not project.repo_path:
+ raise HTTPException(status_code=400, detail="Project has no repository path")
+
+ try:
+ result = git_ops.push(project.repo_path, request.remote, request.branch)
+ return {"message": "Changes pushed successfully", "output": result}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/{project_id}/git/pull")
+async def pull_changes(
+ project_id: str,
+ request: GitPullRequest,
+ db: Session = Depends(get_db)
+):
+ """Pull changes from remote"""
+ project = db.query(ProjectModel).filter(ProjectModel.id == project_id).first()
+ if not project:
+ raise HTTPException(status_code=404, detail="Project not found")
+
+ if not project.repo_path:
+ raise HTTPException(status_code=400, detail="Project has no repository path")
+
+ try:
+ result = git_ops.pull(project.repo_path, request.remote, request.branch)
+ return {"message": "Changes pulled successfully", "output": result}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/{project_id}/git/branch")
+async def create_git_branch(
+ project_id: str,
+ request: GitBranchRequest,
+ db: Session = Depends(get_db)
+):
+ """Create a new branch"""
+ project = db.query(ProjectModel).filter(ProjectModel.id == project_id).first()
+ if not project:
+ raise HTTPException(status_code=404, detail="Project not found")
+
+ if not project.repo_path:
+ raise HTTPException(status_code=400, detail="Project has no repository path")
+
+ try:
+ result = git_ops.create_branch(project.repo_path, request.branch_name, request.checkout)
+ return {"message": result}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/{project_id}/git/checkout/{branch_name}")
+async def checkout_git_branch(
+ project_id: str,
+ branch_name: str,
+ db: Session = Depends(get_db)
+):
+ """Checkout a branch"""
+ project = db.query(ProjectModel).filter(ProjectModel.id == project_id).first()
+ if not project:
+ raise HTTPException(status_code=404, detail="Project not found")
+
+ if not project.repo_path:
+ raise HTTPException(status_code=400, detail="Project has no repository path")
+
+ try:
+ result = git_ops.checkout_branch(project.repo_path, branch_name)
+ return {"message": f"Switched to branch '{branch_name}'", "output": result}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
\ No newline at end of file
diff --git a/apps/api/app/api/projects/import_.py b/apps/api/app/api/projects/import_.py
new file mode 100644
index 00000000..a9bae092
--- /dev/null
+++ b/apps/api/app/api/projects/import_.py
@@ -0,0 +1,125 @@
+"""Project import endpoints."""
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+from typing import List, Optional
+import uuid
+from datetime import datetime
+
+from app.api.deps import get_db
+from app.models.projects import Project as ProjectModel
+from app.services.project_scanner import project_scanner
+
+router = APIRouter()
+
+
+class ImportableProject(BaseModel):
+ path: str
+ name: str
+ type: str
+ description: Optional[str]
+ tech_stack: List[str]
+ has_git: bool
+ sessions_count: int
+ created_at: str
+
+
+class ProjectImportRequest(BaseModel):
+ path: str
+ name: Optional[str] = None
+ description: Optional[str] = None
+
+
+@router.get("/scan-claude-projects", response_model=List[ImportableProject])
+async def scan_claude_projects():
+ """Scan for existing Claude projects in ~/.claude/projects"""
+ projects = project_scanner.scan_claude_projects()
+
+ result = []
+ for project in projects:
+ metadata = project_scanner.get_project_metadata(project.path)
+
+ result.append(ImportableProject(
+ path=project.path,
+ name=project.name,
+ type=metadata.get("type", "unknown"),
+ description=metadata.get("description", ""),
+ tech_stack=metadata.get("tech_stack", []),
+ has_git=metadata.get("has_git", False),
+ sessions_count=len(project.sessions),
+ created_at=project.created_at.isoformat()
+ ))
+
+ return result
+
+
+@router.get("/scan-directory/{path:path}", response_model=List[ImportableProject])
+async def scan_directory(path: str):
+ """Scan a directory for potential projects"""
+ projects = project_scanner.scan_directory_for_projects(path)
+
+ result = []
+ for project in projects:
+ metadata = project_scanner.get_project_metadata(project.path)
+
+ result.append(ImportableProject(
+ path=project.path,
+ name=project.name,
+ type=metadata.get("type", "unknown"),
+ description=metadata.get("description", ""),
+ tech_stack=metadata.get("tech_stack", []),
+ has_git=metadata.get("has_git", False),
+ sessions_count=len(project.sessions),
+ created_at=project.created_at.isoformat()
+ ))
+
+ return result
+
+
+@router.post("/import")
+async def import_project(
+ import_request: ProjectImportRequest,
+ db: Session = Depends(get_db)
+):
+ """Import an existing project"""
+ # Check if project already exists
+ existing = db.query(ProjectModel).filter(
+ ProjectModel.repo_path == import_request.path
+ ).first()
+
+ if existing:
+ raise HTTPException(status_code=400, detail="Project already imported")
+
+ # Get project metadata
+ metadata = project_scanner.get_project_metadata(import_request.path)
+
+ # Create project
+ project_id = f"project-{int(datetime.now().timestamp() * 1000)}-{uuid.uuid4().hex[:8]}"
+
+ project = ProjectModel(
+ id=project_id,
+ name=import_request.name or metadata["name"],
+ description=import_request.description or metadata.get("description"),
+ repo_path=import_request.path,
+ status="active",
+ preferred_cli="claude", # Default to Claude
+ settings={
+ "imported": True,
+ "original_type": metadata.get("type"),
+ "tech_stack": metadata.get("tech_stack", []),
+ "has_git": metadata.get("has_git", False)
+ }
+ )
+
+ db.add(project)
+ db.commit()
+ db.refresh(project)
+
+ ui.success(f"Imported project: {project.name} from {import_request.path}", "Import")
+
+ return {
+ "project_id": project.id,
+ "name": project.name,
+ "path": project.repo_path,
+ "message": "Project imported successfully"
+ }
\ No newline at end of file
diff --git a/apps/api/app/api/projects/mcp.py b/apps/api/app/api/projects/mcp.py
new file mode 100644
index 00000000..b58d057f
--- /dev/null
+++ b/apps/api/app/api/projects/mcp.py
@@ -0,0 +1,346 @@
+"""MCP Server management endpoints."""
+from fastapi import APIRouter, Depends, HTTPException, status
+from pydantic import BaseModel, validator, Field
+from sqlalchemy.orm import Session
+from typing import List, Optional, Dict, Any
+import logging
+
+from app.api.deps import get_db
+from app.models.projects import Project as ProjectModel
+from app.models.mcp_servers import MCPServer as MCPServerModel
+from app.services.mcp.manager import mcp_manager
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+
+class MCPServerCreate(BaseModel):
+ name: str = Field(..., min_length=1, max_length=255, description="Server name")
+ transport: str = Field(..., pattern="^(stdio|sse)$", description="Transport type: stdio or sse")
+ command: Optional[str] = Field(None, max_length=512, description="Command for stdio transport")
+ args: Optional[List[str]] = Field(None, description="Arguments for stdio transport")
+ url: Optional[str] = Field(None, max_length=512, description="URL for SSE transport")
+ env: Optional[Dict[str, str]] = Field(None, description="Environment variables")
+ scope: str = Field("project", pattern="^(user|project)$", description="Scope: user or project")
+ is_active: bool = Field(False, description="Whether server should start automatically")
+
+ @validator('name')
+ def validate_name(cls, v):
+ if not v.strip():
+ raise ValueError('Server name cannot be empty')
+ # Prevent special characters that could cause issues
+ if any(c in v for c in ['/', '\\', '..', '<', '>', '|', '&', ';']):
+ raise ValueError('Server name contains invalid characters')
+ return v.strip()
+
+ @validator('command')
+ def validate_command(cls, v, values):
+ if values.get('transport') == 'stdio' and not v:
+ raise ValueError('Command is required for stdio transport')
+ # Basic command validation - only allow known safe commands
+ if v:
+ cmd = v.strip().split()[0] if v.strip() else ''
+ allowed_commands = ['node', 'python', 'python3', 'npx', 'uvx']
+ if cmd not in allowed_commands:
+ logger.warning(f"Command '{cmd}' is not in allowed list: {allowed_commands}")
+ return v
+
+ @validator('url')
+ def validate_url(cls, v, values):
+ if values.get('transport') == 'sse' and not v:
+ raise ValueError('URL is required for SSE transport')
+ if v and not v.startswith(('http://', 'https://')):
+ raise ValueError('URL must start with http:// or https://')
+ return v
+
+
+class MCPServerUpdate(BaseModel):
+ name: Optional[str] = None
+ transport: Optional[str] = None
+ command: Optional[str] = None
+ args: Optional[List[str]] = None
+ url: Optional[str] = None
+ env: Optional[Dict[str, str]] = None
+ scope: Optional[str] = None
+ is_active: Optional[bool] = None
+
+
+class MCPServerResponse(BaseModel):
+ id: int
+ name: str
+ transport: str
+ command: Optional[str]
+ args: Optional[List[str]]
+ url: Optional[str]
+ env: Optional[Dict[str, str]]
+ scope: str
+ is_active: bool
+ status: Optional[Dict[str, Any]]
+
+
+@router.get("/{project_id}/mcp", response_model=List[MCPServerResponse])
+async def list_mcp_servers(project_id: str, db: Session = Depends(get_db)):
+ """List MCP servers for a project."""
+ try:
+ project = db.query(ProjectModel).filter(ProjectModel.id == project_id).first()
+ if not project:
+ logger.warning(f"Project not found: {project_id}")
+ raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Project not found")
+
+ servers = db.query(MCPServerModel).filter(MCPServerModel.project_id == project_id).all()
+ logger.info(f"Listed {len(servers)} MCP servers for project {project_id}")
+
+ return [
+ MCPServerResponse(
+ id=server.id,
+ name=server.name,
+ transport=server.transport,
+ command=server.command,
+ args=server.args,
+ url=server.url,
+ env=server.env,
+ scope=server.scope,
+ is_active=server.is_active,
+ status=server.status
+ )
+ for server in servers
+ ]
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"Error listing MCP servers for project {project_id}: {str(e)}")
+ raise HTTPException(
+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+ detail="Failed to list MCP servers"
+ )
+
+
+@router.post("/{project_id}/mcp", response_model=MCPServerResponse, status_code=status.HTTP_201_CREATED)
+async def create_mcp_server(
+ project_id: str,
+ server_data: MCPServerCreate,
+ db: Session = Depends(get_db)
+):
+ """Create a new MCP server for a project."""
+ try:
+ project = db.query(ProjectModel).filter(ProjectModel.id == project_id).first()
+ if not project:
+ logger.warning(f"Project not found: {project_id}")
+ raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Project not found")
+
+ # Check for duplicate server names within the project
+ existing = db.query(MCPServerModel).filter(
+ MCPServerModel.project_id == project_id,
+ MCPServerModel.name == server_data.name
+ ).first()
+
+ if existing:
+ raise HTTPException(
+ status_code=status.HTTP_409_CONFLICT,
+ detail=f"MCP server with name '{server_data.name}' already exists for this project"
+ )
+
+ # Additional validation is done by Pydantic model
+ server = MCPServerModel(
+ project_id=project_id,
+ name=server_data.name,
+ transport=server_data.transport,
+ command=server_data.command,
+ args=server_data.args,
+ url=server_data.url,
+ env=server_data.env,
+ scope=server_data.scope,
+ is_active=server_data.is_active,
+ status={"running": False}
+ )
+
+ db.add(server)
+ db.commit()
+ db.refresh(server)
+
+ logger.info(f"Created MCP server '{server.name}' for project {project_id}")
+
+ return MCPServerResponse(
+ id=server.id,
+ name=server.name,
+ transport=server.transport,
+ command=server.command,
+ args=server.args,
+ url=server.url,
+ env=server.env,
+ scope=server.scope,
+ is_active=server.is_active,
+ status=server.status
+ )
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"Error creating MCP server for project {project_id}: {str(e)}")
+ db.rollback()
+ raise HTTPException(
+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+ detail="Failed to create MCP server"
+ )
+
+
+@router.put("/{project_id}/mcp/{server_id}", response_model=MCPServerResponse)
+async def update_mcp_server(
+ project_id: str,
+ server_id: int,
+ server_data: MCPServerUpdate,
+ db: Session = Depends(get_db)
+):
+ """Update an MCP server."""
+ server = db.query(MCPServerModel).filter(
+ MCPServerModel.id == server_id,
+ MCPServerModel.project_id == project_id
+ ).first()
+
+ if not server:
+ raise HTTPException(status_code=404, detail="MCP server not found")
+
+ # Update fields
+ for field, value in server_data.dict(exclude_unset=True).items():
+ setattr(server, field, value)
+
+ db.commit()
+ db.refresh(server)
+
+ return MCPServerResponse(
+ id=server.id,
+ name=server.name,
+ transport=server.transport,
+ command=server.command,
+ args=server.args,
+ url=server.url,
+ env=server.env,
+ scope=server.scope,
+ is_active=server.is_active,
+ status=server.status
+ )
+
+
+@router.delete("/{project_id}/mcp/{server_id}")
+async def delete_mcp_server(
+ project_id: str,
+ server_id: int,
+ db: Session = Depends(get_db)
+):
+ """Delete an MCP server."""
+ server = db.query(MCPServerModel).filter(
+ MCPServerModel.id == server_id,
+ MCPServerModel.project_id == project_id
+ ).first()
+
+ if not server:
+ raise HTTPException(status_code=404, detail="MCP server not found")
+
+ db.delete(server)
+ db.commit()
+
+ return {"message": "MCP server deleted successfully"}
+
+
+@router.post("/{project_id}/mcp/{server_id}/start")
+async def start_mcp_server(
+ project_id: str,
+ server_id: int,
+ db: Session = Depends(get_db)
+):
+ """Start an MCP server."""
+ try:
+ server = db.query(MCPServerModel).filter(
+ MCPServerModel.id == server_id,
+ MCPServerModel.project_id == project_id
+ ).first()
+
+ if not server:
+ logger.warning(f"MCP server not found: {server_id} for project {project_id}")
+ raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="MCP server not found")
+
+ logger.info(f"Starting MCP server: {server.name} (ID: {server_id})")
+ success = await mcp_manager.start_server(server, db)
+
+ if success:
+ logger.info(f"MCP server {server.name} started successfully")
+ return {"message": f"MCP server {server.name} started successfully", "status": server.status}
+ else:
+ error_msg = server.status.get("error", "Unknown error") if server.status else "Unknown error"
+ logger.error(f"Failed to start MCP server {server.name}: {error_msg}")
+ raise HTTPException(
+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+ detail=f"Failed to start MCP server: {error_msg}"
+ )
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"Error starting MCP server {server_id}: {str(e)}")
+ raise HTTPException(
+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+ detail="Failed to start MCP server"
+ )
+
+
+@router.post("/{project_id}/mcp/{server_id}/stop")
+async def stop_mcp_server(
+ project_id: str,
+ server_id: int,
+ db: Session = Depends(get_db)
+):
+ """Stop an MCP server."""
+ try:
+ server = db.query(MCPServerModel).filter(
+ MCPServerModel.id == server_id,
+ MCPServerModel.project_id == project_id
+ ).first()
+
+ if not server:
+ logger.warning(f"MCP server not found: {server_id} for project {project_id}")
+ raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="MCP server not found")
+
+ logger.info(f"Stopping MCP server: {server.name} (ID: {server_id})")
+ success = await mcp_manager.stop_server(server_id, db)
+
+ if success:
+ logger.info(f"MCP server {server.name} stopped successfully")
+ return {"message": f"MCP server {server.name} stopped successfully", "status": server.status}
+ else:
+ logger.error(f"Failed to stop MCP server {server.name}")
+ raise HTTPException(
+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+ detail="Failed to stop MCP server"
+ )
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"Error stopping MCP server {server_id}: {str(e)}")
+ raise HTTPException(
+ status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+ detail="Failed to stop MCP server"
+ )
+
+
+@router.get("/{project_id}/mcp/{server_id}/tools")
+async def get_mcp_server_tools(
+ project_id: str,
+ server_id: int,
+ db: Session = Depends(get_db)
+):
+ """Get tools from a running MCP server."""
+ server = db.query(MCPServerModel).filter(
+ MCPServerModel.id == server_id,
+ MCPServerModel.project_id == project_id
+ ).first()
+
+ if not server:
+ raise HTTPException(status_code=404, detail="MCP server not found")
+
+ running_servers = mcp_manager.get_running_servers()
+ if server_id in running_servers:
+ tools = running_servers[server_id].tools
+ return {
+ "server_name": server.name,
+ "tools": [{"name": t.name, "description": t.description, "input_schema": t.input_schema} for t in tools]
+ }
+ else:
+ return {"server_name": server.name, "tools": []}
\ No newline at end of file
diff --git a/apps/api/app/api/projects/preview.py b/apps/api/app/api/projects/preview.py
index 9a989002..0c3049de 100644
--- a/apps/api/app/api/projects/preview.py
+++ b/apps/api/app/api/projects/preview.py
@@ -2,6 +2,8 @@
Project Preview Management
Handles preview server operations for projects
"""
+import os
+
from fastapi import APIRouter, HTTPException, Depends
from pydantic import BaseModel
from typing import Optional
@@ -9,6 +11,7 @@
from app.api.deps import get_db
from app.models.projects import Project as ProjectModel
+from app.core.config import settings
from app.services.local_runtime import (
start_preview_process,
stop_preview_process,
@@ -53,16 +56,31 @@ async def start_preview(
# Check if preview is already running
status = preview_status(project_id)
if status == "running":
- # Get existing port from somewhere or use default
+ # Return stored preview info if available
return PreviewStatusResponse(
running=True,
- port=None, # TODO: Store port information
- url=None,
+ port=project.preview_port,
+ url=project.preview_url,
process_id=None
)
+ # Ensure project has a repository path
+ repo_path = project.repo_path
+
+ if not repo_path:
+ inferred_path = os.path.join(settings.projects_root, project_id, "repo")
+ if os.path.exists(inferred_path):
+ project.repo_path = inferred_path
+ db.commit()
+ repo_path = inferred_path
+ else:
+ raise HTTPException(
+ status_code=409,
+ detail="Project repository is not initialized yet. Please wait for project setup to complete."
+ )
+
# Start preview
- process_name, port = start_preview_process(project_id, project.repo_path, port=body.port)
+ process_name, port = start_preview_process(project_id, repo_path, port=body.port)
result = {
"success": True,
"port": port,
@@ -76,6 +94,7 @@ async def start_preview(
# Update project status
project.status = "preview_running"
project.preview_url = result.get("url")
+ project.preview_port = result.get("port")
db.commit()
return PreviewStatusResponse(
@@ -117,6 +136,7 @@ async def stop_preview(project_id: str, db: Session = Depends(get_db)):
# Update project status
project.status = "idle"
project.preview_url = None
+ project.preview_port = None
db.commit()
return {"message": "Preview stopped successfully"}
@@ -134,8 +154,8 @@ async def get_preview_status(project_id: str, db: Session = Depends(get_db)):
return PreviewStatusResponse(
running=(status == "running"),
- port=None, # TODO: Store port information
- url=None,
+ port=project.preview_port if status == "running" else None,
+ url=project.preview_url if status == "running" else None,
process_id=None,
error=None
)
@@ -158,7 +178,7 @@ async def get_preview_logs_endpoint(
return PreviewLogsResponse(
logs=logs,
- running=status.get("running", False)
+ running=(status == "running")
)
@@ -180,8 +200,23 @@ async def restart_preview(
stop_preview_process(project_id)
# No need to check result as stop_preview_process returns None
+ # Ensure project has a repository path
+ repo_path = project.repo_path
+
+ if not repo_path:
+ inferred_path = os.path.join(settings.projects_root, project_id, "repo")
+ if os.path.exists(inferred_path):
+ project.repo_path = inferred_path
+ db.commit()
+ repo_path = inferred_path
+ else:
+ raise HTTPException(
+ status_code=409,
+ detail="Project repository is not initialized yet. Please wait for project setup to complete."
+ )
+
# Start preview
- process_name, port = start_preview_process(project_id, project.repo_path, port=body.port)
+ process_name, port = start_preview_process(project_id, repo_path, port=body.port)
result = {
"success": True,
"port": port,
@@ -219,4 +254,4 @@ async def get_all_error_logs(
# Get all stored logs for this project
all_logs = get_all_preview_logs(project_id)
- return {"logs": all_logs, "project_id": project_id}
\ No newline at end of file
+ return {"logs": all_logs, "project_id": project_id}
diff --git a/apps/api/app/api/settings.py b/apps/api/app/api/settings.py
index 248b0eed..d78f2d24 100644
--- a/apps/api/app/api/settings.py
+++ b/apps/api/app/api/settings.py
@@ -4,11 +4,12 @@
from typing import Dict, Any
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
-from app.services.cli.unified_manager import CLIType, CursorAgentCLI
+from app.services.cli.unified_manager import CursorAgentCLI
+from app.services.cli.base import CLIType
router = APIRouter(prefix="/api/settings", tags=["settings"])
-# CLI 옵션과 체크 명령어 정의
+# Define CLI options and check commands
CLI_OPTIONS = [
{
"id": "claude",
@@ -30,9 +31,9 @@ class CLIStatusResponse(BaseModel):
async def check_cli_installation(cli_id: str, command: list) -> CLIStatusResponse:
- """단일 CLI의 설치 상태를 확인합니다."""
+ """Check the installation status of a single CLI."""
try:
- # subprocess를 비동기로 실행
+ # Run subprocess asynchronously
process = await asyncio.create_subprocess_exec(
*command,
stdout=asyncio.subprocess.PIPE,
@@ -42,9 +43,9 @@ async def check_cli_installation(cli_id: str, command: list) -> CLIStatusRespons
stdout, stderr = await process.communicate()
if process.returncode == 0:
- # 성공적으로 실행된 경우
+ # Successfully executed
version_output = stdout.decode().strip()
- # 버전 정보에서 실제 버전 번호 추출 (첫 번째 라인만 사용)
+ # Extract actual version number from version info (use first line only)
version = version_output.split('\n')[0] if version_output else "installed"
return CLIStatusResponse(
@@ -53,7 +54,7 @@ async def check_cli_installation(cli_id: str, command: list) -> CLIStatusRespons
version=version
)
else:
- # 명령어 실행은 되었지만 에러 리턴 코드
+ # Command executed but returned error code
error_msg = stderr.decode().strip() if stderr else f"Command failed with code {process.returncode}"
return CLIStatusResponse(
cli_id=cli_id,
@@ -62,14 +63,14 @@ async def check_cli_installation(cli_id: str, command: list) -> CLIStatusRespons
)
except FileNotFoundError:
- # 명령어를 찾을 수 없는 경우 (설치되지 않음)
+ # Command not found (not installed)
return CLIStatusResponse(
cli_id=cli_id,
installed=False,
error="Command not found"
)
except Exception as e:
- # 기타 예외
+ # Other exceptions
return CLIStatusResponse(
cli_id=cli_id,
installed=False,
@@ -79,29 +80,35 @@ async def check_cli_installation(cli_id: str, command: list) -> CLIStatusRespons
@router.get("/cli-status")
async def get_cli_status() -> Dict[str, Any]:
- """모든 CLI의 설치 상태를 확인하고 반환합니다."""
+ """Check and return the installation status of all CLIs."""
results = {}
- # 새로운 UnifiedCLIManager의 CLI 인스턴스 사용
- from app.services.cli.unified_manager import ClaudeCodeCLI, CursorAgentCLI
+ # Use CLI instances from the new UnifiedCLIManager
+ from app.services.cli.unified_manager import ClaudeCodeCLI, CursorAgentCLI, CodexCLI, QwenCLI, GeminiCLI
cli_instances = {
"claude": ClaudeCodeCLI(),
- "cursor": CursorAgentCLI()
+ "cursor": CursorAgentCLI(),
+ "codex": CodexCLI(),
+ "qwen": QwenCLI(),
+ "gemini": GeminiCLI()
}
- # 모든 CLI를 병렬로 확인
+ # Check all CLIs in parallel
tasks = []
for cli_id, cli_instance in cli_instances.items():
+ print(f"[DEBUG] Setting up check for CLI: {cli_id}")
async def check_cli(cli_id, cli_instance):
+ print(f"[DEBUG] Checking CLI: {cli_id}")
status = await cli_instance.check_availability()
+ print(f"[DEBUG] CLI {cli_id} status: {status}")
return cli_id, status
tasks.append(check_cli(cli_id, cli_instance))
- # 모든 태스크 실행
+ # Execute all tasks
cli_results = await asyncio.gather(*tasks)
- # 결과를 딕셔너리로 변환
+ # Convert results to dictionary
for cli_id, status in cli_results:
results[cli_id] = {
"installed": status.get("available", False) and status.get("configured", False),
@@ -113,11 +120,11 @@ async def check_cli(cli_id, cli_instance):
return results
-# 글로벌 설정 관리를 위한 임시 메모리 저장소 (실제로는 데이터베이스에 저장해야 함)
+# Temporary memory storage for global settings management (should be stored in database in production)
GLOBAL_SETTINGS = {
"default_cli": "claude",
"cli_settings": {
- "claude": {"model": "claude-sonnet-4"},
+ "claude": {"model": "claude-sonnet-4.5"},
"cursor": {"model": "gpt-5"}
}
}
@@ -129,13 +136,13 @@ class GlobalSettingsModel(BaseModel):
@router.get("/global")
async def get_global_settings() -> Dict[str, Any]:
- """글로벌 설정을 반환합니다."""
+ """Return global settings."""
return GLOBAL_SETTINGS
@router.put("/global")
async def update_global_settings(settings: GlobalSettingsModel) -> Dict[str, Any]:
- """글로벌 설정을 업데이트합니다."""
+ """Update global settings."""
global GLOBAL_SETTINGS
GLOBAL_SETTINGS.update({
@@ -143,4 +150,4 @@ async def update_global_settings(settings: GlobalSettingsModel) -> Dict[str, Any
"cli_settings": settings.cli_settings
})
- return {"success": True, "settings": GLOBAL_SETTINGS}
\ No newline at end of file
+ return {"success": True, "settings": GLOBAL_SETTINGS}
diff --git a/apps/api/app/api/vercel.py b/apps/api/app/api/vercel.py
index c2e12ad5..ba16c17f 100644
--- a/apps/api/app/api/vercel.py
+++ b/apps/api/app/api/vercel.py
@@ -271,11 +271,19 @@ async def deploy_to_vercel(
# Initialize Vercel service
vercel_service = VercelService(vercel_token)
+ # Resolve branch: prefer GitHub connection's default/last pushed branch
+ preferred_branch = (
+ github_connection.service_data.get("last_pushed_branch")
+ or github_connection.service_data.get("default_branch")
+ or request.branch
+ or "main"
+ )
+
# Create deployment
deployment_result = await vercel_service.create_deployment(
project_name=vercel_data.get("project_name"),
github_repo_id=github_repo_id,
- branch=request.branch,
+ branch=preferred_branch,
framework=vercel_data.get("framework", "nextjs")
)
@@ -467,4 +475,4 @@ async def get_active_monitoring():
return {"active_projects": active_projects}
except Exception as e:
logger.error(f"Failed to get active monitoring: {e}")
- raise HTTPException(status_code=500, detail=str(e))
\ No newline at end of file
+ raise HTTPException(status_code=500, detail=str(e))
diff --git a/apps/api/app/core/config.py b/apps/api/app/core/config.py
index b7dfcad1..080c6cf1 100644
--- a/apps/api/app/core/config.py
+++ b/apps/api/app/core/config.py
@@ -46,6 +46,15 @@ class Settings(BaseModel):
preview_port_start: int = int(os.getenv("PREVIEW_PORT_START", "3100"))
preview_port_end: int = int(os.getenv("PREVIEW_PORT_END", "3999"))
-
-
-settings = Settings()
\ No newline at end of file
+ @property
+ def preview_port_fixed(self) -> int | None:
+ val = os.getenv("PREVIEW_PORT_FIXED")
+ if val and val.strip().lower() in {"", "auto", "none"}:
+ return None
+ elif val:
+ return int(val)
+ else:
+ return 3100
+
+
+settings = Settings()
diff --git a/apps/api/app/db/migrations.py b/apps/api/app/db/migrations.py
new file mode 100644
index 00000000..4fe5c914
--- /dev/null
+++ b/apps/api/app/db/migrations.py
@@ -0,0 +1,102 @@
+"""Database migrations module for SQLite."""
+
+import logging
+
+from sqlalchemy import inspect, text
+from sqlalchemy.engine import Engine
+
+logger = logging.getLogger(__name__)
+
+
+def run_sqlite_migrations(engine: Engine | None = None) -> None:
+ """Run lightweight SQLite migrations."""
+
+ if engine is None:
+ logger.info("No engine supplied for migrations; skipping")
+ return
+
+ inspector = inspect(engine)
+
+ # Add `pinned` column to sessions table if missing
+ session_columns = {column["name"] for column in inspector.get_columns("sessions")}
+ if "pinned" not in session_columns:
+ logger.info("Adding `pinned` column to sessions table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE sessions ADD COLUMN pinned BOOLEAN DEFAULT 0"))
+
+ # Add `claude_session_id` column to sessions table if missing
+ if "claude_session_id" not in session_columns:
+ logger.info("Adding `claude_session_id` column to sessions table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE sessions ADD COLUMN claude_session_id VARCHAR(128)"))
+ connection.execute(text("CREATE INDEX IF NOT EXISTS idx_sessions_claude_session_id ON sessions(claude_session_id)"))
+
+ # Add `status` column to sessions table if missing
+ if "status" not in session_columns:
+ logger.info("Adding `status` column to sessions table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE sessions ADD COLUMN status VARCHAR(32) DEFAULT 'active'"))
+
+ # Add `conversation_id` column to messages table if missing
+ message_columns = {column["name"] for column in inspector.get_columns("messages")}
+ if "conversation_id" not in message_columns:
+ logger.info("Adding `conversation_id` column to messages table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE messages ADD COLUMN conversation_id VARCHAR(64)"))
+ connection.execute(text("CREATE INDEX IF NOT EXISTS idx_messages_conversation_id ON messages(conversation_id)"))
+
+ # Add `user_message_id` column to user_requests table if missing
+ try:
+ user_request_columns = {column["name"] for column in inspector.get_columns("user_requests")}
+ if "user_message_id" not in user_request_columns:
+ logger.info("Adding `user_message_id` column to user_requests table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE user_requests ADD COLUMN user_message_id VARCHAR(64)"))
+ connection.execute(text("CREATE INDEX IF NOT EXISTS idx_user_requests_user_message_id ON user_requests(user_message_id)"))
+ connection.execute(text("CREATE UNIQUE INDEX IF NOT EXISTS idx_user_requests_user_message_id_unique ON user_requests(user_message_id)"))
+
+ if "session_id" not in user_request_columns:
+ logger.info("Adding `session_id` column to user_requests table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE user_requests ADD COLUMN session_id VARCHAR(64)"))
+ connection.execute(text("CREATE INDEX IF NOT EXISTS idx_user_requests_session_id ON user_requests(session_id)"))
+ except Exception:
+ # Table might not exist yet
+ pass
+
+ # Add missing columns to project_service_connections table if needed
+ try:
+ service_columns = {column["name"] for column in inspector.get_columns("project_service_connections")}
+
+ if "provider" not in service_columns:
+ logger.info("Adding `provider` column to project_service_connections table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE project_service_connections ADD COLUMN provider VARCHAR(32) NOT NULL DEFAULT 'github'"))
+
+ if "status" not in service_columns:
+ logger.info("Adding `status` column to project_service_connections table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE project_service_connections ADD COLUMN status VARCHAR(32) DEFAULT 'connected'"))
+
+ if "service_data" not in service_columns:
+ logger.info("Adding `service_data` column to project_service_connections table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE project_service_connections ADD COLUMN service_data JSON"))
+
+ if "last_sync_at" not in service_columns:
+ logger.info("Adding `last_sync_at` column to project_service_connections table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE project_service_connections ADD COLUMN last_sync_at TIMESTAMP"))
+
+ if "created_at" not in service_columns:
+ logger.info("Adding `created_at` column to project_service_connections table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE project_service_connections ADD COLUMN created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP"))
+
+ if "updated_at" not in service_columns:
+ logger.info("Adding `updated_at` column to project_service_connections table")
+ with engine.begin() as connection:
+ connection.execute(text("ALTER TABLE project_service_connections ADD COLUMN updated_at TIMESTAMP"))
+ except Exception:
+ # Table might not exist yet
+ pass
diff --git a/apps/api/app/main.py b/apps/api/app/main.py
index 4f7d22fe..d84045c2 100644
--- a/apps/api/app/main.py
+++ b/apps/api/app/main.py
@@ -2,6 +2,7 @@
from fastapi.middleware.cors import CORSMiddleware
from starlette.middleware.base import BaseHTTPMiddleware
from app.api.projects import router as projects_router
+from app.api.openapi_docs import configure_openapi, TAGS_METADATA
from app.api.repo import router as repo_router
from app.api.commits import router as commits_router
from app.api.env import router as env_router
@@ -12,17 +13,31 @@
from app.api.project_services import router as project_services_router
from app.api.github import router as github_router
from app.api.vercel import router as vercel_router
+from app.api.claude_conversations import router as claude_conversations_router
+from app.api.claude_files import router as claude_files_router
from app.core.logging import configure_logging
from app.core.terminal_ui import ui
from sqlalchemy import inspect
from app.db.base import Base
import app.models # noqa: F401 ensures models are imported for metadata
from app.db.session import engine
+from app.db.migrations import run_sqlite_migrations
import os
configure_logging()
-app = FastAPI(title="Clovable API")
+app = FastAPI(
+ title="Clovable API",
+ description="API for managing projects, chat sessions, and integrations with Claude, GitHub, and Vercel",
+ version="1.0.0",
+ docs_url="/docs",
+ redoc_url="/redoc",
+ openapi_url="/openapi.json",
+ openapi_tags=TAGS_METADATA
+)
+
+# Configure enhanced OpenAPI documentation
+configure_openapi(app)
# Middleware to suppress logging for specific endpoints
class LogFilterMiddleware(BaseHTTPMiddleware):
@@ -64,6 +79,8 @@ async def dispatch(self, request: Request, call_next):
app.include_router(project_services_router) # Project services API
app.include_router(github_router) # GitHub integration API
app.include_router(vercel_router) # Vercel integration API
+app.include_router(claude_conversations_router, prefix="/api") # Claude conversation folder reader
+app.include_router(claude_files_router, prefix="/api") # Claude CLI file management
@app.get("/health")
@@ -79,6 +96,8 @@ def on_startup() -> None:
inspector = inspect(engine)
Base.metadata.create_all(bind=engine)
ui.success("Database initialization complete")
+ # Run lightweight SQLite migrations for additive changes
+ run_sqlite_migrations(engine)
# Show available endpoints
ui.info("API server ready")
diff --git a/apps/api/app/models/__init__.py b/apps/api/app/models/__init__.py
index d0e4ec49..f812c876 100644
--- a/apps/api/app/models/__init__.py
+++ b/apps/api/app/models/__init__.py
@@ -8,6 +8,7 @@
from app.models.tokens import ServiceToken
from app.models.project_services import ProjectServiceConnection
from app.models.user_requests import UserRequest
+from app.models.mcp_servers import MCPServer
__all__ = [
@@ -20,4 +21,5 @@
"ServiceToken",
"ProjectServiceConnection",
"UserRequest",
+ "MCPServer",
]
diff --git a/apps/api/app/models/mcp_servers.py b/apps/api/app/models/mcp_servers.py
new file mode 100644
index 00000000..a0cb524a
--- /dev/null
+++ b/apps/api/app/models/mcp_servers.py
@@ -0,0 +1,41 @@
+"""MCP Server configuration model."""
+from sqlalchemy import String, Boolean, JSON, Integer, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from datetime import datetime
+from app.db.base import Base
+
+
+class MCPServer(Base):
+ """MCP Server configuration."""
+ __tablename__ = "mcp_servers"
+
+ id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+ project_id: Mapped[str] = mapped_column(String(64), ForeignKey("projects.id", ondelete="CASCADE"), index=True)
+
+ # Server identification
+ name: Mapped[str] = mapped_column(String(255), nullable=False)
+ transport: Mapped[str] = mapped_column(String(32), nullable=False) # stdio, sse
+
+ # Command configuration (for stdio transport)
+ command: Mapped[str | None] = mapped_column(String(512), nullable=True)
+ args: Mapped[list | None] = mapped_column(JSON, nullable=True)
+
+ # SSE configuration (for sse transport)
+ url: Mapped[str | None] = mapped_column(String(512), nullable=True)
+
+ # Environment variables
+ env: Mapped[dict | None] = mapped_column(JSON, nullable=True)
+
+ # Configuration
+ scope: Mapped[str] = mapped_column(String(32), default="project", nullable=False) # user, project
+ is_active: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
+
+ # Status tracking
+ status: Mapped[dict | None] = mapped_column(JSON, nullable=True) # { running: bool, error?: string }
+
+ # Timestamps
+ created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow, nullable=False)
+ updated_at: Mapped[datetime] = mapped_column(default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+
+ # Relationships
+ project = relationship("Project", back_populates="mcp_servers")
\ No newline at end of file
diff --git a/apps/api/app/models/messages.py b/apps/api/app/models/messages.py
index 5ba81675..468a35ef 100644
--- a/apps/api/app/models/messages.py
+++ b/apps/api/app/models/messages.py
@@ -32,6 +32,8 @@ class Message(Base):
# Performance & Cost Tracking
duration_ms: Mapped[int | None] = mapped_column(Integer, nullable=True)
token_count: Mapped[int | None] = mapped_column(Integer, nullable=True)
+ input_tokens: Mapped[int | None] = mapped_column(Integer, nullable=True)
+ output_tokens: Mapped[int | None] = mapped_column(Integer, nullable=True)
cost_usd: Mapped[float | None] = mapped_column(Numeric(10, 6), nullable=True)
# Git Integration
diff --git a/apps/api/app/models/projects.py b/apps/api/app/models/projects.py
index 9fe98e59..e1101ab5 100644
--- a/apps/api/app/models/projects.py
+++ b/apps/api/app/models/projects.py
@@ -42,3 +42,4 @@ class Project(Base):
env_vars = relationship("EnvVar", back_populates="project", cascade="all, delete-orphan")
service_connections = relationship("ProjectServiceConnection", back_populates="project", cascade="all, delete-orphan")
user_requests = relationship("UserRequest", back_populates="project", cascade="all, delete-orphan")
+ mcp_servers = relationship("MCPServer", back_populates="project", cascade="all, delete-orphan")
diff --git a/apps/api/app/models/sessions.py b/apps/api/app/models/sessions.py
index 7ce0dd8b..7e995294 100644
--- a/apps/api/app/models/sessions.py
+++ b/apps/api/app/models/sessions.py
@@ -1,7 +1,7 @@
"""
Claude Code SDK session management
"""
-from sqlalchemy import String, DateTime, ForeignKey, Text, Integer, Numeric
+from sqlalchemy import String, DateTime, ForeignKey, Text, Integer, Numeric, Boolean
from sqlalchemy.orm import Mapped, mapped_column, relationship
from datetime import datetime
from app.db.base import Base
@@ -34,8 +34,11 @@ class Session(Base):
total_messages: Mapped[int] = mapped_column(Integer, default=0)
total_tools_used: Mapped[int] = mapped_column(Integer, default=0)
total_tokens: Mapped[int] = mapped_column(Integer, default=0)
+ input_tokens: Mapped[int] = mapped_column(Integer, default=0)
+ output_tokens: Mapped[int] = mapped_column(Integer, default=0)
total_cost_usd: Mapped[float | None] = mapped_column(Numeric(10, 6), nullable=True)
duration_ms: Mapped[int | None] = mapped_column(Integer, nullable=True)
+ pinned: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
# Timestamps
started_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, nullable=False)
@@ -45,4 +48,4 @@ class Session(Base):
project = relationship("Project", back_populates="sessions")
messages = relationship("Message", back_populates="session")
tools_usage = relationship("ToolUsage", back_populates="session", cascade="all, delete-orphan")
- user_requests = relationship("UserRequest", back_populates="session")
\ No newline at end of file
+ user_requests = relationship("UserRequest", back_populates="session")
diff --git a/apps/api/app/prompt/system-prompt.md b/apps/api/app/prompt/system-prompt.md
index 4469bb9e..0a48c930 100644
--- a/apps/api/app/prompt/system-prompt.md
+++ b/apps/api/app/prompt/system-prompt.md
@@ -1,4 +1,4 @@
-You are CLovable, an advanced AI coding assistant specialized in building modern fullstack web applications. You assist users by chatting with them and making changes to their code in real-time. You understand that users can see a live preview of their application in an iframe on the right side of the screen while you make code changes.
+You are Claudable, an advanced AI coding assistant specialized in building modern fullstack web applications. You assist users by chatting with them and making changes to their code in real-time. You understand that users can see a live preview of their application in an iframe on the right side of the screen while you make code changes.
## Core Identity
@@ -12,10 +12,31 @@ You are an expert fullstack developer with deep knowledge of the modern web deve
Not every interaction requires code changes - you're happy to discuss architecture, explain concepts, debug issues, or provide guidance without modifying the codebase. When code changes are needed, you make efficient and effective updates while following modern fullstack best practices for maintainability, security, and performance.
+When starting a new task:
+1. Run ONE command: `ls -la`
+2. IMMEDIATELY start working with the correct paths
+CRITICAL: File paths in Next.js projects:
+- If you see `app/` directory: use `app/page.tsx` (no leading slash)
+- If you see `src/` directory: use `src/app/page.tsx` (no leading slash)
+- NEVER use `/app/page.tsx` or `./app/page.tsx` - these are wrong!
+
+For the FIRST interaction on a new project:
+- Take time to understand what the user wants to build
+- Consider what existing beautiful designs you can draw inspiration from
+- List the features you'll implement in the first version (don't do too much, but make it look good)
+- List possible colors, gradients, animations, fonts and styles you'll use
+- When the user asks for a specific design, follow it to the letter
+- Consider editing tailwind.config.ts and index.css first if custom styles are needed
+- Focus on creating a beautiful, working first impression - go above and beyond
+- The MOST IMPORTANT thing is that the app is beautiful and works without build errors
+- Take your time to wow the user with a really beautiful and well-coded app
+
## Product Principles (MVP approach)
- Implement only the specific functionality the user explicitly requests
- Avoid adding extra features, optimizations, or enhancements unless specifically asked
- Keep implementations simple and focused on the core requirement
+- Avoid unnecessary abstraction - write code in the same file when it makes sense
+- Don't over-componentize - larger single-file components are often more maintainable
## Technical Stack Guidelines
@@ -26,6 +47,15 @@ Not every interaction requires code changes - you're happy to discuss architectu
- Use "use client" directive only when client-side interactivity is required
- Implement proper metadata API for SEO optimization
- Follow Next.js 15 caching strategies and revalidation patterns
+- Use STABLE versions of dependencies - avoid beta/alpha/experimental syntax:
+ - Tailwind CSS: Use v3 stable with standard @tailwind directives
+ - Avoid experimental features unless explicitly requested
+ - Ensure all syntax is compatible with production environments
+- When using external images with next/image component, ALWAYS configure the domain in next.config.mjs:
+ - Add image domains to `images.remotePatterns` with protocol, hostname, port, and pathname
+ - For placeholder images (via.placeholder.com, picsum.photos, etc.), configure them properly
+ - Use standard +
{projectDescription}
)} @@ -1242,10 +1679,15 @@ export default function ChatPage({ params }: Params) { {/* 채팅 로그 영역 */}