ltcai 8.7.0 → 8.9.0

package/latticeai/services/model_engines.py

@@ -23,6 +23,13 @@ from typing import Any, Dict, List, Optional
 
 from fastapi import HTTPException
 
+from latticeai.services.process_audit import (
+    CommandConfirmationError,
+    append_process_audit_event,
+    command_plan,
+    require_command_confirmation,
+)
+
 
 def _progress_payload(*args, **kwargs) -> Dict[str, object]:
     try:
@@ -440,8 +447,8 @@ def engine_support_status(engine: str) -> Dict[str, object]:
     return {"supported": True, "reason": None}
 
 
-def install_engine(engine: str) -> Dict[str, Any]:
-    from latticeai.services.model_runtime import BASE_DIR, ENGINE_INSTALLERS, engine_installed
+def _engine_install_command(engine: str) -> tuple[list[str], str, bool]:
+    from latticeai.services.model_runtime import BASE_DIR, ENGINE_INSTALLERS
 
     if engine not in ENGINE_INSTALLERS:
         raise HTTPException(status_code=400, detail="지원하지 않는 엔진입니다.")
@@ -449,14 +456,7 @@ def install_engine(engine: str) -> Dict[str, Any]:
     required_binary = installer.get("requires_binary")
     if required_binary and shutil.which(required_binary) is None:
         raise HTTPException(status_code=400, detail=f"{required_binary}가 설치되어 있지 않아 자동 설치할 수 없습니다.")
-    command = installer["command"]
-    run_kwargs = {
-        "cwd": str(BASE_DIR),
-        "capture_output": True,
-        "text": True,
-        "timeout": 900,
-        "check": False,
-    }
+    command = list(installer["command"])
 
     if engine == "vllm" and sys.platform == "darwin" and platform.machine() == "arm64":
         command = [
@@ -468,13 +468,69 @@ def install_engine(engine: str) -> Dict[str, Any]:
             "~/.venv-vllm-metal/bin/pip install -U pip setuptools wheel; "
             "~/.venv-vllm-metal/bin/pip install vllm-metal",
         ]
+    requires_admin = bool(command and command[0] in {"apt", "apt-get", "dnf", "pacman"})
+    return command, str(BASE_DIR), requires_admin
+
+
+def engine_install_plan(engine: str) -> Dict[str, Any]:
+    command, cwd, requires_admin = _engine_install_command(engine)
+    return command_plan(
+        command,
+        name=f"engine:{engine}",
+        purpose="engine_install",
+        cwd=cwd,
+        requires_admin=requires_admin,
+        metadata={"engine": engine},
+    )
+
+
+def install_engine(engine: str, confirmation_token: Optional[str] = None) -> Dict[str, Any]:
+    from latticeai.services.model_runtime import engine_installed
+
+    command, cwd, _requires_admin = _engine_install_command(engine)
+    plan = engine_install_plan(engine)
+    try:
+        require_command_confirmation(command, confirmation_token, cwd=cwd, purpose="engine_install")
+    except CommandConfirmationError as exc:
+        append_process_audit_event("engine_install", plan=plan, status="denied", error=str(exc))
+        raise HTTPException(
+            status_code=403,
+            detail={
+                "status": "confirmation_required",
+                "reason": str(exc),
+                "install_plan": plan,
+            },
+        ) from exc
+
+    run_kwargs = {
+        "cwd": cwd,
+        "capture_output": True,
+        "text": True,
+        "timeout": 900,
+        "check": False,
+    }
     try:
+        append_process_audit_event("engine_install", plan=plan, status="started")
         completed = subprocess.run(command, **run_kwargs)
     except subprocess.TimeoutExpired:
+        append_process_audit_event("engine_install", plan=plan, status="timeout")
         raise HTTPException(status_code=408, detail="엔진 설치 시간이 초과되었습니다.")
