ltcai 8.8.0 → 8.9.0

package/latticeai/services/search_service.py

@@ -42,9 +42,84 @@ class SearchService:
         graph = self._require_graph()
         return graph.filter_scoped_nodes(matches, allowed_workspaces)
 
+    def _graph_search(self, graph, query: str, *, limit: int, allowed_workspaces=None):
+        try:
+            return graph.search(query, limit, allowed_workspaces=allowed_workspaces)
+        except TypeError:
+            payload = graph.search(query, limit)
+            if allowed_workspaces is not None:
+                payload = {
+                    **payload,
+                    "matches": graph.filter_scoped_nodes(
+                        payload.get("matches", []),
+                        allowed_workspaces,
+                    ),
+                }
+            return payload
+
+    def _relationship_search(self, graph, *, allowed_workspaces=None, **kwargs):
+        try:
+            return graph.relationship_search(
+                **kwargs,
+                allowed_workspaces=allowed_workspaces,
+            )
+        except TypeError:
+            payload = graph.relationship_search(**kwargs)
+            if allowed_workspaces is not None:
+                kept = []
+                for rel in payload.get("relationships", []):
+                    endpoints = [
+                        {"id": (rel.get("source") or {}).get("id")},
+                        {"id": (rel.get("target") or {}).get("id")},
+                    ]
+                    if len(graph.filter_scoped_nodes(endpoints, allowed_workspaces)) == 2:
+                        kept.append(rel)
+                payload = {**payload, "relationships": kept}
+            return payload
+
+    def _traverse(self, graph, node_id: str, *, depth: int, limit: int, allowed_workspaces=None):
+        try:
+            return graph.traverse(
+                node_id,
+                depth=depth,
+                limit=limit,
+                allowed_workspaces=allowed_workspaces,
+            )
+        except TypeError:
+            neighborhood = graph.traverse(node_id, depth=depth, limit=limit)
+            if allowed_workspaces is not None:
+                nodes = graph.filter_scoped_nodes(
+                    neighborhood.get("nodes", []),
+                    allowed_workspaces,
+                )
+                kept = {item.get("id") for item in nodes}
+                edges = [
+                    edge for edge in neighborhood.get("edges", [])
+                    if edge.get("from") in kept and edge.get("to") in kept
+                ]
+                neighborhood = {**neighborhood, "nodes": nodes, "edges": edges}
+            return neighborhood
+
+    def _get_node(self, graph, node_id: str, *, allowed_workspaces=None):
+        try:
+            return graph.get_node(node_id, allowed_workspaces=allowed_workspaces)
+        except TypeError:
+            node = graph.get_node(node_id)
+            if allowed_workspaces is not None:
+                visible = graph.filter_scoped_nodes([node], allowed_workspaces)
+                if not visible:
+                    raise ValueError(f"graph node not found: {node_id}")
+                return visible[0]
+            return node
+
     def keyword_search(self, query: str, *, limit: int = 30, allowed_workspaces=None) -> Dict[str, Any]:
         graph = self._require_graph()
