sightmesh 0.13.0__py3-none-any.whl

sightmesh/__init__.py

@@ -0,0 +1,48 @@
+"""Local orchestration for visible Claude and Codex workers."""
+
+from importlib.metadata import PackageNotFoundError, version
+from typing import TYPE_CHECKING, Any
+
+_SDK_EXPORTS = frozenset(
+    {
+        "BatchResult",
+        "Command",
+        "SightMesh",
+        "SightMeshError",
+        "Worker",
+        "WorkerSpec",
+    }
+)
+
+if TYPE_CHECKING:
+    from .sdk import BatchResult, Command, SightMesh, SightMeshError, Worker, WorkerSpec
+
+try:
+    __version__ = version("sightmesh")
+except PackageNotFoundError:
+    __version__ = "0+unknown"
+
+__all__ = [
+    "BatchResult",
+    "Command",
+    "SightMesh",
+    "SightMeshError",
+    "Worker",
+    "WorkerSpec",
+    "__version__",
+]
+
+
+def __getattr__(name: str) -> Any:
+    """Load the SDK only for the package-root convenience exports."""
+    if name not in _SDK_EXPORTS:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    from . import sdk
+
+    value = getattr(sdk, name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | _SDK_EXPORTS)

sightmesh/approvals.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import sqlite3
+import time
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .service import state_dir
+
+
+class ApprovalAuditError(RuntimeError):
+    pass
+
+
+def approval_db_path() -> Path:
+    return state_dir() / "approvals.sqlite3"
+
+
+@dataclass(frozen=True)
+class ApprovalDecision:
+    decision_id: str
+    approval_id: str
+    execution_process_id: str
+    session_id: str | None
+    workspace_id: str | None
+    tool_name: str
+    decision: str
+    reviewer_kind: str
+    reviewer_id: str
+    reason_sha256: str | None
+    status: str
+    error: str | None
+    created_at: float
+    completed_at: float | None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "decision_id": self.decision_id,
+            "approval_id": self.approval_id,
+            "execution_process_id": self.execution_process_id,
+            "session_id": self.session_id,
+            "workspace_id": self.workspace_id,
+            "tool_name": self.tool_name,
+            "decision": self.decision,
+            "reviewer_kind": self.reviewer_kind,
+            "reviewer_id": self.reviewer_id,
+            "reason_sha256": self.reason_sha256,
+            "status": self.status,
+            "error": self.error,
+            "created_at": self.created_at,
+            "completed_at": self.completed_at,
+        }
+
+
+class ApprovalAuditStore:
+    def __init__(self, path: Path | None = None) -> None:
+        self.path = path or approval_db_path()
+        self.path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        self.path.parent.chmod(0o700)
+        self._initialize()
+
+    def _connect(self) -> sqlite3.Connection:
+        try:
+            conn = sqlite3.connect(self.path, timeout=30, isolation_level=None)
+            conn.row_factory = sqlite3.Row
+            conn.execute("PRAGMA busy_timeout = 30000")
+            conn.execute("PRAGMA journal_mode = WAL")
+            for path in (
+                self.path,
+                self.path.with_name(f"{self.path.name}-wal"),
+                self.path.with_name(f"{self.path.name}-shm"),
+            ):
+                if path.exists():
+                    os.chmod(path, 0o600)
+            return conn
+        except sqlite3.Error as exc:
+            raise ApprovalAuditError(
+                f"Cannot open approval audit store {self.path}: {exc}"
+            ) from exc
+
+    def _initialize(self) -> None:
+        try:
+            with self._connect() as conn:
+                conn.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS approval_decisions (
+                        decision_id TEXT PRIMARY KEY,
+                        approval_id TEXT NOT NULL,
+                        execution_process_id TEXT NOT NULL,
+                        session_id TEXT,
+                        workspace_id TEXT,
+                        tool_name TEXT NOT NULL,
+                        decision TEXT NOT NULL
+                            CHECK (decision IN ('approved', 'denied')),
+                        reviewer_kind TEXT NOT NULL
+                            CHECK (reviewer_kind IN ('human', 'session')),
+                        reviewer_id TEXT NOT NULL,
+                        reason_sha256 TEXT,
+                        status TEXT NOT NULL
+                            CHECK (status IN ('submitting', 'responded', 'failed')),
+                        error TEXT,
+                        created_at REAL NOT NULL,
+                        completed_at REAL
+                    )
+                    """
+                )
+                conn.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_approval_decisions_created "
+                    "ON approval_decisions(created_at DESC)"
+                )
+                conn.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_approval_decisions_approval "
+                    "ON approval_decisions(approval_id, created_at DESC)"
+                )
+        except sqlite3.DatabaseError as exc:
+            raise ApprovalAuditError(
+                f"Cannot initialize approval audit store {self.path}: {exc}"
+            ) from exc
+
+    def begin(
+        self,
+        *,
+        approval: dict[str, Any],
+        decision: str,
+        reviewer_kind: str,
+        reviewer_id: str,
+        reason: str | None,
+    ) -> ApprovalDecision:
+        now = time.time()
+        record = ApprovalDecision(
+            decision_id=str(uuid.uuid4()),
+            approval_id=str(approval["approval_id"]),
+            execution_process_id=str(approval["execution_process_id"]),
+            session_id=_optional_string(approval.get("session_id")),
+            workspace_id=_optional_string(approval.get("workspace_id")),
+            tool_name=str(approval["tool_name"]),
+            decision=decision,
+            reviewer_kind=reviewer_kind,
+            reviewer_id=reviewer_id,
+            reason_sha256=(
+                hashlib.sha256(reason.encode("utf-8")).hexdigest() if reason else None
+            ),
+            status="submitting",
+            error=None,
+            created_at=now,
+            completed_at=None,
+        )
+        try:
+            with self._connect() as conn:
+                conn.execute(
+                    """
+                    INSERT INTO approval_decisions (
+                        decision_id, approval_id, execution_process_id, session_id,
+                        workspace_id, tool_name, decision, reviewer_kind,
+                        reviewer_id, reason_sha256, status, error, created_at,
+                        completed_at
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        record.decision_id,
+                        record.approval_id,
+                        record.execution_process_id,
+                        record.session_id,
+                        record.workspace_id,
+                        record.tool_name,
+                        record.decision,
+                        record.reviewer_kind,
+                        record.reviewer_id,
+                        record.reason_sha256,
+                        record.status,
+                        record.error,
+                        record.created_at,
+                        record.completed_at,
+                    ),
+                )
+        except sqlite3.DatabaseError as exc:
+            raise ApprovalAuditError(f"Cannot record approval attempt: {exc}") from exc
+        return record
+
+    def finish(
+        self, decision_id: str, *, succeeded: bool, error: str | None = None
+    ) -> ApprovalDecision:
+        status = "responded" if succeeded else "failed"
+        completed_at = time.time()
+        try:
+            with self._connect() as conn:
+                cursor = conn.execute(
+                    """
+                    UPDATE approval_decisions
+                    SET status = ?, error = ?, completed_at = ?
+                    WHERE decision_id = ? AND status = 'submitting'
+                    """,
+                    (status, error, completed_at, decision_id),
+                )
+                if cursor.rowcount != 1:
+                    raise ApprovalAuditError(
+                        f"Approval audit attempt is missing or already finished: {decision_id}"
+                    )
+                row = conn.execute(
+                    "SELECT * FROM approval_decisions WHERE decision_id = ?",
+                    (decision_id,),
+                ).fetchone()
+        except sqlite3.DatabaseError as exc:
+            raise ApprovalAuditError(f"Cannot finish approval audit: {exc}") from exc
+        if row is None:
+            raise ApprovalAuditError(
+                f"Approval audit attempt is missing: {decision_id}"
+            )
+        return _from_row(row)
+
+    def history(self, *, limit: int = 50) -> list[ApprovalDecision]:
+        if limit < 1 or limit > 500:
+            raise ValueError("Approval history limit must be between 1 and 500")
+        try:
+            with self._connect() as conn:
+                rows = conn.execute(
+                    "SELECT * FROM approval_decisions ORDER BY created_at DESC LIMIT ?",
+                    (limit,),
+                ).fetchall()
+        except sqlite3.DatabaseError as exc:
+            raise ApprovalAuditError(f"Cannot read approval history: {exc}") from exc
+        return [_from_row(row) for row in rows]
+
+
+def _optional_string(value: Any) -> str | None:
+    return str(value) if value is not None else None
+
+
+def _from_row(row: sqlite3.Row) -> ApprovalDecision:
+    return ApprovalDecision(
+        decision_id=row["decision_id"],
+        approval_id=row["approval_id"],
+        execution_process_id=row["execution_process_id"],
+        session_id=row["session_id"],
+        workspace_id=row["workspace_id"],
+        tool_name=row["tool_name"],
+        decision=row["decision"],
+        reviewer_kind=row["reviewer_kind"],
+        reviewer_id=row["reviewer_id"],
+        reason_sha256=row["reason_sha256"],
+        status=row["status"],
+        error=row["error"],
+        created_at=row["created_at"],
+        completed_at=row["completed_at"],
+    )

