Skip to content
Python

fix(teams): enforce worker item visibility

Rakesh Utekare826b48a901d
diff --git a/coworker/server/app.py b/coworker/server/app.py
index 2f558085..f63599c1 100644
--- a/coworker/server/app.py
+++ b/coworker/server/app.py
@@ -164,6 +164,7 @@ from ..providers import AssistantTurn
from .. import toolchain
from ..teams.model import AuthorityError as TeamsAuthorityError
from ..teams.model import BoardError as TeamsBoardError
+from ..teams.model import BoardNotFoundError as TeamsBoardNotFoundError
from .manager import SessionManager
@@ -842,6 +843,8 @@ def create_app(manager: SessionManager) -> FastAPI:
)
try:
return handler(actor)
+ except TeamsBoardNotFoundError as error:
+ return JSONResponse({"error": str(error)}, status_code=404)
except TeamsAuthorityError as error:
return JSONResponse({"error": str(error)}, status_code=403)
except (TeamsBoardError, ValueError) as error:
@@ -873,7 +876,8 @@ def create_app(manager: SessionManager) -> FastAPI:
@app.get("/v1/board/item")
def board_get_item(request: Request, space: str, id: int):
return _board(
- request, lambda actor: manager.team_store.get_item(space, int(id))
+ request,
+ lambda actor: manager.team_store.get_item(space, int(id), actor=actor),
)
@app.post("/v1/board/items")
diff --git a/coworker/server/manager.py b/coworker/server/manager.py
index 1486d906..40285768 100644
--- a/coworker/server/manager.py
+++ b/coworker/server/manager.py
@@ -1697,7 +1697,9 @@ class SessionManager:
if space is None:
return {"error": "no board for this session"}
try:
- item = self.team_store.get_item(space, int(item_id))
+ item = self.team_store.get_item(
+ space, int(item_id), actor=self._user_actor()
+ )
except TeamsBoardError as error:
return {"error": str(error)}
timeline: list[dict[str, Any]] = []
@@ -2295,7 +2297,9 @@ class SessionManager:
# item's ASSIGNEE — a filer merely hears about it.
def _holds(event) -> bool:
try:
- item = self.team_store.get_item(team.space, int(event["item_id"]))
+ item = self.team_store.get_item(
+ team.space, int(event["item_id"]), actor=self._user_actor()
+ )
except Exception:
return False
return item["assignee"] == actor
@@ -2388,7 +2392,9 @@ class SessionManager:
item = None
if item_id is not None:
try:
- item = self.team_store.get_item(team.space, int(item_id))
+ item = self.team_store.get_item(
+ team.space, int(item_id), actor=self._user_actor()
+ )
except Exception:
item = None
title = f"#{item_id} {item['title']}" if item else f"#{item_id}"
diff --git a/coworker/teams/__init__.py b/coworker/teams/__init__.py
index 96320fd6..fd0806a4 100644
--- a/coworker/teams/__init__.py
+++ b/coworker/teams/__init__.py
@@ -7,6 +7,7 @@ from .model import (
Actor,
AuthorityError,
BoardError,
+ BoardNotFoundError,
ChainError,
ItemState,
Role,
@@ -18,6 +19,7 @@ __all__ = [
"Actor",
"AuthorityError",
"BoardError",
+ "BoardNotFoundError",
"ChainError",
"ItemState",
"JournalStore",
diff --git a/coworker/teams/dialect.py b/coworker/teams/dialect.py
index 1bdb4d78..b96a01d8 100644
--- a/coworker/teams/dialect.py
+++ b/coworker/teams/dialect.py
@@ -149,7 +149,7 @@ class LocalDialect:
return self.store.list_items(space, self.actor, state=state, assignee=assignee)
def get_item(self, space: str, item_id: int) -> dict[str, Any]:
- return self.store.get_item(space, item_id)
+ return self.store.get_item(space, item_id, actor=self.actor)
def create_item(
self,
diff --git a/coworker/teams/model.py b/coworker/teams/model.py
index 2228e661..3f89a34b 100644
--- a/coworker/teams/model.py
+++ b/coworker/teams/model.py
@@ -85,6 +85,10 @@ class BoardError(Exception):
"""A verb call the board refuses — illegal transition, missing item, bad input."""
+class BoardNotFoundError(BoardError):
+ """A requested board object is missing or is not visible to the actor."""
+
+
class AuthorityError(BoardError):
"""The actor's role does not permit this verb on this item."""
diff --git a/coworker/teams/store.py b/coworker/teams/store.py
index 876347bf..547a1933 100644
--- a/coworker/teams/store.py
+++ b/coworker/teams/store.py
@@ -38,6 +38,7 @@ from .model import (
Actor,
AuthorityError,
BoardError,
+ BoardNotFoundError,
ChainError,
ItemState,
Role,
@@ -469,7 +470,16 @@ class TeamStore:
)
with self._lock:
if parent is not None:
- parent_item = self._item(space, parent)
+ try:
+ parent_item = self._item(space, parent)
+ except BoardError:
+ raise BoardNotFoundError(
+ f"no visible item #{parent} in space {space!r}"
+ ) from None
+ if not self._item_visible_to(space, actor, parent_item):
+ raise BoardNotFoundError(
+ f"no visible item #{parent} in space {space!r}"
+ )
if case is None:
case = parent_item["case_id"] or None
item_id = self._next_item_id(space)
@@ -489,7 +499,7 @@ class TeamStore:
)
if self.journal is not None and case:
self.journal.ensure_case(case, actor.id)
- return self.get_item(space, item_id, seq=event["seq"])
+ return self.get_item(space, item_id, actor=actor, seq=event["seq"])
def list_items(
self,
@@ -499,8 +509,11 @@ class TeamStore:
state: Optional[str] = None,
assignee: Optional[str] = None,
) -> list[dict[str, Any]]:
- """Items in a space. Workers see only their slice: assigned items plus items
- directly linked to those."""
+ """Return actor-visible items in a space.
+
+ A worker's slice contains items it owns or created, their direct links,
+ and—while claims are open—the open, unassigned claim pool.
+ """
where = ["space = ?"]
params: list[Any] = [space]
if state:
@@ -517,32 +530,50 @@ class TeamStore:
params,
).fetchall()
items = [_row_to_item(row) for row in rows]
+ worker_slice = None
+ claims_open = None
if actor.role == Role.WORKER:
- visible = self._worker_slice(space, actor.id)
- # On an open-claims board the claimable pool is visible too — a
- # pull queue nobody can see is not a queue (drill-caught: an
- # external worker with no assignment saw an empty board). Under
- # lead-only policy workers can't act on it, so it stays hidden.
+ worker_slice = self._worker_slice(space, actor.id)
claims_open = self.policy(space)["claims"] == "open"
- items = [
- item
- for item in items
- if item["id"] in visible
- or (
- claims_open
- and item["state"] == ItemState.OPEN.value
- and not item["assignee"]
- )
- ]
+ items = [
+ item
+ for item in items
+ if self._item_visible_to(
+ space,
+ actor,
+ item,
+ worker_slice=worker_slice,
+ claims_open=claims_open,
+ )
+ ]
for item in items:
item["links"] = self._links_of(space, item["id"])
return items
def get_item(
- self, space: str, item_id: int, *, seq: Optional[int] = None
+ self,
+ space: str,
+ item_id: int,
+ *,
+ actor: Actor,
+ seq: Optional[int] = None,
) -> dict[str, Any]:
+ """Return one actor-visible item.
+
+ The actor is required because detail reads enforce the same worker scope as
+ list reads. Missing and hidden items deliberately share one error contract.
+ """
with self._lock:
- item = self._item(space, item_id)
+ try:
+ item = self._item(space, item_id)
+ except BoardError:
+ raise BoardNotFoundError(
+ f"no visible item #{item_id} in space {space!r}"
+ ) from None
+ if not self._item_visible_to(space, actor, item):
+ raise BoardNotFoundError(
+ f"no visible item #{item_id} in space {space!r}"
+ )
item["links"] = self._links_of(space, item_id)
item["comments"] = self.comments(space, item_id)
if seq is not None:
@@ -587,7 +618,7 @@ class TeamStore:
},
taint=taint,
)
- return self.get_item(space, item_id, seq=event["seq"])
+ return self.get_item(space, item_id, actor=actor, seq=event["seq"])
def comment(
self,
@@ -652,7 +683,7 @@ class TeamStore:
assignee=assignee,
previous=item["assignee"] or "",
)
- return self.get_item(space, item_id, seq=event["seq"])
+ return self.get_item(space, item_id, actor=actor, seq=event["seq"])
def claim(self, space: str, actor: Actor, item_id: int) -> dict[str, Any]:
"""Self-assign an open, unassigned item. Nobody stamps a claim — the store
@@ -694,7 +725,7 @@ class TeamStore:
assignee=actor.id,
previous="",
)
- return self.get_item(space, item_id, seq=event["seq"])
+ return self.get_item(space, item_id, actor=actor, seq=event["seq"])
def policy(self, space: str) -> dict[str, Any]:
with self._lock:
@@ -897,6 +928,30 @@ class TeamStore:
out.add(row["src"])
return out
+ def _item_visible_to(
+ self,
+ space: str,
+ actor: Actor,
+ item: dict[str, Any],
+ *,
+ worker_slice: Optional[set[int]] = None,
+ claims_open: Optional[bool] = None,
+ ) -> bool:
+ """Whether an actor may read one item through any board surface."""
+ if actor.role != Role.WORKER:
+ return True
+ if worker_slice is None:
+ worker_slice = self._worker_slice(space, actor.id)
+ if item["id"] in worker_slice:
+ return True
+ if claims_open is None:
+ claims_open = self.policy(space)["claims"] == "open"
+ return (
+ claims_open
+ and item["state"] == ItemState.OPEN.value
+ and not item["assignee"]
+ )
+
def _links_of(self, space: str, item_id: int) -> list[dict[str, Any]]:
rows = self._conn.execute(
"SELECT src, kind, dst FROM team_links WHERE space = ?"
diff --git a/tests/test_team_board.py b/tests/test_team_board.py
index 42ce7e2d..66cedcf4 100644
--- a/tests/test_team_board.py
+++ b/tests/test_team_board.py
@@ -3,6 +3,7 @@
import pytest
from coworker.teams import Actor, AuthorityError, BoardError, Role, TeamStore
+from coworker.teams.dialect import LocalDialect
from coworker.teams.tools import board_tools
USER = Actor(id="user", role=Role.USER)
@@ -67,6 +68,23 @@ def test_child_inherits_parent_case(store):
assert {"kind": "parent", "item": parent["id"]} in child["links"]
+def test_worker_cannot_expand_its_slice_through_a_hidden_parent(store):
+ hidden = assigned_item(store, assignee="worker-2")
+ before = store.event_count(SPACE)
+
+ with pytest.raises(BoardError):
+ store.create_item(
+ SPACE,
+ WORKER,
+ title="Bridge into another worker's task",
+ criteria="must not be created",
+ parent=hidden,
+ )
+
+ assert store.event_count(SPACE) == before
+ assert store.list_items(SPACE, WORKER) == []
+
+
# ------------------------------------------------------------------- transitions
def test_full_happy_path(store):
@@ -127,7 +145,7 @@ def test_rework_loop(store):
store.transition(SPACE, WORKER, item_id, "in_progress")
store.transition(SPACE, WORKER, item_id, "review")
store.transition(SPACE, LEAD, item_id, "in_progress", comment="criteria 2 unmet")
- item = store.get_item(SPACE, item_id)
+ item = store.get_item(SPACE, item_id, actor=LEAD)
assert item["state"] == "in_progress"
assert item["comments"][-1]["body"] == "criteria 2 unmet"
@@ -161,9 +179,9 @@ def test_blocked_by_shows_on_the_other_side(store):
a = store.create_item(SPACE, LEAD, title="A", criteria="c")
b = store.create_item(SPACE, LEAD, title="B", criteria="c")
store.link(SPACE, LEAD, a["id"], "blocks", b["id"])
- assert {"kind": "blocked_by", "item": a["id"]} in store.get_item(SPACE, b["id"])[
- "links"
- ]
+ assert {"kind": "blocked_by", "item": a["id"]} in store.get_item(
+ SPACE, b["id"], actor=LEAD
+ )["links"]
def test_artifact_refs_accumulate_on_the_item(store):
@@ -174,10 +192,10 @@ def test_artifact_refs_accumulate_on_the_item(store):
SPACE, WORKER, item_id, "review",
comment="done", refs=["branch:fix/acl", "report:posture.html"],
)
- item = store.get_item(SPACE, item_id)
+ item = store.get_item(SPACE, item_id, actor=WORKER)
assert item["refs"] == ["branch:fix/acl", "report:posture.html"] # deduped, ordered
store.rebuild(SPACE)
- assert store.get_item(SPACE, item_id)["refs"] == item["refs"]
+ assert store.get_item(SPACE, item_id, actor=WORKER)["refs"] == item["refs"]
# ------------------------------------------------------------- worker visibility
@@ -194,6 +212,36 @@ def test_worker_sees_only_its_slice(store):
assert len(store.list_items(SPACE, USER)) == 3
+def test_worker_item_detail_matches_list_visibility(store):
+ mine = assigned_item(store, assignee="worker-1")
+ theirs = assigned_item(store, assignee="worker-2")
+ claimable = store.create_item(SPACE, LEAD, title="Available", criteria="c")
+ linked = store.create_item(SPACE, LEAD, title="Dependency", criteria="c")
+ store.link(SPACE, LEAD, linked["id"], "blocks", mine)
+ worker = LocalDialect(store, journal=None, actor=WORKER)
+
+ assert worker.get_item(SPACE, mine)["id"] == mine
+ assert worker.get_item(SPACE, linked["id"])["id"] == linked["id"]
+ assert worker.get_item(SPACE, claimable["id"])["id"] == claimable["id"]
+ assert store.get_item(SPACE, mine, actor=WORKER)["id"] == mine
+
+ with pytest.raises(BoardError):
+ worker.get_item(SPACE, theirs)
+ with pytest.raises(BoardError):
+ store.get_item(SPACE, theirs, actor=WORKER)
+
+ store.claim(SPACE, OTHER, claimable["id"])
+ with pytest.raises(BoardError):
+ worker.get_item(SPACE, claimable["id"])
+
+ held = store.create_item(SPACE, LEAD, title="Held", criteria="c")
+ store.set_policy(SPACE, LEAD, claims="lead-only")
+ with pytest.raises(BoardError):
+ worker.get_item(SPACE, held["id"])
+
+ assert worker.get_item(SPACE, mine)["id"] == mine
+
+
def test_worker_comments_only_on_its_slice(store):
theirs = assigned_item(store, assignee="worker-2")
with pytest.raises(AuthorityError, match="assigned"):
diff --git a/tests/test_team_open_surface.py b/tests/test_team_open_surface.py
index ad7b5d40..2ed8994d 100644
--- a/tests/test_team_open_surface.py
+++ b/tests/test_team_open_surface.py
@@ -248,6 +248,166 @@ def test_token_binds_identity_and_store_enforces_authority(api):
assert bad.status_code == 403 or bad.status_code == 400
+def test_board_item_reads_hide_foreign_worker_items(api):
+ client, manager, _ = api
+ lead_token = _tokens(manager).mint("lead-1", "lead")
+ nia_token = _tokens(manager).mint("nia", "worker")
+ webb_token = _tokens(manager).mint("webb", "worker")
+ lead = {"Authorization": f"Bearer {lead_token}"}
+ nia = {"Authorization": f"Bearer {nia_token}"}
+ webb = {"Authorization": f"Bearer {webb_token}"}
+
+ def create(title, *, description=""):
+ response = client.post(
+ "/v1/board/items",
+ headers=lead,
+ json={
+ "space": "proj",
+ "title": title,
+ "description": description,
+ "criteria": "done",
+ },
+ )
+ assert response.status_code == 200
+ return response.json()
+
+ created = create(
+ "Webb private investigation", description="credential rotation details"
+ )
+ assigned_response = client.post(
+ "/v1/board/items/assign",
+ headers=lead,
+ json={"space": "proj", "id": created["id"], "assignee": "webb"},
+ )
+ assert assigned_response.status_code == 200
+
+ mine = create("Nia task")
+ assert client.post(
+ "/v1/board/items/assign",
+ headers=lead,
+ json={"space": "proj", "id": mine["id"], "assignee": "nia"},
+ ).status_code == 200
+ claimable = create("Available")
+ linked = create("Linked dependency")
+ assert client.post(
+ "/v1/board/link",
+ headers=lead,
+ json={
+ "space": "proj",
+ "src": linked["id"],
+ "kind": "blocks",
+ "dst": mine["id"],
+ },
+ ).status_code == 200
+
+ denied = client.get(
+ "/v1/board/item",
+ headers=nia,
+ params={"space": "proj", "id": created["id"]},
+ )
+ assert denied.status_code == 404
+ assert "Webb private investigation" not in denied.text
+ assert "credential rotation details" not in denied.text
+
+ for item_id in (mine["id"], claimable["id"], linked["id"]):
+ assert client.get(
+ "/v1/board/item",
+ headers=nia,
+ params={"space": "proj", "id": item_id},
+ ).status_code == 200
+
+ assert client.post(
+ "/v1/board/items/claim",
+ headers=webb,
+ json={"space": "proj", "id": claimable["id"]},
+ ).status_code == 200
+ assert client.get(
+ "/v1/board/item",
+ headers=nia,
+ params={"space": "proj", "id": claimable["id"]},
+ ).status_code == 404
+
+ held = create("Held")
+ assert client.post(
+ "/v1/board/policy",
+ headers=lead,
+ json={"space": "proj", "claims": "lead-only"},
+ ).status_code == 200
+ assert client.get(
+ "/v1/board/item",
+ headers=nia,
+ params={"space": "proj", "id": held["id"]},
+ ).status_code == 404
+ assert client.get(
+ "/v1/board/item",
+ headers=nia,
+ params={"space": "proj", "id": mine["id"]},
+ ).status_code == 200
+
+ allowed = client.get(
+ "/v1/board/item",
+ headers=lead,
+ params={"space": "proj", "id": created["id"]},
+ )
+ assert allowed.status_code == 200
+ assert allowed.json()["title"] == "Webb private investigation"
+
+
+def test_board_item_reads_return_not_found_for_missing_items(api):
+ client, manager, _ = api
+ nia_token = _tokens(manager).mint("nia", "worker")
+ lead_token = _tokens(manager).mint("lead-1", "lead")
+ user_token = _tokens(manager).mint("user", "user")
+ nia = {"Authorization": f"Bearer {nia_token}"}
+ lead = {"Authorization": f"Bearer {lead_token}"}
+ user = {"Authorization": f"Bearer {user_token}"}
+
+ for headers in (nia, lead, user):
+ missing = client.get(
+ "/v1/board/item",
+ headers=headers,
+ params={"space": "proj", "id": 999},
+ )
+ assert missing.status_code == 404
+
+
+def test_board_item_create_hides_missing_and_foreign_parents(api):
+ client, manager, _ = api
+ lead_token = _tokens(manager).mint("lead-1", "lead")
+ nia_token = _tokens(manager).mint("nia", "worker")
+ lead = {"Authorization": f"Bearer {lead_token}"}
+ nia = {"Authorization": f"Bearer {nia_token}"}
+
+ hidden_response = client.post(
+ "/v1/board/items",
+ headers=lead,
+ json={"space": "proj", "title": "Webb task", "criteria": "done"},
+ )
+ assert hidden_response.status_code == 200
+ hidden = hidden_response.json()
+ assert client.post(
+ "/v1/board/items/assign",
+ headers=lead,
+ json={"space": "proj", "id": hidden["id"], "assignee": "webb"},
+ ).status_code == 200
+ before = manager.team_store.event_count("proj")
+
+ for parent in (hidden["id"], 999):
+ denied = client.post(
+ "/v1/board/items",
+ headers=nia,
+ json={
+ "space": "proj",
+ "title": "Probe",
+ "criteria": "must not be created",
+ "parent": parent,
+ },
+ )
+ assert denied.status_code == 404
+
+ assert manager.team_store.event_count("proj") == before
+
+
def test_remote_dialect_round_trip(api):
client, manager, app = api
lead_token = _tokens(manager).mint("lead-1", "lead")
@@ -288,6 +448,13 @@ def test_remote_dialect_round_trip(api):
with pytest.raises(BoardError, match="only open items"):
nia.claim("proj", item["id"])
+ foreign = lead.create_item(
+ "proj", title="Webb-only task", criteria="visible only to webb"
+ )
+ lead.assign("proj", foreign["id"], "webb")
+ with pytest.raises(BoardError, match="no visible item"):
+ nia.get_item("proj", foreign["id"])
+
# policy flip over the wire blocks the next worker claim
second = lead.create_item("proj", title="Held back", criteria="c")
lead.set_policy("proj", claims="lead-only")
@@ -477,10 +644,33 @@ def test_mcp_worker_loop_through_call_tool(tmp_path):
call("board_claim", {"item": item["id"]})
call("board_move", {"item": item["id"], "to": "in_progress"})
+ payload = json.loads(call("board_show", {"item": item["id"]})[0].text)
+ assert (payload["id"], payload["assignee"]) == (item["id"], "nia")
shown = lead_dialect.get_item("proj", item["id"])
assert (shown["assignee"], shown["state"]) == ("nia", "in_progress")
+def test_mcp_board_show_does_not_return_a_foreign_item(tmp_path):
+ import anyio
+
+ from coworker.teams.mcp_server import build
+
+ lead = local_dialect(tmp_path, actor="lead-1", role="lead")
+ foreign = lead.create_item(
+ "proj", title="Private Webb task", criteria="not visible to nia"
+ )
+ lead.assign("proj", foreign["id"], "webb")
+ worker = build(LocalDialect(lead.store, lead.journal, NIA), space="proj")
+
+ result = anyio.run(
+ lambda: worker.call_tool("board_show", {"item": foreign["id"]})
+ )
+ payload = json.loads(result[0].text)
+
+ assert "error" in payload
+ assert "Private Webb task" not in payload["error"]
+
+
# ------------------------------------------------------------------ CLI
@@ -497,6 +687,10 @@ def test_cli_headless_flow(tmp_path, capsys):
["board", "claim", "1", *space_args, "--actor", "nia", "--role", "worker"]
) == 0
assert "claimed #1" in capsys.readouterr().out
+ assert main(
+ ["board", "show", "1", *space_args, "--actor", "nia", "--role", "worker"]
+ ) == 0
+ assert "CLI item" in capsys.readouterr().out
assert main(["board", "list", *space_args, "--json"]) == 0
items = json.loads(capsys.readouterr().out)
assert [(i["id"], i["assignee"]) for i in items] == [(1, "nia")]
@@ -518,6 +712,27 @@ def test_cli_headless_flow(tmp_path, capsys):
assert "found it" in capsys.readouterr().out
+def test_cli_worker_cannot_show_a_foreign_item(tmp_path, capsys):
+ from coworker.teams.cli import main
+
+ space_args = ["--db", str(tmp_path), "--space", "proj"]
+ lead_args = [*space_args, "--actor", "lead-1", "--role", "lead"]
+ worker_args = [*space_args, "--actor", "nia", "--role", "worker"]
+
+ assert main(
+ ["board", "create", "Private Webb task", "--criteria", "c", *lead_args]
+ ) == 0
+ capsys.readouterr()
+ assert main(["board", "assign", "1", "webb", *lead_args]) == 0
+ capsys.readouterr()
+
+ assert main(["board", "show", "1", *worker_args]) == 1
+ output = capsys.readouterr()
+ assert output.out == ""
+ assert "no visible item" in output.err
+ assert "Private Webb task" not in output.err
+
+
def test_cli_token_mint_and_list(tmp_path, capsys):
from coworker.teams.cli import main
diff --git a/tests/test_team_store.py b/tests/test_team_store.py
index 2269ca88..b7e04bcc 100644
--- a/tests/test_team_store.py
+++ b/tests/test_team_store.py
@@ -95,7 +95,10 @@ def test_rebuild_reproduces_the_projection(store):
assert after[0]["state"] == "in_progress"
assert after[0]["assignee"] == "worker-1"
# created_ts comes from the event, so replay is deterministic
- assert store.get_item("proj", item["id"])["created_ts"] == item["created_ts"]
+ assert (
+ store.get_item("proj", item["id"], actor=USER)["created_ts"]
+ == item["created_ts"]
+ )
def test_taint_travels_with_the_record(store):