Something went wrong. Try again.
small gleam coding and persistent agent daemon with a detachable cli and a canvas ui forked from okami.mom/albedo
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532"""Moving a session to another daemon, driven by the source daemon.
The source's PATH holds a loopback ssh that runs each command locally withthe "remote" host's ALBEDO_HOME set to the peer daemon's home (or to a fakeolder daemon's), so the relay the move stages and runs over ssh reads thatdaemon's daemon.json and calls it, as it would on vassago. Its login shellreads no profile, so the PATH the ssh sets is the host's. A host named `gone`cannot be reached, and `oldpy` has only python 3.9. A test that creates the `stall` switch holds therelay at the first segment it forwards, so the source daemon can be stoppedmid-copy."""
import http.serverimport jsonimport osimport shleximport shutilimport sqlite3import tempfileimport threadingimport timeimport unittestimport urllib.errorimport urllib.parsefrom contextlib import closingfrom pathlib import Path
from _transfer_support import ( executable, login_shell, preflight, read_move, remote_bin, settled_move, start_move, wait_for,)from harness import ( Albedo, Provider, exclusive, exclusive_class, operation_id, peer_daemon, text,)
FAKE_SSH = """#!/bin/shprintf '%s\\n' "$*" >> {log}query=while [ $# -gt 0 ]; do case "$1" in -o) shift 2 ;; -G) query=1; shift ;; -*) shift ;; *) break ;; esacdonetarget=$1shift[ -n "$query" ] && exit 0if [ "$target" = gone ]; then echo "ssh: connect to host gone port 22: Connection refused" >&2 exit 255fidaemon_home=$(cat {hosts}/"$target")run=case "$*" in *albedo_transfer_relay*) [ -e {stall} ] && run="python3 {hold}" ;;esacpath={path}[ "$target" = oldpy ] && path={oldpy}:$pathexec env -i HOME={home} ALBEDO_HOME="$daemon_home" PATH="$path" SHELL={login} $run /bin/sh -c "$*""""
# Runs the relay command, passing its frames through until the first segment# chunk, where it says so and holds until released (or a minute passes).HOLD = """import os, subprocess, sys, timechild = subprocess.Popen(sys.argv[1:], stdin=subprocess.PIPE)source, frames = sys.stdin.buffer, 0while True: header = source.read(4) if len(header) < 4: break payload = source.read(int.from_bytes(header, "big")) if frames % 2 == 0 and b"/import/segments/" in payload: open({stalled!r}, "w").close() deadline = time.monotonic() + 60 while not os.path.exists({release!r}) and time.monotonic() < deadline: time.sleep(0.1) frames += 1 child.stdin.write(header + payload) child.stdin.flush()child.stdin.close()sys.exit(child.wait())"""
class OldDaemon(http.server.BaseHTTPRequestHandler): """A daemon from before this transfer protocol: it answers protocol 0."""
seen: list[str] = []
def do_GET(self): self.seen.append(f"GET {self.path}") body = json.dumps({"protocol": 0}).encode() self.send_response(200) self.send_header("Content-Type", "application/json") self.send_header("Content-Length", str(len(body))) self.end_headers() self.wfile.write(body)
def do_PUT(self): self.seen.append(f"PUT {self.path}") self.send_response(500) self.end_headers()
do_POST = do_PUT
def log_message(self, format, *args): pass
# exclusive: sets the daemon's PATH for the loopback ssh, and one test# restarts the source daemon@exclusive_classclass MoveTests(unittest.TestCase): remote_home: Path hosts: Path ssh_log: Path stall: Path stalled: Path release: Path
def setUp(self): def prepare(app): # The switches and logs are this test's; the ssh on the daemon's # PATH, and the host's home the daemon remembers, stay put for the # class's tests and are rewritten to point here. root = Path(tempfile.mkdtemp(prefix="host-", dir=app.root)) self.remote_home = app.root / "remote-home" self.hosts = root / "hosts" self.ssh_log = root / "ssh.log" self.stall = root / "stall" self.stalled = root / "stalled" self.release = root / "release" self.hosts.mkdir() local = app.root / "local-bin" for directory in (self.remote_home, local): directory.mkdir(exist_ok=True) remote = remote_bin(root / "remote-bin") oldpy = root / "oldpy-bin" oldpy.mkdir() executable(oldpy / "python3", "#!/bin/sh\necho 3.9\n") hold = root / "hold.py" hold.write_text( HOLD.format(stalled=str(self.stalled), release=str(self.release)) ) login = login_shell(local) path = app.daemon.env["PATH"] executable( local / "ssh", FAKE_SSH.format( log=self.ssh_log, hosts=self.hosts, stall=self.stall, hold=hold, home=self.remote_home, path=shlex.quote(f"{remote}{os.pathsep}{path}"), oldpy=oldpy, login=login, ), ) app.daemon.env["PATH"] = f"{local}{os.pathsep}{path}"
self.provider = Provider(lambda _request: text("done")) self.addCleanup(self.provider.close) self.app = Albedo(self.provider, protocol="responses", prepare=prepare) self.app.__enter__() self.addCleanup(self.app.__exit__, None, None, None) self.addCleanup(lambda: self.release.touch()) # The target runs the source's profiles unless a test says otherwise. self.target = peer_daemon( "move-target", prepare=lambda peer: shutil.copy( self.app.home / "config.json", peer.home / "config.json" ), ) for host in ("vassago", "oldpy"): (self.hosts / host).write_text(str(self.target.home)) self.destination = Path(tempfile.mkdtemp(prefix="dest-", dir=self.remote_home))
def session(self): session = self.app.session() self.app.prompt(session, "hello").close() self.app.idle(session) return session
def preflight(self, session, target): return preflight(self.app, session, target)
def move(self, session, transfer, target): return start_move(self.app, session, transfer, target)
def read(self, transfer): return read_move(self.app, transfer)
def settled(self, transfer, timeout=90): return settled_move(self.app, transfer, timeout)
def exported(self, transfer): path = self.app.home / "albedo.sqlite" with closing(sqlite3.connect(f"file:{path}?mode=ro", uri=True)) as db: return db.execute( "SELECT count(*) FROM transfers WHERE id=?", (transfer,) ).fetchone()[0]
def test_move_keeps_provider_request_counters_local(self): session = self.session() trajectory = operation_id() with sqlite3.connect(self.app.home / "albedo.sqlite") as db: db.execute( "INSERT INTO antigravity_request_state(session,trajectory,next_request) VALUES(?,?,17)", (session, trajectory), ) transfer = operation_id() self.move(session, transfer, f"vassago:{self.destination}") moved = self.settled(transfer) self.assertEqual(moved["state"], "checklist", moved) for home, expected in [ (self.app.home, [(trajectory, 17)]), (self.target.home, []), ]: with closing( sqlite3.connect(f"file:{home / 'albedo.sqlite'}?mode=ro", uri=True) ) as db: self.assertEqual( db.execute( "SELECT trajectory,next_request FROM antigravity_request_state WHERE session=?", (session,), ).fetchall(), expected, )
def test_a_session_moves_and_the_source_copy_refuses_input(self): session = self.session() target = f"vassago:{self.destination}" found = self.preflight(session, target) self.assertTrue(found["available"], found) self.assertIsNone(found["reason"]) self.assertEqual(found["sessions"], [session]) self.assertEqual(found["target_daemon"]["host"], "vassago") self.assertEqual(found["target_daemon"]["home"], str(self.target.home)) self.assertIsInstance(found["target_daemon"]["protocol"], int)
transfer = operation_id() started = self.move(session, transfer, target) self.assertEqual(started["session_id"], session) self.assertEqual(started["target"], target) # A repeat answers the same move. self.assertEqual(self.move(session, transfer, target)["id"], transfer)
waiting = self.settled(transfer) self.assertEqual(waiting["state"], "checklist", waiting) self.assertEqual(waiting["bindings"], []) with self.app.api(f"/transfers/{transfer}/finish", {}) as response: moved = json.load(response) self.assertEqual(moved["state"], "active", moved) self.assertIsNone(moved["error"]) self.assertEqual(moved["target_session_id"], session) self.assertEqual(moved["target_home"], str(self.target.home)) progress = moved["progress"] self.assertGreater(progress["bytes_total"], 0) self.assertEqual(progress["bytes_done"], progress["bytes_total"])
with self.app.api(f"/sessions/{session}?tail=0") as response: record = json.load(response)["moved"] self.assertEqual(record["host"], "vassago") self.assertEqual(record["workspace"], target) self.assertEqual(record["transfer_id"], transfer) with self.app.api("/sessions") as response: [listed] = [s for s in json.load(response)["items"] if s["id"] == session] self.assertEqual(listed["moved"], record)
with self.assertRaises(urllib.error.HTTPError) as refused: self.app.prompt(session, "still here?") self.assertEqual(refused.exception.code, 409) problem = json.load(refused.exception) self.assertEqual(problem["code"], "session_moved") self.assertIn("vassago", problem["detail"])
with self.target.api(f"/sessions/{session}?tail=0") as response: arrived = json.load(response) self.assertEqual(arrived["workspace"], str(self.destination)) self.assertIsNone(arrived["moved"]) # The target's token stays on the target: never in an ssh command line. self.assertNotIn(self.target.connection["token"], self.ssh_log.read_text())
STALE = "0195f3a2-0000-7000-8000-00000000beef"
def seed_expired_import(self): """An import the target staged long ago, which its staging would expire: its row and a segment file, which a preflight must leave.""" staged = self.target.home / "transfers" / self.STALE / "import" staged.mkdir(parents=True) (staged / "0.seg").write_bytes(b"left from an old move") with closing(sqlite3.connect(self.target.home / "albedo.sqlite")) as db: db.execute( "INSERT INTO transfers(id,role,intent,state,manifest,bytes," "created_at,updated_at,workspace) " "VALUES(?,'import','old','staging','{}',21,0,0,'/old')", (self.STALE,), ) db.commit()
def assert_target_untouched(self): """The seeded import is still the target's only transfer state.""" target_db = self.target.home / "albedo.sqlite" with closing(sqlite3.connect(f"file:{target_db}?mode=ro", uri=True)) as db: rows = db.execute("SELECT id,state FROM transfers").fetchall() self.assertEqual(rows, [(self.STALE, "staging")]) self.assertEqual( sorted(p.name for p in (self.target.home / "transfers").iterdir()), [self.STALE], ) staged = self.target.home / "transfers" / self.STALE / "import" self.assertEqual([p.name for p in staged.iterdir()], ["0.seg"])
def test_a_compatible_target_is_available_and_preflight_writes_nothing(self): self.seed_expired_import() session = self.session()
found = self.preflight(session, f"vassago:{self.destination}") self.assertTrue(found["available"], found) self.assertIsNone(found.get("code"), found) self.assert_target_untouched()
# The source's schema changes, so the daemon is this test's alone. @exclusive def test_a_target_lacking_a_column_is_refused_in_preflight_writing_nothing(self): self.seed_expired_import() session = self.session() # A column the target's sessions table lacks, as a newer build adds. with closing(sqlite3.connect(self.app.home / "albedo.sqlite")) as db: db.execute("ALTER TABLE sessions ADD COLUMN check_probe TEXT") db.commit()
found = self.preflight(session, f"vassago:{self.destination}") self.assertFalse(found["available"], found) self.assertEqual(found["code"], "transfer_target_older", found) self.assertIn("core/sessions here lacks check_probe", found["reason"]) self.assert_target_untouched()
def test_a_target_on_another_protocol_is_refused_before_export(self): OldDaemon.seen = [] server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), OldDaemon) self.addCleanup(server.server_close) threading.Thread(target=server.serve_forever, daemon=True).start() self.addCleanup(server.shutdown) old_home = self.remote_home / "old-albedo" old_home.mkdir() (old_home / "daemon.json").write_text( json.dumps({"port": server.server_address[1], "token": "old-token"}) ) (self.hosts / "vassago").write_text(str(old_home)) session = self.session() target = f"vassago:{self.destination}"
found = self.preflight(session, target) self.assertFalse(found["available"], found) self.assertEqual(found["target_daemon"]["protocol"], 0) self.assertIn("vassago runs transfer protocol 0, this daemon", found["reason"]) self.assertIn("update albedo on vassago", found["reason"])
transfer = operation_id() self.move(session, transfer, target) failed = self.settled(transfer) self.assertEqual(failed["state"], "failed", failed) self.assertEqual(failed["error"]["code"], "transfer_protocol") self.assertEqual(failed["error"]["detail"], found["reason"]) self.assertEqual(self.exported(transfer), 0) self.assertFalse((self.app.home / "transfers" / transfer).exists()) self.assertEqual(set(OldDaemon.seen), {"GET /transfers/protocol"}) with self.app.api(f"/sessions/{session}?tail=0") as response: self.assertIsNone(json.load(response)["moved"])
def test_an_unreachable_target_is_unavailable_with_ssh_words(self): session = self.session() began = time.monotonic() found = self.preflight(session, "gone:/srv/project") self.assertLess(time.monotonic() - began, 10) self.assertFalse(found["available"]) self.assertIn("Connection refused", found["reason"]) self.assertEqual(found["target_daemon"]["host"], "gone") self.assertIsNone(found["target_daemon"]["protocol"])
def test_a_host_too_old_for_albedo_fails_the_move_saying_so(self): session = self.session() transfer = operation_id() self.move(session, transfer, f"oldpy:{self.destination}") failed = self.settled(transfer) self.assertEqual(failed["state"], "failed", failed) self.assertEqual(failed["error"]["code"], "host_unsupported") self.assertEqual( failed["error"]["detail"], "oldpy can't run albedo's kernel: needs python >= 3.11 (found 3.9)", ) self.assertEqual(self.exported(transfer), 0)
def test_a_move_resumes_its_copy_after_the_source_daemon_restarts(self): session = self.session() target = f"vassago:{self.destination}" self.stall.touch() transfer = operation_id() self.move(session, transfer, target) wait_for(self.stalled.exists, message="the relay never forwarded a segment") self.assertEqual(self.read(transfer)["state"], "copying") self.stall.unlink() self.app.restart(crash=True) # The restarted daemon reads the ledger, not a client, and goes on. self.assertIn( self.read(transfer)["state"], ("copying", "activating", "checklist") ) moved = self.settled(transfer) self.assertEqual(moved["state"], "checklist", moved) relays = [ line for line in self.ssh_log.read_text().splitlines() if "albedo_transfer_relay" in line ] self.assertGreaterEqual(len(relays), 2) with self.target.api(f"/sessions/{session}?tail=0") as response: self.assertEqual(json.load(response)["id"], session)
def target_profiles(self, **models): """Gives the target only these profiles, by name and model.""" source = json.loads((self.app.home / "config.json").read_text()) [profile] = source["providers"].values() providers = { name: {**profile, "model": model} for name, model in models.items() } (self.target.home / "config.json").write_text( json.dumps({"providers": providers, "active": next(iter(providers))}) )
def target_provider(self, session): path = self.target.home / "albedo.sqlite" with closing(sqlite3.connect(f"file:{path}?mode=ro", uri=True)) as db: return db.execute( "SELECT provider FROM sessions WHERE id=?", (session,) ).fetchone()[0]
def test_a_target_without_the_sessions_profile_is_unavailable(self): session = self.session() self.target_profiles(other="other-model") found = self.preflight(session, f"vassago:{self.destination}") self.assertFalse(found["available"], found) profile = self.app.profile reason = f"vassago has no {profile} profile: sign in there first" self.assertEqual(found["reason"], reason) [run] = found["runs_there"] self.assertEqual(run["session_id"], session) self.assertFalse(run["ok"]) self.assertEqual(run["profile"], profile) self.assertEqual(run["model"], "fixture-model") self.assertEqual(run["reason"], reason) self.assertEqual(run["alternatives"], []) self.assertIsInstance(run["name"], str)
def test_a_session_moves_onto_another_profile_that_lists_its_model(self): session = self.session() self.target_profiles(other="fixture-model") target = f"vassago:{self.destination}" found = self.preflight(session, target) self.assertTrue(found["available"], found) [run] = found["runs_there"] self.assertFalse(run["ok"]) self.assertEqual(run["alternatives"], ["other"])
transfer = operation_id() with self.app.api( f"/sessions/{session}/move", {"transfer_id": transfer, "target": target, "profiles": {session: "other"}}, ) as response: self.assertEqual(response.status, 202) # Another mapping under the same id is another move. with self.assertRaises(urllib.error.HTTPError) as conflict: self.app.api( f"/sessions/{session}/move", {"transfer_id": transfer, "target": target, "profiles": {}}, ) self.assertEqual(conflict.exception.code, 409) moved = self.settled(transfer) self.assertEqual(moved["state"], "checklist", moved) self.assertEqual(self.target_provider(session), "other")
def test_a_mapping_the_target_cannot_run_fails_the_move(self): session = self.session() target = f"vassago:{self.destination}" with self.assertRaises(urllib.error.HTTPError) as outside: self.app.api( f"/sessions/{session}/move", { "transfer_id": operation_id(), "target": target, "profiles": {operation_id(): "other"}, }, ) self.assertEqual(outside.exception.code, 422) self.assertEqual(json.load(outside.exception)["code"], "profile_unavailable")
transfer = operation_id() with self.app.api( f"/sessions/{session}/move", {"transfer_id": transfer, "target": target, "profiles": {session: "nope"}}, ) as response: self.assertEqual(response.status, 202) failed = self.settled(transfer) self.assertEqual(failed["state"], "failed", failed) self.assertEqual(failed["error"]["code"], "profile_unavailable") self.assertIn(session, failed["error"]["detail"]) self.assertIn("vassago has no nope profile", failed["error"]["detail"]) # Nothing went live there. with self.assertRaises(urllib.error.HTTPError) as missing: self.target.api(f"/sessions/{session}?tail=0") self.assertEqual(missing.exception.code, 404)
if __name__ == "__main__": unittest.main()