devops-copilot 0.1.0__py3-none-any.whl

app/modules/servers/models.py

@@ -0,0 +1,30 @@
+from sqlmodel import SQLModel, Field
+from typing import Optional
+
+class Server(SQLModel, table=True):
+    """
+    SQLModel representation of the target managed servers.
+    Stores SSH access configurations with encrypted credentials.
+    """
+    id: Optional[int] = Field(default=None, primary_key=True)
+    
+    # User-friendly identifier (e.g. "staging-vps")
+    name: str = Field(index=True, unique=True, nullable=False)
+    
+    # Target machine host/IP address
+    ip_address: str = Field(nullable=False)
+    
+    # Port target machine is listening to SSH (usually 22)
+    ssh_port: int = Field(default=22)
+    
+    # Username for SSH login (e.g. "root" or "deploy")
+    ssh_username: str = Field(default="root")
+    
+    # Either "password" or "key" (SSH private key authorization)
+    ssh_auth_type: str = Field(default="password")
+    
+    # AES-encrypted password string or private key string
+    encrypted_credential: str = Field(nullable=False)
+    
+    # Owner relation to user table
+    owner_id: int = Field(foreign_key="user.id", nullable=False)

app/modules/servers/router.py

@@ -0,0 +1,67 @@
+from fastapi import APIRouter, Depends, status
+from typing import List
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database import get_session
+from app.modules.auth import User
+from app.modules.auth.service import get_current_user
+from app.modules.servers.schema import ServerCreate, ServerUpdate, ServerResponse, CommandRequest, CommandResponse
+from app.modules.servers.service import servers_service
+
+router = APIRouter()
+
+@router.post("/", response_model=ServerResponse, status_code=status.HTTP_201_CREATED)
+async def create_server(
+    server_in: ServerCreate,
+    current_user: User = Depends(get_current_user),
+    session: AsyncSession = Depends(get_session)
+):
+    """Register a new server connection under the logged-in administrator."""
+    return await servers_service.create_server(session, server_in, current_user.id)
+
+@router.get("/", response_model=List[ServerResponse])
+async def list_servers(
+    current_user: User = Depends(get_current_user),
+    session: AsyncSession = Depends(get_session)
+):
+    """Retrieve all managed servers registered to the current administrator."""
+    return await servers_service.get_all_servers(session, current_user.id)
+
+@router.get("/{server_id}", response_model=ServerResponse)
+async def get_server(
+    server_id: int,
+    current_user: User = Depends(get_current_user),
+    session: AsyncSession = Depends(get_session)
+):
+    """Retrieve specific server credentials configuration metadata."""
+    return await servers_service.get_server_by_id(session, server_id, current_user.id)
+
+@router.put("/{server_id}", response_model=ServerResponse)
+async def update_server(
+    server_id: int,
+    server_in: ServerUpdate,
+    current_user: User = Depends(get_current_user),
+    session: AsyncSession = Depends(get_session)
+):
+    """Update registry configuration metadata for a managed server."""
+    return await servers_service.update_server(session, server_id, server_in, current_user.id)
+
+@router.delete("/{server_id}")
+async def delete_server(
+    server_id: int,
+    current_user: User = Depends(get_current_user),
+    session: AsyncSession = Depends(get_session)
+):
+    """Delete a managed server registry."""
+    return await servers_service.delete_server(session, server_id, current_user.id)
+
+@router.post("/{server_id}/execute", response_model=CommandResponse)
+async def execute_command(
+    server_id: int,
+    payload: CommandRequest,
+    current_user: User = Depends(get_current_user),
+    session: AsyncSession = Depends(get_session)
+):
+    """Execute arbitrary terminal commands asynchronously on target server via secure SSH connection."""
+    server = await servers_service.get_server_by_id(session, server_id, current_user.id)
+    return await servers_service.execute_ssh_command(server, payload.command)

app/modules/servers/schema.py

