ltcai 11.5.2 → 11.6.0

package/latticeai/runtime/service_singletons.py

@@ -1,55 +0,0 @@
-"""The rebinding half of the process-wide service singletons.
-
-Four wiring modules create one service each — the permission dial, the network
-boundary, the hybrid policy, the feature switchboard — and all four had the
-same problem and the same four-line answer to it: a lazy first caller (a tool
-dispatch, a feature gate) can ask for the service *before* routers know the
-configured data dir or the audit sink, and if the later explicit call were
-allowed to be a no-op the service would stay pinned to the fallback path with
-its audit events going nowhere.
-
-So explicit arguments rebind rather than being dropped. That rule was written
-out four times; it lives here once, because "the second caller silently loses"
-is precisely the kind of divergence that produces a second, invisible copy of
-the user's data and no failing test.
-
-The singleton *slot* deliberately stays a module global in each wiring module:
-the modules are the unit of process state, and the suite resets them by
-assigning ``_SHARED = None``.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any, Callable, Optional, TypeVar
-
-from latticeai.core.config import default_data_dir
-
-ServiceT = TypeVar("ServiceT")
-
-__all__ = ["singleton_data_dir", "rebind_singleton"]
-
-
-def singleton_data_dir(data_dir: Optional[Path]) -> Path:
-    """Where a *first* lazy caller should put the store."""
-    return Path(data_dir) if data_dir is not None else default_data_dir()
-
-
-def rebind_singleton(
-    service: ServiceT,
-    *,
-    data_dir: Optional[Path] = None,
-    audit: Optional[Callable[..., None]] = None,
-) -> ServiceT:
-    """Apply explicit arguments to an already-created singleton, then return it.
-
-    ``None`` means "the caller did not say", never "unset it" — a router that
-    mounts without an audit sink must not silence a sink an earlier caller
-    already supplied.
-    """
-    rebindable: Any = service
-    if data_dir is not None:
-        rebindable.rebind_data_dir(Path(data_dir))
-    if audit is not None:
-        rebindable.rebind_audit(audit)
-    return service

package/latticeai/runtime/sso_config_runtime.py

@@ -1,128 +0,0 @@
-"""SSO / OIDC config + discovery seam extracted from the app factory.
-
-Owns the whole SSO surface that used to be inline in ``app_factory._build``:
-the env-default resolution, the ``sso_config.json`` load/save, the public
-(secret-stripped) view, and the OIDC discovery document cache.
-
-Unlike the previous split (config inline in the factory + a separate discovery
-cache in ``sso_runtime``), the discovery cache now lives in the *same* closure
-as ``save_sso_config``, so saving a new SSO config actually invalidates the
-cached discovery document. The old inline ``save_sso_config`` reassigned a
-factory-local cache variable that ``_get_sso_discovery`` never read, so the
-invalidation was a silent no-op — this consolidation fixes that.
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-
-def build_sso_config_runtime(
-    *,
-    sso_file: Path,
-    discovery_url: str,
-    client_id: str,
-    client_secret: str,
-    redirect_uri: str,
-    provider_name: str,
-    logging: Any,
-) -> Dict[str, Any]:
-    """Return the SSO config helpers + discovery accessor as a name → value dict."""
-
-    # Single shared discovery cache: save_sso_config and _get_sso_discovery both
-    # close over it, so a config change is observed on the next discovery fetch.
-    _discovery_cache: Dict[str, Any] = {"data": None, "url": ""}
-    _sso_states: Dict[str, float] = {}
-
-    def _sso_env_defaults() -> Dict[str, object]:
-        return {
-            "enabled": bool(discovery_url and client_id and client_secret),
-            "provider_name": provider_name,
-            "discovery_url": discovery_url,
-            "client_id": client_id,
-            "client_secret": client_secret,
-            "redirect_uri": redirect_uri,
-            "scopes": "openid email profile",
-        }
-
-    def load_sso_config() -> Dict[str, object]:
-        config = _sso_env_defaults()
-        if sso_file.exists():
-            try:
-                data = json.loads(sso_file.read_text(encoding="utf-8"))
-                if isinstance(data, dict):
-                    config.update({k: v for k, v in data.items() if v is not None})
-            except Exception as e:
-                logging.warning("load_sso_config failed (using env/defaults): %s", e)
-        config["provider_name"] = str(config.get("provider_name") or "SSO")
-        config["discovery_url"] = str(config.get("discovery_url") or "")
-        config["client_id"] = str(config.get("client_id") or "")
-        config["client_secret"] = str(config.get("client_secret") or "")
-        config["redirect_uri"] = str(config.get("redirect_uri") or redirect_uri)
-        config["scopes"] = str(config.get("scopes") or "openid email profile")
-        config["enabled"] = bool(config.get("enabled")) and bool(
-            config["discovery_url"] and config["client_id"] and config["client_secret"]
-        )
-        return config
-
-    def get_sso_settings() -> Dict[str, object]:
-        return load_sso_config()
-
-    def public_sso_config(config: Optional[Dict[str, object]] = None) -> Dict[str, object]:
-        cfg = config or get_sso_settings()
-        return {
-            "enabled": bool(cfg.get("enabled")),
-            "provider_name": cfg.get("provider_name") or "",
-            "discovery_url": cfg.get("discovery_url") or "",
-            "client_id": cfg.get("client_id") or "",
-            "redirect_uri": cfg.get("redirect_uri") or redirect_uri,
-            "scopes": cfg.get("scopes") or "openid email profile",
-            "secret_configured": bool(cfg.get("client_secret")),
-        }
-
-    def save_sso_config(update: Dict[str, object]) -> Dict[str, object]:
-        current = load_sso_config()
-        if update.get("client_secret") == "":
-            update.pop("client_secret", None)
-        current.update({k: v for k, v in update.items() if v is not None})
-        current["enabled"] = bool(current.get("enabled")) and bool(
-            current.get("discovery_url") and current.get("client_id") and current.get("client_secret")
-        )
-        sso_file.write_text(json.dumps(current, ensure_ascii=False, indent=2), encoding="utf-8")
-        _discovery_cache["data"] = None
-        _discovery_cache["url"] = ""
-        return current
-
-    async def _get_sso_discovery() -> Optional[Dict]:
-        settings = get_sso_settings()
-        url = str(settings.get("discovery_url", "") or "")
-        if _discovery_cache["data"] and _discovery_cache["url"] == url:
-            return _discovery_cache["data"]
-        if not url:
-            return None
-        try:
-            import httpx as _httpx
-            async with _httpx.AsyncClient() as c:
-                r = await c.get(url, timeout=10)
-                r.raise_for_status()
-                _discovery_cache["data"] = r.json()
-                _discovery_cache["url"] = url
-        except Exception as e:
-            logging.warning("SSO discovery failed: %s", e)
-            return None
-        return _discovery_cache["data"]
-
-    return {
-        "_sso_env_defaults": _sso_env_defaults,
-        "load_sso_config": load_sso_config,
-        "get_sso_settings": get_sso_settings,
-        "public_sso_config": public_sso_config,
-        "save_sso_config": save_sso_config,
-        "_get_sso_discovery": _get_sso_discovery,
-        "_sso_states": _sso_states,
-    }
-
-
-__all__ = ["build_sso_config_runtime"]

