procler 0.2.0__py3-none-any.whl

procler/api/routes/logs.py

@@ -0,0 +1,43 @@
+"""Log retrieval API routes."""
+
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+
+from ...core import ProcessManager
+from ..deps import get_manager
+
+router = APIRouter()
+
+
+class LogsResponse(BaseModel):
+    """Response for log queries."""
+
+    success: bool
+    data: dict[str, Any] | None = None
+    error: str | None = None
+    error_code: str | None = None
+
+
+@router.get("/{name}")
+async def get_logs(
+    name: str,
+    tail: int = Query(default=100, ge=1, le=10000, description="Number of lines to return"),
+    since: str | None = Query(default=None, description="Time filter (e.g., '5m', '1h', ISO timestamp)"),
+    manager: ProcessManager = Depends(get_manager),
+) -> LogsResponse:
+    """
+    Get logs for a process.
+
+    Args:
+        name: Process name
+        tail: Number of lines to return (default: 100, max: 10000)
+        since: Time filter (e.g., '5m', '1h', ISO timestamp)
+    """
+    result = await manager.logs(name, tail=tail, since=since)
+
+    if not result["success"]:
+        raise HTTPException(status_code=404, detail=result)
+
+    return LogsResponse(**result)

procler/api/routes/processes.py

@@ -0,0 +1,185 @@
+"""Process management API routes."""
+
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from ...core import ProcessManager
+from ..deps import get_manager
+
+router = APIRouter()
+
+
+class ProcessDefineRequest(BaseModel):
+    """Request body for defining a process."""
+
+    name: str
+    command: str
+    context_type: str = "local"
+    container_name: str | None = None
+    cwd: str | None = None
+    display_name: str | None = None
+    tags: list[str] | None = None
+    force: bool = False
+
+
+class ProcessResponse(BaseModel):
+    """Standard response wrapper."""
+
+    success: bool
+    data: dict[str, Any] | None = None
+    error: str | None = None
+    error_code: str | None = None
+    suggestion: str | None = None
+
+
+@router.get("")
+async def list_processes(manager: ProcessManager = Depends(get_manager)) -> ProcessResponse:
+    """List all process definitions."""
+    result = await manager.status()
+    return ProcessResponse(**result)
+
+
+@router.get("/{name}")
+async def get_process(
+    name: str,
+    manager: ProcessManager = Depends(get_manager),
+) -> ProcessResponse:
+    """Get a specific process by name."""
+    result = await manager.status(name)
+    if not result["success"]:
+        raise HTTPException(status_code=404, detail=result)
+    return ProcessResponse(**result)
+
+
+@router.post("")
+async def create_process(
+    request: ProcessDefineRequest,
+    manager: ProcessManager = Depends(get_manager),
+) -> ProcessResponse:
+    """Create or update a process definition."""
+    from datetime import datetime
+
+    from sqler.query import SQLerField as F
+
+    from ...db import init_database
+    from ...models import Process
+
+    init_database()
+
+    # Check if context is docker and container is missing
+    if request.context_type == "docker" and not request.container_name:
+        return ProcessResponse(
+            success=False,
+            error="Container name required for docker context",
+            error_code="missing_container",
+            suggestion="Provide container_name for docker context",
+        )
+
+    # Check if process already exists
+    existing = Process.query().filter(F("name") == request.name).all()
+    if existing:
+        if not request.force:
+            return ProcessResponse(
+                success=False,
+                error=f"Process '{request.name}' already exists",
+                error_code="process_exists",
+                suggestion=f"Use force=true to overwrite, or DELETE /api/processes/{request.name} first",
+            )
+        # Force mode: delete existing and continue
+        existing[0].delete()
+
+    process = Process(
+        name=request.name,
+        command=request.command,
+        context_type=request.context_type,
+        container_name=request.container_name,
+        cwd=request.cwd,
+        display_name=request.display_name,
+        tags=request.tags,
+        created_at=datetime.now().isoformat(),
+        updated_at=datetime.now().isoformat(),
+    )
+    process.save()
+
+    return ProcessResponse(
+        success=True,
+        data={
+            "action": "created",
+            "process": {
+                "id": process._id,
+                "name": process.name,
+                "command": process.command,
+                "context_type": process.context_type,
+            },
+        },
+    )
+
+
+@router.delete("/{name}")
+async def delete_process(
+    name: str,
+    manager: ProcessManager = Depends(get_manager),
+) -> ProcessResponse:
+    """Remove a process definition."""
+    from sqler.query import SQLerField as F
+
+    from ...db import init_database
+    from ...models import Process
+
+    init_database()
+
+    results = Process.query().filter(F("name") == name).all()
+    if not results:
+        raise HTTPException(
+            status_code=404,
+            detail={
+                "success": False,
+                "error": f"Process '{name}' not found",
+                "error_code": "process_not_found",
+            },
+        )
+
+    results[0].delete()
+    return ProcessResponse(
+        success=True,
+        data={"action": "removed", "name": name},
+    )
+
+
+@router.post("/{name}/start")
+async def start_process(
+    name: str,
+    manager: ProcessManager = Depends(get_manager),
+) -> ProcessResponse:
+    """Start a process."""
+    result = await manager.start(name)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result)
+    return ProcessResponse(**result)
+
+
+@router.post("/{name}/stop")
+async def stop_process(
+    name: str,
+    manager: ProcessManager = Depends(get_manager),
+) -> ProcessResponse:
+    """Stop a process."""
+    result = await manager.stop(name)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result)
+    return ProcessResponse(**result)
+
+
+@router.post("/{name}/restart")
+async def restart_process(
+    name: str,
+    clear_logs: bool = False,
+    manager: ProcessManager = Depends(get_manager),
+) -> ProcessResponse:
+    """Restart a process. Use ?clear_logs=true to delete old logs."""
+    result = await manager.restart(name, clear_logs=clear_logs)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result)
+    return ProcessResponse(**result)

