ltcai 11.5.2 → 11.7.0

package/latticeai/api/mcp.py

@@ -1,482 +0,0 @@
-"""MCP / skills / plugins API router.
-
-Extracted from ``server_app.py`` in v1.3.0. Paths and schemas unchanged:
-``/mcp/*``, ``/skills/*``, ``/plugins/directory*``, and ``/mcp/call``.
-
-Registry/tool symbols are imported directly from their owning modules
-(``mcp_registry``, ``tools``, ``latticeai.core.tool_registry``); server_app-defined
-helpers (auth, audit, tool governance/dispatch, KG) are injected, so there is no
-import cycle.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel
-
-import latticeai.core.mcp_registry as mcp_registry
-from lattice_brain.ingestion import IngestionItem
-from latticeai.core.mcp_registry import (
-    SKILLS_DIR,
-    _fetch_plugin_directory,
-    _fetch_skills_marketplace,
-    _get_combined_registry,
-    install_skill,
-)
-from latticeai.core.messages import http_error, resolve_language
-from latticeai.core.tool_registry import (
-    KNOWLEDGE_WRITE_TOOLS,
-    MCP_TOOL_DESCRIPTIONS,
-    SCOPED_KNOWLEDGE_TOOLS,
-)
-from latticeai.services.tool_dispatch import EXPLICIT_CONSENT_TOOLS, enforce_tool_policy
-from latticeai.tools import execute_tool
-
-
-class McpRecommendRequest(BaseModel):
-    query: str
-    limit: int = 5
-
-
-class McpInstallRequest(BaseModel):
-    mcp_id: str
-
-
-class McpCustomRequest(BaseModel):
-    name: str
-    package: str
-    description: str = ""
-    category: str = "custom"
-    icon: str = "🔌"
-    env_vars: List[Dict] = []
-
-
-class SkillInstallRequest(BaseModel):
-    plugin: str
-    skill: str
-
-
-class McpCallRequest(BaseModel):
-    action: str
-    args: Dict = {}
-
-
-def create_mcp_router(
-    *,
-    require_user: Callable[[Request], str],
-    require_admin: Callable[[Request], Any],
-    append_audit_event: Callable[..., None],
-    load_mcp_installs: Callable[[], Dict],
-    recommend_mcps: Callable[..., Any],
-    install_mcp: Callable[..., Any],
-    mcp_public_item: Callable[[Dict, Dict], Dict],
-    get_tool_permission: Callable[..., Any],
-    tool_governance: Dict,
-    tool_governance_default: Any,
-    check_tool_role: Callable[[str, str], None],
-    tool_response: Callable[..., Any],
-    require_graph: Callable[[], Any],
-    knowledge_graph: Any,
-    ingestion_pipeline: Any,
-    data_dir: Path,
-    allowed_workspaces_for: Optional[Callable[[Optional[str]], Any]] = None,
-    workspace_service: Any = None,
-) -> APIRouter:
-    router = APIRouter()
-
-    # Bind injected deps to the names the moved handler bodies expect.
-    TOOL_GOVERNANCE = tool_governance
-    _TOOL_GOVERNANCE_DEFAULT = tool_governance_default
-    _check_tool_role = check_tool_role
-    _tool_response = tool_response
-    _require_graph = require_graph
-    KNOWLEDGE_GRAPH = knowledge_graph
-
-    _CUSTOM_MCP_FILE = data_dir / "custom_mcps.json"
-
-    def _load_custom_mcps() -> List[Dict]:
-        if not _CUSTOM_MCP_FILE.exists():
-            return []
-        try:
-            with open(_CUSTOM_MCP_FILE, "r", encoding="utf-8") as f:
-                return json.load(f)
-        except Exception:
-            return []
-
-    def _save_custom_mcps(items: List[Dict]):
-        with open(_CUSTOM_MCP_FILE, "w", encoding="utf-8") as f:
-            json.dump(items, f, ensure_ascii=False, indent=2)
-
-    def _public_env_vars(items: Any) -> List[Dict[str, Any]]:
-        return [
-            {"name": str(item.get("name") or ""), "configured": bool(item.get("value"))}
-            for item in (items or [])
-            if isinstance(item, dict) and item.get("name")
-        ]
-
-    def _allowed_graph_workspaces(user: Optional[str]):
-        return allowed_workspaces_for(user) if allowed_workspaces_for is not None else None
-
-    def _write_workspace(requested: Optional[str], user: Optional[str]) -> Optional[str]:
-        if workspace_service is None:
-            return requested
-        try:
-            return workspace_service.resolve_write_scope(requested, user)
-        except PermissionError as exc:
-            raise HTTPException(status_code=403, detail=str(exc)) from exc
-
-    def _read_workspace(request: Request, requested: Optional[str], user: Optional[str]) -> Optional[str]:
-        if workspace_service is not None:
-            try:
-                return workspace_service.resolve_read_scope(requested, user)
-            except PermissionError as exc:
-                raise HTTPException(status_code=403, detail=str(exc)) from exc
-        workspace_id = requested or "personal"
-        allowed = _allowed_graph_workspaces(user)
-        if allowed is not None and workspace_id not in set(allowed):
-            raise http_error(403, "common.workspace_unreadable", resolve_language(request), workspace=workspace_id)
-        return workspace_id
-
-    @router.get("/mcp/tools")
-    async def mcp_tools(request: Request):
-        require_user(request)
-        installed = load_mcp_installs().get("installed", {})
-        registry = await _get_combined_registry()
-        tools = []
-        for name, description in MCP_TOOL_DESCRIPTIONS.items():
-            if name in EXPLICIT_CONSENT_TOOLS:
-                continue
-            policy = TOOL_GOVERNANCE.get(name, _TOOL_GOVERNANCE_DEFAULT)
-            governance = {
-                "risk":         policy["risk"],
-                "destructive":  policy["destructive"],
-                "shell":        policy["shell"],
-                "network":      policy["network"],
-                "auto_approve": policy["auto_approve"],
-                "sandbox":      policy["sandbox"],
-                "rollback":     policy["rollback"],
-            }
-            if policy.get("capability"):
-                governance["capability"] = policy["capability"]
-            if policy.get("scope"):
-                governance["scope"] = policy["scope"]
-            tools.append({
-                "name": name,
-                "description": description,
-                "permission": get_tool_permission(name),
-                "governance": governance,
-            })
-        return {
-            "status": "ok",
-            # Do not disclose the host user's absolute checkout path through a
-            # discovery endpoint. Tool paths are workspace-relative already.
-            "workspace": ".",
-            "installed_mcps": [mcp_public_item(item, installed) for item in registry],
-            "tools": tools,
-        }
-
-    @router.post("/mcp/recommend")
-    async def mcp_recommend(req: McpRecommendRequest, request: Request):
-        require_user(request)
-        return {"recommendations": await recommend_mcps(req.query, req.limit)}
-
-    @router.post("/mcp/install")
-    async def mcp_install(req: McpInstallRequest, request: Request):
-        admin_email, _ = require_admin(request)
-        append_audit_event("mcp_install", user_email=admin_email, mcp_id=req.mcp_id)
-        return await install_mcp(req.mcp_id)
-
-    @router.get("/mcp/installed")
-    async def mcp_installed(request: Request):
-        require_user(request)
-        installed = load_mcp_installs().get("installed", {})
-        registry = await _get_combined_registry()
-        return {"installed": [mcp_public_item(item, installed) for item in registry]}
-
-    @router.get("/mcp/connectors/{mcp_id}")
-    async def mcp_connector(mcp_id: str, request: Request):
-        require_user(request)
-        registry = await _get_combined_registry()
-        item = next((e for e in registry if e["id"] == mcp_id), None)
-        if not item or item.get("install_mode") != "connector":
-            raise http_error(404, "mcp.connector_not_found", resolve_language(request))
-        installed = load_mcp_installs().get("installed", {})
-        public = mcp_public_item(item, installed)
-        public["instructions"] = [
-            "Codex 또는 ChatGPT 앱의 Connectors 설정을 엽니다.",
-            f"{item['name']} 항목을 선택하고 계정을 인증합니다.",
-            "인증 후 Lattice AI에서 이 MCP를 다시 활성화하면 작업에 사용할 수 있습니다.",
-        ]
-        return public
-
-    @router.post("/mcp/registry/refresh")
-    async def mcp_registry_refresh(request: Request):
-        require_user(request)
-        mcp_registry._REMOTE_REGISTRY_FETCHED_AT = None
-        registry = await _get_combined_registry()
-        return {"status": "ok", "total": len(registry), "remote": len(mcp_registry._REMOTE_REGISTRY_CACHE)}
-
-    @router.get("/mcp/claude-code-servers")
-    async def mcp_claude_code_servers(request: Request):
-        """Read ~/.claude/settings.json mcpServers and return them as Lattice MCP items."""
-        require_admin(request)
-        settings_path = Path.home() / ".claude" / "settings.json"
-        if not settings_path.exists():
-            return {"servers": []}
-        try:
-            # Home may be a network mount, where a read is not the microsecond
-            # a local one is; keep it off the loop like every other file read.
-            raw = await asyncio.to_thread(settings_path.read_text, "utf-8")
-            settings = json.loads(raw)
-            mcp_servers = settings.get("mcpServers", {})
-            servers = []
-            for name, cfg in mcp_servers.items():
-                cmd = cfg.get("command", "")
-                args = cfg.get("args", [])
-                package = " ".join([cmd] + args) if args else cmd
-                env = cfg.get("env", {})
-                env_vars = [{"name": k, "configured": bool(v)} for k, v in env.items()]
-                servers.append({
-                    "id": f"claude-code:{name}",
-                    "name": name,
-                    "description": f"Claude Code MCP: {package}",
-                    "package": package,
-                    "icon": "🤖",
-                    "category": "Claude Code",
-                    "source": "claude-code",
-                    "installed": True,
-                    "env_vars": env_vars,
-                })
-            return {"servers": servers}
-        except Exception as e:
-            logging.warning("mcp_claude_code_servers failed: %s", e)
-            return {"servers": []}
-
-    @router.get("/mcp/custom")
-    async def mcp_custom_list(request: Request):
-        """Return user-added custom MCP entries."""
-        require_user(request)
-        items = []
-        for raw in _load_custom_mcps():
-            item = dict(raw)
-            item["env_vars"] = _public_env_vars(item.get("env_vars"))
-            items.append(item)
-        return {"custom": items}
-
-    @router.post("/mcp/custom")
-    async def mcp_custom_add(req: McpCustomRequest, request: Request):
-        """Save a custom MCP entry (admin-only)."""
-        admin_email, _ = require_admin(request)
-        append_audit_event("mcp_custom_add", user_email=admin_email, name=req.name, package=req.package)
-        if not req.name.strip():
-            raise http_error(400, "mcp.name_required", resolve_language(request))
-        if not req.package.strip():
-            raise http_error(400, "mcp.package_required", resolve_language(request))
-        items = _load_custom_mcps()
-        entry = {
-            "id": f"custom:{req.name.strip().lower().replace(' ', '-')}",
-            "name": req.name.strip(),
-            "package": req.package.strip(),
-            "description": req.description.strip(),
-            "category": req.category or "custom",
-            "icon": req.icon or "🔌",
-            "env_vars": req.env_vars or [],
-            "install_mode": "npm",
-            "source": "custom",
-            "installed": False,
-            "added_at": datetime.now().isoformat(),
-        }
-        items = [e for e in items if e["id"] != entry["id"]]
-        items.append(entry)
-        _save_custom_mcps(items)
-        return {"status": "ok", "entry": entry}
-
-    @router.delete("/mcp/custom/{mcp_id:path}")
-    async def mcp_custom_delete(mcp_id: str, request: Request):
-        """Remove a custom MCP entry."""
-        require_admin(request)
-        items = _load_custom_mcps()
-        before = len(items)
-        items = [e for e in items if e["id"] != mcp_id]
-        if len(items) == before:
-            raise http_error(404, "mcp.item_not_found", resolve_language(request))
-        _save_custom_mcps(items)
-        return {"status": "ok"}
-
-    # ── Skills & Plugin Directory ─────────────────────────────────────────
-
-    @router.get("/skills/marketplace")
-    async def skills_marketplace(request: Request, category: Optional[str] = None, author: Optional[str] = None):
-        require_user(request)
-        skills = await _fetch_skills_marketplace()
-        installed_names = {d.name for d in SKILLS_DIR.iterdir() if d.is_dir()} if SKILLS_DIR.exists() else set()
-        filtered = skills
-        if category:
-            filtered = [s for s in filtered if s.get("category", "").lower() == category.lower()]
-        if author:
-            filtered = [s for s in filtered if s.get("author", "").lower() == author.lower()]
-        return {
-            "skills": [{**s, "installed": s["skill"] in installed_names} for s in filtered],
-            "total": len(filtered),
-            "authors": sorted({s["author"] for s in skills}),
-            "categories": sorted({s["category"] for s in skills}),
-        }
-
-    @router.post("/skills/install")
-    async def skills_install(req: SkillInstallRequest, request: Request):
-        admin_email, _ = require_admin(request)
-        append_audit_event("skill_install", user_email=admin_email, plugin=req.plugin, skill=req.skill)
-        return await install_skill(req.plugin, req.skill)
-
-    @router.get("/skills/list")
-    async def skills_list(request: Request):
-        require_user(request)
-        if not SKILLS_DIR.exists():
-            return {"skills": []}
-        skills = []
-        for skill_dir in sorted(SKILLS_DIR.iterdir()):
-            if not skill_dir.is_dir():
-                continue
-            skill_md = skill_dir / "SKILL.md"
-            if not skill_md.exists():
-                continue
-            lines = skill_md.read_text(encoding="utf-8").splitlines()
-            desc = next((ln.split(":", 1)[1].strip() for ln in lines if ln.startswith("description:")), "")
-            comment = lines[0] if lines else ""
-            if "anthropics/claude-plugins-official" in comment:
-                source = "anthropic"
-            elif "Source:" in comment:
-                source = "third-party"
-            else:
-                source = "local"
-            skills.append({"name": skill_dir.name, "description": desc, "source": source})
-        return {"skills": skills, "total": len(skills)}
-
-    @router.post("/skills/marketplace/refresh")
-    async def skills_marketplace_refresh(request: Request):
-        require_user(request)
-        mcp_registry._SKILLS_MARKETPLACE_FETCHED_AT = None
-        skills = await _fetch_skills_marketplace()
-        by_author: Dict[str, int] = {}
-        for s in skills:
-            by_author[s["author"]] = by_author.get(s["author"], 0) + 1
-        return {"status": "ok", "total": len(skills), "by_author": by_author}
-
-    @router.get("/plugins/directory")
-    async def plugins_directory(
-        request: Request,
-        category: Optional[str] = None,
-        license: Optional[str] = None,
-        q: Optional[str] = None,
-    ):
-        require_user(request)
-        plugins = await _fetch_plugin_directory()
-        filtered = plugins
-        if category:
-            filtered = [p for p in filtered if p.get("category", "").lower() == category.lower()]
-        if license:
-            filtered = [p for p in filtered if p.get("license", "").lower() == license.lower()]
-        if q:
-            q_lower = q.lower()
-            filtered = [
-                p for p in filtered
-                if q_lower in p.get("name", "").lower()
-                or q_lower in p.get("description", "").lower()
-                or q_lower in p.get("author", "").lower()
-            ]
-        return {
-            "plugins": filtered,
-            "total": len(filtered),
-            "categories": sorted({p["category"] for p in plugins if p.get("category")}),
-            "licenses": sorted({p["license"] for p in plugins if p.get("license")}),
-        }
-
-    @router.post("/plugins/directory/refresh")
-    async def plugins_directory_refresh(request: Request):
-        require_user(request)
-        mcp_registry._PLUGIN_DIRECTORY_FETCHED_AT = None
-        plugins = await _fetch_plugin_directory()
-        by_license: Dict[str, int] = {}
-        for p in plugins:
-            lic = p.get("license", "unknown")
-            by_license[lic] = by_license.get(lic, 0) + 1
-        return {"status": "ok", "total": len(plugins), "by_license": by_license}
-
-    @router.post("/mcp/call")
-    async def mcp_call(req: McpCallRequest, request: Request):
-        current_user = require_user(request)
-        args = req.args or {}
-        if req.action == "knowledge_graph_ingest":
-            _require_graph()
-            # v4: MCP messages enter the brain through the unified ingestion
-            # pipeline (provenance + hook lifecycle), not a direct store call.
-            claimed_user = str(args.get("user_email") or "").strip()
-            if current_user and claimed_user and claimed_user.lower() != current_user.strip().lower():
-                raise http_error(403, "common.user_mismatch", resolve_language(request))
-            owner = current_user or claimed_user or None
-            workspace_id = _write_workspace(args.get("workspace_id"), owner)
-            raw = dict(args)
-            raw["user_email"] = owner
-            raw["workspace_id"] = workspace_id
-            result = ingestion_pipeline.ingest(
-                IngestionItem(
-                    source_type="mcp_message",
-                    text=args.get("content") or "",
-                    owner=owner,
-                    workspace_id=workspace_id,
-                    conversation_id=args.get("conversation_id"),
-                    metadata={
-                        "role": args.get("role") or ("assistant" if args.get("type") == "ai_response" else "user"),
-                        "user_nickname": args.get("user_nickname"),
-                        "source": args.get("source") or "mcp",
-                        "raw": raw,
-                    },
-                ),
-                user_email=owner,
-            )
-            return result.as_dict()
-        if req.action == "knowledge_graph_search":
-            _require_graph()
-            return KNOWLEDGE_GRAPH.search(
-                args.get("query") or args.get("q") or "",
-                args.get("limit", 30),
-                allowed_workspaces=_allowed_graph_workspaces(current_user or None),
-            )
-        if req.action == "knowledge_graph_graph":
-            _require_graph()
-            return KNOWLEDGE_GRAPH.graph(
-                args.get("limit", 300),
-                allowed_workspaces=_allowed_graph_workspaces(current_user or None),
-            )
-        if req.action == "knowledge_graph_context":
-            _require_graph()
-            return {
-                "context": KNOWLEDGE_GRAPH.context_for_query(
-                    args.get("query") or args.get("q") or "",
-                    args.get("limit", 6),
-                    allowed_workspaces=_allowed_graph_workspaces(current_user or None),
-                )
-            }
-        dispatch_args = dict(req.args or {})
-        if req.action in SCOPED_KNOWLEDGE_TOOLS:
-            claimed_user = str(dispatch_args.get("user_email") or "").strip().lower()
-            if claimed_user and claimed_user != current_user.strip().lower():
-                raise http_error(403, "common.user_mismatch", resolve_language(request))
-            requested_workspace = dispatch_args.get("workspace_id")
-            if req.action in KNOWLEDGE_WRITE_TOOLS:
-                workspace_id = _write_workspace(requested_workspace, current_user)
-            else:
-                workspace_id = _read_workspace(request, requested_workspace, current_user)
-            dispatch_args["workspace_id"] = workspace_id
-            dispatch_args["user_email"] = current_user
-        enforce_tool_policy(req.action, dispatch_args, current_user=current_user, source="mcp")
-        return _tool_response(execute_tool, req.action, dispatch_args, source="mcp")
-
-    return router