@@ -0,0 +1,45 @@
+from pydantic import BaseModel, Field
+from typing import Literal
+
+class ServerCreate(BaseModel):
+    """DTO for creating a new managed server connection."""
+    name: str = Field(..., min_length=3, max_length=50)
+    ip_address: str = Field(...)
+    ssh_port: int = Field(default=22, ge=1, le=65535)
+    ssh_username: str = Field(default="root")
+    ssh_auth_type: Literal["password", "key"] = Field(default="password")
+    
+    # Raw password or private key string. Will be encrypted before database storage.
+    credential: str = Field(..., min_length=1)
+
+class ServerUpdate(BaseModel):
+    """DTO for updating an existing managed server connection."""
+    name: str | None = Field(None, min_length=3, max_length=50)
+    ip_address: str | None = None
+    ssh_port: int | None = Field(None, ge=1, le=65535)
+    ssh_username: str | None = None
+    ssh_auth_type: Literal["password", "key"] | None = None
+    credential: str | None = None
+
+class ServerResponse(BaseModel):
+    """Safe database projection returning public server parameters (excludes credentials)."""
+    id: int
+    name: str
+    ip_address: str
+    ssh_port: int
+    ssh_username: str
+    ssh_auth_type: str
+    owner_id: int
+
+    class Config:
+        from_attributes = True
+
+class CommandRequest(BaseModel):
+    """Input payload to execute custom commands on target server."""
+    command: str = Field(..., min_length=1)
+
+class CommandResponse(BaseModel):
+    """Response returned after running SSH commands."""
+    stdout: str
+    stderr: str
+    exit_code: int

app/modules/servers/service.py