package/latticeai/runtime/user_key_runtime.py

@@ -1,106 +0,0 @@
-"""User profile + provider API-key helpers extracted from the app factory.
-
-The helpers close over the user store, keyring adapter, identity migration, and
-plaintext-key policy. Returning callables preserves the legacy ``server_app``
-namespace while keeping ``app_factory._build`` focused on wiring.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-
-def build_user_key_runtime(
-    *,
-    load_users: Any,
-    save_users: Any,
-    ensure_user_identity: Any,
-    keyring: Any,
-    allow_plaintext_api_keys: bool,
-    logging: Any,
-    http_exception: Any,
-) -> Dict[str, Any]:
-    """Return history-user and provider API-key helpers."""
-
-    def get_history_user(email: Optional[str], nickname: Optional[str] = None) -> Dict:
-        if not email:
-            return {"user_email": None, "user_nickname": nickname or None}
-        users = load_users()
-        user = users.get(email, {})
-        return {
-            "user_email": email,
-            "user_nickname": nickname or user.get("nickname") or user.get("name") or email,
-        }
-
-    def get_user_api_key(email: Optional[str], provider: str) -> Optional[str]:
-        if not email:
-            return None
-        keyring_key = f"{email}:{provider}"
-        if keyring is not None:
-            try:
-                key = keyring.get_password("LatticeAI", keyring_key)
-                if key:
-                    return key.strip()
-            except Exception as exc:
-                logging.warning("keyring read failed for %s: %s", provider, exc)
-        users = load_users()
-        user = users.get(email) or {}
-        api_keys = user.get("api_keys") or {}
-        key = api_keys.get(provider)
-        if isinstance(key, str) and key.strip() and allow_plaintext_api_keys:
-            return key.strip()
-        return None
-
-    def set_user_api_key(email: str, provider: str, key: str) -> None:
-        keyring_key = f"{email}:{provider}"
-        if keyring is not None:
-            try:
-                keyring.set_password("LatticeAI", keyring_key, key)
-                users = load_users()
-                user = users.get(email)
-                if user and "api_keys" in user:
-                    user["api_keys"].pop(provider, None)
-                    if not user["api_keys"]:
-                        user.pop("api_keys", None)
-                    save_users(users)
-                return
-            except Exception as exc:
-                logging.warning("keyring write failed for %s: %s", provider, exc)
-                if not allow_plaintext_api_keys:
-                    raise http_exception(
-                        status_code=500,
-                        detail="OS keyring에 API 키를 저장하지 못했습니다. keyring 설정을 확인하거나 LATTICEAI_ALLOW_PLAINTEXT_API_KEYS=true를 명시적으로 설정하세요.",
-                    )
-
-        if not allow_plaintext_api_keys:
-            raise http_exception(
-                status_code=500,
-                detail="keyring 패키지를 사용할 수 없어 API 키를 안전하게 저장할 수 없습니다.",
-            )
-
-        users = load_users()
-        user = users.get(email)
-        if not user:
-            user = {
-                "password_hash": "",
-                "salt": "",
-                "name": email,
-                "nickname": email,
-                "role": "user",
-                "disabled": False,
-            }
-        ensure_user_identity(email, user)
-        api_keys = user.get("api_keys") or {}
-        api_keys[provider] = key
-        user["api_keys"] = api_keys
-        users[email] = user
-        save_users(users)
-
-    return {
-        "get_history_user": get_history_user,
-        "get_user_api_key": get_user_api_key,
-        "set_user_api_key": set_user_api_key,
-    }
-
-
-__all__ = ["build_user_key_runtime"]

package/latticeai/runtime/web_runtime.py

@@ -1,92 +0,0 @@
-"""FastAPI shell assembly for the application factory.
-
-This seam owns only the outer web shell: app construction, the request-side
-middleware (CSRF origin guard, CORS), and static asset mounts. Router
-registration stays in ``app_factory`` until the route snapshot/reorder step is
-reviewed.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any, Dict, Iterable, List
-
-
-def build_web_runtime(
-    *,
-    app_mode: str,
-    app_version: str,
-    lifespan: Any,
-    default_host: str,
-    default_port: int,
-    cors_extra_origins: Iterable[str],
-    cors_allow_network: bool,
-    static_dir: Path,
-    csrf_trusted_origins: Iterable[str] = (),
-) -> Dict[str, Any]:
-    """Create the FastAPI shell and mount static assets in legacy order."""
-
-    from fastapi import FastAPI
-    from fastapi.middleware.cors import CORSMiddleware
-    from fastapi.staticfiles import StaticFiles
-
-    from latticeai.core.csrf import CSRFOriginGuardMiddleware, CSRFOriginPolicy
-    from latticeai.core.security import host_is_loopback
-
-    app = FastAPI(
-        title=f"Lattice AI Server ({app_mode})",
-        version=app_version,
-        lifespan=lifespan,
-    )
-
-    cors_allowed_origins = [
-        f"http://localhost:{default_port}",
-        f"http://127.0.0.1:{default_port}",
-        *cors_extra_origins,
-    ]
-    if cors_allow_network:
-        cors_allowed_origins = cors_allowed_origins + [
-            f"http://{default_host}:{default_port}",
-            f"https://{default_host}:{default_port}",
-        ]
-
-    # An origin that CORS already lets send *credentialed* cross-origin
-    # requests is, by that decision, trusted with the session cookie; listing
-    # it again here would be a second place to forget. The explicit
-    # LATTICEAI_CSRF_TRUSTED_ORIGINS entries are for the reverse-proxy case,
-    # where the public hostname is not the bind address.
-    csrf_allowed_origins: List[str] = [
-        *cors_allowed_origins,
-        *csrf_trusted_origins,
-    ]
-    csrf_policy = CSRFOriginPolicy(
-        trusted_origins=csrf_allowed_origins,
-        server_host=default_host,
-        server_port=default_port,
-        bind_is_loopback=host_is_loopback(default_host),
-    )
-
-    # Registration order is stack order in reverse: the LAST middleware added
-    # is the OUTERMOST. CORS must stay outside the guard so a rejected request
-    # still comes back with the CORS headers the browser needs to surface the
-    # 403 instead of an opaque network error.
-    app.add_middleware(CSRFOriginGuardMiddleware, policy=csrf_policy)
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=cors_allowed_origins,
-        allow_methods=["*"],
-        allow_headers=["*"],
-        allow_credentials=True,
-    )
-
-    static_dir.mkdir(parents=True, exist_ok=True)
-    app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
-    icons_dir = static_dir / "icons"
-    if icons_dir.exists():
-        app.mount("/icons", StaticFiles(directory=str(icons_dir)), name="icons")
-
-    return {
-        "app": app,
-        "CORS_ALLOWED_ORIGINS": cors_allowed_origins,
-        "CSRF_ALLOWED_ORIGINS": csrf_allowed_origins,
-    }

