Upload 6 files

api/routes/__init__.py

@@ -0,0 +1 @@
+"""RUHI-CORE API Routes"""

api/routes/auth.py

@@ -0,0 +1,93 @@
+"""
+============================================
+RUHI-CORE - Auth Routes
+============================================
+"""
+
+from datetime import datetime, timedelta
+from fastapi import APIRouter, HTTPException, Request, Response
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from loguru import logger
+
+from core.auth import authenticate_admin, create_access_token, get_current_user, verify_token
+from core.config import settings
+
+router = APIRouter(prefix="/api/auth", tags=["Authentication"])
+
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+class LoginResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+    expires_in: int
+    username: str
+
+
+@router.post("/login", response_model=LoginResponse)
+async def login(credentials: LoginRequest, request: Request):
+    """Admin login endpoint"""
+    
+    client_ip = request.client.host
+    forwarded = request.headers.get("X-Forwarded-For")
+    if forwarded:
+        client_ip = forwarded.split(",")[0].strip()
+    
+    if not authenticate_admin(credentials.username, credentials.password):
+        logger.warning(f"🚫 Failed login attempt from {client_ip} with username: {credentials.username}")
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid username or password"
+        )
+    
+    # Create JWT token
+    token = create_access_token(
+        data={"sub": credentials.username, "ip": client_ip},
+        expires_delta=timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    )
+    
+    logger.info(f"✅ Admin login successful from {client_ip}")
+    
+    response = JSONResponse(content={
+        "access_token": token,
+        "token_type": "bearer",
+        "expires_in": settings.ACCESS_TOKEN_EXPIRE_MINUTES * 60,
+        "username": credentials.username
+    })
+    
+    # Set cookie too
+    response.set_cookie(
+        key="access_token",
+        value=token,
+        max_age=settings.ACCESS_TOKEN_EXPIRE_MINUTES * 60,
+        httponly=True,
+        samesite="lax"
+    )
+    
+    return response
+
+
+@router.post("/logout")
+async def logout(response: Response):
+    """Logout endpoint"""
+    response = JSONResponse(content={"message": "Logged out successfully"})
+    response.delete_cookie("access_token")
+    return response
+
+
+@router.get("/verify")
+async def verify(request: Request):
+    """Verify if current token is valid"""
+    try:
+        user = await get_current_user(request)
+        return {
+            "valid": True,
+            "username": user["username"],
+            "expires": user.get("exp")
+        }
+    except HTTPException:
+        return {"valid": False}

api/routes/files.py

