Something went wrong. Try again.
small gleam coding and (not yet) persistent agent daemon with a detachable cli forked from okami.mom/albedo
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378"""Moving sessions between this checkout's daemon and an older one.
The older daemon is the reference build that test/reference-daemon.sh pins,built once outside the checkout and cached. Both daemons are peers of therunning test, each with its own home, and the reference boots with its ownCLI. A move here is the real one: the source's driver reaches the target overa loopback ssh, as in move_test, stages its bundle there and pumps segmentsthrough its own relay into the target daemon. Host `current` runs commandsagainst this checkout's daemon and host `reference` against the older one.
A move from an older daemon to a newer one is supported, and must carry thesession whole. A move to an older daemon across a schema change is not. Thepinned build predates the read-only `POST /transfers/check`, so the preflightcan't tell and offers the move; the target then refuses the manifest atstaging as `transfer_target_older`, writing nothing, and the source keeps itssession (see robot-docs/workspaces.md, "Moves between versions"). move_testcovers the check against a target of this build."""
import hashlibimport hmacimport jsonimport osimport shleximport shutilimport sqlite3import tempfileimport unittestimport urllib.errorimport urllib.parseimport urllib.requestfrom contextlib import closingfrom pathlib import Path
from _transfer_support import ( executable, idle, login_shell, preflight, read_move, remote_bin, settled_move, start_move, wait_for,)from harness import ( OFFLINE, Provider, fresh_prompt, operation_id, peer_daemon, python, text,)from reference_support import run_reference
FAKE_SSH = """#!/bin/shquery=while [ $# -gt 0 ]; do case "$1" in -o) shift 2 ;; -G) query=1; shift ;; -*) shift ;; *) break ;; esacdonetarget=$1shift[ -n "$query" ] && exit 0mkdir -p {root}/remote-"$target"exec env -i HOME={root}/remote-"$target" ALBEDO_HOME="$(cat {hosts}/"$target")" PATH={path} SHELL={login} /bin/sh -c "$*""""
PROFILE = "versions"NOTE = "the cache key is the prefix hash"WORK = "ship the picker"VENT = "the relay stalled"SCHEDULED = "summarise the deploys"HOOK = "deploys"DELIVERY = b'{"status":"deployed"}'
def body(daemon, path, payload=None, *, method=None, headers=None): with daemon.api(path, payload, method=method, headers=headers) as response: return json.load(response)
class MixedVersionMoves(unittest.TestCase): def setUp(self): self.cells = {}
def reply(request): prompt = fresh_prompt(request) for marker, source in self.cells.items(): if marker in prompt: return python(source) return text("done")
self.provider = Provider(reply) self.addCleanup(self.provider.close) self.root = Path(tempfile.mkdtemp(prefix="versions-")) self.addCleanup(shutil.rmtree, self.root, True) self.hosts = self.root / "hosts" self.hosts.mkdir()
def prepare(daemon): config = { "providers": { PROFILE: { "extension": "openai", "baseUrl": self.provider.url, "apiKey": "fixture-key", "model": "fixture-model", "protocol": "responses", } }, "active": PROFILE, } (daemon.home / "config.json").write_text(json.dumps(config)) (daemon.home / "extensions.json").write_text( json.dumps({**OFFLINE, "enabled": {"webhooks": True}}) ) daemon.env["PATH"] = self.ssh_path(daemon.env["PATH"])
def prepare_reference(daemon): prepare(daemon) run_reference(daemon)
self.current = peer_daemon("versions-current", prepare) self.reference = peer_daemon("versions-reference", prepare_reference) (self.hosts / "current").write_text(str(self.current.home)) (self.hosts / "reference").write_text(str(self.reference.home)) # Two builds, not one daemon twice. self.assertNotEqual( body(self.current, "/server")["digest"], body(self.reference, "/server")["digest"], )
def ssh_path(self, path): """The PATH with the loopback ssh ahead of `path`, written once.""" local, remote = self.root / "local-bin", self.root / "remote-bin" if not local.exists(): local.mkdir() remote_bin(remote) executable( local / "ssh", FAKE_SSH.format( root=self.root, hosts=self.hosts, path=shlex.quote(f"{remote}{os.pathsep}{path}"), login=login_shell(local), ), ) return f"{local}{os.pathsep}{path}"
# -- driving a daemon ----------------------------------------------
def session(self, daemon, workspace): session = operation_id() created = body( daemon, f"/sessions/{session}", {"kind": "new", "workspace": str(workspace), "provider_profile": PROFILE}, method="PUT", headers={"If-None-Match": "*"}, ) self.assertEqual(created["id"], session) return session
def say(self, daemon, session, words): daemon.api( f"/sessions/{session}/inputs/{operation_id()}", {"kind": "message", "text": words}, method="PUT", ).close() idle(daemon, session)
def cell(self, daemon, session, source): """Runs `source` as the model's next cell and answers its result.""" marker = "versions cell " + operation_id() self.cells[marker] = source self.say(daemon, session, marker) results = [ json.loads(part["value"]) for entry in self.history(daemon, session) if entry["kind"] == "tool_result" and entry["tool"]["name"] == "python" for part in entry["content"] if part["kind"] == "json" and part["field"] == "result" ] self.assertTrue(results, f"no cell ran on {daemon.root.name}") self.assertEqual(results[-1]["status"], "ok", results[-1]) return results[-1]["output"]
def history(self, daemon, session): return body(daemon, f"/sessions/{session}/history")["items"]
def deliver(self, daemon, hook, secret, event): signature = ( "sha256=" + hmac.new(secret.encode(), DELIVERY, hashlib.sha256).hexdigest() ) request = urllib.request.Request( f"{daemon.base}/extensions/webhooks/hooks/{hook}/deliveries", data=DELIVERY, headers={"X-Albedo-Signature": signature, "X-Albedo-Event-Id": event}, ) with urllib.request.urlopen(request, timeout=25) as response: self.assertLess(response.status, 300)
def receipts(self, daemon, hook): return body( daemon, f"/extensions/webhooks/hooks/{hook}/deliveries?state=delivered" )["items"]
def populated(self, daemon): """A session on `daemon` with a transcript, cells, a memory note, a work item, a vent, a delivered webhook letter, a schedule and a linked workspace: (session, workspace, hook).""" workspace = Path(tempfile.mkdtemp(prefix="workspace-", dir=self.root)) other = Path(tempfile.mkdtemp(prefix="linked-", dir=self.root)) session = self.session(daemon, workspace) self.say(daemon, session, "hello from the source") self.cell( daemon, session, f"memory.append({NOTE!r})\n" f"await work.create({WORK!r})\n" f"await vent('harness', 'moved mid-copy', title={VENT!r})\n" "print('cell ran on the source')", ) job = { "session_id": session, "kind": "recurring", "prompt": SCHEDULED, "delay_seconds": 3600, "every_seconds": 3600, } with daemon.api("/extensions/schedule/jobs", job) as response: self.assertEqual(response.status, 201) created = body( daemon, "/extensions/webhooks/hooks", {"name": HOOK, "session_id": session} ) hook, secret = created["resource"]["value"]["id"], created["secret"] self.deliver(daemon, hook, secret, "deploy-1") wait_for( lambda: self.receipts(daemon, hook), 30, "the webhook letter was never delivered", ) idle(daemon, session) self.link(daemon, workspace, other) return session, workspace, hook
def link(self, daemon, workspace, other): def group(path): query = urllib.parse.urlencode({"workspace": str(path)}) return body(daemon, f"/extensions/links/groups?{query}")[ "configuration_resource" ]
mine, theirs = group(workspace), group(other) body( daemon, mine["url"], {"other_workspace": str(other), "other_etag": theirs["etag"]}, headers={"If-Match": mine["etag"]}, )
def move(self, source, session, target): transfer = operation_id() start_move(source, session, transfer, target) return transfer, settled_move(source, transfer, 120)
def read(self, daemon, transfer): return read_move(daemon, transfer)
def preflight(self, source, session, target): return preflight(source, session, target)
# -- scenarios ------------------------------------------------------
def moves_and_works(self, source, target, host): session, _workspace, hook = self.populated(source) destination = Path(tempfile.mkdtemp(prefix="moved-", dir=self.root)) where = f"{host}:{destination}" found = self.preflight(source, session, where) self.assertTrue(found["available"], found)
transfer, move = self.move(source, session, where) self.assertEqual(move["state"], "checklist", move) kinds = {binding["kind"] for binding in move["bindings"]} self.assertEqual(kinds, {"schedule", "webhook"}, move["bindings"]) finished = body(source, f"/transfers/{transfer}/finish", {}) self.assertEqual(finished["state"], "active", finished) self.assertIsNone(finished["error"])
# The source copy refuses input and says where it went. with self.assertRaises(urllib.error.HTTPError) as refused: source.api( f"/sessions/{session}/inputs/{operation_id()}", {"kind": "message", "text": "still here?"}, method="PUT", ) self.assertEqual(refused.exception.code, 409) self.assertEqual(json.load(refused.exception)["code"], "session_moved")
# The target runs the session with everything it carried. arrived = body(target, f"/sessions/{session}?tail=0") self.assertEqual(arrived["workspace"], str(destination)) self.assertIsNone(arrived["moved"]) said = json.dumps(self.history(target, session)) self.assertIn("hello from the source", said) self.assertIn("cell ran on the source", said) self.assertIn(f"webhook {HOOK} #", said) [receipt] = self.receipts(target, hook) self.assertIsNotNone(receipt["delivered_at"]) self.assertEqual(receipt["session_id"], session) jobs = body(target, f"/extensions/schedule/jobs?session_id={session}") self.assertEqual([job["value"]["prompt"] for job in jobs["items"]], [SCHEDULED]) output = self.cell( target, session, "print('cell ran on the target')\n" f"print(memory.grep({NOTE!r}))\n" "print(sorted(i.title for i in await work.list()))\n" "print([v['title'] for v in await vents()])", ) self.assertIn("cell ran on the target", output) self.assertIn(NOTE, output) self.assertIn(repr([WORK]), output) self.assertIn(VENT, output) self.say(target, session, "and a turn on the target")
def test_a_session_moves_from_the_reference_to_this_daemon(self): self.moves_and_works(self.reference, self.current, "current")
def test_a_move_to_the_reference_is_refused_and_the_source_keeps_it(self): session, _workspace, _hook = self.populated(self.current) # A schema change in a carried table, so the refusal does not wait # for this checkout's schema to drift from the pinned reference. with closing(sqlite3.connect(self.current.home / "albedo.sqlite")) as db: db.execute("ALTER TABLE sessions ADD COLUMN versions_probe TEXT") db.commit() destination = Path(tempfile.mkdtemp(prefix="moved-", dir=self.root)) where = f"reference:{destination}" # The reference predates the read-only check, so the preflight can't # tell and offers the move; nothing is staged there to ask it. found = self.preflight(self.current, session, where) self.assertTrue(found["available"], found) self.assertIsNone(found.get("code"), found) self.assertEqual(found["target_daemon"]["home"], str(self.reference.home))
# Its staging refuses the move as from an older target, naming what # it lacks, before it writes a receipt or a staging directory. transfer, move = self.move(self.current, session, where) self.assertEqual(move["state"], "failed", move) self.assertEqual(move["error"]["code"], "transfer_target_older", move) self.assertIn("core/sessions here lacks", move["error"]["detail"]) self.assertIn("versions_probe", move["error"]["detail"]) with closing(sqlite3.connect(self.reference.home / "albedo.sqlite")) as db: staged = db.execute("SELECT COUNT(*) FROM transfers").fetchone()[0] self.assertEqual(staged, 0) self.assertFalse((self.reference.home / "transfers" / transfer).exists()) self.assertIsNone(move["target_session_id"]) self.assertEqual(move["bindings"], []) # Nothing went live on the reference, and the source still runs it. with self.assertRaises(urllib.error.HTTPError) as absent: self.reference.api(f"/sessions/{session}?tail=0") self.assertEqual(absent.exception.code, 404) self.assertIsNone(body(self.current, f"/sessions/{session}?tail=0")["moved"]) jobs = body(self.current, f"/extensions/schedule/jobs?session_id={session}") self.assertEqual([job["value"]["prompt"] for job in jobs["items"]], [SCHEDULED]) self.say(self.current, session, "still here") self.assertIn("still here", json.dumps(self.history(self.current, session)))
if __name__ == "__main__": unittest.main()