@@ -0,0 +1,164 @@
+import asyncio
+import asyncssh
+from typing import List, Optional
+from fastapi import HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import select
+
+from app.core.security import encrypt_data, decrypt_data
+from app.modules.servers.models import Server
+from app.modules.servers.schema import ServerCreate, ServerUpdate
+
+class ServersService:
+    async def create_server(self, session: AsyncSession, server_in: ServerCreate, owner_id: int) -> Server:
+        """Create a server registry after encrypting credentials."""
+        # Ensure server name is unique
+        statement = select(Server).where(Server.name == server_in.name)
+        result = await session.exec(statement)
+        if result.first():
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Server name already registered"
+            )
+
+        # Encrypt password or private key before saving to DB
+        encrypted_cred = encrypt_data(server_in.credential)
+
+        # Instantiate Server DB record
+        new_server = Server(
+            name=server_in.name,
+            ip_address=server_in.ip_address,
+            ssh_port=server_in.ssh_port,
+            ssh_username=server_in.ssh_username,
+            ssh_auth_type=server_in.ssh_auth_type,
+            encrypted_credential=encrypted_cred,
+            owner_id=owner_id
+        )
+
+        session.add(new_server)
+        await session.commit()
+        await session.refresh(new_server)
+        return new_server
+
+    async def get_all_servers(self, session: AsyncSession, owner_id: int) -> List[Server]:
+        """Fetch all servers owned by the user."""
+        statement = select(Server).where(Server.owner_id == owner_id)
+        result = await session.exec(statement)
+        return result.all()
+
+    async def get_server_by_id(self, session: AsyncSession, server_id: int, owner_id: int) -> Optional[Server]:
+        """Fetch a specific server by ID and verify ownership."""
+        statement = select(Server).where(Server.id == server_id, Server.owner_id == owner_id)
+        result = await session.exec(statement)
+        server = result.first()
+        if not server:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Server not found"
+            )
+        return server
+
+    async def get_server_by_name(self, session: AsyncSession, name: str, owner_id: int) -> Optional[Server]:
+        """Fetch a specific server by name and verify ownership."""
+        statement = select(Server).where(Server.name == name, Server.owner_id == owner_id)
+        result = await session.exec(statement)
+        server = result.first()
+        if not server:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Server not found"
+            )
+        return server
+
+    async def update_server(self, session: AsyncSession, server_id: int, server_in: ServerUpdate, owner_id: int) -> Server:
+        """Update an existing server registry configuration."""
+        server = await self.get_server_by_id(session, server_id, owner_id)
+        
+        if server_in.name is not None and server_in.name != server.name:
+            # Ensure name is unique if changed
+            statement = select(Server).where(Server.name == server_in.name)
+            result = await session.exec(statement)
+            if result.first():
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail="Server name already registered"
+                )
+            server.name = server_in.name
+
+        if server_in.ip_address is not None:
+            server.ip_address = server_in.ip_address
+        if server_in.ssh_port is not None:
+            server.ssh_port = server_in.ssh_port
+        if server_in.ssh_username is not None:
+            server.ssh_username = server_in.ssh_username
+        if server_in.ssh_auth_type is not None:
+            server.ssh_auth_type = server_in.ssh_auth_type
+        if server_in.credential is not None:
+            server.encrypted_credential = encrypt_data(server_in.credential)
+
+        session.add(server)
+        await session.commit()
+        await session.refresh(server)
+        return server
+
+    async def delete_server(self, session: AsyncSession, server_id: int, owner_id: int) -> dict:
+        """Delete an existing server registry."""
+        server = await self.get_server_by_id(session, server_id, owner_id)
+        await session.delete(server)
+        await session.commit()
+        return {"status": "success", "message": f"Server {server_id} deleted successfully"}
+
+    async def execute_ssh_command(self, server: Server, command: str) -> dict:
+        """
+        Decrypt server connection credentials, establish SSH tunnel,
+        execute bash command, and return outputs.
+        """
+        # Decrypt password or SSH Private Key
+        credential = decrypt_data(server.encrypted_credential)
+
+        # Build connection arguments
+        conn_args = {
+            "host": server.ip_address,
+            "port": server.ssh_port,
+            "username": server.ssh_username,
+            "known_hosts": None, # Bypass host key verification for dynamic servers (warning: MITM vulnerable)
+        }
+
+        if server.ssh_auth_type == "password":
+            conn_args["password"] = credential
+        else:
+            try:
+                # Import private key object from decrypted PEM string
+                key = asyncssh.import_private_key(credential)
+                conn_args["client_keys"] = [key]
+            except Exception as e:
+                raise HTTPException(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    detail=f"Invalid SSH private key format: {str(e)}"
+                )
+
+        try:
+            # Connect and execute command using asyncssh with 30s timeout
+            async def run_command_with_ssh():
+                async with asyncssh.connect(**conn_args) as conn:
+                    result = await conn.run(command, check=False)
+                    return {
+                        "stdout": result.stdout,
+                        "stderr": result.stderr,
+                        "exit_code": result.exit_status
+                    }
+            
+            return await asyncio.wait_for(run_command_with_ssh(), timeout=30.0)
+        except asyncio.TimeoutError:
+            raise HTTPException(
+                status_code=status.HTTP_504_GATEWAY_TIMEOUT,
+                detail=f"SSH execution timed out after 30 seconds on {server.ip_address}"
+            )
+        except (asyncssh.Error, OSError) as e:
+            raise HTTPException(
+                status_code=status.HTTP_502_BAD_GATEWAY,
+                detail=f"SSH Connection Failed to {server.ip_address}:{server.ssh_port} - {str(e)}"
+            )
+
+# Single instance representing the service provider
+servers_service = ServersService()

