feat(supervise): orchestrator-side operator-approval API (Step 2a)

The orchestrator owns the single DB *and* the live policy, so operator decisions belong there — applied server-side, reached over HTTP. Adds: GET /supervise/proposals -> pending proposals across bottles POST /supervise/respond -> apply + record an operator decision `supervise_respond` is one atomic server-side op on the one DB: approve/ modify on an egress tool rewrites the bottle's policy (so the gateway serves the new routes on its next /resolve — the live "apply" that was a documented TODO), then writes the queued Response (unblocking the agent's MCP call) and an audit entry. reject records the response + audit only. Fails closed (409) when the proposal is unknown or the bottle was torn down before the operator acted (an egress apply would have no target). This is the server half of unifying every backend onto one HTTP path for supervise; the host TUI (direct-DB today) moves onto this client next. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01WBMWTEtQdJ4W5UrWuLHCck
2026-07-16 18:51:55 -04:00
parent 38bc555dbf
commit 9085d6f713
4 changed files with 332 additions and 0 deletions
@@ -13,11 +13,19 @@ import threading
 import unittest
 import urllib.request
 from pathlib import Path
+from unittest.mock import patch

 from bot_bottle.orchestrator.broker import StubBroker
 from bot_bottle.orchestrator.control_plane import dispatch, make_server
 from bot_bottle.orchestrator.registry import RegistryStore
 from bot_bottle.orchestrator.service import Orchestrator
+from bot_bottle.store_manager import StoreManager
+from bot_bottle.supervise import (
+    Proposal,
+    TOOL_EGRESS_ALLOW,
+    sha256_hex,
+    write_proposal,
+)


 def _body(obj: object) -> bytes:
@@ -235,5 +243,70 @@ class TestServerRoundTrip(unittest.TestCase):
        self.assertEqual(reg["bottle_id"], attr["bottle_id"])


+class TestDispatchSupervise(unittest.TestCase):
+    """The /supervise/* routes over the pure dispatch()."""
+
+    def setUp(self) -> None:
+        self._tmp = tempfile.TemporaryDirectory()
+        root = Path(self._tmp.name)
+        db = root / "db" / "bot-bottle.db"
+        db.parent.mkdir(parents=True)
+        self._env = patch.dict("os.environ", {
+            "BOT_BOTTLE_ROOT": str(root),
+            "SUPERVISE_DB_PATH": str(db),
+        })
+        self._env.start()
+        self.store = RegistryStore(db)
+        self.store.migrate()
+        StoreManager(db).migrate()
+        secret = secrets.token_bytes(16)
+        self.orch = Orchestrator(self.store, StubBroker(secret), secret)
+
+    def tearDown(self) -> None:
+        self._env.stop()
+        self._tmp.cleanup()
+
+    def _queue(self, slug: str, proposed: str) -> str:
+        self.store.register(
+            "10.243.0.1", metadata=json.dumps({"slug": slug}), policy="routes: []\n")
+        p = Proposal.new(
+            bottle_slug=slug, tool=TOOL_EGRESS_ALLOW, proposed_file=proposed,
+            justification="need it", current_file_hash=sha256_hex(proposed))
+        write_proposal(p)
+        return p.id
+
+    def test_list_pending(self) -> None:
+        pid = self._queue("demo", "routes:\n  - host: google.com\n")
+        status, payload = dispatch(self.orch, "GET", "/supervise/proposals", b"")
+        self.assertEqual(200, status)
+        proposals = payload["proposals"]
+        assert isinstance(proposals, list)
+        self.assertEqual(pid, proposals[0]["id"])
+
+    def test_respond_approve_applies_and_clears(self) -> None:
+        pid = self._queue("demo", "routes:\n  - host: google.com\n")
+        status, payload = dispatch(
+            self.orch, "POST", "/supervise/respond",
+            _body({"proposal_id": pid, "bottle_slug": "demo", "decision": "approve"}),
+        )
+        self.assertEqual(200, status)
+        self.assertTrue(payload["responded"])
+        _, listing = dispatch(self.orch, "GET", "/supervise/proposals", b"")
+        self.assertEqual([], listing["proposals"])
+
+    def test_respond_requires_fields(self) -> None:
+        status, _ = dispatch(
+            self.orch, "POST", "/supervise/respond", _body({"decision": "approve"}))
+        self.assertEqual(400, status)
+
+    def test_respond_unknown_proposal_conflicts(self) -> None:
+        status, payload = dispatch(
+            self.orch, "POST", "/supervise/respond",
+            _body({"proposal_id": "ghost", "bottle_slug": "demo", "decision": "approve"}),
+        )
+        self.assertEqual(409, status)
+        self.assertIn("no such proposal", str(payload["error"]))
+
+
 if __name__ == "__main__":
    unittest.main()
@@ -2,15 +2,26 @@

 from __future__ import annotations

+import json
 import secrets
 import tempfile
 import unittest
 from pathlib import Path
+from unittest.mock import patch

 from bot_bottle.orchestrator.broker import LaunchBroker, LaunchRequest, StubBroker
 from bot_bottle.orchestrator.registry import RegistryStore
 from bot_bottle.orchestrator.service import Orchestrator
 from bot_bottle.orchestrator.gateway import Gateway
