@agentunion/kite 1.3.2 → 1.4.0

package/extensions/services/web/routes/routes_modules.py

@@ -1,249 +0,0 @@
-"""Routes for module management — scan, view, and edit module metadata + config."""
-
-from __future__ import annotations
-
-import logging
-import os
-import re
-from pathlib import Path
-from typing import Any
-
-import yaml
-from fastapi import APIRouter, HTTPException
-
-from routes.schemas import ModuleConfigUpdate, ModuleMetadataUpdate
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(tags=["modules"])
-
-# Fields that may NOT be changed via the metadata API
-_READONLY_FIELDS = frozenset({"name", "type", "runtime", "entry"})
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-def _get_project_root() -> Path:
-    """Return the Kite project root directory."""
-    env = os.environ.get("KITE_PROJECT")
-    if env:
-        return Path(env)
-    # Fallback: __file__ is routes/routes_modules.py → up 5 levels to project root
-    # routes_modules.py → routes/ → web/ → services/ → extensions/ → Kite/
-    return Path(__file__).resolve().parents[4]
-
-
-def _scan_modules() -> list[dict[str, Any]]:
-    """Discover all modules by scanning kernel/ (depth 0) and extensions/ (depth 2)."""
-    root = _get_project_root()
-    found: list[dict[str, Any]] = []
-
-    # 1. kernel/module.md
-    kernel_md = root / "kernel" / "module.md"
-    if kernel_md.is_file():
-        meta, _ = _parse_module_md(kernel_md)
-        if meta:
-            meta["_path"] = str(kernel_md)
-            meta["_dir"] = str(kernel_md.parent)
-            found.append(meta)
-
-    # 2. launcher/module.md
-    launcher_md = root / "launcher" / "module.md"
-    if launcher_md.is_file():
-        meta, _ = _parse_module_md(launcher_md)
-        if meta:
-            meta["_path"] = str(launcher_md)
-            meta["_dir"] = str(launcher_md.parent)
-            found.append(meta)
-
-    # 3. extensions/{category}/{name}/module.md  (depth 2)
-    ext_dir = root / "extensions"
-    if ext_dir.is_dir():
-        for category in sorted(ext_dir.iterdir()):
-            if not category.is_dir() or category.name.startswith("."):
-                continue
-            for mod_dir in sorted(category.iterdir()):
-                if not mod_dir.is_dir() or mod_dir.name.startswith("."):
-                    continue
-                md_path = mod_dir / "module.md"
-                if md_path.is_file():
-                    meta, _ = _parse_module_md(md_path)
-                    if meta:
-                        meta["_path"] = str(md_path)
-                        meta["_dir"] = str(mod_dir)
-                        found.append(meta)
-
-    return found
-
-
-_FRONTMATTER_RE = re.compile(r"^---\s*\n(.*?)\n---\s*\n?(.*)", re.DOTALL)
-
-
-def _parse_module_md(path: Path) -> tuple[dict[str, Any], str]:
-    """Parse YAML frontmatter from a module.md file. Returns (frontmatter_dict, body_str)."""
-    try:
-        text = path.read_text(encoding="utf-8")
-    except Exception as exc:
-        logger.warning("Failed to read %s: %s", path, exc)
-        return {}, ""
-
-    m = _FRONTMATTER_RE.match(text)
-    if not m:
-        return {}, text
-
-    try:
-        fm = yaml.safe_load(m.group(1)) or {}
-    except yaml.YAMLError as exc:
-        logger.warning("Failed to parse frontmatter in %s: %s", path, exc)
-        return {}, text
-
-    return fm, m.group(2)
-
-
-def _write_module_md(path: Path, frontmatter: dict[str, Any], body: str) -> None:
-    """Write frontmatter + body back to module.md."""
-    fm_str = yaml.dump(frontmatter, allow_unicode=True, sort_keys=False, default_flow_style=False).rstrip()
-    content = f"---\n{fm_str}\n---\n{body}"
-    path.write_text(content, encoding="utf-8")
-
-
-def _find_module(name: str) -> dict[str, Any] | None:
-    """Find a single module by name."""
-    for m in _scan_modules():
-        if m.get("name") == name:
-            return m
-    return None
-
-
-def _deep_merge(base: dict, overlay: dict) -> dict:
-    """Recursively merge overlay into base (mutates base)."""
-    for k, v in overlay.items():
-        if k in base and isinstance(base[k], dict) and isinstance(v, dict):
-            _deep_merge(base[k], v)
-        else:
-            base[k] = v
-    return base
-
-
-# ---------------------------------------------------------------------------
-# API endpoints
-# ---------------------------------------------------------------------------
-
-@router.get("/modules")
-async def list_modules():
-    """List all discovered modules."""
-    modules = _scan_modules()
-    result = []
-    for m in modules:
-        mod_dir = Path(m["_dir"])
-        has_config = (mod_dir / "config.yaml").is_file()
-        result.append({
-            "name": m.get("name", ""),
-            "display_name": m.get("display_name", ""),
-            "type": m.get("type", ""),
-            "state": m.get("state", "enabled"),
-            "version": m.get("version", ""),
-            "runtime": m.get("runtime", ""),
-            "preferred_port": m.get("preferred_port"),
-            "monitor": m.get("monitor"),
-            "has_config": has_config,
-        })
-    return result
-
-
-@router.get("/modules/{name}")
-async def get_module(name: str):
-    """Get module details including config.yaml content (if any)."""
-    m = _find_module(name)
-    if not m:
-        raise HTTPException(404, f"Module not found: {name}")
-
-    mod_dir = Path(m["_dir"])
-    md_path = Path(m["_path"])
-
-    # Parse full frontmatter
-    frontmatter, _ = _parse_module_md(md_path)
-
-    # Read config.yaml if present
-    config = None
-    config_path = mod_dir / "config.yaml"
-    if config_path.is_file():
-        try:
-            config = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
-        except Exception as exc:
-            logger.warning("Failed to read config.yaml for %s: %s", name, exc)
-
-    return {
-        "name": frontmatter.get("name", name),
-        "display_name": frontmatter.get("display_name", ""),
-        "type": frontmatter.get("type", ""),
-        "state": frontmatter.get("state", "enabled"),
-        "version": frontmatter.get("version", ""),
-        "runtime": frontmatter.get("runtime", ""),
-        "entry": frontmatter.get("entry", ""),
-        "preferred_port": frontmatter.get("preferred_port"),
-        "advertise_ip": frontmatter.get("advertise_ip"),
-        "monitor": frontmatter.get("monitor"),
-        "events": frontmatter.get("events"),
-        "subscriptions": frontmatter.get("subscriptions"),
-        "depends_on": frontmatter.get("depends_on"),
-        "has_config": config is not None,
-        "config": config,
-    }
-
-
-@router.put("/modules/{name}/metadata")
-async def update_module_metadata(name: str, update: ModuleMetadataUpdate):
-    """Update module.md frontmatter (whitelisted fields only)."""
-    m = _find_module(name)
-    if not m:
-        raise HTTPException(404, f"Module not found: {name}")
-
-    md_path = Path(m["_path"])
-    frontmatter, body = _parse_module_md(md_path)
-    if not frontmatter:
-        raise HTTPException(500, "Failed to parse module.md frontmatter")
-
-    # Apply only non-None fields, excluding readonly
-    changes = update.model_dump(exclude_none=True)
-    for key in list(changes.keys()):
-        if key in _READONLY_FIELDS:
-            continue
-        frontmatter[key] = changes[key]
-
-    _write_module_md(md_path, frontmatter, body)
-    return {"ok": True, "name": name}
-
-
-@router.put("/modules/{name}/config")
-async def update_module_config(name: str, update: ModuleConfigUpdate):
-    """Deep-merge update into module's config.yaml."""
-    m = _find_module(name)
-    if not m:
-        raise HTTPException(404, f"Module not found: {name}")
-
-    mod_dir = Path(m["_dir"])
-    config_path = mod_dir / "config.yaml"
-
-    # Read existing config
-    existing: dict[str, Any] = {}
-    if config_path.is_file():
-        try:
-            existing = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
-        except Exception:
-            pass
-
-    # Deep merge
-    overlay = update.model_dump(exclude_none=True)
-    # Remove pydantic internal keys
-    overlay.pop("model_config", None)
-    _deep_merge(existing, overlay)
-
-    # Write back
-    config_path.write_text(
-        yaml.dump(existing, allow_unicode=True, sort_keys=False, default_flow_style=False),
-        encoding="utf-8",
-    )
-    return {"ok": True, "name": name, "config": existing}