package/latticeai/server_app.py

@@ -1,51 +0,0 @@
-"""Lazy compatibility facade over :mod:`latticeai.app_factory`.
-
-The application used to be assembled here at import time (MLX/GPU init,
-~15 singletons, file creation under the data dir). All of that now lives in
-``latticeai.app_factory.create_app``. This module keeps every historical
-module-level name (``app``, ``KNOWLEDGE_GRAPH``, ``load_users``,
-``save_to_history``, …) importable for tests and legacy callers via module
-``__getattr__`` — construction happens on *first attribute access*, never on
-import. Importing ``latticeai.server_app`` has no side effects.
-"""
-
-from __future__ import annotations
-
-from typing import Any, List
-
-from latticeai.runtime.namespace_runtime import SERVER_APP_EXPORTS
-
-
-def _runtime():
-    from latticeai.app_factory import get_shared_runtime
-
-    return get_shared_runtime()
-
-
-def __getattr__(name: str) -> Any:
-    if name.startswith("__") and name.endswith("__"):
-        # Never let dunder probes (importlib, inspect, pickling) trigger the
-        # full application construction.
-        raise AttributeError(name)
-    if name not in SERVER_APP_EXPORTS:
-        raise AttributeError(f"module 'latticeai.server_app' has no attribute '{name}'")
-    try:
-        return getattr(_runtime(), name)
-    except AttributeError as exc:
-        raise AttributeError(
-            f"module 'latticeai.server_app' has no attribute '{name}'"
-        ) from exc
-
-
-def __dir__() -> List[str]:
-    return sorted(set(globals()) | set(SERVER_APP_EXPORTS))
-
-
-def main() -> None:
-    from latticeai.app_factory import main as _main
-
-    _main()
-
-
-if __name__ == "__main__":
-    main()