@@ -0,0 +1,573 @@
+"""
+============================================
+🔥 RUHI-CORE - File Management API Routes
+============================================
+Complete REST API for file operations:
+- Browse directories
+- Read/Write/Edit files
+- Create/Delete/Rename
+- Search files
+- Upload/Download
+- ZIP deploy
+- Disk usage
+- Bulk operations
+"""
+
+import os
+from typing import Optional, List
+from fastapi import APIRouter, HTTPException, Depends, UploadFile, File, Form, Query, Request
+from fastapi.responses import FileResponse, StreamingResponse
+from pydantic import BaseModel
+from loguru import logger
+
+from core.auth import get_current_user
+from core.file_manager import file_manager
+from core.zip_deployer import zip_deployer
+from core.config import settings
+
+router = APIRouter(prefix="/api/files", tags=["File Manager"])
+
+
+# =========================================
+# Request Models
+# =========================================
+class WriteFileRequest(BaseModel):
+    path: str
+    content: str
+
+
+class CreateFileRequest(BaseModel):
+    path: str
+    content: str = ""
+    is_directory: bool = False
+
+
+class RenameRequest(BaseModel):
+    path: str
+    new_name: str
+
+
+class MoveRequest(BaseModel):
+    source: str
+    destination: str
+
+
+class CopyRequest(BaseModel):
+    source: str
+    destination: str
+
+
+class BulkDeleteRequest(BaseModel):
+    paths: List[str]
+
+
+class ChmodRequest(BaseModel):
+    path: str
+    permissions: str
+
+
+class DeployRequest(BaseModel):
+    deploy_id: str
+    extract_dir: str
+    service_name: str
+    language: str = "python"
+    entry_file: str = "main.py"
+    service_type: str = "web"
+    auto_start: bool = True
+    install_deps: bool = True
+    env_vars: dict = {}
+    command: str = ""
+    description: str = ""
+
+
+# =========================================
+# Directory Browsing
+# =========================================
+@router.get("/browse")
+async def browse_directory(
+    path: str = Query(default="", description="Relative path to browse"),
+    show_hidden: bool = Query(default=False, description="Show hidden files"),
+    user=Depends(get_current_user)
+):
+    """Browse a directory and list its contents"""
+    try:
+        result = await file_manager.list_directory(path, show_hidden)
+        return result
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+    except NotADirectoryError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+# =========================================
+# File Read/Write
+# =========================================
+@router.get("/read")
+async def read_file(
+    path: str = Query(description="File path to read"),
+    user=Depends(get_current_user)
+):
+    """Read a file's content for the code editor"""
+    try:
+        result = await file_manager.read_file(path)
+        return result
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except IsADirectoryError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+
+
+@router.post("/write")
+async def write_file(
+    req: WriteFileRequest,
+    user=Depends(get_current_user)
+):
+    """Write/save content to a file (Code Editor save)"""
+    try:
+        result = await file_manager.write_file(req.path, req.content)
+        return result
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+    except IOError as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# =========================================
+# Create File/Directory
+# =========================================
+@router.post("/create")
+async def create_file_or_dir(
+    req: CreateFileRequest,
+    user=Depends(get_current_user)
+):
+    """Create a new file or directory"""
+    try:
+        if req.is_directory:
+            result = await file_manager.create_directory(req.path)
+        else:
+            result = await file_manager.create_file(req.path, req.content)
+        return result
+    except FileExistsError as e:
+        raise HTTPException(status_code=409, detail=str(e))
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+
+
+# =========================================
+# Delete
+# =========================================
+@router.delete("/delete")
+async def delete_file_or_dir(
+    path: str = Query(description="Path to delete"),
+    user=Depends(get_current_user)
+):
+    """Delete a file or directory"""
+    try:
+        result = await file_manager.delete_path(path)
+        return result
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+
+
+@router.post("/bulk-delete")
+async def bulk_delete(
+    req: BulkDeleteRequest,
+    user=Depends(get_current_user)
+):
+    """Delete multiple files/directories"""
+    result = await file_manager.bulk_delete(req.paths)
+    return result
+
+
+# =========================================
+# Rename & Move & Copy
+# =========================================
+@router.post("/rename")
+async def rename_file_or_dir(
+    req: RenameRequest,
+    user=Depends(get_current_user)
+):
+    """Rename a file or directory"""
+    try:
+        result = await file_manager.rename_path(req.path, req.new_name)
+        return result
+    except (FileNotFoundError, FileExistsError, ValueError) as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/move")
+async def move_file_or_dir(
+    req: MoveRequest,
+    user=Depends(get_current_user)
+):
+    """Move a file or directory"""
+    try:
+        result = await file_manager.move_path(req.source, req.destination)
+        return result
+    except (FileNotFoundError, FileExistsError) as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/copy")
+async def copy_file_or_dir(
+    req: CopyRequest,
+    user=Depends(get_current_user)
+):
+    """Copy a file or directory"""
+    try:
+        result = await file_manager.copy_path(req.source, req.destination)
+        return result
+    except (FileNotFoundError, FileExistsError) as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+# =========================================
+# File Info & Search
+# =========================================
+@router.get("/info")
+async def get_file_info(
+    path: str = Query(description="File/directory path"),
+    user=Depends(get_current_user)
+):
+    """Get detailed file/directory information"""
+    try:
+        result = await file_manager.get_file_info(path)
+        return result
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.get("/search")
+async def search_files(
+    query: str = Query(description="Search query"),
+    path: str = Query(default="", description="Search within path"),
+    max_results: int = Query(default=100, ge=1, le=500),
+    user=Depends(get_current_user)
+):
+    """Search for files by name"""
+    try:
+        result = await file_manager.search_files(query, path, max_results)
+        return result
+    except NotADirectoryError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+# =========================================
+# Disk Usage
+# =========================================
+@router.get("/disk-usage")
+async def get_disk_usage(
+    path: str = Query(default="", description="Path to analyze"),
+    user=Depends(get_current_user)
+):
+    """Get detailed disk usage analysis"""
+    try:
+        result = await file_manager.get_disk_usage(path)
+        return result
+    except NotADirectoryError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+# =========================================
+# File Download
+# =========================================
+@router.get("/download")
+async def download_file(
+    path: str = Query(description="File path to download"),
+    user=Depends(get_current_user)
+):
+    """Download a file"""
+    try:
+        file_path, mime_type = await file_manager.download_file_path(path)
+        return FileResponse(
+            path=str(file_path),
+            filename=file_path.name,
+            media_type=mime_type
+        )
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except IsADirectoryError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+# =========================================
+# File Upload (Simple)
+# =========================================
+@router.post("/upload")
+async def upload_file(
+    file: UploadFile = File(...),
+    path: str = Form(default="uploads", description="Upload destination directory"),
+    user=Depends(get_current_user)
+):
+    """Upload a single file to a specified directory"""
+    try:
+        content = await file.read()
+        
+        # Check size
+        if len(content) > settings.MAX_UPLOAD_SIZE:
+            raise HTTPException(
+                status_code=413,
+                detail=f"File too large. Max: {settings.MAX_UPLOAD_SIZE / (1024*1024):.0f}MB"
+            )
+        
+        # Save file
+        dest_path = f"{path}/{file.filename}"
+        result = await file_manager.write_file(dest_path, "")
+        
+        # Write binary content
+        import aiofiles
+        full_path = file_manager._resolve_path(dest_path)
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        async with aiofiles.open(full_path, 'wb') as f:
+            await f.write(content)
+        
+        size = len(content)
+        
+        return {
+            "filename": file.filename,
+            "path": dest_path,
+            "size": size,
+            "size_formatted": file_manager._format_size(size),
+            "content_type": file.content_type,
+            "message": f"File '{file.filename}' uploaded successfully"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# =========================================
+# Multi-File Upload
+# =========================================
+@router.post("/upload-multiple")
+async def upload_multiple_files(
+    files: List[UploadFile] = File(...),
+    path: str = Form(default="uploads"),
+    user=Depends(get_current_user)
+):
+    """Upload multiple files"""
+    results = []
+    total_size = 0
+    
+    for file in files:
+        try:
+            content = await file.read()
+            dest_path = f"{path}/{file.filename}"
+            
+            full_path = file_manager._resolve_path(dest_path)
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            import aiofiles
+            async with aiofiles.open(full_path, 'wb') as f:
+                await f.write(content)
+            
+            size = len(content)
+            total_size += size
+            
+            results.append({
+                "filename": file.filename,
+                "path": dest_path,
+                "size": size,
+                "success": True
+            })
+        except Exception as e:
+            results.append({
+                "filename": file.filename,
+                "error": str(e),
+                "success": False
+            })
+    
+    return {
+        "total_files": len(files),
+        "successful": sum(1 for r in results if r['success']),
+        "failed": sum(1 for r in results if not r['success']),
+        "total_size": total_size,
+        "total_size_formatted": file_manager._format_size(total_size),
+        "results": results
+    }
+
+
+# =========================================
+# ZIP Deploy Routes
+# =========================================
+@router.post("/deploy/upload")
+async def deploy_upload_zip(
+    file: UploadFile = File(...),
+    service_name: str = Form(default=""),
+    auto_start: bool = Form(default=True),
+    user=Depends(get_current_user)
+):
+    """
+    🚀 Quick Deploy: Upload ZIP -> Auto-detect -> Deploy
+    One-click deployment!
+    """
+    try:
+        content = await file.read()
+        
+        # Check size
+        if len(content) > settings.MAX_UPLOAD_SIZE:
+            raise HTTPException(
+                status_code=413,
+                detail=f"File too large. Max: {settings.MAX_UPLOAD_SIZE / (1024*1024):.0f}MB"
+            )
+        
+        result = await zip_deployer.quick_deploy(
+            filename=file.filename,
+            content=content,
+            service_name=service_name or None,
+            auto_start=auto_start
+        )
+        
+        return result
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except RuntimeError as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/deploy/extract")
+async def deploy_extract(
+    file: UploadFile = File(...),
+    user=Depends(get_current_user)
+):
+    """
+    Step 1 of manual deploy: Upload and extract archive.
+    Returns file list and auto-detection results.
+    """
+    try:
+        content = await file.read()
+        
+        # Save
+        upload_info = await zip_deployer.save_upload(file.filename, content)
+        
+        # Extract
+        extract_info = await zip_deployer.extract_archive(
+            upload_info["path"],
+            upload_info["deploy_id"]
+        )
+        
+        # Auto-detect
+        detection = await zip_deployer.auto_detect(extract_info["extract_dir"])
+        
+        return {
+            "upload": upload_info,
+            "extraction": extract_info,
+            "detection": detection,
+            "message": "Archive extracted and analyzed. Ready to deploy."
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/deploy/confirm")
+async def deploy_confirm(
+    req: DeployRequest,
+    user=Depends(get_current_user)
+):
+    """
+    Step 2 of manual deploy: Confirm settings and deploy.
+    """
+    try:
+        result = await zip_deployer.deploy(
+            deploy_id=req.deploy_id,
+            extract_dir=req.extract_dir,
+            service_name=req.service_name,
+            language=req.language,
+            entry_file=req.entry_file,
+            service_type=req.service_type,
+            auto_start=req.auto_start,
+            install_deps=req.install_deps,
+            env_vars=req.env_vars,
+            command=req.command,
+            description=req.description
+        )
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/deploy/history")
+async def deployment_history(user=Depends(get_current_user)):
+    """Get deployment history"""
+    history = await zip_deployer.get_deployment_history()
+    return {"deployments": history}
+
+
+# =========================================
+# Permissions
+# =========================================
+@router.post("/chmod")
+async def change_permissions(
+    req: ChmodRequest,
+    user=Depends(get_current_user)
+):
+    """Change file/directory permissions"""
+    try:
+        result = await file_manager.chmod_path(req.path, req.permissions)
+        return result
+    except (FileNotFoundError, ValueError) as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+# =========================================
+# Tree View
+# =========================================
+@router.get("/tree")
+async def get_file_tree(
+    path: str = Query(default="", description="Root path"),
+    depth: int = Query(default=3, ge=1, le=5),
+    user=Depends(get_current_user)
+):
+    """Get a tree view of the directory structure"""
+    
+    def build_tree(dir_path, current_depth=0, max_depth=3):
+        if current_depth >= max_depth:
+            return []
+        
+        items = []
+        try:
+            entries = sorted(dir_path.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower()))
+            for entry in entries:
+                if entry.name.startswith('.') and entry.name not in ('.env', '.gitignore'):
+                    continue
+                
+                item = {
+                    "name": entry.name,
+                    "path": str(entry.relative_to(file_manager.base_path)),
+                    "is_dir": entry.is_dir(),
+                    "icon": "📁" if entry.is_dir() else file_manager._get_file_icon(entry.name),
+                }
+                
+                if entry.is_dir():
+                    item["children"] = build_tree(entry, current_depth + 1, max_depth)
+                else:
+                    try:
+                        item["size"] = file_manager._format_size(entry.stat().st_size)
+                    except OSError:
+                        item["size"] = "?"
+                
+                items.append(item)
+        except PermissionError:
+            pass
+        
+        return items
+    
+    root = file_manager._resolve_path(path)
+    if not root.is_dir():
+        raise HTTPException(status_code=400, detail="Not a directory")
+    
+    tree = build_tree(root, max_depth=depth)
+    
+    return {
+        "path": path or "/data",
+        "depth": depth,
+        "tree": tree
+    }

api/routes/metrics.py

@@ -0,0 +1,116 @@
+"""
+============================================
+RUHI-CORE - Metrics & Monitoring Routes
+============================================
+"""
+
+import os
+import shutil
+from fastapi import APIRouter, Depends, Query
+from loguru import logger
+
+from core.auth import get_current_user
+from core.metrics_collector import metrics_collector
+from core.process_manager import process_manager
+from core.websocket_handler import ws_manager
+from core.config import settings
+
+router = APIRouter(prefix="/api/metrics", tags=["Metrics"])
+
+
+@router.get("/current")
+async def get_current_metrics(user=Depends(get_current_user)):
+    """Get current system metrics snapshot"""
+    metrics = await metrics_collector.collect_all()
+    metrics["services"] = process_manager.get_stats()
+    metrics["websocket_connections"] = ws_manager.total_connections
+    return {"metrics": metrics}
+
+
+@router.get("/history")
+async def get_metrics_history(
+    minutes: int = Query(default=60, ge=1, le=1440),
+    user=Depends(get_current_user)
+):
+    """Get metrics history for charts"""
+    history = metrics_collector.get_history(minutes)
+    return {
+        "period_minutes": minutes,
+        "data_points": len(history),
+        "history": history
+    }
+
+
+@router.get("/summary")
+async def get_system_summary(user=Depends(get_current_user)):
+    """Get a complete system summary - perfect for dashboard overview"""
+    metrics = await metrics_collector.collect_all()
+    service_stats = process_manager.get_stats()
+    
+    # Storage breakdown
+    data_path = str(settings.DATA_DIR)
+    storage_breakdown = {}
+    for subdir in ["apps", "logs", "uploads", "backups", "db", "config"]:
+        dir_path = os.path.join(data_path, subdir)
+        if os.path.exists(dir_path):
+            total_size = 0
+            for dirpath, dirnames, filenames in os.walk(dir_path):
+                for f in filenames:
+                    fp = os.path.join(dirpath, f)
+                    try:
+                        total_size += os.path.getsize(fp)
+                    except OSError:
+                        pass
+            storage_breakdown[subdir] = round(total_size / (1024 * 1024), 2)
+    
+    return {
+        "system": {
+            "platform": metrics.get("platform"),
+            "hostname": metrics.get("hostname"),
+            "python_version": metrics.get("python_version"),
+            "uptime": metrics.get("ruhi_uptime_formatted"),
+        },
+        "cpu": {
+            "usage_percent": metrics.get("cpu_percent"),
+            "cores_logical": metrics.get("cpu_cores_logical"),
+            "cores_physical": metrics.get("cpu_cores_physical"),
+            "frequency_mhz": metrics.get("cpu_freq_current"),
+            "load_average": [
+                metrics.get("load_avg_1"),
+                metrics.get("load_avg_5"),
+                metrics.get("load_avg_15")
+            ]
+        },
+        "memory": {
+            "usage_percent": metrics.get("memory_percent"),
+            "used_mb": metrics.get("memory_used_mb"),
+            "total_mb": metrics.get("memory_total_mb"),
+            "available_mb": metrics.get("memory_available_mb"),
+        },
+        "disk": {
+            "data_usage_percent": metrics.get("disk_data_percent"),
+            "data_used_gb": metrics.get("disk_data_used_gb"),
+            "data_total_gb": metrics.get("disk_data_total_gb"),
+            "data_free_gb": metrics.get("disk_data_free_gb"),
+            "breakdown_mb": storage_breakdown
+        },
+        "network": {
+            "sent_rate_kbps": metrics.get("net_sent_rate_kbps"),
+            "recv_rate_kbps": metrics.get("net_recv_rate_kbps"),
+            "total_sent_mb": round(metrics.get("net_bytes_sent_total", 0) / (1024*1024), 1),
+            "total_recv_mb": round(metrics.get("net_bytes_recv_total", 0) / (1024*1024), 1),
+            "active_connections": metrics.get("net_active_connections"),
+        },
+        "services": service_stats,
+        "processes": {
+            "total": metrics.get("total_processes"),
+            "running": metrics.get("running_processes"),
+            "sleeping": metrics.get("sleeping_processes"),
+            "zombie": metrics.get("zombie_processes"),
+            "top": metrics.get("top_processes", [])[:5]
+        },
+        "websockets": {
+            "total_connections": ws_manager.total_connections,
+            "dashboard_connections": len(ws_manager.dashboard_connections),
+        }
+    }

api/routes/services.py

@@ -0,0 +1,205 @@
+"""
+============================================
+RUHI-CORE - Service Management Routes
+============================================
+"""
+
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Depends, Request
+from pydantic import BaseModel
+from loguru import logger
+
+from core.auth import get_current_user
+from core.process_manager import process_manager
+from core.port_manager import port_manager
+
+router = APIRouter(prefix="/api/services", tags=["Services"])
+
+
+class CreateServiceRequest(BaseModel):
+    name: str
+    type: str = "web"  # web, worker, bot, cron
+    language: str = "python"  # python, node, shell
+    entry_file: str = "main.py"
+    command: Optional[str] = ""
+    auto_restart: bool = True
+    env_vars: dict = {}
+    description: str = ""
+    max_memory_mb: int = 512
+    port: Optional[int] = None
+
+
+class UpdateServiceRequest(BaseModel):
+    name: Optional[str] = None
+    entry_file: Optional[str] = None
+    command: Optional[str] = None
+    auto_restart: Optional[bool] = None
+    env_vars: Optional[dict] = None
+    description: Optional[str] = None
+    max_memory_mb: Optional[int] = None
+
+
+@router.get("/")
+async def list_services(user=Depends(get_current_user)):
+    """List all services"""
+    return {
+        "services": process_manager.get_all_services(),
+        "stats": process_manager.get_stats()
+    }
+
+
+@router.post("/")
+async def create_service(req: CreateServiceRequest, user=Depends(get_current_user)):
+    """Create a new service"""
+    try:
+        service = await process_manager.create_service(
+            name=req.name,
+            type=req.type,
+            language=req.language,
+            entry_file=req.entry_file,
+            command=req.command,
+            auto_restart=req.auto_restart,
+            env_vars=req.env_vars,
+            description=req.description,
+            max_memory_mb=req.max_memory_mb,
+            port=req.port
+        )
+        return {
+            "message": f"Service '{req.name}' created successfully",
+            "service": service.get_info()
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/{service_id}")
+async def get_service(service_id: str, user=Depends(get_current_user)):
+    """Get service details"""
+    service = process_manager.get_service(service_id)
+    if not service:
+        raise HTTPException(status_code=404, detail="Service not found")
+    return {"service": service.get_info()}
+
+
+@router.delete("/{service_id}")
+async def delete_service(service_id: str, user=Depends(get_current_user)):
+    """Delete a service"""
+    try:
+        await process_manager.delete_service(service_id)
+        return {"message": "Service deleted successfully"}
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.post("/{service_id}/start")
+async def start_service(service_id: str, user=Depends(get_current_user)):
+    """Start a service"""
+    try:
+        success = await process_manager.start_service(service_id)
+        service = process_manager.get_service(service_id)
+        return {
+            "message": f"Service start {'successful' if success else 'failed'}",
+            "success": success,
+            "service": service.get_info() if service else None
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.post("/{service_id}/stop")
+async def stop_service(service_id: str, user=Depends(get_current_user)):
+    """Stop a service"""
+    try:
+        success = await process_manager.stop_service(service_id)
+        service = process_manager.get_service(service_id)
+        return {
+            "message": f"Service stop {'successful' if success else 'failed'}",
+            "success": success,
+            "service": service.get_info() if service else None
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.post("/{service_id}/restart")
+async def restart_service(service_id: str, user=Depends(get_current_user)):
+    """Restart a service"""
+    try:
+        success = await process_manager.restart_service(service_id)
+        service = process_manager.get_service(service_id)
+        return {
+            "message": f"Service restart {'successful' if success else 'failed'}",
+            "success": success,
+            "service": service.get_info() if service else None
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.get("/{service_id}/logs")
+async def get_service_logs(
+    service_id: str, 
+    lines: int = 100,
+    user=Depends(get_current_user)
+):
+    """Get recent logs for a service"""
+    service = process_manager.get_service(service_id)
+    if not service:
+        raise HTTPException(status_code=404, detail="Service not found")
+    
+    logs = list(service.log_buffer)[-lines:]
+    return {
+        "service_id": service_id,
+        "service_name": service.name,
+        "total_lines": len(service.log_buffer),
+        "returned_lines": len(logs),
+        "logs": logs
+    }
+
+
+@router.put("/{service_id}")
+async def update_service(
+    service_id: str,
+    req: UpdateServiceRequest,
+    user=Depends(get_current_user)
+):
+    """Update service configuration"""
+    service = process_manager.get_service(service_id)
+    if not service:
+        raise HTTPException(status_code=404, detail="Service not found")
+    
+    if req.name is not None:
+        service.name = req.name
+    if req.entry_file is not None:
+        service.entry_file = req.entry_file
+    if req.command is not None:
+        service.command = req.command
+    if req.auto_restart is not None:
+        service.auto_restart = req.auto_restart
+    if req.env_vars is not None:
+        service.env_vars = req.env_vars
+    if req.description is not None:
+        service.description = req.description
+    if req.max_memory_mb is not None:
+        service.max_memory_mb = req.max_memory_mb
+    
+    await service._save_to_db()
+    
+    return {
+        "message": "Service updated successfully",
+        "service": service.get_info()
+    }
+
+
+@router.post("/start-all")
+async def start_all_services(user=Depends(get_current_user)):
+    """Start all services"""
+    await process_manager.start_all()
+    return {"message": "All services starting..."}
+
+
+@router.post("/stop-all")
+async def stop_all_services(user=Depends(get_current_user)):
+    """Stop all services"""
+    await process_manager.stop_all()
+    return {"message": "All services stopped"}

api/routes/terminal.py

@@ -0,0 +1,140 @@
+"""
+============================================
+RUHI-CORE - Terminal Emulator Route
+============================================
+"""
+
+import os
+import asyncio
+import subprocess
+from fastapi import APIRouter, Depends, WebSocket, WebSocketDisconnect, Query
+from loguru import logger
+
+from core.auth import get_current_user, verify_token
+from core.config import settings
+
+router = APIRouter(prefix="/api/terminal", tags=["Terminal"])
+
+
+@router.post("/execute")
+async def execute_command(
+    command: dict,
+    user=Depends(get_current_user)
+):
+    """Execute a shell command and return output"""
+    cmd = command.get("command", "").strip()
+    cwd = command.get("cwd", str(settings.DATA_DIR))
+    
+    if not cmd:
+        return {"error": "No command provided"}
+    
+    # Block dangerous commands
+    dangerous = ["rm -rf /", "mkfs", "dd if=", ":(){", "fork bomb", "shutdown", "reboot", "halt", "poweroff"]
+    for d in dangerous:
+        if d in cmd.lower():
+            return {"error": f"Dangerous command blocked: {cmd}"}
+    
+    try:
+        result = await asyncio.get_event_loop().run_in_executor(
+            None,
+            lambda: subprocess.run(
+                cmd,
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                cwd=cwd,
+                env={**os.environ, "TERM": "xterm-256color"}
+            )
+        )
+        
+        return {
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "return_code": result.returncode,
+            "command": cmd,
+            "cwd": cwd
+        }
+    except subprocess.TimeoutExpired:
+        return {"error": "Command timed out (30s limit)", "command": cmd}
+    except Exception as e:
+        return {"error": str(e), "command": cmd}
+
+
+@router.websocket("/ws")
+async def terminal_websocket(websocket: WebSocket, token: str = Query(default="")):
+    """Interactive terminal via WebSocket"""
+    
+    # Verify authentication
+    try:
+        verify_token(token)
+    except Exception:
+        await websocket.close(code=4001, reason="Unauthorized")
+        return
+    
+    await websocket.accept()
+    logger.info("🖥️ Terminal WebSocket connected")
+    
+    try:
+        while True:
+            data = await websocket.receive_text()
+            
+            try:
+                import json
+                cmd_data = json.loads(data)
+                cmd = cmd_data.get("command", "")
+                cwd = cmd_data.get("cwd", str(settings.DATA_DIR))
+            except json.JSONDecodeError:
+                cmd = data
+                cwd = str(settings.DATA_DIR)
+            
+            if not cmd.strip():
+                continue
+            
+            # Block dangerous commands
+            dangerous = ["rm -rf /", "mkfs", "dd if=", ":(){", "shutdown", "reboot"]
+            blocked = False
+            for d in dangerous:
+                if d in cmd.lower():
+                    await websocket.send_text(json.dumps({
+                        "type": "error",
+                        "message": f"⛔ Blocked: {cmd}"
+                    }))
+                    blocked = True
+                    break
+            
+            if blocked:
+                continue
+            
+            try:
+                result = await asyncio.get_event_loop().run_in_executor(
+                    None,
+                    lambda: subprocess.run(
+                        cmd, shell=True, capture_output=True,
+                        text=True, timeout=30, cwd=cwd
+                    )
+                )
+                
+                import json as json_mod
+                await websocket.send_text(json_mod.dumps({
+                    "type": "output",
+                    "stdout": result.stdout,
+                    "stderr": result.stderr,
+                    "return_code": result.returncode,
+                    "cwd": cwd
+                }))
+            except subprocess.TimeoutExpired:
+                await websocket.send_text(json.dumps({
+                    "type": "error",
+                    "message": "Command timed out (30s)"
+                }))
+            except Exception as e:
+                await websocket.send_text(json.dumps({
+                    "type": "error",
+                    "message": str(e)
+                }))
+                
+    except WebSocketDisconnect:
+        logger.info("🖥️ Terminal WebSocket disconnected")
+    except Exception as e:
+        logger.error(f"Terminal WebSocket error: {str(e)}")