logtap 0.2.0__py3-none-any.whl

logtap/__init__.py

@@ -0,0 +1,8 @@
+"""
+logtap - A CLI-first log access tool for Unix systems.
+
+Remote log file access without SSH. No database. No complex setup.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Kyle Cain"

logtap/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running logtap as a module: python -m logtap"""
+
+from logtap.cli.main import app
+
+if __name__ == "__main__":
+    app()

logtap/api/__init__.py

@@ -0,0 +1,5 @@
+"""FastAPI server for logtap."""
+
+from logtap.api.app import create_app
+
+__all__ = ["create_app"]

logtap/api/app.py

@@ -0,0 +1,45 @@
+"""FastAPI application factory for logtap."""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from logtap import __version__
+from logtap.api.routes import files, health, logs, parsed
+
+
+def create_app() -> FastAPI:
+    """
+    Create and configure the FastAPI application.
+
+    Returns:
+        Configured FastAPI application instance.
+    """
+    app = FastAPI(
+        title="logtap",
+        description="A CLI-first log access tool for Unix systems.",
+        version=__version__,
+        docs_url="/docs",
+        redoc_url="/redoc",
+        openapi_url="/openapi.json",
+    )
+
+    # Configure CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Include routers
+    app.include_router(health.router, tags=["health"])
+    app.include_router(logs.router, prefix="/logs", tags=["logs"])
+    app.include_router(files.router, prefix="/files", tags=["files"])
+    app.include_router(parsed.router, prefix="/parsed", tags=["parsed"])
+
+    return app
+
+
+# Create default app instance for uvicorn
+app = create_app()

logtap/api/dependencies.py

@@ -0,0 +1,61 @@
+"""FastAPI dependencies for logtap."""
+
+import secrets
+from functools import lru_cache
+from typing import Optional
+
+from fastapi import Header, HTTPException, status
+
+from logtap.models.config import Settings
+
+
+@lru_cache()
+def get_settings() -> Settings:
+    """
+    Get cached application settings.
+
+    Returns:
+        Application settings instance.
+    """
+    return Settings()
+
+
+async def verify_api_key(
+    x_api_key: Optional[str] = Header(default=None, alias="X-API-Key"),
+) -> Optional[str]:
+    """
+    Verify the API key if authentication is enabled.
+
+    If LOGTAP_API_KEY is not set, authentication is disabled and all requests are allowed.
+    If LOGTAP_API_KEY is set, requests must include a matching X-API-Key header.
+
+    Args:
+        x_api_key: The API key from the request header.
+
+    Returns:
+        The validated API key, or None if authentication is disabled.
+
+    Raises:
+        HTTPException: If authentication is enabled and the key is invalid.
+    """
+    settings = get_settings()
+
+    # If no API key is configured, skip authentication
+    if not settings.api_key:
+        return None
+
+    # API key is required but not provided
+    if not x_api_key:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="API key required. Set X-API-Key header.",
+        )
+
+    # Use timing-safe comparison to prevent timing attacks
+    if not secrets.compare_digest(x_api_key, settings.api_key):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key.",
+        )
+
+    return x_api_key

logtap/api/routes/__init__.py

@@ -0,0 +1 @@
+"""API routes for logtap."""

logtap/api/routes/files.py

@@ -0,0 +1,38 @@
+"""File listing endpoint for logtap."""
+
+import os
+from typing import Optional
+
+from fastapi import APIRouter, Depends
+
+from logtap.api.dependencies import get_settings, verify_api_key
+from logtap.models.config import Settings
+from logtap.models.responses import FileListResponse
+
+router = APIRouter()
+
+
+@router.get("", response_model=FileListResponse)
+async def list_files(
+    settings: Settings = Depends(get_settings),
+    _api_key: Optional[str] = Depends(verify_api_key),
+) -> FileListResponse:
+    """
+    List available log files in the configured log directory.
+
+    Returns:
+        List of log file names and the directory path.
+    """
+    log_dir = settings.get_log_directory()
+
+    # Get list of files (not directories)
+    try:
+        files = [
+            f for f in os.listdir(log_dir)
+            if os.path.isfile(os.path.join(log_dir, f))
+        ]
+        files.sort()
+    except OSError:
+        files = []
+
+    return FileListResponse(files=files, directory=log_dir)

logtap/api/routes/health.py