package/latticeai/services/app_context.py

@@ -1,130 +0,0 @@
-"""Application dependency context for router assembly.
-
-``latticeai.app_factory.create_app`` builds one ``AppContext`` per app and
-hands it to router factories, replacing the historical 25-30-kwarg closure
-wiring. Every field defaults to ``None``-ish so tests can construct a context
-carrying only the dependencies a router actually touches.
-
-Fields are grouped by the consumer that motivated them; routers must treat the
-context as read-only.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Callable, Optional
-
-
-@dataclass(frozen=True)
-class AppContext:
-    # ── core configuration / paths ────────────────────────────────────────
-    config: Any = None
-    data_dir: Optional[Path] = None
-    static_dir: Optional[Path] = None
-    base_dir: Optional[Path] = None
-    skills_dir: Optional[Path] = None
-
-    # ── singletons ────────────────────────────────────────────────────────
-    model_router: Any = None
-    workspace_store: Any = None
-    workspace_service: Any = None
-    knowledge_graph: Any = None
-    local_kg_watcher: Any = None
-    chat_service: Any = None
-    context_assembler: Any = None
-    # Re-search loop (v9.9.6): conversation-scoped ledger of just-written
-    # artifacts, so a follow-up turn sees them before indexing catches up.
-    artifact_ledger: Any = None
-    brain_memory: Any = None
-    # Unified ingestion gateway (lattice_brain.ingestion.IngestionPipeline);
-    # None when the knowledge graph is disabled.
-    ingestion_pipeline: Any = None
-    chat_agent_runtime: Any = None
-    gardener: Any = None
-    hooks: Any = None
-    realtime_bus: Any = None
-    capability_registry: Any = None
-    # UX funnel metrics (latticeai.services.funnel_metrics); None in tests
-    # that don't observe the funnel — every increment site is nil-safe.
-    funnel_metrics: Any = None
-
-    # ── auth / session callables ──────────────────────────────────────────
-    require_user: Optional[Callable[..., str]] = None
-    require_admin: Optional[Callable[..., tuple]] = None
-    get_current_user: Optional[Callable[..., Optional[str]]] = None
-    load_users: Optional[Callable[[], dict]] = None
-    get_user_role: Optional[Callable[..., str]] = None
-    enforce_rate_limit: Optional[Callable[..., None]] = None
-    allowed_workspaces_for: Optional[Callable[..., Any]] = None
-
-    # ── audit / history callables ─────────────────────────────────────────
-    append_audit_event: Optional[Callable[..., None]] = None
-    get_audit_log: Optional[Callable[[], list]] = None
-    get_history: Optional[Callable[[], list]] = None
-    get_history_user: Optional[Callable[..., dict]] = None
-    save_to_history: Optional[Callable[..., None]] = None
-    clear_history: Optional[Callable[..., dict]] = None
-    clear_conversation: Optional[Callable[..., dict]] = None
-    group_history_conversations: Optional[Callable[..., list]] = None
-    get_conversation_messages: Optional[Callable[..., list]] = None
-    conversation_title: Optional[Callable[..., str]] = None
-
-    # ── knowledge graph access ────────────────────────────────────────────
-    enable_graph: bool = False
-    require_graph: Optional[Callable[[], None]] = None
-    workspace_graph: Optional[Callable[[], Any]] = None
-    graph_stats: Optional[Callable[[], dict]] = None
-
-    # ── review center ─────────────────────────────────────────────────────
-    # ``ReviewQueueService``, reached through a provider like
-    # ``workspace_graph`` above: the queue is built in a later runtime phase
-    # than this context, so a value captured here would be ``None`` forever.
-    # Call it per request; ``None`` means no Review Center is wired (tests,
-    # headless helpers) and the callers stage nothing rather than writing.
-    review_queue: Optional[Callable[[], Any]] = None
-
-    # ── workspace payload providers / skills ──────────────────────────────
-    workspace_models: Optional[Callable[[], dict]] = None
-    workspace_settings: Optional[Callable[[], dict]] = None
-    scan_environment: Optional[Callable[[], Any]] = None
-    local_sysinfo: Optional[Callable[..., Any]] = None
-    get_recommendations: Optional[Callable[..., Any]] = None
-    fetch_skills_marketplace: Optional[Callable[..., Any]] = None
-    install_skill: Optional[Callable[..., Any]] = None
-    remove_skill_directory: Optional[Callable[..., dict]] = None
-    redact_secret_text: Optional[Callable[[str], str]] = None
-    ui_file_response: Optional[Callable[..., Any]] = None
-
-    # ── models ────────────────────────────────────────────────────────────
-    public_model: str = ""
-    local_model: str = ""
-
-    # ── integrations ──────────────────────────────────────────────────────
-    # Fired as on_chat_message(role, text, source) after a chat exchange is
-    # persisted; ``None`` means no external chat mirror is registered. The
-    # telegram bridge subscribes here only when ENABLE_TELEGRAM is truthy.
-    on_chat_message: Optional[Callable[..., None]] = None
-
-    def require(self, field: str) -> Any:
-        """Return a dependency this router cannot operate without.
-
-        Every field defaults to ``None`` so a test can build a context holding
-        only what it exercises. A router that binds an absent dependency used
-        to discover it as ``TypeError: 'NoneType' object is not callable``
-        inside a request handler, far from the wiring mistake. Binding through
-        ``require`` moves that to router construction with the field named.
-
-        It is also what makes the binding statically honest: the declared type
-        is ``Optional[...]``, so a type checker reports every call site as
-        ``"None" not callable`` — 105 of them in the workspace router alone.
-        ``require`` states the precondition once instead.
-        """
-        if field not in self.__dataclass_fields__:
-            raise AttributeError(f"AppContext has no field {field!r}")
-        value = getattr(self, field)
-        if value is None:
-            raise RuntimeError(
-                f"AppContext.{field} is required by this router but was not provided"
-            )
-        return value