-        payload = graph.search(query, limit)
+        payload = self._graph_search(
+            graph,
+            query,
+            limit=limit,
+            allowed_workspaces=allowed_workspaces,
+        )
         matches = []
         for rank, match in enumerate(payload.get("matches", []), start=1):
             matches.append({
@@ -95,8 +170,18 @@ class SearchService:
         graph = self._require_graph()
         limit = max(1, min(int(limit or 30), 100))
         expand_depth = max(0, min(int(expand_depth or 1), 3))
-        direct = graph.search(query, limit=max(limit, 10)).get("matches", [])
-        relationships = graph.relationship_search(query=query, limit=limit).get("relationships", [])
+        direct = self._graph_search(
+            graph,
+            query,
+            limit=max(limit, 10),
+            allowed_workspaces=allowed_workspaces,
+        ).get("matches", [])
+        relationships = self._relationship_search(
+            graph,
+            query=query,
+            limit=limit,
+            allowed_workspaces=allowed_workspaces,
+        ).get("relationships", [])
         by_id: Dict[str, Dict[str, Any]] = {}
 
         def add_node(node: Mapping[str, Any], score: float, reason: str, edge: Optional[Mapping[str, Any]] = None) -> None:
@@ -138,7 +223,13 @@ class SearchService:
             if expand_depth <= 0:
                 continue
             try:
-                neighborhood = graph.traverse(match["id"], depth=expand_depth, limit=limit * 3)
+                neighborhood = self._traverse(
+                    graph,
+                    match["id"],
+                    depth=expand_depth,
+                    limit=limit * 3,
+                    allowed_workspaces=allowed_workspaces,
+                )
             except Exception:
                 neighborhood = {"nodes": [], "edges": []}
             edge_by_pair = {
@@ -262,23 +353,16 @@ class SearchService:
         allowed_workspaces=None,
     ) -> Dict[str, Any]:
         graph = self._require_graph()
-        node = graph.get_node(node_id)
-        if allowed_workspaces is not None:
-            visible = graph.filter_scoped_nodes([node], allowed_workspaces)
-            if not visible:
-                raise ValueError(f"graph node not found: {node_id}")
-            node = visible[0]
+        node = self._get_node(graph, node_id, allowed_workspaces=allowed_workspaces)
         payload = {"node": node}
         if include_neighbors:
-            neighborhood = graph.traverse(node_id, depth=depth, limit=limit)
-            if allowed_workspaces is not None:
-                nodes = graph.filter_scoped_nodes(neighborhood.get("nodes", []), allowed_workspaces)
-                kept = {item.get("id") for item in nodes}
-                edges = [
-                    edge for edge in neighborhood.get("edges", [])
-                    if edge.get("from") in kept and edge.get("to") in kept
-                ]
-                neighborhood = {**neighborhood, "nodes": nodes, "edges": edges}
+            neighborhood = self._traverse(
+                graph,
+                node_id,
+                depth=depth,
+                limit=limit,
+                allowed_workspaces=allowed_workspaces,
+            )
             payload["neighborhood"] = neighborhood
         return payload
 
@@ -292,22 +376,14 @@ class SearchService:
         allowed_workspaces=None,
     ) -> Dict[str, Any]:
         graph = self._require_graph()
-        payload = graph.relationship_search(
+        payload = self._relationship_search(
+            graph,
             query=query,
             node_id=node_id,
             relationship_type=relationship_type,
             limit=limit,
+            allowed_workspaces=allowed_workspaces,
         )
-        if allowed_workspaces is not None:
-            kept = []
-            for rel in payload.get("relationships", []):
-                endpoints = [
-                    {"id": (rel.get("source") or {}).get("id")},
-                    {"id": (rel.get("target") or {}).get("id")},
-                ]
-                if len(graph.filter_scoped_nodes(endpoints, allowed_workspaces)) == 2:
-                    kept.append(rel)
-            payload = {**payload, "relationships": kept}
         return payload
 
     def index_status(self) -> Dict[str, Any]:

package/latticeai/services/tool_dispatch.py

@@ -107,6 +107,53 @@ class ToolDispatchService:
                 detail=f"'{tool_name}' 툴은 관리자 전용입니다.",
             )
 
+    def user_role(self, current_user: str) -> str:
+        users = self.load_users()
+        try:
+            return str(self.get_user_role(current_user, users) or "user")
+        except Exception:
+            return "user"
+
+    def enforce_policy(
+        self,
+        tool_name: str,
+        args: Optional[dict],
+        *,
+        current_user: str,
+        source: str,
+        require_auto_approval: bool = True,
+        trusted_admin: bool = False,
+    ) -> ToolPolicy:
+        """Authorize a tool call before any hook or handler can execute.
+
+        This is the shared policy gate for direct HTTP/MCP/tool surfaces. Agent
+        runtime uses the same policy data and blocks non-auto-approved steps in
+        its state machine so Computer Use direct endpoints can remain unchanged
+        when explicitly excluded from a hardening pass.
+        """
+        policy = self.policy_for(tool_name, args or {})
+        if not trusted_admin:
+            self.check_role(tool_name, current_user)
+        if policy["destructive"] or policy["risk"] == "destructive":
+            raise HTTPException(
+                status_code=403,
+                detail=f"'{tool_name}' 툴은 파괴적 작업으로 차단되었습니다.",
+            )
+        if (
+            require_auto_approval
+            and not trusted_admin
+            and not policy["auto_approve"]
+            and self.user_role(current_user) != "admin"
+        ):
+            raise HTTPException(
+                status_code=403,
+                detail=(
+                    f"'{tool_name}' 툴은 명시 승인이 필요합니다. "
+                    "8.9.0에서는 승인 UI가 없는 직접 실행 경로에서 기본 차단됩니다."
+                ),
+            )
+        return policy
+
     def rollback_file(self, path: str) -> Dict[str, Any]:
         r = subprocess.run(
             ["git", "checkout", "--", path],
@@ -160,6 +207,25 @@ def check_tool_role(tool_name: str, current_user: str) -> None:
     DEFAULT_TOOL_DISPATCH_SERVICE.check_role(tool_name, current_user)
 
 
+def enforce_tool_policy(
+    tool_name: str,
+    args: Optional[dict],
+    *,
+    current_user: str,
+    source: str,
+    require_auto_approval: bool = True,
+    trusted_admin: bool = False,
+) -> ToolPolicy:
+    return DEFAULT_TOOL_DISPATCH_SERVICE.enforce_policy(
+        tool_name,
+        args or {},
+        current_user=current_user,
+        source=source,
+        require_auto_approval=require_auto_approval,
+        trusted_admin=trusted_admin,
+    )
+
+
 def collect_created_files(transcript: list) -> list:
     files = []
     for step in transcript:

package/latticeai/services/workspace_service.py

@@ -79,6 +79,21 @@ class WorkspaceService:
     def can_write(self, workspace_id: str, user_id: Optional[str]) -> bool:
         return self.store.has_permission(workspace_id, self._identity(user_id), "write")
 
+    def readable_workspaces(self, user_id: Optional[str]) -> list[str]:
+        """Return workspace ids the caller can read.
+
+        This keeps scoped read APIs from each reconstructing membership logic
+        from raw workspace state. The personal workspace remains readable via
+        the store's normal permission rules.
+        """
+        resolved_user = self._identity(user_id)
+        workspaces = (self.store.load_state().get("workspaces") or {})
+        return [
+            str(workspace_id)
+            for workspace_id in workspaces
+            if self.store.has_permission(str(workspace_id), resolved_user, "read")
+        ]
+
     # ── record-level authorization (by-id access must not bypass gating) ──
 
     def authorize_record_read(self, record: Dict[str, Any], user_id: Optional[str]) -> None:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "8.8.0",
+  "version": "8.9.0",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {

package/scripts/check_i18n_literals.mjs

@@ -4,10 +4,12 @@ import { join, relative } from "node:path";
 
 const repo = join(import.meta.dirname, "..");
 const roots = [
-  join(repo, "frontend", "src", "features", "brain"),
-  join(repo, "frontend", "src", "features", "admin"),
-  join(repo, "frontend", "src", "components", "onboarding"),
+  join(repo, "frontend", "src"),
 ];
+const allowlistPath = join(repo, "scripts", "i18n_literal_allowlist.json");
+const allowlist = existsSync(allowlistPath)
+  ? JSON.parse(readFileSync(allowlistPath, "utf8"))
+  : {};
 
 function walk(dir) {
   if (!existsSync(dir)) return [];
@@ -16,7 +18,9 @@ function walk(dir) {
     const path = join(dir, name);
     const stat = statSync(path);
     if (stat.isDirectory()) out.push(...walk(path));
-    else if (name.endsWith(".tsx")) out.push(path);
+    else if ((name.endsWith(".tsx") || name.endsWith(".ts")) && name !== "openapi.ts") {
+      out.push(path);
+    }
   }
   return out;
 }
@@ -25,6 +29,7 @@ const rawLocalizedProps = /\b(?:aria-label|placeholder|title)=["'][^"'{]*[A-Za-z
 const rawJsxText = />\s*([A-Z][A-Za-z0-9][^<>{}\n]{2,})\s*</g;
 const rawComponentCopy = /\b(?:title|detail|description|successLabel|empty)=["'][^"'{]*[A-Za-z][^"']*["']/g;
 let failures = 0;
+let allowed = 0;
 
 for (const file of roots.flatMap(walk)) {
   const text = readFileSync(file, "utf8");
@@ -38,9 +43,16 @@ for (const file of roots.flatMap(walk)) {
     matches.push(`JSX text: ${literal}`);
   }
   if (!matches.length) continue;
-  failures += matches.length;
-  for (const match of matches) {
-    console.error(`${relative(repo, file)}: hardcoded localized prop: ${match}`);
+  const rel = relative(repo, file);
+  const budget = Number(allowlist[rel]?.maxFindings || 0);
+  if (budget >= matches.length) {
+    allowed += matches.length;
+    continue;
+  }
+  const newMatches = matches.slice(budget);
+  failures += newMatches.length;
+  for (const match of newMatches) {
+    console.error(`${rel}: hardcoded localized prop: ${match}`);
   }
 }
 
@@ -49,4 +61,4 @@ if (failures) {
   process.exit(1);
 }
 
-console.log("i18n literal check: localized props use translation keys");
+console.log(`i18n literal check: localized props use translation keys (${allowed} allowlisted legacy literal(s))`);

package/scripts/i18n_literal_allowlist.json

@@ -0,0 +1,34 @@
+{
+  "frontend/src/App.tsx": {
+    "maxFindings": 1,
+    "reason": "legacy shell aria label pending translation-key migration"
+  },
+  "frontend/src/components/LivingBrain.tsx": {
+    "maxFindings": 1,
+    "reason": "legacy visual component aria label pending translation-key migration"
+  },
+  "frontend/src/components/primitives.tsx": {
+    "maxFindings": 1,
+    "reason": "shared empty-state fallback pending translation-key migration"
+  },
+  "frontend/src/pages/Act.tsx": {
+    "maxFindings": 41,
+    "reason": "large legacy automation page pending incremental copy migration"
+  },
+  "frontend/src/pages/Brain.tsx": {
+    "maxFindings": 25,
+    "reason": "large legacy memory page pending incremental copy migration"
+  },
+  "frontend/src/pages/Capture.tsx": {
+    "maxFindings": 2,
+    "reason": "technical type-name literals are intentionally preserved for now"
+  },
+  "frontend/src/pages/Library.tsx": {
+    "maxFindings": 21,
+    "reason": "large legacy model/plugin page pending incremental copy migration"
+  },
+  "frontend/src/pages/System.tsx": {
+    "maxFindings": 118,
+    "reason": "large legacy system/admin page pending incremental copy migration"
+  }
+}

package/scripts/lint_frontend.mjs

@@ -52,8 +52,12 @@ for (const file of files) {
 console.log(`privacy: ${scanned} frontend/static files scanned`);
 
 const client = readFileSync(join(frontend, "src", "api", "client.ts"), "utf8");
-if (!client.includes("openapi-fetch") || !client.includes("./openapi")) {
-  fail("frontend/src/api/client.ts must use the generated OpenAPI client");
+const apiBase = readFileSync(join(frontend, "src", "api", "base.ts"), "utf8");
+if (
+  !(client.includes("openapi-fetch") || apiBase.includes("openapi-fetch")) ||
+  !(client.includes("./openapi") || apiBase.includes("./openapi"))
+) {
+  fail("frontend/src/api/client.ts or base.ts must use the generated OpenAPI client");
 }
 if (!existsSync(join(frontend, "src", "api", "openapi.ts"))) {
   fail("generated OpenAPI types missing");