@@ -0,0 +1,19 @@
+"""Health check endpoint for logtap."""
+
+from fastapi import APIRouter
+
+from logtap import __version__
+from logtap.models.responses import HealthResponse
+
+router = APIRouter()
+
+
+@router.get("/health", response_model=HealthResponse)
+async def health_check() -> HealthResponse:
+    """
+    Check the health of the logtap service.
+
+    Returns:
+        Health status and version information.
+    """
+    return HealthResponse(status="healthy", version=__version__)

logtap/api/routes/logs.py

@@ -0,0 +1,249 @@
+"""Log query endpoints for logtap."""
+
+import asyncio
+import os
+from typing import Optional
+
+import aiofiles
+from fastapi import APIRouter, Depends, HTTPException, Query, WebSocket, WebSocketDisconnect, status
+from starlette.responses import StreamingResponse
+
+from logtap.api.dependencies import get_settings, verify_api_key
+from logtap.core.reader import tail_async
+from logtap.core.search import filter_lines
+from logtap.core.validation import is_filename_valid, is_limit_valid, is_search_term_valid
+from logtap.models.config import Settings
+from logtap.models.responses import LogResponse
+
+router = APIRouter()
+
+
+# Error messages (matching original for backward compatibility)
+ERROR_INVALID_FILENAME = 'Invalid filename: must not contain ".." or start with "/"'
+ERROR_LONG_SEARCH_TERM = "Search term is too long: must be 100 characters or fewer"
+ERROR_INVALID_LIMIT = "Invalid limit value: must be between 1 and 1000"
+
+
+def validate_filename(filename: str) -> None:
+    """Validate filename and raise HTTPException if invalid."""
+    if not is_filename_valid(filename):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=ERROR_INVALID_FILENAME,
+        )
+    # Block any filename with path separators
+    if "/" in filename or "\\" in filename:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=ERROR_INVALID_FILENAME,
+        )
+
+
+def get_filepath(filename: str, settings: Settings) -> str:
+    """Get full filepath and validate it exists."""
+    log_dir = settings.get_log_directory()
+    filepath = os.path.join(log_dir, filename)
+    if not os.path.isfile(filepath):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"File not found: {filepath} does not exist",
+        )
+    return filepath
+
+
+@router.get("", response_model=LogResponse)
+async def get_logs(
+    filename: str = Query(default="syslog", description="Name of the log file to read"),
+    term: str = Query(default="", description="Substring to search for in log lines"),
+    regex: Optional[str] = Query(default=None, description="Regex pattern to match log lines"),
+    limit: int = Query(default=50, ge=1, le=1000, description="Number of lines to return (1-1000)"),
+    case_sensitive: bool = Query(default=True, description="Whether search is case-sensitive"),
+    settings: Settings = Depends(get_settings),
+    _api_key: Optional[str] = Depends(verify_api_key),
+) -> LogResponse:
+    """
+    Retrieve log entries from a specified log file.
+
+    This endpoint reads the last N lines from a log file and optionally
+    filters them by a search term or regex pattern.
+    """
+    validate_filename(filename)
+
+    if term and not is_search_term_valid(term):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=ERROR_LONG_SEARCH_TERM,
+        )
+
+    if not is_limit_valid(limit):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=ERROR_INVALID_LIMIT,
+        )
+
+    filepath = get_filepath(filename, settings)
+    lines = await tail_async(filepath, limit)
+
+    if regex:
+        lines = filter_lines(lines, regex=regex, case_sensitive=case_sensitive)
+    elif term:
+        lines = filter_lines(lines, term=term, case_sensitive=case_sensitive)
+
+    return LogResponse(lines=lines, count=len(lines), filename=filename)
+
+
+@router.get("/multi")
+async def get_logs_multi(
+    filenames: str = Query(..., description="Comma-separated list of log file names"),
+    term: str = Query(default="", description="Substring to search for"),
+    regex: Optional[str] = Query(default=None, description="Regex pattern to match"),
+    limit: int = Query(default=50, ge=1, le=1000, description="Lines per file"),
+    case_sensitive: bool = Query(default=True, description="Case-sensitive search"),
+    settings: Settings = Depends(get_settings),
+    _api_key: Optional[str] = Depends(verify_api_key),
+) -> dict:
+    """
+    Query multiple log files simultaneously.
+
+    Returns results grouped by filename.
+    """
+    file_list = [f.strip() for f in filenames.split(",") if f.strip()]
+
+    if not file_list:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="No filenames provided",
+        )
+
+    if len(file_list) > 10:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Maximum 10 files per request",
+        )
+
+    results = {}
+    log_dir = settings.get_log_directory()
+
+    for filename in file_list:
+        try:
+            validate_filename(filename)
+            filepath = os.path.join(log_dir, filename)
+
+            if not os.path.isfile(filepath):
+                results[filename] = {"error": "File not found", "lines": []}
+                continue
+
+            lines = await tail_async(filepath, limit)
+
+            if regex:
+                lines = filter_lines(lines, regex=regex, case_sensitive=case_sensitive)
+            elif term:
+                lines = filter_lines(lines, term=term, case_sensitive=case_sensitive)
+
+            results[filename] = {"lines": lines, "count": len(lines)}
+
+        except HTTPException as e:
+            results[filename] = {"error": e.detail, "lines": []}
+
+    return {"results": results, "files_queried": len(file_list)}
+
+
+@router.websocket("/stream")
+async def stream_logs(
+    websocket: WebSocket,
+    filename: str = Query(default="syslog"),
+):
+    """
+    Stream log file changes in real-time via WebSocket.
+
+    Connect to this endpoint to receive new log lines as they are written.
+    Similar to `tail -f`.
+    """
+    await websocket.accept()
+
+    # Get settings (can't use Depends in WebSocket easily)
+    settings = get_settings()
+
+    try:
+        validate_filename(filename)
+    except HTTPException as e:
+        await websocket.send_json({"error": e.detail})
+        await websocket.close()
+        return
+
+    log_dir = settings.get_log_directory()
+    filepath = os.path.join(log_dir, filename)
+
+    if not os.path.isfile(filepath):
+        await websocket.send_json({"error": f"File not found: {filename}"})
+        await websocket.close()
+        return
+
+    try:
+        async with aiofiles.open(filepath, mode="r", encoding="utf-8") as f:
+            # Seek to end of file
+            await f.seek(0, 2)
+
+            while True:
+                line = await f.readline()
+                if line:
+                    await websocket.send_text(line.rstrip("\n"))
+                else:
+                    # No new content, wait a bit
+                    await asyncio.sleep(0.1)
+
+                # Check if client is still connected
+                try:
+                    # Non-blocking receive to check connection
+                    await asyncio.wait_for(websocket.receive_text(), timeout=0.01)
+                except asyncio.TimeoutError:
+                    # No message, continue streaming
+                    pass
+
+    except WebSocketDisconnect:
+        pass
+    except Exception as e:
+        try:
+            await websocket.send_json({"error": str(e)})
+        except Exception:
+            # Connection already closed, ignore
+            pass
+
+
+@router.get("/sse")
+async def stream_logs_sse(
+    filename: str = Query(default="syslog", description="Log file to stream"),
+    settings: Settings = Depends(get_settings),
+    _api_key: Optional[str] = Depends(verify_api_key),
+):
+    """
+    Stream log file changes via Server-Sent Events (SSE).
+
+    Alternative to WebSocket for simpler clients.
+    """
+    validate_filename(filename)
+    filepath = get_filepath(filename, settings)
+
+    async def event_generator():
+        async with aiofiles.open(filepath, mode="r", encoding="utf-8") as f:
+            # Seek to end
+            await f.seek(0, 2)
+
+            while True:
+                line = await f.readline()
+                if line:
+                    # SSE format: data: <content>\n\n
+                    yield f"data: {line.rstrip()}\n\n"
+                else:
+                    # Send heartbeat to keep connection alive
+                    yield ": heartbeat\n\n"
+                    await asyncio.sleep(1)
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+        },
+    )

