detecti-cli 2.0.0__py3-none-any.whl

detecti/web/process_manager.py

@@ -0,0 +1,283 @@
+"""Background process management for DetecTI-CLI web server."""
+
+import json
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Dict, Optional
+
+try:
+    import psutil
+    PSUTIL_AVAILABLE = True
+except ImportError:
+    psutil = None
+    PSUTIL_AVAILABLE = False
+
+from detecti.config import DETECTI_HOME
+
+
+class WebServerManager:
+    """Manages background web server process lifecycle."""
+    
+    def __init__(self, state_file: Path = DETECTI_HOME / "run" / ".webserver.json"):
+        self.state_file = state_file
+        self.state_file.parent.mkdir(parents=True, exist_ok=True)
+    
+    def is_running(self) -> bool:
+        """Check if web server is currently running."""
+        if not PSUTIL_AVAILABLE:
+            # Fallback to basic PID check
+            if not self.state_file.exists():
+                return False
+            try:
+                state = self._read_state()
+                pid = state.get("pid")
+                if not pid:
+                    return False
+                # Basic check if PID exists (Unix/Linux only)
+                try:
+                    os.kill(pid, 0)
+                    return True
+                except (OSError, ProcessLookupError):
+                    return False
+            except (json.JSONDecodeError, ValueError):
+                return False
+            
+        if not self.state_file.exists():
+            return False
+        
+        try:
+            state = self._read_state()
+            pid = state.get("pid")
+            if not pid:
+                return False
+            
+            # Check if process exists and is running
+            return psutil.pid_exists(pid) and psutil.Process(pid).is_running()
+        except (json.JSONDecodeError, psutil.NoSuchProcess, psutil.AccessDenied):
+            return False
+    
+    def get_status(self) -> Optional[Dict]:
+        """Get current server status information."""
+        if not self.state_file.exists():
+            return None
+        
+        try:
+            state = self._read_state()
+            pid = state.get("pid")
+            
+            if not pid:
+                return None
+            
+            # Check if process is running
+            is_running = False
+            if PSUTIL_AVAILABLE:
+                try:
+                    if psutil.pid_exists(pid):
+                        process = psutil.Process(pid)
+                        if process.is_running():
+                            is_running = True
+                            # Calculate uptime
+                            start_time = state.get("started_at")
+                            if start_time:
+                                from datetime import datetime
+                                started = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+                                uptime = datetime.now().astimezone() - started
+                                state["uptime_seconds"] = uptime.total_seconds()
+                            
+                            state["status"] = "RUNNING"
+                            state["memory_mb"] = process.memory_info().rss / 1024 / 1024
+                            return state
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    pass
+            else:
+                # Fallback check
+                try:
+                    os.kill(pid, 0)
+                    is_running = True
+                    state["status"] = "RUNNING"
+                    # Calculate uptime
+                    start_time = state.get("started_at")
+                    if start_time:
+                        from datetime import datetime
+                        started = datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+                        uptime = datetime.now().astimezone() - started
+                        state["uptime_seconds"] = uptime.total_seconds()
+                    return state
+                except (OSError, ProcessLookupError):
+                    pass
+            
+            if not is_running:
+                # Process not running, clean up state file
+                self._cleanup_state()
+                return None
+            
+        except (json.JSONDecodeError, ValueError):
+            self._cleanup_state()
+            return None
+        
+        return None
+    
+    def start_server(self, db_path: Optional[str] = None, host: str = "127.0.0.1", port: int = 8000) -> bool:
+        """Start web server in background process."""
+        # Check if user wants to override host/port via .webserver.json
+        if self.state_file.exists():
+            try:
+                import json
+                state = json.loads(self.state_file.read_text(encoding="utf-8"))
+                if not self.is_running():
+                    if "host" in state and host == "127.0.0.1":
+                        host = state["host"]
+                    if "port" in state and port == 8000:
+                        port = state["port"]
+            except Exception:
+                pass
+                
+        if self.is_running():
+            return False  # Already running
+        
+        resolved_db_path = None
+        if db_path:
+            # Resolve database path
+            if not os.path.isabs(db_path):
+                # Check if it's in ./data/dbs/ directory
+                data_db_path = DETECTI_HOME / "data" / "dbs" / db_path
+                if data_db_path.exists():
+                    resolved_db_path = str(data_db_path.resolve())
+                else:
+                    # Try with .sqlite extension if not present
+                    if not db_path.endswith('.sqlite'):
+                        data_db_path_with_ext = DETECTI_HOME / "data" / "dbs" / f"{db_path}.sqlite"
+                        if data_db_path_with_ext.exists():
+                            resolved_db_path = str(data_db_path_with_ext.resolve())
+                        else:
+                            # Try removing underscores and using dots (example_com -> example.com)
+                            normalized_name = db_path.replace('_', '.')
+                            data_db_normalized = DETECTI_HOME / "data" / "dbs" / f"{normalized_name}.sqlite"
+                            if data_db_normalized.exists():
+                                resolved_db_path = str(data_db_normalized.resolve())
+                            else:
+                                resolved_db_path = str(Path(db_path).resolve())
+                    else:
+                        resolved_db_path = str(Path(db_path).resolve())
+            else:
+                resolved_db_path = str(Path(db_path).resolve())
+            
+            if not Path(resolved_db_path).exists():
+                raise FileNotFoundError(f"Database file not found: {db_path}")
+        
+        # Start server process
+        cmd = [
+            sys.executable, "-m", "web.server",
+            "--host", host,
+            "--port", str(port)
+        ]
+        if resolved_db_path:
+            cmd.extend(["--db-path", resolved_db_path])
+        
+        try:
+            # Start detached background process
+            process = subprocess.Popen(
+                cmd,
+                start_new_session=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                cwd=str(Path(__file__).resolve().parent.parent)
+            )
+            
+            # Give process time to start
+            time.sleep(2)
+            
+            # Verify it's still running
+            if process.poll() is None:
+                # Save state
+                from datetime import datetime
+                state = {
+                    "pid": process.pid,
+                    "port": port,
+                    "host": host,
+                    "db_path": resolved_db_path or "No DB pre-loaded (Select from UI)",
+                    "started_at": datetime.now().isoformat() + "Z",
+                    "status": "RUNNING"
+                }
+                self._write_state(state)
+                return True
+            else:
+                return False
+                
+        except Exception:
+            return False
+    
+    def stop_server(self) -> bool:
+        """Stop the background web server."""
+        if not self.is_running():
+            return False
+        
+        try:
+            state = self._read_state()
+            pid = state.get("pid")
+            
+            if not pid:
+                return False
+            
+            if PSUTIL_AVAILABLE:
+                try:
+                    if psutil.pid_exists(pid):
+                        process = psutil.Process(pid)
+                        
+                        # Send SIGTERM for graceful shutdown
+                        process.terminate()
+                        
+                        # Wait up to 10 seconds for graceful shutdown
+                        try:
+                            process.wait(timeout=10)
+                        except psutil.TimeoutExpired:
+                            # Force kill if still running
+                            process.kill()
+                            process.wait(timeout=5)
+                        
+                        self._cleanup_state()
+                        return True
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    self._cleanup_state()
+                    return True
+            else:
+                # Fallback: send SIGTERM signal
+                try:
+                    os.kill(pid, signal.SIGTERM)
+                    time.sleep(2)  # Give it time to shutdown
+                    # Check if still running
+                    try:
+                        os.kill(pid, 0)
+                        # Still running, force kill
+                        os.kill(pid, signal.SIGKILL)
+                    except (OSError, ProcessLookupError):
+                        pass  # Process already terminated
+                    
+                    self._cleanup_state()
+                    return True
+                except (OSError, ProcessLookupError):
+                    self._cleanup_state()
+                    return True
+            
+        except (json.JSONDecodeError, ValueError):
+            self._cleanup_state()
+            return True
+        
+        return False
+    
+    def _read_state(self) -> Dict:
+        """Read state from JSON file."""
+        return json.loads(self.state_file.read_text())
+    
+    def _write_state(self, state: Dict) -> None:
+        """Write state to JSON file."""
+        self.state_file.write_text(json.dumps(state, indent=2))
+    
+    def _cleanup_state(self) -> None:
+        """Remove state file."""
+        if self.state_file.exists():
+            self.state_file.unlink()

