ltcai 6.3.0 → 6.4.0

package/latticeai/api/knowledge_graph.py

@@ -27,12 +27,32 @@ class KnowledgeGraphIngestRequest(BaseModel):
     metadata: Optional[Dict[str, Any]] = None
 
 
+def _format_context(matches: list, limit: int) -> str:
+    """Mirror ``KnowledgeGraphRetrievalMixin.context_for_query`` formatting for a
+    pre-filtered match list, so scoped callers get identical context lines minus
+    the rows they are not allowed to see."""
+    lines = []
+    for match in matches[:limit]:
+        meta = match.get("metadata") or {}
+        source = (
+            meta.get("relative_path")
+            or meta.get("filename")
+            or meta.get("conversation_id")
+            or meta.get("source")
+            or match.get("id")
+        )
+        summary = " ".join(str(match.get("summary") or "").split())[:700]
+        lines.append(f"- [{match.get('type')}] {match.get('title')} | source={source} | {summary}")
+    return "\n".join(lines)
+
+
 def create_knowledge_graph_router(
     *,
     get_graph: Callable[[], Any],
     require_graph: Callable[[], None],
     require_user: Callable[[Request], str],
     static_dir: Path,
+    allowed_workspaces_for: Optional[Callable[[Optional[str]], Any]] = None,
 ) -> APIRouter:
     router = APIRouter()
 
