mirror of
https://github.com/0xWheatyz/handler.git
synced 2026-08-30 13:16:24 +00:00
Claude
9ad13b2488
Agents could be marked done while leaving work uncommitted or unpushed: the Stop gate only ran the test suite, and the headless supervisor's fallback marked any still-working agent done on a clean process exit even when the Stop gate never recorded a verdict. Checkmarks also only ever carried hook-written boilerplate, so the webui had no real checkpoint to show. The Stop gate now blocks the turn on any of: failing tests, uncommitted changes, or commits no origin/* ref contains (rev-list --not --remotes=origin, so it works for the --no-track worktree branches). All blockers are reported at once; status 'done' only ever accompanies a fully passing gate. Working dirs that aren't git checkouts, and repos without an origin remote, skip the git half so local-only projects can't deadlock. The supervisor's clean-exit fallback now reconciles a still-working agent to blocked instead of done — done is a gate verdict, not an exit code (operator cancels still settle as done). The agent's final message is captured deterministically from the session transcript onto the checkmark's where_it_stopped, so the dashboard always shows a real checkpoint regardless of whether the agent thought to leave one; a blocked checkmark shows the blockers. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01V7mF6qeryi9nJthaxYkfPm
126 lines
4.5 KiB
Python
126 lines
4.5 KiB
Python
"""End-to-end web management: the dashboard's HTTP calls -> command queue -> worker ->
|
|
real ``spawn.spawn`` -> a real headless subprocess (the fake claude binary). Proves the
|
|
full container-split flow works with only the claude binary faked, not the control
|
|
layer: events stream into the DB, the run reconciles, kill cancels."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import time
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from handler.control import worker
|
|
from handler.db import repository as repo
|
|
from handler.db.engine import get_engine
|
|
|
|
REPO_ROOT = Path(__file__).resolve().parents[1]
|
|
FAKE_CLAUDE = str(REPO_ROOT / "tests" / "fixtures" / "fake_claude.py")
|
|
|
|
|
|
@pytest.fixture
|
|
def headless_env(env, monkeypatch):
|
|
from handler import config
|
|
|
|
monkeypatch.setenv("CLAUDE_BIN", FAKE_CLAUDE)
|
|
config.get_settings.cache_clear()
|
|
yield env
|
|
config.get_settings.cache_clear()
|
|
|
|
|
|
def _spawnable_project(root):
|
|
root.mkdir(parents=True, exist_ok=True)
|
|
(root / ".mise.toml").write_text("[tasks.test]\nrun = 'pytest'\n")
|
|
with get_engine().begin() as conn:
|
|
repo.create_project(conn, "proj", str(root))
|
|
|
|
|
|
def _wait(predicate, timeout=20.0):
|
|
deadline = time.monotonic() + timeout
|
|
while time.monotonic() < deadline:
|
|
result = predicate()
|
|
if result:
|
|
return result
|
|
time.sleep(0.1)
|
|
return None
|
|
|
|
|
|
def test_spawn_via_api_then_worker_runs_headless_claude(client, auth, headless_env):
|
|
_spawnable_project(headless_env["tmp"] / "proj")
|
|
|
|
# 1. The dashboard enqueues a spawn (202 + a queued command). A task is mandatory —
|
|
# headless claude has no idle-REPL mode.
|
|
r = client.post(
|
|
"/projects/proj/agents/spawn",
|
|
json={"name": "api", "task": "build the thing"},
|
|
headers=auth,
|
|
)
|
|
assert r.status_code == 202
|
|
command_id = r.json()["id"]
|
|
assert r.json()["status"] == "queued"
|
|
|
|
# No agent yet — the worker hasn't run.
|
|
assert client.get("/projects/proj/agents", headers=auth).json() == []
|
|
|
|
# 2. The control worker drains the queue (real spawn.spawn -> real subprocess).
|
|
assert worker.drain("test-worker") == 1
|
|
|
|
# 3. The command finished at launch (fire-and-forget)...
|
|
got = client.get(f"/commands/{command_id}", headers=auth).json()
|
|
assert got["status"] == "done"
|
|
assert got["result"]["name"] == "api"
|
|
|
|
# ...and the run's whole life shows up via the API: events stream in, the agent
|
|
# reconciles, last_output is the assistant's text. The fake claude never runs the
|
|
# Stop gate, so the clean exit reconciles to blocked, not done — done is only ever
|
|
# a gate verdict (tests pass, work committed and pushed).
|
|
def finished():
|
|
agents = client.get("/projects/proj/agents", headers=auth).json()
|
|
return agents if agents and agents[0]["status"] == "blocked" else None
|
|
|
|
agents = _wait(finished)
|
|
assert agents is not None, "run never reconciled"
|
|
agent = agents[0]
|
|
assert agent["name"] == "api"
|
|
assert agent["session_id"]
|
|
assert agent["worker_id"] == "test-worker"
|
|
assert agent["last_output"] == "working on: build the thing"
|
|
|
|
events = client.get("/projects/proj/agents/api/events", headers=auth).json()
|
|
assert [e["type"] for e in events] == ["system", "assistant", "result"]
|
|
|
|
|
|
def test_spawn_without_task_is_rejected(client, auth, headless_env):
|
|
_spawnable_project(headless_env["tmp"] / "proj")
|
|
r = client.post("/projects/proj/agents/spawn", json={"name": "api"}, headers=auth)
|
|
assert r.status_code == 400
|
|
assert "task is required" in r.json()["detail"]
|
|
|
|
|
|
def test_kill_via_api_then_worker(client, auth, headless_env, monkeypatch):
|
|
monkeypatch.setenv("FAKE_CLAUDE_MODE", "hang")
|
|
_spawnable_project(headless_env["tmp"] / "proj")
|
|
client.post(
|
|
"/projects/proj/agents/spawn", json={"name": "api", "task": "hang"}, headers=auth
|
|
)
|
|
worker.drain("w")
|
|
|
|
# The hanging run is live; kill flags it and the supervisor SIGTERMs its child.
|
|
r = client.post("/projects/proj/agents/api/kill", headers=auth)
|
|
assert r.status_code == 202
|
|
worker.drain("w")
|
|
|
|
assert client.get(f"/commands/{r.json()['id']}", headers=auth).json()["status"] == "done"
|
|
with get_engine().begin() as conn:
|
|
agent = repo.get_agent_by_name(conn, "proj", "api")
|
|
assert agent["status"] == "done"
|
|
|
|
def canceled():
|
|
with get_engine().begin() as conn:
|
|
run = repo.get_latest_run(conn, agent["id"])
|
|
return run if run["status"] != "running" else None
|
|
|
|
run = _wait(canceled, timeout=30.0)
|
|
assert run is not None, "kill never terminated the hanging run"
|
|
assert run["status"] == "canceled"
|