+    except Exception as exc:
+        append_process_audit_event("engine_install", plan=plan, status="error", error=str(exc))
+        raise
+    append_process_audit_event(
+        "engine_install",
+        plan=plan,
+        status="finished",
+        returncode=completed.returncode,
+        stdout=completed.stdout,
+        stderr=completed.stderr,
+    )
     result = {
         "engine": engine,
-        "command": " ".join(command),
+        "command_hash": plan["command_hash"],
+        "command_preview": plan["command_preview"],
+        "install_plan": plan,
         "returncode": completed.returncode,
         "stdout": completed.stdout[-12000:],
         "stderr": completed.stderr[-12000:],
@@ -491,15 +547,25 @@ def install_engine(engine: str) -> Dict[str, Any]:
         if already_up:
             result["daemon_started"] = "already_running"
         else:
+            daemon_command = [ollama, "serve"]
+            daemon_plan = command_plan(
+                daemon_command,
+                name="engine:ollama:serve",
+                purpose="engine_daemon_start",
+                metadata={"engine": "ollama"},
+            )
             try:
+                append_process_audit_event("engine_daemon_start", plan=daemon_plan, status="started")
                 subprocess.Popen(
-                    [ollama, "serve"],
+                    daemon_command,
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.DEVNULL,
                     start_new_session=True,
                 )
+                append_process_audit_event("engine_daemon_start", plan=daemon_plan, status="spawned")
                 result["daemon_started"] = True
             except Exception as exc:
+                append_process_audit_event("engine_daemon_start", plan=daemon_plan, status="error", error=str(exc))
                 logging.warning("ollama serve spawn failed: %s", exc)
                 result["daemon_started"] = False
     return result
@@ -589,6 +655,7 @@ __all__ = [
     "pull_ollama_model_with_progress",
     "get_ollama_pulled_models",
     "engine_support_status",
+    "engine_install_plan",
     "install_engine",
     "_smoke_test_loaded_model",
 ]

package/latticeai/services/model_runtime.py

@@ -47,6 +47,7 @@ from .model_engines import (
     pull_ollama_model_with_progress as _pull_ollama_model_with_progress,
     get_ollama_pulled_models as _get_ollama_pulled_models,
     engine_support_status as _engine_support_status,
+    engine_install_plan as _engine_install_plan,
     install_engine as _install_engine,
     local_binary as _local_binary,
     vllm_executable as _vllm_executable,
@@ -88,6 +89,8 @@ class ModelRuntimeState:
         self.ENABLE_GRAPH = True
         self.AUTOLOAD_MODELS = False
         self.MODEL_IDLE_UNLOAD_SECONDS = 0
+        self.ALLOW_MODEL_DOWNLOADS = False
+        self.MODEL_DOWNLOAD_TIMEOUT = 300
         self.ALLOW_LOCAL_MODELS = True
         self.REQUIRE_AUTH = False
         self.INVITE_GATE_ENABLED = False
@@ -118,7 +121,8 @@ class ModelRuntimeState:
         """Internal no-warning sync used at init."""
         global router, APP_MODE, DEFAULT_HOST, DEFAULT_PORT, DATA_DIR, BASE_DIR
         global ENABLE_TELEGRAM, ENABLE_GRAPH, AUTOLOAD_MODELS, MODEL_IDLE_UNLOAD_SECONDS
-        global ALLOW_LOCAL_MODELS, REQUIRE_AUTH, INVITE_GATE_ENABLED, ALLOW_PLAINTEXT_API_KEYS
+        global ALLOW_MODEL_DOWNLOADS, MODEL_DOWNLOAD_TIMEOUT, ALLOW_LOCAL_MODELS, REQUIRE_AUTH
+        global INVITE_GATE_ENABLED, ALLOW_PLAINTEXT_API_KEYS
         global CORS_ALLOW_NETWORK, PUBLIC_MODEL, LOCAL_MODEL, IS_PUBLIC_MODE
         global keyring, get_current_user, get_user_api_key
         router = self.router
@@ -131,6 +135,8 @@ class ModelRuntimeState:
         ENABLE_GRAPH = self.ENABLE_GRAPH
         AUTOLOAD_MODELS = self.AUTOLOAD_MODELS
         MODEL_IDLE_UNLOAD_SECONDS = self.MODEL_IDLE_UNLOAD_SECONDS
+        ALLOW_MODEL_DOWNLOADS = self.ALLOW_MODEL_DOWNLOADS
+        MODEL_DOWNLOAD_TIMEOUT = self.MODEL_DOWNLOAD_TIMEOUT
         ALLOW_LOCAL_MODELS = self.ALLOW_LOCAL_MODELS
         REQUIRE_AUTH = self.REQUIRE_AUTH
         INVITE_GATE_ENABLED = self.INVITE_GATE_ENABLED
@@ -159,7 +165,8 @@ def _env_bool(key: str, default: bool = False) -> bool:
 def _download_allowed(allow_download: bool = False) -> bool:
     # Prefer STATE (the source of truth) over bare module global for internal logic.
     autoload = getattr(STATE, "AUTOLOAD_MODELS", AUTOLOAD_MODELS)
-    return bool(allow_download) or _env_bool("LATTICEAI_ALLOW_MODEL_DOWNLOADS", default=False) or bool(autoload)
+    configured = getattr(STATE, "ALLOW_MODEL_DOWNLOADS", ALLOW_MODEL_DOWNLOADS)
+    return bool(allow_download) or bool(configured) or bool(autoload)
 
 
 def _download_block(provider: str, model_name: str) -> None:
@@ -726,6 +733,13 @@ def ensure_llamacpp_server(model_name: str) -> None:
     return _ensure_llamacpp_server(model_name)
 
 
+def _safe_engine_install_plan(engine: str) -> Optional[Dict[str, object]]:
+    try:
+        return _engine_install_plan(engine)
+    except Exception:
+        return None
+
+
 def engine_installed(engine: str) -> bool:
     if engine == "local_mlx":
         return bool(
@@ -847,6 +861,7 @@ def engine_status() -> List[Dict]:
             "installed": engine_installed("local_mlx"),
             "installable": True,
             "install_label": ENGINE_INSTALLERS["local_mlx"]["label"],
+            "install_plan": _safe_engine_install_plan("local_mlx"),
             "models": mlx_models,
         },
         {
@@ -857,6 +872,7 @@ def engine_status() -> List[Dict]:
             "installed": ollama_installed,
             "installable": True,
             "install_label": ENGINE_INSTALLERS["ollama"]["label"],
+            "install_plan": _safe_engine_install_plan("ollama"),
             "models": ollama_models,
         },
     ]
@@ -872,6 +888,7 @@ def engine_status() -> List[Dict]:
             "support_reason": support["reason"],
             "installable": support["supported"] and spec["id"] in ENGINE_INSTALLERS,
             "install_label": ENGINE_INSTALLERS.get(spec["id"], {}).get("label"),
+            "install_plan": _safe_engine_install_plan(spec["id"]) if spec["id"] in ENGINE_INSTALLERS else None,
             "requires": spec["requires"],
             "models": (
                 vllm_models if spec["id"] == "vllm"
@@ -900,6 +917,7 @@ def engine_status() -> List[Dict]:
             "installed": engine_installed(provider),
             "installable": True,
             "install_label": ENGINE_INSTALLERS[provider]["label"],
+            "install_plan": _safe_engine_install_plan(provider),
             "requires": env_key,
             "models": provider_models,
         })
