kryten-api-gate 0.2.0__py3-none-any.whl

kryten_api_gate/__init__.py

@@ -0,0 +1,8 @@
+"""kryten-api-gate: HTTP REST gateway for the Kryten ecosystem."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("kryten-api-gate")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

kryten_api_gate/__main__.py

@@ -0,0 +1,126 @@
+"""Entry point for kryten-api-gate service."""
+
+import argparse
+import asyncio
+import logging
+import signal
+import sys
+
+import uvicorn
+from kryten import KrytenClient
+
+from .app import create_app
+from .config import load_config
+
+logger = logging.getLogger("kryten_api_gate")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Kryten API Gate — HTTP REST gateway")
+    parser.add_argument(
+        "--config",
+        type=str,
+        default=None,
+        help="Path to config JSON file",
+    )
+    parser.add_argument(
+        "--log-level",
+        type=str,
+        default=None,
+        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
+        help="Log level override",
+    )
+    return parser.parse_args()
+
+
+def setup_logging(level: str) -> None:
+    logging.basicConfig(
+        level=getattr(logging, level.upper()),
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+
+async def main_async() -> None:
+    args = parse_args()
+    config = load_config(args.config)
+
+    log_level = args.log_level or config.log_level
+    setup_logging(log_level)
+
+    logger.info("Starting kryten-api-gate v0.1.0")
+    logger.info(f"Channel: {config.channel} @ {config.domain}")
+    logger.info(f"NATS: {config.nats_url}")
+    logger.info(f"HTTP: {config.http_host}:{config.http_port}")
+
+    # Create KrytenClient
+    client_config = {
+        "nats": {"servers": [config.nats_url]},
+        "channels": [{"domain": config.domain, "channel": config.channel}],
+        "service": {
+            "name": config.service_name,
+            "version": "0.1.0",
+            "enable_lifecycle": True,
+            "enable_heartbeat": True,
+            "enable_discovery": True,
+        },
+    }
+    client = KrytenClient(client_config)
+
+    # Connect to NATS
+    await client.connect()
+    logger.info("Connected to NATS")
+
+    # Create FastAPI app and inject state
+    app = create_app()
+    app.state.client = client
+    app.state.config = config
+
+    # Setup shutdown event
+    shutdown_event = asyncio.Event()
+
+    def _signal_handler() -> None:
+        logger.info("Shutdown signal received")
+        shutdown_event.set()
+
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, _signal_handler)
+        except NotImplementedError:
+            # Windows doesn't support add_signal_handler
+            signal.signal(sig, lambda s, f: _signal_handler())
+
+    # Run uvicorn
+    uv_config = uvicorn.Config(
+        app,
+        host=config.http_host,
+        port=config.http_port,
+        log_level=log_level.lower(),
+        access_log=log_level.upper() == "DEBUG",
+    )
+    server = uvicorn.Server(uv_config)
+
+    # Run server with shutdown monitoring
+    server_task = asyncio.create_task(server.serve())
+
+    await shutdown_event.wait()
+
+    # Graceful shutdown
+    logger.info("Shutting down...")
+    server.should_exit = True
+    await server_task
+    await client.disconnect("API gate shutting down")
+    logger.info("Shutdown complete")
+
+
+def main() -> None:
+    try:
+        asyncio.run(main_async())
+    except KeyboardInterrupt:
+        pass
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

kryten_api_gate/app.py

@@ -0,0 +1,47 @@
+"""FastAPI application factory for kryten-api-gate."""
+
+from fastapi import FastAPI
+
+from . import __version__
+from .routes import (
+    admin,
+    chat,
+    emotes,
+    filters,
+    kv,
+    library,
+    moderation,
+    playback,
+    playlist,
+    polls,
+    state,
+    system,
+)
+
+
+def create_app() -> FastAPI:
+    """Create and configure the FastAPI application."""
+    app = FastAPI(
+        title="kryten-api-gate",
+        version=__version__,
+        description="HTTP REST gateway for the Kryten ecosystem",
+    )
+
+    # Public routes (no auth)
+    app.include_router(system.public_router, prefix="/api/v1/system", tags=["system"])
+
+    # Protected routes (require API key)
+    app.include_router(system.router, prefix="/api/v1/system", tags=["system"])
+    app.include_router(chat.router, prefix="/api/v1/chat", tags=["chat"])
+    app.include_router(playlist.router, prefix="/api/v1/playlist", tags=["playlist"])
+    app.include_router(playback.router, prefix="/api/v1/playback", tags=["playback"])
+    app.include_router(moderation.router, prefix="/api/v1/moderation", tags=["moderation"])
+    app.include_router(admin.router, prefix="/api/v1/admin", tags=["admin"])
+    app.include_router(emotes.router, prefix="/api/v1/emotes", tags=["emotes"])
+    app.include_router(filters.router, prefix="/api/v1/filters", tags=["filters"])
+    app.include_router(polls.router, prefix="/api/v1/polls", tags=["polls"])
+    app.include_router(library.router, prefix="/api/v1/library", tags=["library"])
+    app.include_router(kv.router, prefix="/api/v1/kv", tags=["kv"])
+    app.include_router(state.router, prefix="/api/v1/state", tags=["state"])
+
+    return app

kryten_api_gate/auth.py

@@ -0,0 +1,36 @@
+"""Authentication dependency for kryten-api-gate."""
+
+from fastapi import Depends, HTTPException, Request, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+from .config import Config
+
+_bearer_scheme = HTTPBearer(auto_error=False)
+
+
+async def verify_api_key(
+    request: Request,
+    credentials: HTTPAuthorizationCredentials | None = Depends(_bearer_scheme),
+) -> str:
+    """Validate Bearer token against configured API keys.
+
+    Returns the validated API key string.
+    Raises 401 if missing or invalid.
+    """
+    config: Config = request.app.state.config
+
+    if credentials is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Missing authorization header",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    if credentials.credentials not in config.api_keys:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    return credentials.credentials

kryten_api_gate/config.py

@@ -0,0 +1,62 @@
+"""Configuration model for kryten-api-gate."""
+
+import json
+import logging
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+# Config search paths in priority order
+CONFIG_SEARCH_PATHS = [
+    Path("./config.json"),
+    Path("/etc/kryten/api-gate/config.json"),
+    Path("/opt/kryten/api-gate/config.json"),
+]
+
+
+class Config(BaseModel):
+    """API gate configuration."""
+
+    nats_url: str = Field(default="nats://localhost:4222")
+    channel: str = Field(description="CyTube channel name")
+    domain: str = Field(default="cytu.be")
+    http_host: str = Field(default="127.0.0.1")
+    http_port: int = Field(default=28288)
+    api_keys: list[str] = Field(description="Authorized bearer tokens")
+    kv_read_only: bool = Field(default=False)
+    service_name: str = Field(default="api-gate")
+    log_level: str = Field(default="INFO")
+    disabled_routes: list[str] = Field(
+        default_factory=list,
+        description="List of route operation IDs to disable (e.g. 'playback_pause', 'playback_seek')",
+    )
+
+
+def load_config(config_path: str | None = None) -> Config:
+    """Load configuration from JSON file.
+
+    Search order:
+    1. Explicit path (if provided)
+    2. ./config.json (cwd)
+    3. /etc/kryten/api-gate/config.json
+    4. /opt/kryten/api-gate/config.json
+    """
+    if config_path:
+        path = Path(config_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Config file not found: {config_path}")
+        logger.info(f"Loading config from: {path}")
+        data = json.loads(path.read_text())
+        return Config(**data)
+
+    for path in CONFIG_SEARCH_PATHS:
+        if path.exists():
+            logger.info(f"Loading config from: {path}")
+            data = json.loads(path.read_text())
+            return Config(**data)
+
+    raise FileNotFoundError(
+        f"No config file found. Searched: {[str(p) for p in CONFIG_SEARCH_PATHS]}"
+    )

kryten_api_gate/deps.py

@@ -0,0 +1,16 @@
+"""Dependency injection for kryten-api-gate routes."""
+
+from fastapi import Request
+from kryten import KrytenClient
+
+from .config import Config
+
+
+def get_client(request: Request) -> KrytenClient:
+    """Get the shared KrytenClient instance."""
+    return request.app.state.client
+
+
+def get_config(request: Request) -> Config:
+    """Get the loaded configuration."""
+    return request.app.state.config

kryten_api_gate/routes/__init__.py

@@ -0,0 +1 @@
+"""Route modules for kryten-api-gate."""

kryten_api_gate/routes/admin.py

@@ -0,0 +1,187 @@
+"""Admin routes — MOTD, CSS, JS, options, permissions, ranks, channel log."""
+
+from fastapi import APIRouter, Depends
+from kryten import KrytenClient
+from pydantic import BaseModel
+
+from ..auth import verify_api_key
+from ..config import Config
+from ..deps import get_client, get_config
+
+router = APIRouter(dependencies=[Depends(verify_api_key)])
+
+
+class MotdRequest(BaseModel):
+    motd: str
+
+
+class CssRequest(BaseModel):
+    css: str
+
+
+class JsRequest(BaseModel):
+    js: str
+
+
+class OptionsRequest(BaseModel):
+    options: dict
+
+
+class PermissionsRequest(BaseModel):
+    permissions: dict
+
+
+class SetRankRequest(BaseModel):
+    username: str
+    rank: int
+
+
+# --- MOTD ---
+
+
+@router.get("/motd")
+async def get_motd(
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    motd = await client.get_state_motd(config.channel, domain=config.domain)
+    return {"motd": motd}
+
+
+@router.put("/motd")
+async def set_motd(
+    body: MotdRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.set_motd(config.channel, body.motd, domain=config.domain)
+    return {"message_id": msg_id}
+
+
+# --- CSS ---
+
+
+@router.get("/css")
+async def get_channel_css(
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    css = await client.get_state_channel_css(config.channel, domain=config.domain)
+    return {"css": css}
+
+
+@router.put("/css")
+async def set_channel_css(
+    body: CssRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.set_channel_css(config.channel, body.css, domain=config.domain)
+    return {"message_id": msg_id}
+
+
+# --- JS ---
+
+
+@router.get("/js")
+async def get_channel_js(
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    js = await client.get_state_channel_js(config.channel, domain=config.domain)
+    return {"js": js}
+
+
+@router.put("/js")
+async def set_channel_js(
+    body: JsRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.set_channel_js(config.channel, body.js, domain=config.domain)
+    return {"message_id": msg_id}
+
+
+# --- Options ---
+
+
+@router.get("/options")
+async def get_options(
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    options = await client.get_state_channel_options(config.channel, domain=config.domain)
+    return {"options": options}
+
+
+@router.put("/options")
+async def set_options(
+    body: OptionsRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.set_options(config.channel, body.options, domain=config.domain)
+    return {"message_id": msg_id}
+
+
+# --- Permissions ---
+
+
+@router.get("/permissions")
+async def get_permissions(
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    permissions = await client.get_state_channel_permissions(
+        config.channel, domain=config.domain
+    )
+    return {"permissions": permissions}
+
+
+@router.put("/permissions")
+async def set_permissions(
+    body: PermissionsRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.set_permissions(
+        config.channel, body.permissions, domain=config.domain
+    )
+    return {"message_id": msg_id}
+
+
+# --- Ranks ---
+
+
+@router.get("/ranks")
+async def request_channel_ranks(
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.request_channel_ranks(config.channel, domain=config.domain)
+    return {"message_id": msg_id}
+
+
+@router.put("/rank")
+async def set_channel_rank(
+    body: SetRankRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.set_channel_rank(
+        config.channel, body.username, body.rank, domain=config.domain
+    )
+    return {"message_id": msg_id}
+
+
+# --- Channel Log ---
+
+
+@router.get("/log")
+async def read_chan_log(
+    count: int = 100,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.read_chan_log(config.channel, count, domain=config.domain)
+    return {"message_id": msg_id}

kryten_api_gate/routes/chat.py

@@ -0,0 +1,42 @@
+"""Chat routes — send messages and PMs."""
+
+from fastapi import APIRouter, Depends
+from kryten import KrytenClient
+from pydantic import BaseModel
+
+from ..auth import verify_api_key
+from ..config import Config
+from ..deps import get_client, get_config
+
+router = APIRouter(dependencies=[Depends(verify_api_key)])
+
+
+class SendChatRequest(BaseModel):
+    message: str
+
+
+class SendPmRequest(BaseModel):
+    username: str
+    message: str
+
+
+@router.post("/send")
+async def send_chat(
+    body: SendChatRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.send_chat(config.channel, body.message, domain=config.domain)
+    return {"message_id": msg_id}
+
+
+@router.post("/pm")
+async def send_pm(
+    body: SendPmRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.send_pm(
+        config.channel, body.username, body.message, domain=config.domain
+    )
+    return {"message_id": msg_id}

kryten_api_gate/routes/emotes.py

@@ -0,0 +1,71 @@
+"""Emotes routes — update, remove, bulk import/export emotes."""
+
+from fastapi import APIRouter, Depends
+from kryten import KrytenClient
+from pydantic import BaseModel
+
+from ..auth import verify_api_key
+from ..config import Config
+from ..deps import get_client, get_config
+
+router = APIRouter(dependencies=[Depends(verify_api_key)])
+
+
+class UpdateEmoteRequest(BaseModel):
+    image: str
+    source: str = "imgur"
+
+
+class EmoteImportItem(BaseModel):
+    name: str
+    image: str
+    source: str = "imgur"
+
+
+class BulkImportRequest(BaseModel):
+    emotes: list[EmoteImportItem]
+
+
+@router.get("/")
+async def export_emotes(
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    emotes = await client.export_emotes(config.channel, domain=config.domain)
+    return {"emotes": emotes}
+
+
+@router.post("/import")
+async def import_emotes(
+    body: BulkImportRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    emote_dicts = [e.model_dump() for e in body.emotes]
+    message_ids = await client.import_emotes(
+        config.channel, emote_dicts, domain=config.domain
+    )
+    return {"message_ids": message_ids, "count": len(message_ids)}
+
+
+@router.put("/{name}")
+async def update_emote(
+    name: str,
+    body: UpdateEmoteRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.update_emote(
+        config.channel, name, body.image, body.source, domain=config.domain
+    )
+    return {"message_id": msg_id}
+
+
+@router.delete("/{name}")
+async def remove_emote(
+    name: str,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.remove_emote(config.channel, name, domain=config.domain)
+    return {"message_id": msg_id}

kryten_api_gate/routes/filters.py

@@ -0,0 +1,77 @@
+"""Filters routes — add, update, remove chat filters."""
+
+from fastapi import APIRouter, Depends
+from kryten import KrytenClient
+from pydantic import BaseModel
+
+from ..auth import verify_api_key
+from ..config import Config
+from ..deps import get_client, get_config
+
+router = APIRouter(dependencies=[Depends(verify_api_key)])
+
+
+class FilterRequest(BaseModel):
+    name: str
+    source: str
+    flags: str = "gi"
+    replace: str = ""
+    filterlinks: bool = False
+    active: bool = True
+
+
+class UpdateFilterRequest(BaseModel):
+    source: str
+    flags: str = "gi"
+    replace: str = ""
+    filterlinks: bool = False
+    active: bool = True
+
+
+@router.post("/")
+async def add_filter(
+    body: FilterRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.add_filter(
+        config.channel,
+        body.name,
+        body.source,
+        body.flags,
+        body.replace,
+        filterlinks=body.filterlinks,
+        active=body.active,
+        domain=config.domain,
+    )
+    return {"message_id": msg_id}
+
+
+@router.put("/{name}")
+async def update_filter(
+    name: str,
+    body: UpdateFilterRequest,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.update_filter(
+        config.channel,
+        name,
+        body.source,
+        body.flags,
+        body.replace,
+        filterlinks=body.filterlinks,
+        active=body.active,
+        domain=config.domain,
+    )
+    return {"message_id": msg_id}
+
+
+@router.delete("/{name}")
+async def remove_filter(
+    name: str,
+    client: KrytenClient = Depends(get_client),
+    config: Config = Depends(get_config),
+) -> dict:
+    msg_id = await client.remove_filter(config.channel, name, domain=config.domain)
+    return {"message_id": msg_id}