create-workframe 0.1.11 → 0.1.13

package/workframe-api/cell_authority.py

@@ -0,0 +1,231 @@
+"""CellAuthorityGate — install/cell authority (WF-007)."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal
+
+from domain.entities import Cell, DeploymentMode, Grant, GrantCapability
+
+CellOperation = Literal["create", "open", "update", "connect", "adopt"]
+CellDecisionKind = Literal["allow", "allow_readonly", "deny", "needs_user_action"]
+
+
+@dataclass(frozen=True)
+class CellAuthorityDecision:
+    operation: CellOperation
+    decision: CellDecisionKind
+    reason: str
+    cell: Cell | None
+    mutation_plan: tuple[str, ...] = field(default_factory=tuple)
+
+
+def _read_json(path: Path) -> dict[str, Any] | None:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def load_cell_from_manifest(install_root: str | Path) -> Cell | None:
+    root = Path(install_root).resolve()
+    manifest_path = root / "workframe-manifest.json"
+    data = _read_json(manifest_path)
+    if not data:
+        return None
+    layout = data.get("layout") if isinstance(data.get("layout"), dict) else {}
+    security = data.get("security") if isinstance(data.get("security"), dict) else {}
+    docker = data.get("docker") if isinstance(data.get("docker"), dict) else {}
+    mode_raw = str(security.get("deployment_mode") or data.get("deployment_mode") or "single_user_local")
+    try:
+        mode = DeploymentMode(mode_raw)
+    except ValueError:
+        mode = DeploymentMode.SINGLE_USER_LOCAL
+    return Cell(
+        cell_id=str(data.get("install_id") or data.get("project_name") or root.name),
+        install_root=str(root),
+        manifest_path=str(manifest_path),
+        package_name=str(data.get("package_name") or "create-workframe"),
+        package_version=str(data.get("package_version") or ""),
+        deployment_mode=mode,
+        created_at=None,  # type: ignore[arg-type]
+        git_ref=data.get("git_ref"),
+        packed_artifact_digest=data.get("packed_artifact_digest"),
+    )
+
+
+def _dir_nonempty(path: Path) -> bool:
+    if not path.is_dir():
+        return False
+    try:
+        return any(path.iterdir())
+    except OSError:
+        return False
+
+
+def evaluate_create(
+    target: str | Path,
+    *,
+    force: bool = False,
+    package_version: str = "",
+    packed_digest: str | None = None,
+) -> CellAuthorityDecision:
+    root = Path(target).resolve()
+    if root.exists() and _dir_nonempty(root) and not force:
+        return CellAuthorityDecision(
+            operation="create",
+            decision="deny",
+            reason="target_not_empty",
+            cell=None,
+            mutation_plan=(),
+        )
+    plan = (
+        "assert target writable",
+        "write scaffold tree",
+        f"record package_version={package_version or 'unknown'}",
+        "atomic write workframe-manifest.json",
+        "verify layout Agents/ Files/",
+    )
+    cell = Cell(
+        cell_id=root.name,
+        install_root=str(root),
+        manifest_path=str(root / "workframe-manifest.json"),
+        package_name="create-workframe",
+        package_version=package_version,
+        deployment_mode=DeploymentMode.SINGLE_USER_LOCAL,
+        created_at=None,  # type: ignore[arg-type]
+        packed_artifact_digest=packed_digest,
+    )
+    return CellAuthorityDecision(
+        operation="create",
+        decision="allow",
+        reason="empty_target_or_force",
+        cell=cell,
+        mutation_plan=plan,
+    )
+
+
+def evaluate_open(install_root: str | Path, *, doctor_report: dict[str, Any] | None = None) -> CellAuthorityDecision:
+    root = Path(install_root).resolve()
+    cell = load_cell_from_manifest(root)
+    if not cell:
+        return CellAuthorityDecision(
+            operation="open",
+            decision="deny",
+            reason="manifest_missing",
+            cell=None,
+        )
+    manifest_layout = _read_json(Path(cell.manifest_path)) or {}
+    layout = manifest_layout.get("layout") if isinstance(manifest_layout.get("layout"), dict) else {}
+    expected_ws = str(layout.get("workspace") or "Files")
+    if not (root / expected_ws).is_dir():
+        return CellAuthorityDecision(
+            operation="open",
+            decision="deny",
+            reason="workspace_mount_missing",
+            cell=cell,
+        )
+    if doctor_report and doctor_report.get("decision") == "needs_user_action":
+        return CellAuthorityDecision(
+            operation="open",
+            decision="needs_user_action",
+            reason="doctor_prerequisites",
+            cell=cell,
+        )
+    return CellAuthorityDecision(
+        operation="open",
+        decision="allow_readonly",
+        reason="manifest_and_layout_ok",
+        cell=cell,
+    )
+
+
+def evaluate_update(
+    install_root: str | Path,
+    *,
+    open_decision: CellAuthorityDecision | None = None,
+    user_ack: bool = False,
+) -> CellAuthorityDecision:
+    opened = open_decision or evaluate_open(install_root)
+    if opened.decision != "allow_readonly":
+        return CellAuthorityDecision(
+            operation="update",
+            decision="deny",
+            reason=f"open_blocked:{opened.reason}",
+            cell=opened.cell,
+        )
+    if not user_ack:
+        return CellAuthorityDecision(
+            operation="update",
+            decision="needs_user_action",
+            reason="explicit_user_ack_required",
+            cell=opened.cell,
+            mutation_plan=(
+                "snapshot manifest digest",
+                "apply bounded file mutations",
+                "verify health",
+                "record evidence artifact",
+            ),
+        )
+    return CellAuthorityDecision(
+        operation="update",
+        decision="allow",
+        reason="open_ok_and_ack",
+        cell=opened.cell,
+        mutation_plan=(
+            "snapshot manifest digest",
+            "apply bounded file mutations",
+            "verify health",
+            "record evidence artifact",
+        ),
+    )
+
+
+def evaluate_connect(*, remote_attested: bool = False) -> CellAuthorityDecision:
+    if not remote_attested:
+        return CellAuthorityDecision(
+            operation="connect",
+            decision="deny",
+            reason="remote_not_attested",
+            cell=None,
+        )
+    return CellAuthorityDecision(
+        operation="connect",
+        decision="allow_readonly",
+        reason="remote_attested",
+        cell=None,
+    )
+
+
+def evaluate_adopt(*, runtime_kind: str = "") -> CellAuthorityDecision:
+    # ponytail: adopt blocked until WF-014/NS-P4 — always deny non-proven adapters
+    if runtime_kind and runtime_kind not in ("hermes_managed", ""):
+        return CellAuthorityDecision(
+            operation="adopt",
+            decision="deny",
+            reason="adapter_not_proven",
+            cell=None,
+        )
+    return CellAuthorityDecision(
+        operation="adopt",
+        decision="deny",
+        reason="adopt_deferred_wf014",
+        cell=None,
+    )
+
+
+def file_write_grant(cell: Cell) -> Grant:
+    return Grant(
+        grant_id=f"cell-fw-{cell.cell_id}",
+        run_id="",
+        capability=GrantCapability.FILE_WRITE,
+        scope={"install_root": cell.install_root},
+        granted_by="cell_authority_gate",
+    )
+
+
+def cell_id_from_env() -> str:
+    return str(os.environ.get("WORKFRAME_PROJECT") or os.environ.get("PROJECT_NAME") or "default")

package/workframe-api/chat_bind.py

@@ -0,0 +1,319 @@
+"""WF-032 extract: chat bind and room session handlers."""
+from __future__ import annotations
+
+import re
+import sqlite3
+import urllib.parse
+import uuid
+from typing import Any
+
+import lane_bindings
+
+
+def _srv():
+    import server as srv
+
+    return srv
+
+
+def room_chat_bind(room_id: str, payload: dict[str, Any], user_id: str = "") -> dict[str, Any]:
+    """Room-scoped bind — identity from room.agent_profile_id, not the URL."""
+    body = dict(payload or {})
+    body["room_id"] = str(room_id or "").strip()
+    return profile_chat_bind("", body, user_id)
+
+
+def profile_chat_bind(profile: str, payload: dict[str, Any], user_id: str = "") -> dict[str, Any]:
+    session = lane_bindings.profile_chat_session(profile, payload, user_id)
+    sid = str(session.get("session_id") or "").strip()
+    hermes_prof = str(session.get("profile") or _srv().resolve_validated_profile(profile))
+    template_prof = str(session.get("template_profile") or "").strip()
+    if not template_prof:
+        template_prof = (
+            _srv()._runtime_template_slug(hermes_prof)
+            if _srv()._is_runtime_profile_slug(hermes_prof)
+            else _srv().resolve_validated_profile(profile)
+        )
+    workspace_id = str(session.get("workspace_id") or payload.get("workspace_id") or "").strip()
+    history = _srv().chat_messages(hermes_prof, sid)
+    # ponytail: cohort manifest is lazy — GET /api/me/cohort; bind must stay fast
+    cohort: list[dict[str, Any]] = []
+    display_name = (
+        _srv()._runtime_display_label(user_id, template_prof, workspace_id)
+        if user_id and _srv()._is_runtime_profile_slug(hermes_prof)
+        else _srv()._profile_display_name(hermes_prof, workspace_id)
+    )
+    return {
+        "ok": True,
+        "profile": session.get("profile") or profile,
+        "template_profile": template_prof,
+        "agent_display_name": display_name,
+        "cohort": cohort,
+        "session_id": sid,
+        "title": session.get("title") or "",
+        "created": bool(session.get("created")),
+        "api_port": session.get("api_port"),
+        "llm_ready": bool(session.get("llm_ready")),
+        "has_llm_provider": bool(session.get("has_llm_provider")),
+        "messages": history.get("messages") or [],
+        "session": history.get("session") or {},
+    }
+
+
+def _room_session_rows(conn: sqlite3.Connection, room_id: str) -> list[sqlite3.Row]:
+    return conn.execute(
+        """
+        SELECT rs.*, ap.slug AS agent_slug, ap.display_name AS agent_display_name
+        FROM room_sessions rs
+        LEFT JOIN agent_profiles ap ON ap.id = rs.agent_profile_id
+        WHERE rs.room_id = ? AND rs.deleted_at IS NULL
+        ORDER BY rs.updated_at DESC, rs.created_at DESC
+        """,
+        (room_id,),
+    ).fetchall()
+
+
+def list_room_sessions(room_id: str, user_id: str) -> dict[str, Any]:
+    room_id = str(room_id or "").strip()
+    user_id = str(user_id or "").strip()
+    if not room_id or not user_id:
+        raise ValueError("room_id and user required")
+    conn = _srv()._workframe_db()
+    try:
+        room = conn.execute(
+            "SELECT * FROM rooms WHERE id = ? AND deleted_at IS NULL",
+            (room_id,),
+        ).fetchone()
+        if not room:
+            raise ValueError("room_not_found")
+        if not _srv()._user_can_access_room(conn, room_id, user_id):
+            raise ValueError("room_access_denied")
+        workspace_id = str(room["workspace_id"])
+        rows = _room_session_rows(conn, room_id)
+    finally:
+        conn.close()
+
+    sessions: list[dict[str, Any]] = []
+    for row in rows:
+        template_slug = str(row["agent_slug"] or "").strip()
+        agent_db_id = str(row["agent_profile_id"] or "").strip()
+        if not template_slug or not agent_db_id:
+            continue
+        sid = str(row["session_id"] or "").strip()
+        try:
+            hermes_prof = _srv()._resolve_chat_hermes_profile(template_slug, user_id, room_id, workspace_id)
+            if not sid or not _srv()._session_exists(hermes_prof, sid):
+                continue
+            info = _srv()._session_info(hermes_prof, sid)
+        except ValueError:
+            # ponytail: skip orphaned bindings (e.g. deleted smoke-agent profiles)
+            continue
+        sessions.append(
+            {
+                "id": str(row["id"]),
+                "room_id": room_id,
+                "agent_profile_id": agent_db_id,
+                "agent_slug": template_slug,
+                "hermes_profile": hermes_prof,
+                "session_id": sid,
+                "title": _srv()._resolved_session_title(hermes_prof, sid, str(row["title"] or "")),
+                "status": str(row["status"] or "active"),
+                "message_count": int(info.get("message_count") or 0),
+                "created_at": _srv()._iso_from_unix(row["created_at"]),
+                "updated_at": _srv()._iso_from_unix(row["updated_at"]),
+                "active": str(row["status"] or "") == "active",
+            }
+        )
+    return {"ok": True, "room_id": room_id, "sessions": sessions}
+
+
+def profile_chat_activate_room_session(
+    room_id: str,
+    session_id: str,
+    user_id: str,
+    template_prof: str = "",
+    *,
+    source_id: str = "ui",
+    client_id: str = "default",
+    binding_version: int = 0,
+) -> dict[str, Any]:
+    room_id = str(room_id or "").strip()
+    session_id = str(session_id or "").strip()
+    user_id = str(user_id or "").strip()
+    if not room_id or not session_id or not user_id:
+        raise ValueError("room_id, session_id, and user required")
+
+    conn = _srv()._workframe_db()
+    try:
+        room = conn.execute(
+            "SELECT * FROM rooms WHERE id = ? AND deleted_at IS NULL",
+            (room_id,),
+        ).fetchone()
+        if not room:
+            raise ValueError("room_not_found")
+        if not _srv()._user_can_access_room(conn, room_id, user_id):
+            raise ValueError("room_access_denied")
+        workspace_id = str(room["workspace_id"])
+        row = conn.execute(
+            """
+            SELECT rs.*, ap.slug AS agent_slug
+            FROM room_sessions rs
+            LEFT JOIN agent_profiles ap ON ap.id = rs.agent_profile_id
+            WHERE rs.room_id = ? AND rs.session_id = ? AND rs.deleted_at IS NULL
+            LIMIT 1
+            """,
+            (room_id, session_id),
+        ).fetchone()
+        if not row:
+            raise ValueError("room_session_not_found")
+        template_slug = str(template_prof or row["agent_slug"] or "").strip()
+        if not template_slug:
+            raise ValueError("agent_profile_not_found")
+        agent_db_id = str(row["agent_profile_id"] or "").strip()
+        hermes_prof = _srv()._resolve_chat_hermes_profile(template_slug, user_id, room_id, workspace_id)
+        if not _srv()._session_exists(hermes_prof, session_id):
+            raise ValueError("session_not_found")
+        gateway_sid = str(row["gateway_session_id"] or f"api:{hermes_prof}:{session_id}").strip()
+        title = str(_srv()._session_info(hermes_prof, session_id).get("title") or row["title"] or "")
+        _srv()._upsert_room_session(
+            conn,
+            room_id=room_id,
+            agent_profile_id=agent_db_id,
+            session_id=session_id,
+            gateway_session_id=gateway_sid,
+            created_by=user_id,
+            title=title,
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+    lane_bindings._sync_lane_binding(
+        hermes_prof,
+        source_id,
+        client_id,
+        binding_version,
+        session_id,
+        gateway_sid,
+    )
+
+    if user_id:
+        _srv()._reconcile_profile_llm_for_user(hermes_prof, user_id, workspace_id)
+    llm_provider = _srv()._llm_billing_provider(hermes_prof, user_id=user_id, workspace_id=workspace_id)
+    llm_ready = _srv()._overlay_chat_llm_env(hermes_prof, user_id, workspace_id, llm_provider)
+
+    history = _srv().chat_messages(hermes_prof, session_id)
+    cohort = _srv().ensure_user_agent_cohort(user_id, workspace_id)
+    return {
+        "ok": True,
+        "profile": hermes_prof,
+        "template_profile": template_slug,
+        "agent_display_name": _srv()._runtime_display_label(user_id, template_slug, workspace_id),
+        "cohort": cohort,
+        "room_id": room_id,
+        "session_id": session_id,
+        "title": title,
+        "created": False,
+        "resumed": True,
+        "llm_ready": llm_ready,
+        "has_llm_provider": llm_ready,
+        "messages": history.get("messages") or [],
+        "session": history.get("session") or {},
+    }
+
+
+def profile_chat_message(profile: str, payload: dict[str, Any]) -> dict[str, Any]:
+    source_id = str(payload.get("source_id") or "ui").strip() or "ui"
+    client_id = str(payload.get("client_id") or "default").strip() or "default"
+    session_id = str(payload.get("session_id") or "").strip()
+    text = str(payload.get("text") or "").strip()
+    if not session_id:
+        raise ValueError("session_id required")
+    if not text:
+        raise ValueError("text required")
+    payer = str(payload.get("user_id") or "").strip()
+    workspace_id = str(payload.get("workspace_id") or "").strip()
+    room_id = str(payload.get("room_id") or "").strip()
+    hermes_prof, _template_prof = _srv()._resolve_bind_profile_arg(
+        profile, payer, room_id, workspace_id,
+    )
+    if payer:
+        _srv()._reconcile_profile_llm_for_user(hermes_prof, payer, workspace_id)
+    llm_provider = _srv()._llm_billing_provider(hermes_prof, user_id=payer, workspace_id=workspace_id)
+    lifecycle = _srv().ensure_profile_api(
+        hermes_prof,
+        payer,
+        workspace_id,
+    )
+    turn_run_id = str(uuid.uuid4())
+    try:
+        if payer:
+            _srv()._overlay_turn_provider_env(
+                hermes_prof, payer, workspace_id, llm_provider, turn_run_id,
+            )
+            _srv()._overlay_turn_user_env(hermes_prof, payer, workspace_id, turn_run_id)
+        turn_body = _srv()._profile_turn_payload(hermes_prof, text, room_id)
+        if payer and workspace_id:
+            _srv()._inject_turn_credentials(turn_body, payer, workspace_id, llm_provider)
+        status, data = _srv()._profile_api_request(
+            hermes_prof,
+            "POST",
+            f"/api/sessions/{urllib.parse.quote(session_id, safe='')}/chat",
+            turn_body,
+        )
+        if status >= 300:
+            raise ValueError(f"session chat failed: {data}")
+        assistant = ""
+        if isinstance(data, dict):
+            msg = data.get("message")
+            if isinstance(msg, dict):
+                assistant = str(msg.get("content") or "")
+        lane_bindings.chat_dispatch(
+            {
+                "profile": hermes_prof,
+                "session_id": session_id,
+                "gateway_session_id": f"api:{hermes_prof}:{session_id}",
+                "source_id": source_id,
+                "client_id": client_id,
+                "room_id": room_id,
+                "user_id": payer,
+                "text": text,
+            }
+        )
+        return {
+            "ok": True,
+            "profile": hermes_prof,
+            "session_id": session_id,
+            "api_port": lifecycle["api_port"],
+            "assistant": assistant,
+        }
+    finally:
+        if payer:
+            _srv()._revoke_turn_credential_lease(turn_run_id, hermes_prof)
+
+
+def _enrich_room_chat_payload(payload: dict[str, Any], user_id: str) -> dict[str, Any]:
+    body = dict(payload) if isinstance(payload, dict) else {}
+    body["user_id"] = user_id
+    room_id = str(body.get("room_id") or "").strip()
+    if room_id and not str(body.get("workspace_id") or "").strip():
+        try:
+            conn = _srv()._workframe_db()
+            row = conn.execute(
+                "SELECT workspace_id FROM rooms WHERE id = ? AND deleted_at IS NULL",
+                (room_id,),
+            ).fetchone()
+            conn.close()
+            if row:
+                body["workspace_id"] = str(row["workspace_id"])
+        except Exception:  # noqa: BLE001
+            pass
+    return body
+
+
+def _extract_title(text: str, fallback: str) -> str:
+    for line in text.splitlines():
+        m = re.match(r"^#\s+(.+)$", line.strip())
+        if m:
+            return m.group(1).strip()
+    return fallback