@@ -920,6 +938,8 @@ def runtime_features() -> Dict:
         "graph_enabled": s.ENABLE_GRAPH,
         "autoload_models": s.AUTOLOAD_MODELS,
         "model_idle_unload_seconds": s.MODEL_IDLE_UNLOAD_SECONDS,
+        "allow_model_downloads": s.ALLOW_MODEL_DOWNLOADS,
+        "model_download_timeout": s.MODEL_DOWNLOAD_TIMEOUT,
         "model_memory_policy": r.model_memory_policy() if r else None,
         "allow_local_models": s.ALLOW_LOCAL_MODELS,
         "security": {
@@ -944,8 +964,8 @@ def runtime_features() -> Dict:
         },
     }
 
-def install_engine(engine: str) -> Dict:
-    return _install_engine(engine)
+def install_engine(engine: str, confirmation_token: Optional[str] = None) -> Dict:
+    return _install_engine(engine, confirmation_token=confirmation_token)
 
 
 def _resolve_model_alias(model_id: str, engine: Optional[str] = None) -> str:

package/latticeai/services/process_audit.py

@@ -0,0 +1,208 @@
+"""Auditable command plans for installer and local process execution."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import time
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Optional, Sequence
+
+
+_SECRET_RE = re.compile(
+    r"(api[_-]?key|access[_-]?token|auth[_-]?token|bearer|client[_-]?secret|password|secret|token)",
+    re.IGNORECASE,
+)
+_SENSITIVE_FLAGS = {
+    "--api-key",
+    "--access-token",
+    "--auth-token",
+    "--client-secret",
+    "--password",
+    "--secret",
+    "--token",
+}
+
+
+class CommandConfirmationError(ValueError):
+    """Raised when a process command lacks the expected execution token."""
+
+
+def _default_audit_file() -> Path:
+    base = Path(os.environ.get("LATTICEAI_DATA_DIR") or Path.home() / ".ltcai")
+    return base / "process_audit.jsonl"
+
+
+def _normalize_command(command: Sequence[Any]) -> list[str]:
+    return [str(part) for part in command]
+
+
+def redact_command(command: Sequence[Any]) -> list[str]:
+    redacted: list[str] = []
+    redact_next = False
+    for raw in _normalize_command(command):
+        lower = raw.lower()
+        if redact_next:
+            redacted.append("[REDACTED]")
+            redact_next = False
+            continue
+        if lower in _SENSITIVE_FLAGS:
+            redacted.append(raw)
+            redact_next = True
+            continue
+        if "=" in raw:
+            key, _value = raw.split("=", 1)
+            if _SECRET_RE.search(key):
+                redacted.append(f"{key}=[REDACTED]")
+                continue
+        if _SECRET_RE.search(raw) and len(raw) > 32:
+            redacted.append("[REDACTED]")
+            continue
+        redacted.append(raw)
+    return redacted
+
+
+def _digest_payload(payload: Mapping[str, Any]) -> str:
+    encoded = json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def command_hash(command: Sequence[Any], *, cwd: Optional[str] = None) -> str:
+    return _digest_payload({"command": _normalize_command(command), "cwd": cwd or ""})
+
+
+def confirmation_token(command: Sequence[Any], *, cwd: Optional[str] = None, purpose: str = "execute") -> str:
+    digest = _digest_payload(
+        {
+            "purpose": purpose,
+            "command": _normalize_command(command),
+            "cwd": cwd or "",
+        }
+    )
+    return digest[:16]
+
+
+def command_plan(
+    command: Sequence[Any],
+    *,
+    name: str,
+    purpose: str = "installer",
+    cwd: Optional[str] = None,
+    requires_admin: bool = False,
+    metadata: Optional[Mapping[str, Any]] = None,
+) -> dict[str, Any]:
+    return {
+        "name": name,
+        "purpose": purpose,
+        "command_preview": redact_command(command),
+        "command_hash": command_hash(command, cwd=cwd),
+        "confirmation_token": confirmation_token(command, cwd=cwd, purpose=purpose),
+        "requires_admin": bool(requires_admin),
+        "cwd": cwd,
+        "metadata": dict(metadata or {}),
+    }
+
+
+def command_plan_for_commands(
+    commands: Iterable[Sequence[Any]],
+    *,
+    name: str,
+    purpose: str = "installer",
+    cwd: Optional[str] = None,
+    metadata: Optional[Mapping[str, Any]] = None,
+) -> dict[str, Any]:
+    normalized = [_normalize_command(command) for command in commands]
+    digest = _digest_payload({"purpose": purpose, "commands": normalized, "cwd": cwd or ""})
+    return {
+        "name": name,
+        "purpose": purpose,
+        "command_count": len(normalized),
+        "command_hash": digest,
+        "confirmation_token": digest[:16],
+        "cwd": cwd,
+        "metadata": dict(metadata or {}),
+    }
+
+
+def verify_command_confirmation(
+    command: Sequence[Any],
+    provided_token: Optional[str],
+    *,
+    cwd: Optional[str] = None,
+    purpose: str = "installer",
+) -> bool:
+    if not provided_token:
+        return False
+    return str(provided_token).strip() == confirmation_token(command, cwd=cwd, purpose=purpose)
+
+
+def require_command_confirmation(
+    command: Sequence[Any],
+    provided_token: Optional[str],
+    *,
+    cwd: Optional[str] = None,
+    purpose: str = "installer",
+) -> None:
+    if not verify_command_confirmation(command, provided_token, cwd=cwd, purpose=purpose):
+        raise CommandConfirmationError("installer command requires a matching confirmation token")
+
+
+def _preview_text(text: Optional[str], *, limit: int = 500) -> Optional[str]:
+    if text is None:
+        return None
+    value = str(text)[-limit:]
+    value = re.sub(r"(?i)(api[_-]?key|access[_-]?token|auth[_-]?token|password|secret|token)=\S+", r"\1=[REDACTED]", value)
+    return value
+
+
+def _text_hash(text: Optional[str]) -> Optional[str]:
+    if text is None:
+        return None
+    return hashlib.sha256(str(text).encode("utf-8", errors="replace")).hexdigest()
+
+
+def append_process_audit_event(
+    event_type: str,
+    *,
+    plan: Mapping[str, Any],
+    status: str,
+    user_email: Optional[str] = None,
+    returncode: Optional[int] = None,
+    stdout: Optional[str] = None,
+    stderr: Optional[str] = None,
+    error: Optional[str] = None,
+    audit_file: Optional[Path] = None,
+    extra: Optional[Mapping[str, Any]] = None,
+) -> None:
+    path = audit_file or _default_audit_file()
+    entry = {
+        "ts": time.time(),
+        "event_type": event_type,
+        "status": status,
+        "user_email": user_email,
+        "plan": {
+            "name": plan.get("name"),
+            "purpose": plan.get("purpose"),
+            "command_preview": plan.get("command_preview"),
+            "command_hash": plan.get("command_hash"),
+            "requires_admin": plan.get("requires_admin"),
+            "cwd": plan.get("cwd"),
+            "metadata": plan.get("metadata") or {},
+        },
+        "returncode": returncode,
+        "stdout_hash": _text_hash(stdout),
+        "stderr_hash": _text_hash(stderr),
+        "stdout_preview": _preview_text(stdout),
+        "stderr_preview": _preview_text(stderr),
+        "error": _preview_text(error),
+        "extra": dict(extra or {}),
+    }
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(entry, ensure_ascii=False, sort_keys=True) + "\n")
+    except Exception:
+        # Auditing must never make setup recovery paths unusable.
+        return

package/latticeai/services/product_readiness.py

@@ -18,7 +18,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "8.7.0"
+PRODUCT_VERSION_TARGET = "8.9.0"
 
 
 @dataclass(frozen=True)
@@ -76,10 +76,10 @@ PRODUCT_GATES: List[ProductGate] = [
         evidence=[
             "package.json::release:artifacts",
             "package.json::release:validate",
-            "README.md::dist/ltcai-8.7.0-py3-none-any.whl",
-            "README.md::dist/ltcai-8.7.0.tar.gz",
-            "README.md::dist/ltcai-8.7.0.vsix",
-            "README.md::ltcai-8.7.0.tgz",
+            "README.md::dist/ltcai-8.9.0-py3-none-any.whl",
+            "README.md::dist/ltcai-8.9.0.tar.gz",
+            "README.md::dist/ltcai-8.9.0.vsix",
+            "README.md::ltcai-8.9.0.tgz",
             "scripts/validate_release_artifacts.py",
             "scripts/release_smoke.py",
             "Dockerfile",
@@ -95,12 +95,12 @@ PRODUCT_GATES: List[ProductGate] = [
         title="Release story is documented and honest",
         evidence=[
             "README.md",
-            "README.md::The current release is **8.7.0",
-            "SECURITY.md::8.7.x (latest)",
-            "vscode-extension/README.md::**8.7.0",
-            "docs/CHANGELOG.md::## [8.7.0]",
+            "README.md::The current release is **8.9.0",
+            "SECURITY.md::8.9.x (latest)",
+            "vscode-extension/README.md::**8.9.0",
+            "docs/CHANGELOG.md::## [8.9.0]",
             "FEATURE_STATUS.md",
-            "RELEASE_NOTES_v8.7.0.md",
+            "RELEASE_NOTES_v8.9.0.md",
             "latticeai/core/agent.py::SingleAgentRuntime",
             "latticeai/core/agent.py::AgentRuntime = SingleAgentRuntime",
             "lattice_brain/runtime/contracts.py::runtime-boundary/v1",
@@ -115,7 +115,7 @@ PRODUCT_GATES: List[ProductGate] = [
         id="ecosystem-path",
         title="Community and plugin growth path is explicit",
         evidence=[
-            "docs/COMMUNITY_AND_PLUGINS.md::8.7.0",
+            "docs/COMMUNITY_AND_PLUGINS.md::8.9.0",
             "docs/PLUGIN_SDK.md",
             "plugins/README.md",
             "plugins/hello-world/plugin.json",