ltcai 11.5.2 → 11.7.0

package/latticeai/api/portability.py

@@ -1,391 +0,0 @@
-"""Knowledge Graph portability routes — local export / import / backup / restore.
-
-Status reads require a signed-in user. Whole-graph exports, provenance, and all
-mutating operations require admin because the graph is machine-global, not
-workspace-scoped. Nothing here touches a cloud service.
-
-The ``/share`` family (v11.1.0) adds the selective Brain Network prototype:
-export a *chosen* subgraph signed by this device, and receive one as review
-proposals rather than a merge. It is gated on ``LATTICEAI_BRAIN_NETWORK`` and
-answers 403 with the reason while that flag is off — except ``GET
-/api/knowledge-graph/share``, which reports ``enabled: false`` so a UI can say
-why the feature is absent instead of guessing.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Callable, Dict, List, Optional
-
-from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel
-
-from latticeai.core.messages import http_error, resolve_language, translate
-from latticeai.services.review_queue import InvalidReviewTransition
-
-
-class ImportRequest(BaseModel):
-    artifact: dict
-    mode: str = "merge"
-    dry_run: bool = False
-
-
-class BackupRequest(BaseModel):
-    path: Optional[str] = None
-
-
-class RestoreRequest(BaseModel):
-    path: str
-    verify: bool = True
-    dry_run: bool = False
-    confirm: bool = False
-
-
-class EncryptedArchiveRequest(BaseModel):
-    path: Optional[str] = None
-    passphrase: str
-
-
-class EncryptedRestoreRequest(BaseModel):
-    path: str
-    passphrase: str
-    dry_run: bool = False
-    confirm: bool = False
-
-
-class EncryptedInspectRequest(BaseModel):
-    path: str
-    passphrase: Optional[str] = None
-
-
-class EncryptedVerifyRequest(BaseModel):
-    path: str
-    passphrase: str
-
-
-class DockerPostgresRequest(BaseModel):
-    consent: bool = False
-    dry_run: bool = False
-    port: int = 5432
-
-
-class SQLiteToPostgresRequest(BaseModel):
-    dsn: str
-    schema_name: str = "lattice_brain"
-    dry_run: bool = True
-
-
-class SubgraphSelection(BaseModel):
-    """What to share. At least one selector is required by the service."""
-
-    node_ids: List[str] = []
-    node_types: List[str] = []
-    source_types: List[str] = []
-    workspace_id: Optional[str] = None
-    include_legacy_global: bool = False
-    include_neighbors: bool = False
-    redact_provenance: bool = True
-
-
-class SubgraphArchiveRequest(SubgraphSelection):
-    """Exactly one recipient mechanism — a passphrase, or a public key.
-
-    Both optional at the schema level and validated in the service, so the
-    error a caller gets names the rule ("choose one") instead of a field.
-    """
-
-    path: Optional[str] = None
-    passphrase: Optional[str] = None
-    #: The recipient's X25519 public key, from their ``/share/recipient-key``.
-    recipient_public_key: Optional[str] = None
-
-
-class SubgraphImportRequest(BaseModel):
-    """Either an inline ``artifact`` or a ``path`` (+ passphrase) on disk."""
-
-    artifact: Optional[Dict[str, Any]] = None
-    path: Optional[str] = None
-    passphrase: Optional[str] = None
-    workspace_id: Optional[str] = None
-    dry_run: bool = False
-
-
-class SubgraphAcceptRequest(BaseModel):
-    workspace_id: Optional[str] = None
-
-
-def create_portability_router(
-    *,
-    service: Any,
-    require_user: Callable[[Request], str],
-    require_admin: Callable[[Request], Any],
-    review_queue: Any = None,
-) -> APIRouter:
-    router = APIRouter()
-
-    def _require_service(request: Request):
-        if service is None or not service.available():
-            raise http_error(503, "common.graph_disabled", resolve_language(request))
-
-    def _require_review_queue(request: Request):
-        if review_queue is None:
-            raise http_error(503, "portability.review_queue_unavailable", resolve_language(request))
-
-    @router.get("/api/knowledge-graph/portability")
-    async def portability_status(request: Request):
-        require_user(request)
-        _require_service(request)
-        return service.snapshot_metadata()
-
-    @router.get("/api/brain/storage")
-    async def brain_storage_status(request: Request):
-        require_user(request)
-        _require_service(request)
-        return service.storage_status()
-
-    @router.get("/api/knowledge-graph/backup-health")
-    async def backup_health(request: Request):
-        require_user(request)
-        _require_service(request)
-        return service.backup_health()
-
-    @router.get("/api/knowledge-graph/provenance")
-    async def recent_provenance(request: Request, limit: int = 50, source_type: Optional[str] = None):
-        """Recent ingestions (provenance trail) for the ingestion-sources UI."""
-        require_admin(request)
-        _require_service(request)
-        return service.recent_ingestions(limit=limit, source_type=source_type)
-
-    @router.post("/api/knowledge-graph/export")
-    async def export_graph(request: Request):
-        """Logical JSON export of the whole graph (read-only)."""
-        require_admin(request)
-        _require_service(request)
-        return service.export()
-
-    @router.post("/api/knowledge-graph/export-file")
-    async def export_graph_file(request: Request):
-        require_admin(request)
-        _require_service(request)
-        return service.export_to_file()
-
-    @router.post("/api/knowledge-graph/import")
-    async def import_graph(req: ImportRequest, request: Request):
-        require_admin(request)
-        _require_service(request)
-        try:
-            return service.import_data(req.artifact, mode=req.mode, dry_run=req.dry_run)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    @router.post("/api/knowledge-graph/backup")
-    async def backup_graph(req: BackupRequest, request: Request):
-        require_admin(request)
-        _require_service(request)
-        return service.backup(req.path)
-
-    @router.post("/api/knowledge-graph/restore")
-    async def restore_graph(req: RestoreRequest, request: Request):
-        require_admin(request)
-        _require_service(request)
-        try:
-            return service.restore(req.path, verify=req.verify, dry_run=req.dry_run, confirm=req.confirm)
-        except (ValueError, FileNotFoundError) as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    @router.post("/api/knowledge-graph/archive")
-    async def encrypted_archive(req: EncryptedArchiveRequest, request: Request):
-        require_admin(request)
-        _require_service(request)
-        try:
-            return service.encrypted_archive(req.path, passphrase=req.passphrase)
-        except (ValueError, FileNotFoundError) as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    @router.post("/api/knowledge-graph/archive/inspect")
-    async def inspect_encrypted_archive(req: EncryptedInspectRequest, request: Request):
-        require_admin(request)
-        _require_service(request)
-        try:
-            return service.inspect_encrypted_archive(req.path, passphrase=req.passphrase)
-        except (ValueError, FileNotFoundError) as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    @router.post("/api/knowledge-graph/archive/verify")
-    async def verify_encrypted_archive(req: EncryptedVerifyRequest, request: Request):
-        require_admin(request)
-        _require_service(request)
-        result = service.verify_encrypted_archive(req.path, passphrase=req.passphrase)
-        if not result.get("ok"):
-            raise HTTPException(
-            status_code=400,
-            detail="; ".join(
-                result.get("errors")
-                or [translate("portability.verification_failed", resolve_language(request))]
-            ),
-        )
-        return result
-
-    @router.post("/api/knowledge-graph/archive/import")
-    async def import_encrypted_archive(req: EncryptedRestoreRequest, request: Request):
-        require_admin(request)
-        _require_service(request)
-        try:
-            return service.import_encrypted_archive(
-                req.path,
-                passphrase=req.passphrase,
-                dry_run=req.dry_run,
-                confirm=req.confirm,
-            )
-        except (ValueError, FileNotFoundError) as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    @router.post("/api/knowledge-graph/archive/restore")
-    async def restore_encrypted_archive(req: EncryptedRestoreRequest, request: Request):
-        require_admin(request)
-        _require_service(request)
-        try:
-            return service.restore_encrypted_archive(
-                req.path,
-                passphrase=req.passphrase,
-                dry_run=req.dry_run,
-                confirm=req.confirm,
-            )
-        except (ValueError, FileNotFoundError) as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    # ── selective subgraph share (opt-in; 403 with the reason while off) ─────
-    @router.get("/api/knowledge-graph/share")
-    async def share_status(request: Request):
-        """Reports whether sharing is on, and names the flag when it is not."""
-        require_user(request)
-        status = service.share_status()
-        if not status.get("enabled"):
-            status["detail"] = translate(
-                "portability.brain_network_disabled", resolve_language(request)
-            )
-        return status
-
-    @router.post("/api/knowledge-graph/share/export")
-    async def share_export(req: SubgraphSelection, request: Request):
-        """Signed JSON bundle of the selected subgraph (no file written)."""
-        require_admin(request)
-        _require_service(request)
-        try:
-            return service.export_subgraph(**req.model_dump())
-        except PermissionError:
-            raise http_error(403, "portability.brain_network_disabled", resolve_language(request))
-        except (ValueError, RuntimeError) as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    @router.get("/api/knowledge-graph/share/recipient-key")
-    async def share_recipient_key(request: Request):
-        """This Brain's X25519 receiving key, for a sender to seal a bundle to.
-
-        Public by construction — a public key encrypts, it does not decrypt —
-        so handing it out is the whole point. Still admin-gated and still
-        behind the share flag, because minting the key is a decision to
-        participate in sharing at all.
-        """
-        require_admin(request)
-        _require_service(request)
-        try:
-            return service.recipient_key()
-        except PermissionError:
-            raise http_error(403, "portability.brain_network_disabled", resolve_language(request))
-
-    @router.post("/api/knowledge-graph/share/archive")
-    async def share_archive(req: SubgraphArchiveRequest, request: Request):
-        """Same bundle, written as an encrypted ``.latticebrain`` file."""
-        require_admin(request)
-        _require_service(request)
-        body = req.model_dump()
-        path = body.pop("path")
-        passphrase = body.pop("passphrase")
-        recipient_public_key = body.pop("recipient_public_key")
-        try:
-            return service.export_subgraph_archive(
-                path,
-                passphrase=passphrase,
-                recipient_public_key=recipient_public_key,
-                **body,
-            )
-        except PermissionError:
-            raise http_error(403, "portability.brain_network_disabled", resolve_language(request))
-        except (ValueError, RuntimeError) as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    @router.post("/api/knowledge-graph/share/import")
-    async def share_import(req: SubgraphImportRequest, request: Request):
-        """Receive a bundle as review proposals. Never merges on its own."""
-        require_admin(request)
-        _require_service(request)
-        user = require_user(request)
-        _require_review_queue(request)
-        try:
-            artifact = req.artifact
-            if artifact is None:
-                if not req.path:
-                    raise ValueError(
-                        "Provide an artifact, or the path of a bundle on disk."
-                    )
-                # A sealed bundle needs no passphrase — the envelope says which
-                # mechanism it used and the service refuses if the wrong one is
-                # supplied, so the route does not have to guess here.
-                artifact = service.read_subgraph_archive(req.path, passphrase=req.passphrase)
-            return service.import_subgraph_proposals(
-                artifact,
-                review_sink=review_queue,
-                workspace_id=req.workspace_id,
-                user_email=user or None,
-                dry_run=req.dry_run,
-            )
-        except PermissionError:
-            raise http_error(403, "portability.brain_network_disabled", resolve_language(request))
-        except FileNotFoundError as exc:
-            raise HTTPException(status_code=404, detail=str(exc))
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    @router.post("/api/knowledge-graph/share/proposals/{item_id}/accept")
-    async def share_accept(item_id: str, req: SubgraphAcceptRequest, request: Request):
-        """Merge one reviewed proposal into this Brain and approve the item."""
-        require_admin(request)
-        _require_service(request)
-        _require_review_queue(request)
-        try:
-            return service.accept_subgraph_proposal(
-                item_id, review_sink=review_queue, workspace_id=req.workspace_id,
-            )
-        except PermissionError:
-            raise http_error(403, "portability.brain_network_disabled", resolve_language(request))
-        except FileNotFoundError:
-            raise http_error(404, "review.item_not_found", resolve_language(request))
-        except InvalidReviewTransition as exc:
-            raise HTTPException(status_code=409, detail=str(exc))
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    @router.post("/api/brain/storage/postgres/docker")
-    async def setup_postgres_docker(req: DockerPostgresRequest, request: Request):
-        require_admin(request)
-        _require_service(request)
-        return service.postgres_docker_setup(
-            consent=req.consent,
-            dry_run=req.dry_run,
-            port=req.port,
-        )
-
-    @router.post("/api/brain/storage/migrate-postgres")
-    async def migrate_sqlite_to_postgres(req: SQLiteToPostgresRequest, request: Request):
-        require_admin(request)
-        _require_service(request)
-        try:
-            return service.migrate_sqlite_to_postgres(
-                dsn=req.dsn,
-                schema=req.schema_name,
-                dry_run=req.dry_run,
-            )
-        except (ValueError, FileNotFoundError, RuntimeError) as exc:
-            raise HTTPException(status_code=400, detail=str(exc))
-
-    return router

package/latticeai/api/project_sessions.py

@@ -1,114 +0,0 @@
-"""Project session router — the multi-turn project loop (v9.9.6).
-
-CRUD over :class:`~latticeai.core.project_sessions.ProjectSessionStore`. A
-project session carries what a single agent run cannot: the files the project
-already produced, what is still open, and the last honest verification result.
-Runs fold themselves in through the agent HTTP layer; this surface is what the
-user drives.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Callable, List, Optional
-
-from fastapi import APIRouter, Request
-from pydantic import BaseModel, Field
-
-from latticeai.core.messages import http_error, resolve_language
-
-
-class CreateProjectRequest(BaseModel):
-    title: str = Field(..., min_length=1, max_length=200)
-    goal: str = ""
-
-
-class UpdateProjectRequest(BaseModel):
-    title: Optional[str] = None
-    goal: Optional[str] = None
-    status: Optional[str] = None
-
-
-class TodosRequest(BaseModel):
-    todos: List[Any] = Field(default_factory=list)
-
-
-def create_project_sessions_router(
-    *,
-    store: Any,
-    require_user: Callable[[Request], Any],
-    gate_read: Optional[Callable[[Request], Optional[str]]] = None,
-    gate_write: Optional[Callable[[Request], Optional[str]]] = None,
-) -> APIRouter:
-    router = APIRouter()
-
-    def _scope(request: Request, write: bool = False):
-        gate = gate_write if write else gate_read
-        return gate(request) if gate is not None else None
-
-    @router.get("/api/projects")
-    async def list_projects(request: Request, status: str = "active"):
-        user = require_user(request)
-        return store.list(
-            user_email=user, workspace_id=_scope(request), status=status
-        )
-
-    @router.post("/api/projects")
-    async def create_project(req: CreateProjectRequest, request: Request):
-        user = require_user(request)
-        return store.create(
-            title=req.title,
-            goal=req.goal,
-            user_email=user,
-            workspace_id=_scope(request, write=True),
-        )
-
-    @router.get("/api/projects/{session_id}")
-    async def get_project(session_id: str, request: Request):
-        user = require_user(request)
-        record = store.get(session_id, user_email=user, workspace_id=_scope(request))
-        if record is None:
-            raise http_error(404, "project.not_found", resolve_language(request))
-        return record
-
-    @router.patch("/api/projects/{session_id}")
-    async def update_project(session_id: str, req: UpdateProjectRequest, request: Request):
-        user = require_user(request)
-        record = store.update(
-            session_id,
-            title=req.title,
-            goal=req.goal,
-            status=req.status,
-            user_email=user,
-            workspace_id=_scope(request, write=True),
-        )
-        if record is None:
-            raise http_error(404, "project.not_found", resolve_language(request))
-        return record
-
-    @router.put("/api/projects/{session_id}/todos")
-    async def set_todos(session_id: str, req: TodosRequest, request: Request):
-        user = require_user(request)
-        record = store.set_todos(
-            session_id,
-            req.todos,
-            user_email=user,
-            workspace_id=_scope(request, write=True),
-        )
-        if record is None:
-            raise http_error(404, "project.not_found", resolve_language(request))
-        return record
-
-    @router.delete("/api/projects/{session_id}")
-    async def delete_project(session_id: str, request: Request):
-        user = require_user(request)
-        removed = store.delete(
-            session_id, user_email=user, workspace_id=_scope(request, write=True)
-        )
-        if not removed:
-            raise http_error(404, "project.not_found", resolve_language(request))
-        return {"status": "deleted", "id": session_id}
-
-    return router
-
-
-__all__ = ["create_project_sessions_router"]