devops_copilot-0.1.0.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: devops-copilot
+Version: 0.1.0
+Summary: An AI-driven DevOps Copilot and CLI Client for managing bare-metal servers securely
+Author: irzix
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: websockets>=12.0
+Provides-Extra: server
+Requires-Dist: fastapi>=0.111.0; extra == "server"
+Requires-Dist: uvicorn>=0.30.0; extra == "server"
+Requires-Dist: sqlmodel>=0.0.22; extra == "server"
+Requires-Dist: pyjwt>=2.8.0; extra == "server"
+Requires-Dist: aiosqlite>=0.20.0; extra == "server"
+Requires-Dist: cryptography>=42.0.0; extra == "server"
+Requires-Dist: langchain>=0.2.0; extra == "server"
+Requires-Dist: chromadb>=0.5.0; extra == "server"
+Requires-Dist: pydantic-settings>=2.2.0; extra == "server"
+Requires-Dist: bcrypt>=4.1.0; extra == "server"
+Requires-Dist: python-multipart>=0.0.9; extra == "server"
+Requires-Dist: greenlet>=3.0.0; extra == "server"
+Requires-Dist: langchain-openai>=0.1.0; extra == "server"
+Requires-Dist: asyncssh>=2.14.0; extra == "server"
+
+# DevOps-Copilot 🚀
+
+An open-source, AI-driven DevOps Copilot and CLI Client designed to manage raw root/bare-metal servers securely. It features persistent credential encryption, real-time terminal streaming, and semantic security guardrails using a local vector database.
+
+---
+
+## Key Features
+- **Lean RAG Knowledge Base:** Automatically chunks and indexes executed SSH command outputs, logs, and server configs into separate **ChromaDB** collections, enabling the agent to search past server history before executing new commands.
+- **Semantic Guardrails:** Uses local vector search to intercept and block dangerous terminal commands.
+- **Human-in-the-Loop (HITL):** Enforces admin approval (`[y/N]`) inside the terminal for any state-modifying actions with clean prompt synchronization.
+- **CLI Connection Resilience:** Automatically reconnects to the WebSocket server using exponential backoff if the network drops or the server restarts.
+- **Real-Time Streaming:** Streams LLM thoughts and active SSH `stdout`/`stderr` line-by-line using WebSockets with 30s execution timeouts.
+- **Encrypted Credentials:** Securely encrypts passwords and SSH private keys using Fernet (AES-256).
+- **Server & Session CRUD:** Full REST API support for updating/deleting server connections and deleting chat sessions (with cascade cleanup).
+- **Flexible AI Models:** Powered by **OpenRouter** (supports Llama 3, Gemini, GPT, etc.).
+
+---
+
+## 📦 Quick Start (Backend Server)
+
+### 1. Configure Settings
+Copy the env file and populate keys:
+```bash
+cp .env.example .env
+```
+Make sure to add your `OPENROUTER_API_KEY` and a custom base64 `ENCRYPTION_KEY` in `.env`.
+
+### 2. Run with Docker Compose
+```bash
+docker compose up -d --build
+```
+The server will boot on port `8000`. Database tables and security blacklist vectors are automatically seeded on startup.
+
+---
+
+## 💻 Quick Start (CLI Client)
+
+### 1. Install Globally
+Install the package in editable mode from your local repository root:
+```bash
+uv pip install -e .
+```
+
+### 2. Authenticate
+Configure the server URL and log in to get your JWT access token:
+```bash
+devops-copilot login
+```
+
+### 3. Interactive Chat
+Start the real-time DevOps chat session:
+```bash
+devops-copilot chat
+```
+*Ask the agent to check stats or run actions. Approve state-modifying commands directly in the prompt.*