logtap/api/routes/parsed.py

@@ -0,0 +1,102 @@
+"""Parsed log endpoints for logtap - with format detection and severity filtering."""
+
+import os
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+
+from logtap.api.dependencies import get_settings, verify_api_key
+from logtap.core.parsers import AutoParser, LogLevel
+from logtap.core.reader import tail_async
+from logtap.core.search import filter_entries
+from logtap.models.config import Settings
+
+router = APIRouter()
+
+
+@router.get("")
+async def get_parsed_logs(
+    filename: str = Query(default="syslog", description="Name of the log file to read"),
+    term: str = Query(default="", description="Substring to search for"),
+    regex: Optional[str] = Query(default=None, description="Regex pattern to match"),
+    limit: int = Query(default=50, ge=1, le=1000, description="Number of lines"),
+    level: Optional[str] = Query(
+        default=None,
+        description="Minimum severity level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+    ),
+    levels: Optional[str] = Query(
+        default=None,
+        description="Comma-separated list of specific levels to include",
+    ),
+    case_sensitive: bool = Query(default=True),
+    settings: Settings = Depends(get_settings),
+    _api_key: Optional[str] = Depends(verify_api_key),
+) -> dict:
+    """
+    Retrieve and parse log entries with format auto-detection.
+
+    Returns structured log data with extracted fields like timestamp,
+    severity level, source, and message. Supports filtering by severity.
+
+    Supported formats: syslog, JSON, nginx, apache (auto-detected).
+    """
+    # Validate filename
+    if ".." in filename or filename.startswith("/") or "/" in filename or "\\" in filename:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail='Invalid filename: must not contain ".." or start with "/"',
+        )
+
+    # Build file path
+    log_dir = settings.get_log_directory()
+    filepath = os.path.join(log_dir, filename)
+
+    if not os.path.isfile(filepath):
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"File not found: {filepath} does not exist",
+        )
+
+    # Read file lines
+    lines = await tail_async(filepath, limit)
+
+    # Parse lines
+    parser = AutoParser()
+    entries = parser.parse_many(lines)
+
+    # Parse level filter
+    min_level = None
+    if level:
+        min_level = LogLevel.from_string(level)
+        if not min_level:
+            valid = "DEBUG, INFO, NOTICE, WARNING, ERROR, CRITICAL, ALERT, EMERGENCY"
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Invalid level: {level}. Valid levels: {valid}",
+            )
+
+    # Parse levels filter
+    level_list = None
+    if levels:
+        level_list = []
+        for lvl in levels.split(","):
+            parsed = LogLevel.from_string(lvl.strip())
+            if parsed:
+                level_list.append(parsed)
+
+    # Apply filters
+    filtered = filter_entries(
+        entries,
+        term=term if term else None,
+        regex=regex,
+        min_level=min_level,
+        levels=level_list,
+        case_sensitive=case_sensitive,
+    )
+
+    return {
+        "entries": [e.to_dict() for e in filtered],
+        "count": len(filtered),
+        "filename": filename,
+        "format": parser.name,
+    }