package/latticeai/api/realtime.py

@@ -1,118 +0,0 @@
-"""Realtime Collaboration API router (v2).
-
-Server-Sent-Events stream + presence + activity feed over
-:class:`latticeai.core.realtime.RealtimeBus`. Workspace isolation is enforced by
-resolving each caller's allowed workspace scope before subscribing; single-user
-local mode works with no scope restriction.
-"""
-
-from __future__ import annotations
-
-import secrets
-from pathlib import Path
-from typing import Any, Callable, Optional, Set
-
-from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
-
-from lattice_brain.runtime.contracts import contract_views
-from latticeai.api.ui_redirects import app_redirect
-
-
-class PresenceRequest(BaseModel):
-    client_id: Optional[str] = None
-    workspace_id: Optional[str] = None
-
-
-def create_realtime_router(
-    *,
-    bus,
-    require_user: Callable[[Request], str],
-    get_current_user: Callable[[Request], Optional[str]],
-    allowed_scopes: Callable[[Optional[str]], Optional[Set[str]]],
-    ui_file_response: Optional[Callable[[Path], Any]] = None,
-    static_dir: Optional[Path] = None,
-) -> APIRouter:
-    router = APIRouter()
-
-    @router.get("/activity")
-    async def activity_page(request: Request):
-        require_user(request)
-        return app_redirect("activity", request)
-
-    @router.get("/realtime/stream")
-    async def realtime_stream(request: Request):
-        user = require_user(request)
-        scope = allowed_scopes(user or None)
-        sub_id = secrets.token_urlsafe(12)
-        sub = bus.add_subscriber(sub_id, workspace_scope=scope, user=user or None)
-
-        def refresh_authorization(current_sub) -> bool:
-            try:
-                refreshed_user = require_user(request)
-            except Exception:
-                return False
-            if refreshed_user != user:
-                return False
-            current_sub.workspace_scope = allowed_scopes(refreshed_user or None)
-            return True
-
-        async def event_gen():
-            async for frame in bus.stream(
-                sub,
-                refresh_authorization=refresh_authorization,
-            ):
-                if await request.is_disconnected():
-                    break
-                yield frame
-
-        return StreamingResponse(
-            event_gen(),
-            media_type="text/event-stream",
-            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no", "Connection": "keep-alive"},
-        )
-
-    @router.get("/realtime/feed")
-    async def realtime_feed(request: Request, limit: int = 50):
-        user = require_user(request)
-        scope = allowed_scopes(user or None)
-        events = bus.recent(limit=limit, workspace_scope=scope)
-        return {"events": events, "contracts": contract_views(events), "stats": bus.stats()}
-
-    @router.get("/realtime/presence")
-    async def realtime_presence(request: Request):
-        user = require_user(request)
-        scope = allowed_scopes(user or None)
-        return {"presence": bus.presence(workspace_scope=scope), "stats": bus.stats()}
-
-    @router.post("/realtime/presence/join")
-    async def realtime_join(req: PresenceRequest, request: Request):
-        user = require_user(request)
-        scope = allowed_scopes(user or None)
-        workspace_id = req.workspace_id
-        if scope is not None:
-            if workspace_id is None:
-                if not scope:
-                    raise HTTPException(status_code=403, detail="No accessible workspace for presence.")
-                workspace_id = "personal" if "personal" in scope else sorted(scope)[0]
-            elif workspace_id not in scope:
-                raise HTTPException(status_code=403, detail="Workspace presence access denied.")
-        client_id = req.client_id or secrets.token_urlsafe(8)
-        try:
-            record = bus.join(client_id, user=user or None, workspace_id=workspace_id)
-        except PermissionError as exc:
-            raise HTTPException(status_code=403, detail=str(exc)) from exc
-        return {"presence": record}
-
-    @router.post("/realtime/presence/leave")
-    async def realtime_leave(req: PresenceRequest, request: Request):
-        user = require_user(request)
-        if req.client_id:
-            try:
-                bus.leave(req.client_id, user=user or None)
-            except PermissionError as exc:
-                raise HTTPException(status_code=403, detail=str(exc)) from exc
-        return {"status": "ok"}
-
-    return router