sightmesh/bridge.py

@@ -0,0 +1,368 @@
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import logging
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import websockets
+
+from . import leases
+from .cdesktop import CdesktopClient, CdesktopError
+from .durable import DurableExecutionReconciler
+from .execution_routing import ExecutionRoutingError
+from .fence import open_transport
+from .pool.core import PoolError
+from .routing import (
+    clear_peer_identity,
+    enabled_workspaces,
+    peer_identity,
+    set_peer_identity,
+)
+from .sdk import SightMesh, SightMeshError
+from .succession import SuccessionError
+from .task_store import TaskStoreError
+
+LOGGER = logging.getLogger("sightmesh.bridge")
+
+
+def _peer_name(workspace: dict[str, Any], session: dict[str, Any]) -> str:
+    raw = f"cd-{workspace.get('name') or 'workspace'}-{session['id'][:6]}"
+    normalized = re.sub(r"[^A-Za-z0-9_.-]+", "-", raw).strip("-.")
+    normalized = re.sub(r"-+", "-", normalized)
+    return normalized[:48] or f"cd-session-{session['id'][:6]}"
+
+
+_BACKENDS = {"CLAUDE_CODE": "claude-code", "CODEX": "codex", "OPENCODE": "opencode"}
+
+
+def _backend(executor: str | None) -> str:
+    return _BACKENDS.get(executor or "", "codex")
+
+
+def _repo_path(client: CdesktopClient, workspace: dict[str, Any]) -> str:
+    repos = client.workspace_repos(workspace["id"])
+    if not repos:
+        raise CdesktopError(f"Workspace {workspace['id']} has no repository")
+    repo = repos[0]
+    if workspace.get("use_worktree"):
+        container = workspace.get("container_ref")
+        if not container:
+            raise CdesktopError(f"Workspace {workspace['id']} has no container path")
+        return str(Path(container) / repo["name"])
+    return str(Path(repo["path"]).expanduser().resolve())
+
+
+@dataclass(frozen=True)
+class BridgedSession:
+    workspace: dict[str, Any]
+    session: dict[str, Any]
+    path: str
+
+
+class RepowireSessionBridge:
+    def __init__(
+        self,
+        client: CdesktopClient,
+        bridged: BridgedSession,
+        repowire_url: str,
+    ) -> None:
+        self.client = client
+        self.bridged = bridged
+        self.repowire_url = repowire_url
+        self.assigned_name = _peer_name(bridged.workspace, bridged.session)
+
+    async def run(self) -> None:
+        delay = 1.0
+        while True:
+            try:
+                await self._connection()
+                delay = 1.0
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:  # noqa: BLE001 - isolate one bridge connection
+                LOGGER.warning("Bridge %s disconnected: %s", self.assigned_name, exc)
+                await asyncio.sleep(delay)
+                delay = min(delay * 2, 15.0)
+
+    async def _connection(self) -> None:
+        async with open_transport(
+            websockets.connect, self.repowire_url, ping_interval=20, ping_timeout=20
+        ) as ws:
+            connect: dict[str, Any] = {
+                "type": "connect",
+                "display_name": self.assigned_name,
+                "circle": "default",
+                "backend": _backend(self.bridged.session.get("executor")),
+                "path": self.bridged.path,
+                "role": "agent",
+                "hook_version": 1,
+                "capabilities": ["cdesktop_followup_bridge"],
+            }
+            existing_peer_id = peer_identity(self.bridged.session["id"])
+            if existing_peer_id:
+                connect["peer_id"] = existing_peer_id
+            auth_token = os.environ.get("REPOWIRE_AUTH_TOKEN")
+            if auth_token:
+                connect["auth_token"] = auth_token
+            await ws.send(json.dumps(connect))
+            connected = json.loads(await ws.recv())
+            if connected.get("code") == "peer_retired" and existing_peer_id:
+                clear_peer_identity(self.bridged.session["id"])
+            if connected.get("type") != "connected":
+                raise RuntimeError(str(connected))
+            set_peer_identity(self.bridged.session["id"], connected["session_id"])
+            self.assigned_name = connected.get("display_name") or self.assigned_name
+            await ws.send(
+                json.dumps({"type": "status", "status": "online", "turn_state": "idle"})
+            )
+            LOGGER.info(
+                "Bridged %s to cdesktop session %s",
+                self.assigned_name,
+                self.bridged.session["id"],
+            )
+            async for raw in ws:
+                message = json.loads(raw)
+                await self._handle(ws, message)
+
+    async def _handle(self, ws: Any, message: dict[str, Any]) -> None:
+        message_type = message.get("type")
+        if message_type == "ping":
+            await ws.send(json.dumps({"type": "pong"}))
+            return
+        if message_type not in {"ask", "notify", "broadcast"}:
+            if message_type == "query":
+                await ws.send(
+                    json.dumps(
+                        {
+                            "type": "error",
+                            "correlation_id": message.get("correlation_id"),
+                            "error": "Legacy query is unsupported by the cdesktop bridge; use ask",
+                        }
+                    )
+                )
+            return
+
+        from_peer = message.get("from_peer", "unknown")
+        text = message.get("text", "")
+        correlation_id = message.get("correlation_id")
+        if message_type == "ask":
+            question_flag = " --question" if message.get("question") else ""
+            prompt = (
+                f"## Request from @{from_peer}\n\n{text}\n\n"
+                "When complete, send a concise result back with:\n\n"
+                f"sightmesh bridge-reply {correlation_id} --from-peer {self.assigned_name}"
+                f"{question_flag} --message 'RESULT'\n\n"
+                "Do not delegate to hidden or native subagents."
+            )
+        else:
+            prompt = (
+                f"## {message_type.title()} from @{from_peer}\n\n{text}\n\n"
+                "Do not delegate to hidden or native subagents."
+            )
+
+        try:
+            await asyncio.to_thread(
+                self.client.send,
+                self.bridged.session["id"],
+                prompt,
+                None,
+                dedupe_key=_dedupe_key(
+                    self.bridged.session["id"], message_type, message
+                ),
+            )
+        except (CdesktopError, OSError, RuntimeError) as exc:
+            await self._send_delivery_failure(ws, message, str(exc))
+            return
+        await self._send_delivery_ack(ws, message)
+
+    async def _send_delivery_ack(self, ws: Any, message: dict[str, Any]) -> None:
+        delivery_id = message.get("delivery_id")
+        if not delivery_id:
+            return
+        await ws.send(
+            json.dumps(
+                {
+                    "type": "delivery_ack",
+                    "delivery_id": delivery_id,
+                    "message_type": message.get("type"),
+                    "status": "injected",
+                }
+            )
+        )
+
+    async def _send_delivery_failure(
+        self, ws: Any, message: dict[str, Any], detail: str
+    ) -> None:
+        delivery_id = message.get("delivery_id")
+        if delivery_id:
+            await ws.send(
+                json.dumps(
+                    {
+                        "type": "delivery_ack",
+                        "delivery_id": delivery_id,
+                        "message_type": message.get("type"),
+                        "status": "failed",
+                        "detail": detail,
+                    }
+                )
+            )
+        correlation_id = message.get("correlation_id")
+        if correlation_id:
+            await self._send_error(ws, correlation_id, detail)
+
+    async def _send_error(self, ws: Any, correlation_id: str, error: str) -> None:
+        await ws.send(
+            json.dumps(
+                {"type": "error", "correlation_id": correlation_id, "error": error}
+            )
+        )
+
+
+class BridgeSupervisor:
+    def __init__(
+        self,
+        client: CdesktopClient,
+        repowire_url: str,
+    ) -> None:
+        self.client = client
+        self.repowire_url = repowire_url
+        self.tasks: dict[str, asyncio.Task[None]] = {}
+        self.reconciler = DurableExecutionReconciler(client)
+        self.managed_tasks = SightMesh(
+            client=client,
+            store=self.reconciler.task_store,
+            ownership=self.reconciler.ownership,
+        )
+    async def run(self) -> None:
+        while True:
+            try:
+                await self.reconcile()
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:  # noqa: BLE001 - one tick never ends the loop
+                LOGGER.warning("Bridge reconcile tick failed: %s", exc)
+            await asyncio.sleep(2)
+
+    async def reconcile(self) -> None:
+        enabled = enabled_workspaces()
+        desired: dict[str, BridgedSession] = {}
+        # Wake delivery reads task rows, not workspaces, so it runs once per
+        # tick and cannot be starved behind a slow or failing workspace scan.
+        try:
+            await asyncio.to_thread(self.reconciler.reconcile_kernel)
+        except Exception as exc:  # noqa: BLE001 - a kernel pass never ends a tick
+            LOGGER.warning("Cannot reconcile the task kernel: %s", exc)
+        # A launch rejected before its task ever activated holds no session, so
+        # the per-session pass below can never reach it. This journal-keyed
+        # sweep is what advances it past its typed provider outcome.
+        try:
+            await asyncio.to_thread(self.managed_tasks.reconcile_provider_outcomes)
+        except (
+            CdesktopError,
+            ExecutionRoutingError,
+            PoolError,
+            SightMeshError,
+            SuccessionError,
+            TaskStoreError,
+        ) as exc:
+            LOGGER.warning("Cannot reconcile typed provider outcomes: %s", exc)
+        try:
+            await asyncio.to_thread(
+                leases.sync_active_workspaces,
+                self.client,
+                on_error=lambda detail: LOGGER.warning(
+                    "Cannot reconcile one cdesktop workspace: %s", detail
+                ),
+            )
+            workspaces = await asyncio.to_thread(self.client.workspaces)
+            for workspace in workspaces:
+                if workspace.get("archived"):
+                    continue
+                try:
+                    sessions = await asyncio.to_thread(
+                        self.client.sessions, workspace["id"]
+                    )
+                except CdesktopError as exc:
+                    LOGGER.warning(
+                        "Cannot inspect workspace %s sessions: %s", workspace["id"], exc
+                    )
+                    continue
+                await asyncio.to_thread(self.reconciler.reconcile_sessions, sessions)
+                for session in sessions:
+                    try:
+                        await asyncio.to_thread(
+                            self.managed_tasks.reconcile_provider_outcome,
+                            str(session["id"]),
+                        )
+                    except (
+                        CdesktopError,
+                        ExecutionRoutingError,
+                        PoolError,
+                        SightMeshError,
+                        SuccessionError,
+                        TaskStoreError,
+                    ) as exc:
+                        LOGGER.warning(
+                            "Cannot reconcile managed task %s: %s",
+                            session.get("id"),
+                            exc,
+                        )
+                if workspace["id"] not in enabled:
+                    continue
+                try:
+                    path = await asyncio.to_thread(_repo_path, self.client, workspace)
+                except CdesktopError as exc:
+                    LOGGER.warning(
+                        "Cannot bridge workspace %s: %s", workspace["id"], exc
+                    )
+                    continue
+                for session in sessions:
+                    # A quarantined (retired/superseded) session never gets a
+                    # peer bridge; injected follow-ups would auto-resume it
+                    # into a worktree its successor now owns.
+                    if self.reconciler.ownership.is_quarantined(session["id"]):
+                        continue
+                    desired[session["id"]] = BridgedSession(workspace, session, path)
+        except (CdesktopError, leases.LeaseError) as exc:
+            LOGGER.warning("Cannot reconcile cdesktop ownership: %s", exc)
+            return
+
+        for session_id in set(self.tasks) - set(desired):
+            self.tasks.pop(session_id).cancel()
+        for session_id, bridged in desired.items():
+            task = self.tasks.get(session_id)
+            if task is None or task.done():
+                self.tasks[session_id] = asyncio.create_task(
+                    RepowireSessionBridge(
+                        self.client,
+                        bridged,
+                        self.repowire_url,
+                    ).run(),
+                    name=f"bridge-{session_id}",
+                )
+
+
+async def run_bridge(cdesktop_url: str | None, repowire_url: str) -> None:
+    client = CdesktopClient(cdesktop_url)
+    await BridgeSupervisor(client, repowire_url).run()
+
+
+def _dedupe_key(session_id: str, message_type: str, message: dict[str, Any]) -> str:
+    source = message.get("delivery_id") or message.get("correlation_id")
+    if not source:
+        source = hashlib.sha256(
+            json.dumps(
+                {
+                    "from_peer": message.get("from_peer"),
+                    "text": message.get("text"),
+                },
+                sort_keys=True,
+            ).encode("utf-8")
+        ).hexdigest()
+    return f"repowire:{session_id}:{message_type}:{source}"