logtap/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI commands for logtap."""

logtap/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands for logtap."""

logtap/cli/commands/files.py

@@ -0,0 +1,86 @@
+"""Files command for logtap CLI - list available log files."""
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def files(
+    server: str = typer.Option(
+        "http://localhost:8000",
+        "--server",
+        "-s",
+        help="URL of the logtap server.",
+        envvar="LOGTAP_SERVER",
+    ),
+    api_key: Optional[str] = typer.Option(
+        None,
+        "--api-key",
+        "-k",
+        help="API key for authentication.",
+        envvar="LOGTAP_API_KEY",
+    ),
+    output: str = typer.Option(
+        "pretty",
+        "--output",
+        "-o",
+        help="Output format: pretty, json, plain.",
+    ),
+) -> None:
+    """
+    List available log files on the server.
+
+    Example:
+        logtap files
+        logtap files --server http://myserver:8000
+    """
+    import httpx
+
+    headers = {}
+    if api_key:
+        headers["X-API-Key"] = api_key
+
+    try:
+        with httpx.Client(timeout=30.0) as client:
+            response = client.get(f"{server}/files", headers=headers)
+
+        if response.status_code != 200:
+            error_detail = response.json().get("detail", response.text)
+            console.print(f"[bold red]Error:[/bold red] {error_detail}")
+            raise typer.Exit(1)
+
+        data = response.json()
+        files_list = data.get("files", [])
+        directory = data.get("directory", "")
+
+        # Format output
+        if output == "json":
+            console.print_json(data=data)
+        elif output == "plain":
+            for f in files_list:
+                console.print(f)
+        else:
+            # Pretty output with table
+            if files_list:
+                table = Table(title=f"Log files in {directory}")
+                table.add_column("Filename", style="cyan")
+
+                for f in files_list:
+                    table.add_row(f)
+
+                console.print(table)
+                console.print(f"\n[dim]{len(files_list)} files found[/dim]")
+            else:
+                console.print(f"[dim]No log files found in {directory}[/dim]")
+
+    except httpx.ConnectError:
+        console.print(f"[bold red]Error:[/bold red] Could not connect to {server}")
+        console.print("[dim]Is the logtap server running? Start it with 'logtap serve'[/dim]")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        raise typer.Exit(1)