detecti/web/server.py

@@ -0,0 +1,183 @@
+"""FastAPI web server for DetecTI-CLI EASM dashboard."""
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Dict
+
+# Add project root to Python path for imports
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+try:
+    import uvicorn
+    from fastapi import FastAPI, HTTPException, Request
+    from fastapi.staticfiles import StaticFiles
+    from fastapi.responses import FileResponse
+    from fastapi.middleware.cors import CORSMiddleware
+    FASTAPI_AVAILABLE = True
+except ImportError:
+    FASTAPI_AVAILABLE = False
+    # Create dummy classes for type hints
+    class FastAPI:
+        pass
+    class HTTPException(Exception):
+        pass
+
+from detecti.core.database.storage import DatabaseManager
+from detecti.web.api.routes import router as api_router
+from detecti.web.api.auth import router as auth_router, get_current_user
+from jose import jwt, JWTError
+from detecti.web.api.auth import SECRET_KEY, ALGORITHM, get_config_db
+
+
+def create_app(db_path: str = None) -> FastAPI:
+    """Create FastAPI application with optional database connection."""
+    if not FASTAPI_AVAILABLE:
+        raise ImportError("FastAPI and uvicorn are required for web server functionality. Install with: pip install fastapi uvicorn")
+    
+    from fastapi import FastAPI
+    app = FastAPI(
+        title="DetecTI-CLI EASM Dashboard",
+        description="Interactive External Attack Surface Management Dashboard",
+        version="2.0.0"
+    )
+    
+    # Add CORS middleware
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    
+    # Load DETECTI_HOME for global path resolution
+    try:
+        from config import DETECTI_HOME
+    except ImportError:
+        DETECTI_HOME = Path.home() / ".detecti"
+
+    # Check if db_path was provided or auto-discover from data/dbs/
+    resolved_db_path = None
+    if db_path:
+        p = Path(db_path)
+        if not p.is_absolute():
+            candidate = DETECTI_HOME / "data" / "dbs" / db_path
+            if candidate.exists():
+                p = candidate
+            elif not db_path.endswith(".sqlite"):
+                cand_ext = DETECTI_HOME / "data" / "dbs" / f"{db_path}.sqlite"
+                if cand_ext.exists():
+                    p = cand_ext
+        if p.exists():
+            resolved_db_path = str(p.resolve())
+    
+    if not resolved_db_path:
+        # Auto-discover databases in data/dbs/ - Prioritize example.com.sqlite as default if present
+        dbs_dir = DETECTI_HOME / "data" / "dbs"
+        if dbs_dir.exists():
+            example_db = dbs_dir / "example.com.sqlite"
+            if example_db.exists():
+                resolved_db_path = str(example_db.resolve())
+            else:
+                existing_dbs = sorted(list(dbs_dir.glob("*.sqlite")), key=lambda x: x.stat().st_mtime, reverse=True)
+                if existing_dbs:
+                    resolved_db_path = str(existing_dbs[0].resolve())
+    
+    # Store database manager in app state
+    if resolved_db_path and Path(resolved_db_path).exists():
+        app.state.db_manager = DatabaseManager(Path(resolved_db_path))
+        app.state.db_path = resolved_db_path
+    else:
+        app.state.db_manager = None
+        app.state.db_path = None
+    
+    # Include API routes
+    from fastapi import Depends
+    app.include_router(auth_router, prefix="/api/v1/auth")
+    app.include_router(api_router, prefix="/api/v1", dependencies=[Depends(get_current_user)])
+    
+    # Serve static files
+    static_dir = Path(__file__).parent / "static"
+    if static_dir.exists():
+        app.mount("/static", StaticFiles(directory=static_dir), name="static")
+    
+    @app.get("/")
+    async def serve_dashboard(request: Request):
+        """Serve the main dashboard SPA or login page."""
+        static_dir = Path(__file__).parent / "static"
+        
+        # Check authentication
+        token = request.cookies.get("detecti_token")
+        authenticated = False
+        if token:
+            try:
+                payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+                username = payload.get("sub")
+                if username:
+                    config_db = get_config_db()
+                    if config_db.user_exists(username):
+                        authenticated = True
+            except JWTError:
+                pass
+                
+        if not authenticated:
+            login_file = static_dir / "login.html"
+            if login_file.exists():
+                return FileResponse(login_file)
+            else:
+                return {"message": "Login required but login.html not found"}
+                
+        index_file = static_dir / "index.html"
+        if index_file.exists():
+            return FileResponse(index_file)
+        else:
+            return {"message": "DetecTI-CLI EASM Dashboard", "status": "Dashboard files not found"}
+    
+    @app.get("/health")
+    async def health_check():
+        """Health check endpoint."""
+        return {
+            "status": "healthy",
+            "database": app.state.db_path,
+            "version": "2.0.0"
+        }
+    
+    return app
+
+
+def main():
+    """Main entry point for web server."""
+    if not FASTAPI_AVAILABLE:
+        print("FastAPI and uvicorn are required for web server functionality.", file=sys.stderr)
+        print("Install with: pip install fastapi uvicorn", file=sys.stderr)
+        sys.exit(1)
+    
+    parser = argparse.ArgumentParser(description="DetecTI-CLI Web Server")
+    parser.add_argument("--db-path", default=None, help="Path to SQLite database (optional)")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind to")
+    
+    args = parser.parse_args()
+    
+    try:
+        app = create_app(args.db_path)
+        
+        # Run server
+        import uvicorn
+        uvicorn.run(
+            app,
+            host=args.host,
+            port=args.port,
+            log_level="warning",  # Reduce log noise
+            access_log=False
+        )
+
+    except Exception as e:
+        print(f"Failed to start server: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

detecti/web/static/css/__init__.py

@@ -0,0 +1 @@
+# Static CSS files for DetecTI-CLI dashboard