procler/api/routes/recipes.py

@@ -0,0 +1,69 @@
+"""Recipe management API routes."""
+
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from ...core.recipes import get_recipe_executor
+
+router = APIRouter()
+
+
+class RecipeResponse(BaseModel):
+    """Standard response wrapper."""
+
+    success: bool
+    data: dict[str, Any] | None = None
+    error: str | None = None
+    error_code: str | None = None
+    suggestion: str | None = None
+
+
+class RunRecipeRequest(BaseModel):
+    """Request body for running a recipe."""
+
+    dry_run: bool = False
+    continue_on_error: bool | None = None
+
+
+@router.get("")
+async def list_recipes() -> RecipeResponse:
+    """List all defined recipes."""
+    executor = get_recipe_executor()
+    result = executor.list_recipes()
+    return RecipeResponse(**result)
+
+
+@router.get("/{name}")
+async def get_recipe(name: str) -> RecipeResponse:
+    """Get a specific recipe with full details."""
+    executor = get_recipe_executor()
+    result = executor.get_recipe(name)
+    return RecipeResponse(**result)
+
+
+@router.post("/{name}/run")
+async def run_recipe(name: str, request: RunRecipeRequest | None = None) -> RecipeResponse:
+    """
+    Execute a recipe.
+
+    Pass dry_run=true to preview what would happen without executing.
+    Pass continue_on_error to override the recipe's default error handling.
+    """
+    executor = get_recipe_executor()
+    req = request or RunRecipeRequest()
+    result = await executor.run_recipe(
+        name=name,
+        dry_run=req.dry_run,
+        continue_on_error=req.continue_on_error,
+    )
+    return RecipeResponse(**result)
+
+
+@router.post("/{name}/dry-run")
+async def dry_run_recipe(name: str) -> RecipeResponse:
+    """Preview what a recipe would do without executing."""
+    executor = get_recipe_executor()
+    result = await executor.run_recipe(name=name, dry_run=True)
+    return RecipeResponse(**result)

procler/api/routes/snippets.py

@@ -0,0 +1,134 @@
+"""Snippet management API routes."""
+
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+
+from ...core import SnippetManager
+from ..deps import get_snippets
+
+router = APIRouter()
+
+
+class SnippetCreateRequest(BaseModel):
+    """Request body for creating a snippet."""
+
+    name: str
+    command: str
+    description: str | None = None
+    context_type: str = "local"
+    container_name: str | None = None
+    tags: list[str] | None = None
+
+
+class SnippetResponse(BaseModel):
+    """Standard response wrapper for snippets."""
+
+    success: bool
+    data: dict[str, Any] | None = None
+    error: str | None = None
+    error_code: str | None = None
+    suggestion: str | None = None
+
+
+@router.get("")
+async def list_snippets(
+    tag: str | None = Query(default=None, description="Filter by tag"),
+    manager: SnippetManager = Depends(get_snippets),
+) -> SnippetResponse:
+    """List all snippets, optionally filtered by tag."""
+    result = manager.list_snippets(tag=tag)
+    return SnippetResponse(**result)
+
+
+@router.post("")
+async def create_snippet(
+    request: SnippetCreateRequest,
+    manager: SnippetManager = Depends(get_snippets),
+) -> SnippetResponse:
+    """Create a new snippet."""
+    result = manager.save_snippet(
+        name=request.name,
+        command=request.command,
+        description=request.description,
+        context_type=request.context_type,
+        container_name=request.container_name,
+        tags=request.tags,
+    )
+
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result)
+
+    return SnippetResponse(**result)
+
+
+@router.get("/{name}")
+async def get_snippet(
+    name: str,
+    manager: SnippetManager = Depends(get_snippets),
+) -> SnippetResponse:
+    """Get a specific snippet by name."""
+    from sqler.query import SQLerField as F
+
+    from ...db import init_database
+    from ...models import Snippet
+
+    init_database()
+
+    results = Snippet.query().filter(F("name") == name).all()
+    if not results:
+        raise HTTPException(
+            status_code=404,
+            detail={
+                "success": False,
+                "error": f"Snippet '{name}' not found",
+                "error_code": "snippet_not_found",
+            },
+        )
+
+    snippet = results[0]
+    return SnippetResponse(
+        success=True,
+        data={
+            "snippet": {
+                "id": snippet._id,
+                "name": snippet.name,
+                "command": snippet.command,
+                "description": snippet.description,
+                "context_type": snippet.context_type,
+                "container_name": snippet.container_name,
+                "tags": snippet.tags or [],
+                "created_at": snippet.created_at,
+            }
+        },
+    )
+
+
+@router.delete("/{name}")
+async def delete_snippet(
+    name: str,
+    manager: SnippetManager = Depends(get_snippets),
+) -> SnippetResponse:
+    """Remove a snippet."""
+    result = manager.remove_snippet(name)
+
+    if not result["success"]:
+        raise HTTPException(status_code=404, detail=result)
+
+    return SnippetResponse(**result)
+
+
+@router.post("/{name}/run")
+async def run_snippet(
+    name: str,
+    manager: SnippetManager = Depends(get_snippets),
+) -> SnippetResponse:
+    """Run a snippet."""
+    result = await manager.run_snippet(name)
+
+    if not result["success"]:
+        status_code = 404 if result.get("error_code") == "snippet_not_found" else 400
+        raise HTTPException(status_code=status_code, detail=result)
+
+    return SnippetResponse(**result)