+from bot_bottle.store_manager import StoreManager
+from bot_bottle.supervise import (
+    Proposal,
+    STATUS_APPROVED,
+    TOOL_EGRESS_ALLOW,
+    read_response,
+    sha256_hex,
+    write_proposal,
+)


 class _FailingBroker(LaunchBroker):
@@ -155,5 +166,111 @@ class TestOrchestrator(unittest.TestCase):
        )


+class TestOrchestratorSupervise(unittest.TestCase):
+    """Operator-approval flow: the orchestrator applies the decision
+    server-side against the single DB (queue + policy + audit)."""
+
+    def setUp(self) -> None:
+        self._tmp = tempfile.TemporaryDirectory()
+        root = Path(self._tmp.name)
+        db = root / "db" / "bot-bottle.db"
+        db.parent.mkdir(parents=True)
+        # One DB for registry + supervise queue + audit (as in the VM).
+        self._env = patch.dict("os.environ", {
+            "BOT_BOTTLE_ROOT": str(root),
+            "SUPERVISE_DB_PATH": str(db),
+        })
+        self._env.start()
+        self.store = RegistryStore(db)
+        self.store.migrate()
+        StoreManager(db).migrate()
+        secret = secrets.token_bytes(16)
+        self.orch = Orchestrator(self.store, StubBroker(secret), secret)
+
+    def tearDown(self) -> None:
+        self._env.stop()
+        self._tmp.cleanup()
+
+    def _register(self, slug: str, policy: str) -> str:
+        rec = self.store.register(
+            "10.243.0.1", metadata=json.dumps({"slug": slug}), policy=policy)
+        return rec.bottle_id
+
+    def _queue(self, slug: str, proposed: str) -> str:
+        p = Proposal.new(
+            bottle_slug=slug, tool=TOOL_EGRESS_ALLOW, proposed_file=proposed,
+            justification="need it", current_file_hash=sha256_hex(proposed))
+        write_proposal(p)
+        return p.id
+
+    def test_pending_lists_queued_proposal(self) -> None:
+        self._register("demo", "routes: []\n")
+        pid = self._queue("demo", "routes:\n  - host: google.com\n")
+        pending = self.orch.supervise_pending()
+        self.assertEqual(1, len(pending))
+        self.assertEqual(pid, pending[0]["id"])
+        self.assertEqual("demo", pending[0]["bottle_slug"])
+
+    def test_approve_applies_policy_writes_response_and_clears_pending(self) -> None:
+        bottle_id = self._register("demo", "routes:\n  - host: existing.com\n")
+        new_routes = "routes:\n  - host: google.com\n"
+        pid = self._queue("demo", new_routes)
+        ok, err = self.orch.supervise_respond(
+            pid, bottle_slug="demo", decision="approve")
+        self.assertTrue(ok, err)
+        # policy live-applied so /resolve serves the new routes
+        rec = self.store.get(bottle_id)
+        assert rec is not None
+        self.assertEqual(new_routes, rec.policy)
+        # response written -> agent unblocks, proposal no longer pending
+        self.assertEqual(STATUS_APPROVED, read_response("demo", pid).status)
+        self.assertEqual([], self.orch.supervise_pending())
+
+    def test_modify_applies_final_file_not_proposed(self) -> None:
+        bottle_id = self._register("demo", "routes: []\n")
+        pid = self._queue("demo", "routes:\n  - host: google.com\n")
+        edited = "routes:\n  - host: example.com\n"
+        ok, _ = self.orch.supervise_respond(
+            pid, bottle_slug="demo", decision="modify", final_file=edited)
+        self.assertTrue(ok)
+        rec = self.store.get(bottle_id)
+        assert rec is not None
+        self.assertEqual(edited, rec.policy)
+
+    def test_reject_leaves_policy_unchanged(self) -> None:
+        bottle_id = self._register("demo", "routes:\n  - host: existing.com\n")
+        pid = self._queue("demo", "routes:\n  - host: google.com\n")
+        ok, _ = self.orch.supervise_respond(
+            pid, bottle_slug="demo", decision="reject", notes="no")
+        self.assertTrue(ok)
+        rec = self.store.get(bottle_id)
+        assert rec is not None
+        self.assertEqual("routes:\n  - host: existing.com\n", rec.policy)
+        self.assertEqual("rejected", read_response("demo", pid).status)
+
+    def test_unknown_proposal_is_error(self) -> None:
+        ok, err = self.orch.supervise_respond(
+            "ghost", bottle_slug="demo", decision="approve")
+        self.assertFalse(ok)
+        self.assertIn("no such proposal", err)
+
+    def test_unknown_decision_is_error(self) -> None:
+        self._register("demo", "routes: []\n")
+        pid = self._queue("demo", "routes:\n  - host: google.com\n")
+        ok, err = self.orch.supervise_respond(
+            pid, bottle_slug="demo", decision="bogus")
+        self.assertFalse(ok)
+        self.assertIn("unknown decision", err)
+
+    def test_approve_when_bottle_gone_cannot_apply(self) -> None:
+        # Proposal queued but the bottle was torn down before the operator
+        # acted: an egress apply has no target, so respond fails closed.
+        pid = self._queue("ghost-bottle", "routes:\n  - host: google.com\n")
+        ok, err = self.orch.supervise_respond(
+            pid, bottle_slug="ghost-bottle", decision="approve")
+        self.assertFalse(ok)
+        self.assertIn("no longer registered", err)
+
+
 if __name__ == "__main__":
    unittest.main()