devops_copilot-0.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+app/__init__.py,sha256=prAfDw-CuIvjA35TsMKTzgRHKOsvlHYhpthqzg7gtQc,45
+app/main.py,sha256=oHGIJKeGghwCJU5xMkU0OetTcFrcC7CM3xjuLl_ns9g,1078
+app/cli/__init__.py,sha256=2dEVPQKy6c3qcm1D2j981g3B9KxXamfwQpTfF_X309Q,49
+app/cli/config.py,sha256=SIoNL7v-TicY7dFgekSgjgNNufOv8upAXbGoOKPgcOo,1483
+app/cli/main.py,sha256=ybZ4-b5_16tzQZ0ljNsY8He4hNKSlzWh51Q10_fsmYA,11196
+app/core/config.py,sha256=XEx9PG49BLVAC7NPhD58aTOb9pHnmiYeJ0Nuv0Cc1ag,708
+app/core/security.py,sha256=l3jLCc7UujYQwInghM1d_VS8R8jjlPsyhtAvAdebytc,595
+app/core/database/__init__.py,sha256=SUnd9pdtT2JFDb2AiQ13LW-z00A_B1aNWolmFAvyZs0,790
+app/modules/__init__.py,sha256=NmdHNlZ_Beg05caUEHllKj1TIIlXdoMMVLmZ74hr4KQ,45
+app/modules/auth/__init__.py,sha256=J4mhJsBHQRhZpEvORz2opYAACOQcyhnUNzVlu5kYhOA,336
+app/modules/auth/router.py,sha256=mBbmYjuhGkpzOgVy9vt39rtuMwRLKLC8X3U2AWFihm4,3341
+app/modules/auth/schema.py,sha256=iPE2hzj5yNM4v_4rC0i8oUC3W09wOs5o_cL3_FDHYbE,980
+app/modules/auth/service.py,sha256=hPE_CRKzBXchAhWKO7kvEkrCYKk3_eMpvtDIANFs7dQ,2797
+app/modules/chat/__init__.py,sha256=e5afKCCktlS6c0PHDejf7XTt-A5ifO3ziU34h4JoO68,46
+app/modules/chat/agent.py,sha256=Xx9lX77dZmvYf2nkQWvLWl8tUknemCY04Zr4AIA5ons,18406
+app/modules/chat/models.py,sha256=6g9d82vnNtYVnc1JiLgqPUGNlrEkCKTkoC-0biR4VkM,1827
+app/modules/chat/router.py,sha256=ioky2_ffORQoOX7y5OaO6Poht--S-kEkQZcnWvmoHx8,16241
+app/modules/chat/schema.py,sha256=vl6sSCp4F3GxLMIcHV2vtrKT9Oldw6qJ1S3_AEvx-gg,962
+app/modules/guardrails/__init__.py,sha256=E_i6gXiXTvsyZSwvplJsAii06Tw8MHQLTPrPfcx4CL0,45
+app/modules/guardrails/schema.py,sha256=q4xQJ9v0XXceclvcQujneawBnh14tFJuRBZPFeVZ09Q,775
+app/modules/guardrails/service.py,sha256=s2gwHlA5weOdyVEZoCB2oxOQIv-Pvm0Np5TvCCE9b7k,4692
+app/modules/knowledge/__init__.py,sha256=rydpZI76T8AnuAULTQOsMfcYu0BKNZ0D3RciBEmvU-c,51
+app/modules/knowledge/service.py,sha256=Ut73BOVxVz5nE1iZ2iAUuI8slNLpDtnwOsIa0VBhxmQ,3794
+app/modules/servers/__init__.py,sha256=z20A6YQjS8e3q7nD7eQTk3ziImlH8Rv8eJoXup0ZV-0,27
+app/modules/servers/models.py,sha256=fxdq6y4lS_232pxkZ6QjH7A6PsgnXdav8pfOhk3PQc0,1061
+app/modules/servers/router.py,sha256=OOqTM4d1c2xuyjgd65OeY4eaEOWmvMzswGu8uXAe3aQ,2787
+app/modules/servers/schema.py,sha256=YC2iut3_QgyyCAsYgwPGUfIBA7FM-RpkEr_HcSagStE,1532
+app/modules/servers/service.py,sha256=vmTiJQSSmOUrfdIi20YllKNCHsj9r2GlzFhDmFFjIYY,6992
+devops_copilot-0.1.0.dist-info/METADATA,sha256=qsbmYxYIUcQXLA5OBhTqIUn_tYuubcxyT7wtMnB1QXE,3410
+devops_copilot-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+devops_copilot-0.1.0.dist-info/entry_points.txt,sha256=pJGQfofbOaBpIy2QK7-u4fGLVT3rS6bteGs4SeSaT-U,52
+devops_copilot-0.1.0.dist-info/top_level.txt,sha256=io9g7LCbfmTG1SFKgEOGXmCFB9uMP2H5lerm0HiHWQE,4
+devops_copilot-0.1.0.dist-info/RECORD,,

devops_copilot-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

devops_copilot-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devops-copilot = app.cli.main:app

devops_copilot-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+app