@@ -40,6 +60,21 @@ def create_knowledge_graph_router(
         require_graph()
         return get_graph()
 
+    def _scoped(request: Request):
+        """Authenticate the caller and resolve their allowed workspace set.
+
+        Returns ``(graph, allowed)``. ``allowed is None`` means no scoping
+        (single-user / no-auth mode); otherwise it is the set of workspace ids
+        the caller may read. Legacy-global rows (no workspace) stay visible —
+        the documented pre-v4 compatibility behavior enforced by
+        ``filter_scoped_nodes``.
+        """
+        user = require_user(request)
+        allowed = None
+        if allowed_workspaces_for is not None and user:
+            allowed = allowed_workspaces_for(user)
+        return graph(), allowed
+
     @router.get("/graph")
     async def knowledge_graph_page(request: Request):
         """Serve the interactive knowledge graph canvas UI."""
@@ -81,8 +116,10 @@ def create_knowledge_graph_router(
 
     @router.get("/knowledge-graph/graph")
     async def knowledge_graph_data(request: Request, limit: int = 300):
-        require_user(request)
-        return graph().graph(limit)
+        kg, allowed = _scoped(request)
+        if allowed is None:
+            return kg.graph(limit)
+        return kg.graph(limit, allowed_workspaces=allowed)
 
     @router.get("/knowledge-graph/documents")
     async def knowledge_graph_documents(request: Request, limit: int = 200):
@@ -91,27 +128,51 @@ def create_knowledge_graph_router(
         Backs the Files view so uploaded content is visible end-to-end:
         upload → Files → Knowledge Graph → Hybrid Search → Chat.
         """
-        require_user(request)
-        return graph().list_documents(limit)
+        kg, allowed = _scoped(request)
+        payload = kg.list_documents(limit)
+        if allowed is not None:
+            documents = kg.filter_scoped_nodes(payload.get("documents", []), allowed)
+            payload = {**payload, "documents": documents, "total": len(documents)}
+        return payload
 
     @router.get("/knowledge-graph/search")
     async def knowledge_graph_search(q: str, request: Request, limit: int = 30):
-        require_user(request)
+        kg, allowed = _scoped(request)
         if not q or not q.strip():
             return {"query": q, "matches": []}
-        return graph().search(q, limit)
+        payload = kg.search(q, limit)
+        if allowed is not None:
+            payload = {**payload, "matches": kg.filter_scoped_nodes(payload.get("matches", []), allowed)}
+        return payload
 
     @router.get("/knowledge-graph/context")
     async def knowledge_graph_context(q: str, request: Request, limit: int = 6):
-        require_user(request)
-        return {"query": q, "context": graph().context_for_query(q, limit)}
+        kg, allowed = _scoped(request)
+        if allowed is None:
+            return {"query": q, "context": kg.context_for_query(q, limit)}
+        # Scoped mode: derive context from scope-filtered search matches so the
+        # RAG context never carries content from workspaces the caller can't read.
+        matches = kg.filter_scoped_nodes(kg.search(q, limit).get("matches", []), allowed)
+        return {"query": q, "context": _format_context(matches, limit)}
 
     @router.get("/knowledge-graph/neighbors/{node_id:path}")
     async def knowledge_graph_neighbors(node_id: str, request: Request):
-        require_user(request)
+        kg, allowed = _scoped(request)
         if not node_id:
             raise HTTPException(status_code=400, detail="node_id required")
-        return graph().neighbors(node_id)
+        if allowed is not None and not kg.filter_scoped_nodes([{"id": node_id}], allowed):
+            raise HTTPException(status_code=404, detail="node not found")
+        payload = kg.neighbors(node_id)
+        if allowed is not None:
+            neighbors = kg.filter_scoped_nodes(payload.get("neighbors", []), allowed)
+            kept = {n.get("id") for n in neighbors}
+            edges = [
+                e for e in payload.get("edges", [])
+                if (e.get("from") == node_id or e.get("from") in kept)
+                and (e.get("to") == node_id or e.get("to") in kept)
+            ]
+            payload = {**payload, "neighbors": neighbors, "edges": edges}
+        return payload
 
     @router.post("/knowledge-graph/ingest")
     async def knowledge_graph_ingest(req: KnowledgeGraphIngestRequest, request: Request):

package/latticeai/api/local_files.py

@@ -48,6 +48,7 @@ def create_local_files_router(
     local_kg_watcher,
     hooks=None,
     data_dir: Optional[Path] = None,
+    allowed_workspaces_for=None,
 ) -> APIRouter:
     router = APIRouter()
 
@@ -210,6 +211,7 @@ def create_local_files_router(
             require_graph=require_graph,
             require_user=require_user,
             static_dir=static_dir,
+            allowed_workspaces_for=allowed_workspaces_for,
         )
     )
 

package/latticeai/api/memory.py

@@ -74,16 +74,16 @@ def create_memory_router(
     @router.post("/api/memory/prune")
     async def memory_prune(req: PruneRequest, request: Request):
         user = require_user(request)
-        gate_write(request)
-        result = service.prune(ids=req.ids, kind=req.kind, user_email=user)
+        scope = gate_write(request)
+        result = service.prune(ids=req.ids, kind=req.kind, user_email=user, workspace_id=scope)
         append_audit_event("memory_prune", user_email=user, count=result.get("count", 0))
         return result
 
     @router.post("/api/memory/compact")
     async def memory_compact(request: Request):
         user = require_user(request)
-        gate_write(request)
-        result = service.compact(user_email=user)
+        scope = gate_write(request)
+        result = service.compact(user_email=user, workspace_id=scope)
         append_audit_event("memory_compact", user_email=user, compacted=result.get("compacted", 0))
         return result
 
@@ -98,9 +98,9 @@ def create_memory_router(
     @router.post("/api/memory/clear")
     async def memory_clear(req: ClearRequest, request: Request):
         user = require_user(request)
-        gate_write(request)
+        scope = gate_write(request)
         try:
-            result = service.clear(scope=req.scope, confirm=req.confirm, user_email=user)
+            result = service.clear(scope=req.scope, confirm=req.confirm, user_email=user, workspace_id=scope)
         except ValueError as exc:
             raise HTTPException(status_code=400, detail=str(exc)) from exc
         append_audit_event("memory_clear", user_email=user, scope=req.scope)

package/latticeai/api/search.py

@@ -51,7 +51,15 @@ class _ScopedSearchService:
     """Injects the caller's workspace scope into every search call —
     enforcement lives at this one chokepoint, not in each handler."""
 
-    _SCOPED = {"keyword_search", "vector_search", "graph_search", "hybrid_search"}
+    _SCOPED = {
+        "keyword_search",
+        "vector_search",
+        "graph_search",
+        "hybrid_search",
+        "graph",
+        "node",
+        "relationships",
+    }
 
     def __init__(self, service: SearchService, allowed):
         self._service = service

package/latticeai/api/tools.py

@@ -202,6 +202,7 @@ def create_tools_router(
     install_mcp=None,
     mcp_public_item=None,
     hooks=None,
+    allowed_workspaces_for=None,
 ) -> APIRouter:
     if tool_context is not None:
         config = tool_context.config
@@ -227,6 +228,7 @@ def create_tools_router(
         install_mcp = tool_context.install_mcp
         mcp_public_item = tool_context.mcp_public_item
         hooks = tool_context.hooks
+        allowed_workspaces_for = tool_context.allowed_workspaces_for
 
     api_router = APIRouter()
     HOOKS = hooks
@@ -486,6 +488,7 @@ def create_tools_router(
         local_kg_watcher=LOCAL_KG_WATCHER,
         hooks=HOOKS,
         data_dir=DATA_DIR,
+        allowed_workspaces_for=allowed_workspaces_for,
     ))
     api_router.include_router(create_computer_use_router(
         model_router=router,

package/latticeai/app_factory.py

@@ -18,6 +18,7 @@ import threading
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from latticeai.runtime.app_context_runtime import build_app_context
+from latticeai.runtime.access_runtime import build_access_runtime
 from latticeai.runtime.bootstrap import build_session_runtime
 from latticeai.runtime.brain_runtime import build_brain_runtime
 from latticeai.runtime.chat_wiring import (
@@ -122,12 +123,11 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from latticeai.core.enterprise import (
         capability_registry,
     )
-    from latticeai.core.policy import normalize_role, policy_matrix, require_capability
+    from latticeai.core.policy import policy_matrix
     from latticeai.core.users import (
         ensure_user_identity,
         load_users_file,
         migrate_knowledge_graph_identity,
-        normalize_email,
         save_users_file,
         user_id_for_email as _user_id_for_email,
     )
@@ -813,42 +813,21 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     def clear_conversation(conversation_id: str, started_at: Optional[str] = None) -> Dict:
         return CONVERSATIONS.clear_conversation(conversation_id, started_at=started_at)
 
-    def get_user_role(email: str, users: Optional[Dict] = None) -> str:
-        users = users or load_users()
-        identity = str(email or "")
-        normalized_email = normalize_email(identity)
-        user = users.get(normalized_email) or users.get(identity) or next(
-            (
-                item for item in users.values()
-                if isinstance(item, dict) and item.get("id") == identity
-            ),
-            {},
-        )
-        if isinstance(user, dict) and user.get("role"):
-            return normalize_role(user["role"])
-        admin_emails = {normalize_email(item) for item in CONFIG.admin_emails}
-        if normalized_email in admin_emails:
-            return "admin"
-        first_email = next(iter(users), None)
-        return "admin" if first_email == normalized_email else "user"
-
-    def _extract_bearer_token(request: Request) -> Optional[str]:
-        auth = request.headers.get("Authorization", "")
-        if auth.startswith("Bearer "):
-            return auth[7:].strip()
-        return request.cookies.get("session_token")
-
-    def get_current_user(request: Request) -> Optional[str]:
-        token = _extract_bearer_token(request)
-        if token:
-            return get_session_email(token)
-        return None
-
-    def require_user(request: Request) -> str:
-        email = get_current_user(request)
-        if REQUIRE_AUTH and not email:
-            raise HTTPException(status_code=401, detail="인증이 필요합니다.")
-        return email or ""
+    _access_runtime = build_access_runtime(
+        config=CONFIG,
+        require_auth=REQUIRE_AUTH,
+        http_exception=HTTPException,
+        request_type=Request,
+        load_users=load_users,
+        get_session_email=get_session_email,
+        user_id_for_email=_user_id_for_email,
+    )
+    get_user_role = _access_runtime["get_user_role"]
+    _extract_bearer_token = _access_runtime["_extract_bearer_token"]
+    get_current_user = _access_runtime["get_current_user"]
+    require_user = _access_runtime["require_user"]
+    require_admin = _access_runtime["require_admin"]
+    public_user = _access_runtime["public_user"]
 
 
     # ── Rate limiting & file validation — delegated to latticeai.core.security ────
@@ -917,35 +896,6 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             raise HTTPException(status_code=403, detail="승인된 파일 내용과 요청 내용이 다릅니다.")
 
 
-    def require_admin(request: Request) -> tuple[str, Dict]:
-        users = load_users()
-        if not REQUIRE_AUTH:
-            return "", users
-        token = _extract_bearer_token(request)
-        if token:
-            email = get_session_email(token)
-            if email:
-                role = get_user_role(email, users)
-                try:
-                    require_capability(role, "admin:users")
-                    return email, users
-                except PermissionError:
-                    pass
-        raise HTTPException(status_code=403, detail="관리자 권한이 필요합니다.")
-
-    def public_user(email: str, user: Dict, users: Dict) -> Dict:
-        role = get_user_role(email, users)
-        user_id = user.get("id") or _user_id_for_email(users, email)
-        return {
-            "id": user_id,
-            "email": email,
-            "identity": user_id,
-            "name": user.get("name", ""),
-            "nickname": user.get("nickname", ""),
-            "role": role,
-            "disabled": bool(user.get("disabled", False)),
-        }
-
     def get_history_user(email: Optional[str], nickname: Optional[str] = None) -> Dict:
         if not email:
             return {"user_email": None, "user_nickname": nickname or None}

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "6.3.0"
+MARKETPLACE_VERSION = "6.4.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/workspace_os.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "6.3.0"
+WORKSPACE_OS_VERSION = "6.4.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/runtime/access_runtime.py

@@ -0,0 +1,97 @@
+"""Access-control helper closures for the app factory."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+
+def build_access_runtime(
+    *,
+    config: Any,
+    require_auth: bool,
+    http_exception: Any,
+    request_type: Any,
+    load_users: Callable[[], Dict],
+    get_session_email: Callable[[str], Optional[str]],
+    user_id_for_email: Callable[[Dict, str], str],
+) -> Dict[str, Any]:
+    """Build user/admin access helpers without changing legacy call signatures."""
+
+    from latticeai.core.policy import normalize_role, require_capability
+    from latticeai.core.users import normalize_email
+
+    def get_user_role(email: str, users: Optional[Dict] = None) -> str:
+        users = users or load_users()
+        identity = str(email or "")
+        normalized_email = normalize_email(identity)
+        user = users.get(normalized_email) or users.get(identity) or next(
+            (
+                item
+                for item in users.values()
+                if isinstance(item, dict) and item.get("id") == identity
+            ),
+            {},
+        )
+        if isinstance(user, dict) and user.get("role"):
+            return normalize_role(user["role"])
+        admin_emails = {normalize_email(item) for item in config.admin_emails}
+        if normalized_email in admin_emails:
+            return "admin"
+        first_email = next(iter(users), None)
+        return "admin" if first_email == normalized_email else "user"
+
+    def extract_bearer_token(request: request_type) -> Optional[str]:
+        auth = request.headers.get("Authorization", "")
+        if auth.startswith("Bearer "):
+            return auth[7:].strip()
+        return request.cookies.get("session_token")
+
+    def get_current_user(request: request_type) -> Optional[str]:
+        token = extract_bearer_token(request)
+        if token:
+            return get_session_email(token)
+        return None
+
+    def require_user(request: request_type) -> str:
+        email = get_current_user(request)
+        if require_auth and not email:
+            raise http_exception(status_code=401, detail="인증이 필요합니다.")
+        return email or ""
+
+    def require_admin(request: request_type) -> tuple[str, Dict]:
+        users = load_users()
+        if not require_auth:
+            return "", users
+        token = extract_bearer_token(request)
+        if token:
+            email = get_session_email(token)
+            if email:
+                role = get_user_role(email, users)
+                try:
+                    require_capability(role, "admin:users")
+                    return email, users
+                except PermissionError:
+                    pass
+        raise http_exception(status_code=403, detail="관리자 권한이 필요합니다.")
+
+    def public_user(email: str, user: Dict, users: Dict) -> Dict:
+        role = get_user_role(email, users)
+        user_id = user.get("id") or user_id_for_email(users, email)
+        return {
+            "id": user_id,
+            "email": email,
+            "identity": user_id,
+            "name": user.get("name", ""),
+            "nickname": user.get("nickname", ""),
+            "role": role,
+            "disabled": bool(user.get("disabled", False)),
+        }
+
+    return {
+        "get_user_role": get_user_role,
+        "_extract_bearer_token": extract_bearer_token,
+        "get_current_user": get_current_user,
+        "require_user": require_user,
+        "require_admin": require_admin,
+        "public_user": public_user,
+    }

package/latticeai/runtime/chat_wiring.py

@@ -88,6 +88,7 @@ def build_interaction_contexts(
         install_mcp=install_mcp,
         mcp_public_item=mcp_public_item,
         hooks=hooks,
+        allowed_workspaces_for=allowed_workspaces_for,
     )
     interaction_router_context = InteractionRouterContext(
         chat_context=chat_context,

package/latticeai/services/memory_service.py

@@ -133,8 +133,11 @@ class MemoryService:
 
     # ── Memory Manager: sources / usage / health ──────────────────────────
     def manager(self, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        ws_mem = self._workspace_memories(user_email=user_email, workspace_id="personal")
-        project_mem = [m for m in self._all_memories() if (m.get("workspace_id") or "personal") != "personal"]
+        ws_mem = self._workspace_memories(user_email=user_email, workspace_id=workspace_id or "personal")
+        if workspace_id is None:
+            project_mem = [m for m in self._all_memories() if (m.get("workspace_id") or "personal") != "personal"]
+        else:
+            project_mem = self._workspace_memories(user_email=user_email, workspace_id=workspace_id)
         snaps = self._snapshots(workspace_id=workspace_id)
         convs = self._conversations()
         kg_stats = self._kg_stats()
@@ -268,10 +271,13 @@ class MemoryService:
     # ── inspect a single tier ─────────────────────────────────────────────
     def inspect(self, source: str, *, user_email: Optional[str] = None, workspace_id: Optional[str] = None, limit: int = 50) -> Dict[str, Any]:
         if source == "workspace":
-            items = self._workspace_memories(user_email=user_email, workspace_id="personal")[:limit]
+            items = self._workspace_memories(user_email=user_email, workspace_id=workspace_id or "personal")[:limit]
             return {"source": source, "items": items, "count": len(items)}
         if source == "project":
-            items = [m for m in self._all_memories() if (m.get("workspace_id") or "personal") != "personal"][:limit]
+            if workspace_id is None:
+                items = [m for m in self._all_memories() if (m.get("workspace_id") or "personal") != "personal"][:limit]
+            else:
+                items = self._workspace_memories(user_email=user_email, workspace_id=workspace_id)[:limit]
             return {"source": source, "items": items, "count": len(items)}
         if source == "agent":
             items = self._snapshots(workspace_id=workspace_id)[:limit]
@@ -287,12 +293,39 @@ class MemoryService:
         raise KeyError(source)
 
     # ── mutating operations ───────────────────────────────────────────────
-    def prune(self, *, ids: Optional[List[str]] = None, kind: Optional[str] = None, user_email: Optional[str] = None) -> Dict[str, Any]:
+    def prune(
+        self,
+        *,
+        ids: Optional[List[str]] = None,
+        kind: Optional[str] = None,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        # Ownership guard: a caller may only prune memories they own. Both the
+        # explicit-id and kind paths are intersected with the caller's own
+        # memories, so a forged id for another user's memory is refused, not
+        # silently deleted.
+        owned_ids = {
+            m["id"]
+            for m in self._workspace_memories(user_email=user_email, workspace_id=workspace_id)
+            if m.get("id")
+        }
         removed: List[str] = []
-        target_ids = list(ids or [])
+        skipped: List[str] = []
+        target_ids: List[str] = []
+        seen: set = set()
+        for mid in (ids or []):
+            if mid in seen:
+                continue
+            seen.add(mid)
+            if mid in owned_ids:
+                target_ids.append(mid)
+            else:
+                skipped.append(mid)
         if kind:
-            for m in self._workspace_memories(user_email=user_email, workspace_id=None):
-                if m.get("kind") == kind and m.get("id"):
+            for m in self._workspace_memories(user_email=user_email, workspace_id=workspace_id):
+                if m.get("kind") == kind and m.get("id") and m["id"] not in seen:
+                    seen.add(m["id"])
                     target_ids.append(m["id"])
         for mid in target_ids:
             try:
@@ -300,14 +333,22 @@ class MemoryService:
                 removed.append(mid)
             except Exception:
                 continue
-        return {"removed": removed, "count": len(removed)}
+        result: Dict[str, Any] = {"removed": removed, "count": len(removed)}
+        if skipped:
+            result["skipped"] = skipped
+        return result
 
-    def compact(self, *, user_email: Optional[str] = None) -> Dict[str, Any]:
+    def compact(
+        self,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
         """Dedupe workspace memories with identical (kind, content)."""
         seen: set = set()
         removed: List[str] = []
         # Oldest first so the first occurrence (oldest) is kept.
-        memories = list(reversed(self._workspace_memories(user_email=user_email, workspace_id=None)))
+        memories = list(reversed(self._workspace_memories(user_email=user_email, workspace_id=workspace_id)))
         for m in memories:
             key = (m.get("kind"), str(m.get("content") or "").strip())
             if key in seen:
@@ -332,21 +373,23 @@ class MemoryService:
                 return {"status": "error", "detail": str(exc)}
         return {"status": "error", "detail": f"Unknown rebuild target: {target}"}
 
-    def clear(self, *, scope: str, confirm: bool = False, user_email: Optional[str] = None) -> Dict[str, Any]:
+    def clear(
+        self,
+        *,
+        scope: str,
+        confirm: bool = False,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
         if not confirm:
             raise ValueError("clear requires confirm=true")
         if scope in WORKSPACE_KINDS:
-            result = self.prune(kind=scope, user_email=user_email)
+            result = self.prune(kind=scope, user_email=user_email, workspace_id=workspace_id)
             return {"cleared": scope, **result}
         if scope == "workspace":
-            ids = [m["id"] for m in self._workspace_memories(user_email=user_email, workspace_id=None) if m.get("id")]
-            result = self.prune(ids=ids, user_email=user_email)
+            ids = [m["id"] for m in self._workspace_memories(user_email=user_email, workspace_id=workspace_id) if m.get("id")]
+            result = self.prune(ids=ids, user_email=user_email, workspace_id=workspace_id)
             return {"cleared": "workspace", **result}
         if scope == "graph":
-            if not self._enable_graph:
-                return {"status": "unavailable", "detail": "Knowledge graph disabled."}
-            try:
-                return {"cleared": "graph", "result": self._kg.clear_all()}
-            except Exception as exc:
-                return {"status": "error", "detail": str(exc)}
+            raise ValueError("graph clear is disabled from Memory Manager because it is not workspace-scoped")
         raise ValueError(f"unsupported clear scope: {scope}")

package/latticeai/services/router_context.py

@@ -34,6 +34,10 @@ class ToolRouterContext:
     install_mcp: Any
     mcp_public_item: Any
     hooks: Any = None
+    # Resolves a caller email to their allowed workspace set (None = no scoping,
+    # i.e. single-user / no-auth mode). Threaded to the knowledge-graph router so
+    # its read endpoints enforce the same workspace boundary as /api/search.
+    allowed_workspaces_for: Any = None
 
 
 @dataclass(frozen=True)