ltcai 8.8.0 → 9.0.0

package/latticeai/api/permissions.py

@@ -30,6 +30,7 @@ class PermissionGateway:
         self.get_current_user = get_current_user
         self.local_approval_ttl_seconds = 5 * 60
         self.local_approval_lock = threading.Lock()
+        self.perm_queue_lock = threading.Lock()
         self.local_approvals: Dict[str, Dict[str, object]] = {}
         self.discord_permission_webhook_url = config.discord_permission_webhook
         self.discord_bot_token = config.discord_bot_token
@@ -37,26 +38,46 @@ class PermissionGateway:
         self.permission_monitor_secret = config.permission_monitor_secret
         self.perm_queue_file = data_dir / "permission_queue.json"
 
+    @staticmethod
+    def token_hash(token: str) -> str:
+        return hashlib.sha256(str(token or "").encode("utf-8")).hexdigest()
+
+    @staticmethod
+    def token_hint(token: str) -> str:
+        value = str(token or "")
+        return value[:8] if value else ""
+
+    def _read_queue(self) -> Dict:
+        if not self.perm_queue_file.exists():
+            return {}
+        try:
+            return json.loads(self.perm_queue_file.read_text(encoding="utf-8"))
+        except Exception:
+            return {}
+
+    def _write_queue(self, queue: Dict) -> None:
+        self.perm_queue_file.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self.perm_queue_file.with_suffix(self.perm_queue_file.suffix + ".tmp")
+        tmp.write_text(json.dumps(queue, ensure_ascii=False, indent=2), encoding="utf-8")
+        tmp.replace(self.perm_queue_file)
+
     def _perm_queue_write(self, token: str, record: Dict[str, object]) -> None:
         try:
-            queue: Dict = {}
-            if self.perm_queue_file.exists():
-                try:
-                    queue = json.loads(self.perm_queue_file.read_text(encoding="utf-8"))
-                except Exception:
-                    queue = {}
-            queue[token] = {**record, "notified": False}
-            self.perm_queue_file.write_text(json.dumps(queue, ensure_ascii=False, indent=2), encoding="utf-8")
+            key = self.token_hash(token)
+            with self.perm_queue_lock:
+                queue = self._read_queue()
+                queue[key] = {**record, "token_hint": self.token_hint(token), "notified": False}
+                self._write_queue(queue)
         except Exception as exc:
             logging.warning("perm_queue_write failed: %s", exc)
 
     def _perm_queue_remove(self, token: str) -> None:
         try:
-            if not self.perm_queue_file.exists():
-                return
-            queue: Dict = json.loads(self.perm_queue_file.read_text(encoding="utf-8"))
-            queue.pop(token, None)
-            self.perm_queue_file.write_text(json.dumps(queue, ensure_ascii=False, indent=2), encoding="utf-8")
+            key = self.token_hash(token)
+            with self.perm_queue_lock:
+                queue = self._read_queue()
+                queue.pop(key, None)
+                self._write_queue(queue)
         except Exception as exc:
             logging.warning("perm_queue_remove failed: %s", exc)
 
@@ -156,9 +177,10 @@ class PermissionGateway:
             "approved": False,
         }
         if action == "write":
+            self.ensure_path_allowed(path, action="write")
             record["content_hash"] = self.content_fingerprint(content)
         with self.local_approval_lock:
-            self.local_approvals[token] = record
+            self.local_approvals[self.token_hash(token)] = {**record, "token_hint": self.token_hint(token)}
         self._perm_queue_write(token, record)
         action_label = _PERMISSION_ACTION_LABELS.get(action, action)
         return {
@@ -190,12 +212,14 @@ class PermissionGateway:
         if not token:
             raise HTTPException(status_code=403, detail="파일 접근 승인 토큰이 필요합니다.")
         normalized = self.normalize_local_path_for_approval(path)
+        self.ensure_path_allowed(normalized, action=action)
         now = time.time()
+        key = self.token_hash(token)
         with self.local_approval_lock:
-            expired = [key for key, value in self.local_approvals.items() if float(value.get("expires_at", 0)) < now]
-            for key in expired:
-                self.local_approvals.pop(key, None)
-            record = self.local_approvals.get(token)
+            expired = [approval_key for approval_key, value in self.local_approvals.items() if float(value.get("expires_at", 0)) < now]
+            for expired_key in expired:
+                self.local_approvals.pop(expired_key, None)
+            record = self.local_approvals.get(key)
         if not record:
             raise HTTPException(status_code=403, detail="파일 접근 승인이 만료되었거나 유효하지 않습니다.")
         if not record.get("approved"):
@@ -213,13 +237,25 @@ class PermissionGateway:
             if auth_header == f"Bearer {self.permission_monitor_secret}":
                 return
         if token:
+            key = self.token_hash(token)
             current_user = self.get_current_user(request)
             with self.local_approval_lock:
-                record = self.local_approvals.get(token)
+                record = self.local_approvals.get(key)
             if current_user and record and record.get("user_email") == current_user:
                 return
         self.require_admin(request)
 
+    def ensure_path_allowed(self, path: str, *, action: str) -> None:
+        if action != "write":
+            return
+        normalized = self.normalize_local_path_for_approval(path)
+        from latticeai.services.tool_dispatch import LOCAL_WRITE_BLOCKED_PREFIXES
+
+        for prefix in LOCAL_WRITE_BLOCKED_PREFIXES:
+            normalized_prefix = str(Path(prefix).expanduser()).rstrip("/")
+            if normalized == normalized_prefix or normalized.startswith(normalized_prefix + "/"):
+                raise HTTPException(status_code=403, detail=f"쓰기 금지 경로입니다: {prefix}")
+
 
 def create_permissions_router(
     *,
@@ -243,11 +279,11 @@ def create_permissions_router(
         now = time.time()
         with gateway.local_approval_lock:
             result = {}
-            for tok, rec in list(gateway.local_approvals.items()):
+            for token_hash, rec in list(gateway.local_approvals.items()):
                 expires_at = float(rec.get("expires_at", 0))
                 if expires_at < now:
                     continue
-                result[tok] = {
+                result[str(rec.get("token_hint") or token_hash[:8])] = {
                     "path": rec.get("path"),
                     "action": rec.get("action"),
                     "action_label": _PERMISSION_ACTION_LABELS.get(str(rec.get("action", "")), str(rec.get("action", ""))),
@@ -260,25 +296,26 @@ def create_permissions_router(
     @router.post("/permissions/approve/{token}")
     async def permissions_approve(token: str, request: Request):
         gateway.check_permission_auth(request, token)
+        key = gateway.token_hash(token)
         with gateway.local_approval_lock:
-            record = gateway.local_approvals.get(token)
+            record = gateway.local_approvals.get(key)
             if not record:
                 raise HTTPException(status_code=404, detail="토큰이 없거나 만료되었습니다.")
             if float(record.get("expires_at", 0)) < time.time():
-                gateway.local_approvals.pop(token, None)
+                gateway.local_approvals.pop(key, None)
                 raise HTTPException(status_code=410, detail="토큰이 만료되었습니다.")
             record["approved"] = True
         gateway._perm_queue_remove(token)
         logging.info(
             "Permission approved: token=%s path=%s action=%s user=%s",
-            token,
+            gateway.token_hint(token),
             record.get("path"),
             record.get("action"),
             record.get("user_email"),
         )
         return {
             "ok": True,
-            "token": token,
+            "token_hint": gateway.token_hint(token),
             "path": record.get("path"),
             "action": record.get("action"),
             "user_email": record.get("user_email"),
@@ -287,14 +324,15 @@ def create_permissions_router(
     @router.post("/permissions/deny/{token}")
     async def permissions_deny(token: str, request: Request):
         gateway.check_permission_auth(request, token)
+        key = gateway.token_hash(token)
         with gateway.local_approval_lock:
-            record = gateway.local_approvals.pop(token, None)
+            record = gateway.local_approvals.pop(key, None)
         gateway._perm_queue_remove(token)
         if not record:
             raise HTTPException(status_code=404, detail="토큰이 없거나 이미 처리되었습니다.")
         logging.info(
             "Permission denied: token=%s path=%s action=%s user=%s",
-            token,
+            gateway.token_hint(token),
             record.get("path"),
             record.get("action"),
             record.get("user_email"),
@@ -302,7 +340,7 @@ def create_permissions_router(
         return {
             "ok": True,
             "denied": True,
-            "token": token,
+            "token_hint": gateway.token_hint(token),
             "path": record.get("path"),
             "action": record.get("action"),
         }
@@ -311,17 +349,18 @@ def create_permissions_router(
     async def permissions_status(token: str, request: Request):
         require_user(request)
         now = time.time()
+        key = gateway.token_hash(token)
         with gateway.local_approval_lock:
-            record = gateway.local_approvals.get(token)
+            record = gateway.local_approvals.get(key)
         if not record:
-            return {"status": "denied_or_expired", "token": token}
+            return {"status": "denied_or_expired", "token_hint": gateway.token_hint(token)}
         if float(record.get("expires_at", 0)) < now:
-            return {"status": "expired", "token": token}
+            return {"status": "expired", "token_hint": gateway.token_hint(token)}
         if record.get("approved"):
-            return {"status": "approved", "token": token}
+            return {"status": "approved", "token_hint": gateway.token_hint(token)}
         return {
             "status": "pending",
-            "token": token,
+            "token_hint": gateway.token_hint(token),
             "expires_in": round(float(record.get("expires_at", 0)) - now),
         }
 

package/latticeai/api/setup.py

@@ -8,6 +8,7 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
+from latticeai.services.process_audit import command_plan
 from auto_setup import (
     plan as auto_setup_plan,
     preset as auto_setup_preset,
@@ -21,6 +22,7 @@ from setup_wizard import get_recommendations, install_stream, open_url, scan_env
 
 class SetupInstallRequest(BaseModel):
     items: List[Dict]
+    confirmation_token: Optional[str] = None
 
 
 def create_setup_router(*, model_router, require_user) -> APIRouter:
@@ -83,11 +85,19 @@ def create_setup_router(*, model_router, require_user) -> APIRouter:
                     command = ["lattice-ai", "models", "load", str(model_id)]
                 else:
                     command = ["huggingface-cli", "download", str(model_id), "--quiet"]
+                step_plan = command_plan(
+                    command,
+                    name=f"weights:{model_id}",
+                    purpose="auto_setup_install",
+                    metadata={"model_id": str(model_id)},
+                )
                 zero_config["plan"]["steps"] = [{
                     "name": f"weights:{model_id}",
                     "why": "추론에 사용할 모델 가중치",
                     "command": command,
                     "requires_admin": False,
+                    "command_plan": step_plan,
+                    "confirmation_token": step_plan["confirmation_token"],
                 }]
             if isinstance(zero_config.get("preset"), dict):
                 zero_config["preset"].setdefault("model", {})["id"] = model_id
@@ -107,9 +117,14 @@ def create_setup_router(*, model_router, require_user) -> APIRouter:
     @api_router.post("/setup/install")
     async def setup_install(req: SetupInstallRequest, request: Request):
         """선택된 항목을 순서대로 설치 · 로드하는 SSE 스트림."""
-        require_user(request)
+        user_email = require_user(request)
         async def _gen():
-            async for chunk in install_stream(req.items, router):
+            async for chunk in install_stream(
+                req.items,
+                router,
+                confirmation_token=req.confirmation_token,
+                user_email=user_email,
+            ):
                 yield chunk
         return StreamingResponse(_gen(), media_type="text/event-stream",
                                  headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})

package/latticeai/api/tools.py

@@ -3,11 +3,12 @@
 from __future__ import annotations
 
 import base64
+import inspect
 import io
 import logging
 import shutil
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, File, HTTPException, Request, UploadFile
 from fastapi.responses import FileResponse
@@ -24,6 +25,7 @@ from latticeai.services.tool_dispatch import (
     TOOL_GOVERNANCE_DEFAULT as _TOOL_GOVERNANCE_DEFAULT,
     check_tool_role as _check_tool_role,
     get_tool_permission,
+    enforce_tool_policy,
     list_tool_permissions,
     tool_registry_diagnostics,
     tool_registry_manifest,
@@ -253,7 +255,21 @@ def create_tools_router(
 
     # ── Direct Tool API ───────────────────────────────────────────────────────────
     
-    def _tool_response(fn, *args, **kwargs):
+    def _policy_args(fn, *args, **kwargs) -> Dict:
+        try:
+            bound = inspect.signature(fn).bind_partial(*args, **kwargs)
+            return dict(bound.arguments)
+        except Exception:
+            return dict(kwargs)
+
+    def _tool_response(
+        fn,
+        *args,
+        current_user: Optional[str] = None,
+        source: str = "http",
+        trusted_admin: bool = False,
+        **kwargs,
+    ):
         # Shared tool lifecycle (same path as the agent + workflow tool calls):
         # pre_tool (may block) → execute → post_tool. Keyword args are forwarded
         # to the tool and surfaced in the hook payload so read_file / edit_file /
@@ -261,7 +277,16 @@ def create_tools_router(
         # tool instead of bypassing it.
         tool_name = getattr(fn, "__name__", "tool")
         try:
-            result = dispatch_tool(HOOKS, tool_name, dict(kwargs), lambda: fn(*args, **kwargs), source="http")
+            policy_args = _policy_args(fn, *args, **kwargs)
+            if current_user is not None:
+                enforce_tool_policy(
+                    tool_name,
+                    policy_args,
+                    current_user=current_user,
+                    source=source,
+                    trusted_admin=trusted_admin,
+                )
+            result = dispatch_tool(HOOKS, tool_name, dict(kwargs), lambda: fn(*args, **kwargs), source=source)
         except PermissionError as exc:
             raise HTTPException(status_code=403, detail=str(exc))
         except ToolError as exc:
@@ -277,47 +302,58 @@ def create_tools_router(
             raise HTTPException(status_code=403, detail=str(exc))
         except ToolError as exc:
             raise HTTPException(status_code=400, detail=str(exc))
+
+    def _history_scope(user_email: str) -> Dict[str, Any]:
+        require_auth = bool(getattr(CONFIG, "require_auth", False))
+        scope: Dict[str, Any] = {
+            "user_email": user_email if require_auth else None,
+            "allowed_workspaces": None,
+            "include_legacy_global": not require_auth,
+        }
+        if require_auth and user_email and allowed_workspaces_for is not None:
+            scope["allowed_workspaces"] = allowed_workspaces_for(user_email)
+        return scope
     
     
     @api_router.post("/tools/list_dir")
     async def tools_list_dir(req: ToolPathRequest, request: Request):
-        require_user(request)
-        return _tool_response(list_dir, req.path)
+        current_user = require_user(request)
+        return _tool_response(list_dir, req.path, current_user=current_user)
     
     
     @api_router.post("/tools/workspace_tree")
     async def tools_workspace_tree(req: ToolWorkspaceTreeRequest, request: Request):
-        require_user(request)
-        return _tool_response(workspace_tree, req.path, req.max_depth)
+        current_user = require_user(request)
+        return _tool_response(workspace_tree, req.path, req.max_depth, current_user=current_user)
     
     
     @api_router.post("/tools/read_file")
     async def tools_read_file(req: ToolReadFileRequest, request: Request):
-        require_user(request)
-        return _tool_response(read_file, req.path, offset=req.offset, limit=req.limit, line_numbers=req.line_numbers)
+        current_user = require_user(request)
+        return _tool_response(read_file, req.path, offset=req.offset, limit=req.limit, line_numbers=req.line_numbers, current_user=current_user)
     
     
     @api_router.post("/tools/write_file")
     async def tools_write_file(req: ToolWriteFileRequest, request: Request):
-        require_user(request)
-        return _tool_response(write_file, req.path, req.content)
+        current_user = require_user(request)
+        return _tool_response(write_file, req.path, req.content, current_user=current_user)
     
     
     @api_router.post("/tools/edit_file")
     async def tools_edit_file(req: ToolEditFileRequest, request: Request):
-        require_user(request)
-        return _tool_response(edit_file, req.path, req.old_string, req.new_string, replace_all=req.replace_all)
+        current_user = require_user(request)
+        return _tool_response(edit_file, req.path, req.old_string, req.new_string, replace_all=req.replace_all, current_user=current_user)
     
     
     @api_router.post("/tools/search_files")
     async def tools_search_files(req: ToolSearchFilesRequest, request: Request):
-        require_user(request)
-        return _tool_response(search_files, req.query, req.path, req.max_results)
+        current_user = require_user(request)
+        return _tool_response(search_files, req.query, req.path, req.max_results, current_user=current_user)
     
     
     @api_router.post("/tools/grep")
     async def tools_grep(req: ToolGrepRequest, request: Request):
-        require_user(request)
+        current_user = require_user(request)
         return _tool_response(
             grep,
             req.pattern,
@@ -326,25 +362,31 @@ def create_tools_router(
             max_results=req.max_results,
             case_insensitive=req.case_insensitive,
             context_lines=req.context_lines,
+            current_user=current_user,
         )
     
     
     @api_router.post("/tools/todo_read")
     async def tools_todo_read(request: Request):
-        require_user(request)
-        return _tool_response(todo_read)
+        current_user = require_user(request)
+        return _tool_response(todo_read, current_user=current_user)
     
     
     @api_router.post("/tools/todo_write")
     async def tools_todo_write(req: ToolTodoWriteRequest, request: Request):
-        require_user(request)
-        return _tool_response(todo_write, req.todos)
+        current_user = require_user(request)
+        return _tool_response(todo_write, req.todos, current_user=current_user)
     
     
     @api_router.post("/tools/clear_history")
     async def tools_clear_history(req: ToolClearHistoryRequest, request: Request):
         current_user = require_user(request)
-        result = _dispatch("clear_history", {"keep_last": req.keep_last}, lambda: clear_history(req.keep_last))
+        scope = _history_scope(current_user)
+        result = _dispatch(
+            "clear_history",
+            {"keep_last": req.keep_last, **scope},
+            lambda: clear_history(req.keep_last, **scope),
+        )
         append_audit_event(
             "history_delete",
             user_email=current_user,
@@ -358,38 +400,38 @@ def create_tools_router(
     
     @api_router.post("/tools/inspect_html")
     async def tools_inspect_html(req: ToolPathRequest, request: Request):
-        require_user(request)
-        return _tool_response(inspect_html, req.path)
+        current_user = require_user(request)
+        return _tool_response(inspect_html, req.path, current_user=current_user)
     
     
     @api_router.post("/tools/preview_url")
     async def tools_preview_url(req: ToolPathRequest, request: Request):
-        require_user(request)
-        return _tool_response(preview_url, req.path)
+        current_user = require_user(request)
+        return _tool_response(preview_url, req.path, current_user=current_user)
     
     
     @api_router.post("/tools/create_docx")
     async def tools_create_docx(req: ToolDocxRequest, request: Request):
-        require_user(request)
-        return _tool_response(create_docx, req.title, req.body, req.filename)
+        current_user = require_user(request)
+        return _tool_response(create_docx, req.title, req.body, req.filename, current_user=current_user)
     
     
     @api_router.post("/tools/create_xlsx")
     async def tools_create_xlsx(req: ToolXlsxRequest, request: Request):
-        require_user(request)
-        return _tool_response(create_xlsx, req.rows, req.filename, req.sheet_name)
+        current_user = require_user(request)
+        return _tool_response(create_xlsx, req.rows, req.filename, req.sheet_name, current_user=current_user)
     
     
     @api_router.post("/tools/create_pptx")
     async def tools_create_pptx(req: ToolPptxRequest, request: Request):
-        require_user(request)
-        return _tool_response(create_pptx, req.title, req.slides, req.filename)
+        current_user = require_user(request)
+        return _tool_response(create_pptx, req.title, req.slides, req.filename, current_user=current_user)
     
     
     @api_router.post("/tools/create_pdf")
     async def tools_create_pdf(req: ToolPdfRequest, request: Request):
-        require_user(request)
-        return _tool_response(create_pdf, req.title, req.body, req.filename)
+        current_user = require_user(request)
+        return _tool_response(create_pdf, req.title, req.body, req.filename, current_user=current_user)
     
     
     @api_router.post("/tools/read_document")
@@ -402,7 +444,7 @@ def create_tools_router(
                 action="read",
                 user_email=current_user,
             )
-        return _tool_response(read_document, req.path)
+        return _tool_response(read_document, req.path, current_user=current_user)
     
     
     @api_router.get("/tools/pdf_pages")
@@ -499,42 +541,43 @@ def create_tools_router(
         tool_response=_tool_response,
         save_to_history=save_to_history,
         hooks=HOOKS,
+        append_audit_event=append_audit_event,
     ))
 
     @api_router.post("/tools/knowledge_save")
     async def tools_knowledge_save(req: ToolKnowledgeSaveRequest, request: Request):
-        require_user(request)
-        return _tool_response(knowledge_save, req.content, req.folder, req.title)
+        current_user = require_user(request)
+        return _tool_response(knowledge_save, req.content, req.folder, req.title, current_user=current_user)
     
     
     @api_router.post("/tools/knowledge_search")
     async def tools_knowledge_search(req: ToolKnowledgeSearchRequest, request: Request):
-        require_user(request)
-        return _tool_response(knowledge_search, req.query, req.max_results)
+        current_user = require_user(request)
+        return _tool_response(knowledge_search, req.query, req.max_results, current_user=current_user)
     
     
     @api_router.get("/tools/knowledge_tree")
     async def tools_knowledge_tree(request: Request):
-        require_user(request)
-        return _tool_response(knowledge_tree)
+        current_user = require_user(request)
+        return _tool_response(knowledge_tree, current_user=current_user)
     
     
     @api_router.post("/tools/obsidian_save")
     async def tools_obsidian_save(req: ToolKnowledgeSaveRequest, request: Request):
-        require_user(request)
-        return _tool_response(obsidian_save, req.content, req.folder, req.title)
+        current_user = require_user(request)
+        return _tool_response(obsidian_save, req.content, req.folder, req.title, current_user=current_user)
     
     
     @api_router.post("/tools/obsidian_search")
     async def tools_obsidian_search(req: ToolKnowledgeSearchRequest, request: Request):
-        require_user(request)
-        return _tool_response(obsidian_search, req.query, req.max_results)
+        current_user = require_user(request)
+        return _tool_response(obsidian_search, req.query, req.max_results, current_user=current_user)
     
     
     @api_router.get("/tools/obsidian_tree")
     async def tools_obsidian_tree(request: Request):
-        require_user(request)
-        return _tool_response(obsidian_tree)
+        current_user = require_user(request)
+        return _tool_response(obsidian_tree, current_user=current_user)
     
     
     @api_router.get("/obsidian/status")
@@ -550,50 +593,50 @@ def create_tools_router(
     
     @api_router.get("/tools/git_status")
     async def tools_git_status(request: Request):
-        require_user(request)
-        return _tool_response(git_status)
+        current_user = require_user(request)
+        return _tool_response(git_status, current_user=current_user)
     
     
     @api_router.post("/tools/git_diff")
     async def tools_git_diff(req: ToolGitDiffRequest, request: Request):
-        require_user(request)
-        return _tool_response(git_diff, req.path, req.cwd)
+        current_user = require_user(request)
+        return _tool_response(git_diff, req.path, req.cwd, current_user=current_user)
     
     
     @api_router.post("/tools/git_log")
     async def tools_git_log(req: ToolGitLogRequest, request: Request):
-        require_user(request)
-        return _tool_response(git_log, req.max_count, req.cwd)
+        current_user = require_user(request)
+        return _tool_response(git_log, req.max_count, req.cwd, current_user=current_user)
     
     
     @api_router.post("/tools/git_show")
     async def tools_git_show(req: ToolGitShowRequest, request: Request):
-        require_user(request)
-        return _tool_response(git_show, req.revision, req.cwd)
+        current_user = require_user(request)
+        return _tool_response(git_show, req.revision, req.cwd, current_user=current_user)
     
     
     @api_router.post("/tools/run_command")
     async def tools_run_command(req: ToolRunCommandRequest, request: Request):
-        require_admin(request)
-        return _tool_response(run_command, req.command, req.cwd)
+        current_user, _users = require_admin(request)
+        return _tool_response(run_command, req.command, req.cwd, current_user=current_user, trusted_admin=True)
     
     
     @api_router.get("/tools/network_status")
     async def tools_network_status(request: Request):
-        require_user(request)
-        return _tool_response(network_status)
+        current_user = require_user(request)
+        return _tool_response(network_status, current_user=current_user)
     
     
     @api_router.post("/tools/build_project")
     async def tools_build_project(req: ToolScriptRequest, request: Request):
-        require_admin(request)
-        return _tool_response(build_project, req.cwd, req.script)
+        current_user, _users = require_admin(request)
+        return _tool_response(build_project, req.cwd, req.script, current_user=current_user, trusted_admin=True)
     
     
     @api_router.post("/tools/deploy_project")
     async def tools_deploy_project(req: ToolScriptRequest, request: Request):
-        require_admin(request)
-        return _tool_response(deploy_project, req.cwd, req.script)
+        current_user, _users = require_admin(request)
+        return _tool_response(deploy_project, req.cwd, req.script, current_user=current_user, trusted_admin=True)
     
     
     @api_router.get("/tools/permissions")