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.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186//go:build unix
// A ChatClient built before a real daemon restart must send another turn via// its refreshed connection without losing the first turn's transcript. A fake// daemon cannot exercise process lifetime or on-disk session persistence.package e2e
import ( "context" "fmt" "strings" "testing" "time"
"albedo/cli/internal/daemon" "albedo/cli/internal/tui"
tea "charm.land/bubbletea/v2")
// restartDaemon replaces the suite daemon under the same hermetic home and// records its new pid for later scenarios.func restartDaemon(t *testing.T) daemon.ConnectionSnapshot { t.Helper() old := suite.daemonPID
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() if _, err := daemon.Request[map[string]any](ctx, conn(t), "/shutdown", map[string]any{}); err != nil { t.Fatalf("shutdown request: %v", err) } if !awaitExit(old, 15*time.Second) { t.Fatalf("daemon %d did not exit after shutdown", old) }
if _, stderr, err := runCLI("sessions"); err != nil { t.Fatalf("rebooting the daemon: %v\n%s", err, stderr) } deadline := time.Now().Add(2 * time.Minute) for { snap, err := readDaemonSnapshot(suite.home) if err == nil && snap.Pid != old { suite.daemonPID = snap.Pid return snap } if time.Now().After(deadline) { t.Fatalf("no daemon other than %d published daemon.json after the restart", old) } time.Sleep(100 * time.Millisecond) }}
// TestChatClientSendReconnectsAfterDaemonRestart sends two turns through the// same client and session, with a real restart between them.func TestChatClientSendReconnectsAfterDaemonRestart(t *testing.T) { profile := providerRoute(t, echoReply) workspace := t.TempDir() id := newSession(t, workspace)
// The client exists before the restart and is the only thing this test // uses afterwards; a client created after the reboot would prove nothing. shared := conn(t) client := daemon.NewChatClient(shared, id)
prompt1 := "turn before the restart" if _, err := client.Send(context.Background(), prompt1, nil); err != nil { t.Fatalf("first send: %v", err) } waitIdle(t, id, profile, 1)
oldSnap := shared.Snapshot() snap := restartDaemon(t)
prompt2 := "turn after the restart" sent, err := client.Send(context.Background(), prompt2, nil) if err != nil || sent == nil || !sent.OK { t.Fatalf("second send through the same client after the restart: ok=%v err=%v", sent != nil && sent.OK, err) } waitIdle(t, id, profile, 2)
// The shared connection must now describe the restarted daemon, not the // one it was built on. if shared.Pid() != snap.Pid { t.Errorf("connection pid is %d, restarted daemon is %d", shared.Pid(), snap.Pid) } if shared.Token() != snap.Token { t.Errorf("connection token is not the restarted daemon's") } if want := fmt.Sprintf("http://127.0.0.1:%d", snap.Port); shared.BaseURL() != want { t.Errorf("connection base url is %s, want %s", shared.BaseURL(), want) } if shared.Token() == oldSnap.Token { t.Errorf("the token never changed, so this run did not exercise a real restart") }
// Both turns crossed the whole stack to the provider. requests := suite.provider.requests(profile) if len(requests) < 2 { t.Fatalf("provider profile %s saw %d requests, want one per turn", profile, len(requests)) } body, _ := requests[0]["body"].(map[string]any) if forwarded := lastUserText(body); !strings.Contains(forwarded, prompt1) { t.Errorf("first provider request does not carry the first prompt %q: %q", prompt1, forwarded) } body, _ = requests[len(requests)-1]["body"].(map[string]any) if forwarded := lastUserText(body); !strings.Contains(forwarded, prompt2) { t.Errorf("last provider request does not carry the post-restart prompt: %q", forwarded) }
// The transcript survived the restart in the same session. reply := strings.Join(eventText(streamSnapshot(t, id), "message"), "\n") if !strings.Contains(reply, "echo: "+prompt1) || !strings.Contains(reply, "echo: "+prompt2) { t.Fatalf("transcript after the restart is missing a turn; got:\n%s", reply) }}
// A stopped turn survives a daemon restart as idle-but-interrupted. Reopening// it must accept ordinary input without a slash command changing its phase.func TestTUIReopensInterruptedSessionWithoutCompacting(t *testing.T) { entered, release := make(chan struct{}), make(chan struct{}) defer close(release) profile := providerRoute(t, func(request map[string]any) string { if lastUserText(request) == "stop this turn" { close(entered) <-release } return echoReply(request) }) id := newSession(t, t.TempDir()) client := daemon.NewChatClient(conn(t), id) ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) defer cancel() if _, err := client.Send(ctx, "stop this turn", nil); err != nil { t.Fatal(err) } select { case <-entered: case <-ctx.Done(): t.Fatal("the turn never reached the provider") } if interrupted, err := client.Interrupt(ctx); err != nil || !interrupted { t.Fatalf("interrupt: %v, %v", interrupted, err) } waitIdle(t, id, profile, 1) restartDaemon(t) status, err := daemon.Request[struct { Phase string `json:"phase"` Idle bool `json:"idle"` }](ctx, conn(t), "/sessions/"+id+"/status", nil) if err != nil || !status.Idle || status.Phase != "interrupted" { t.Fatalf("reopened status: %+v, %v", status, err) }
session := daemonSession(t, id) d := driveTUI(t, &session) defer d.App.Chat.Close() page, err := client.History(ctx, 0, 120) if err != nil { t.Fatal(err) } for _, event := range page.Events { d.Update(tui.ChatStreamEventMsg{ SessionID: id, Generation: d.App.Chat.Generation, Event: event, }) } if !strings.Contains(d.View(), "stop this turn") { t.Fatal("the interrupted transcript did not load") } d.connected() d.App.Chat.TextArea.SetValue("continue without compacting") command := d.Update(tea.KeyPressMsg{Code: tea.KeyEnter}) if command == nil { t.Fatal("the composer refused the new prompt") } for _, msg := range d.results(command) { if _, ok := msg.(tui.ChatTurnSentMsg); ok { d.Update(msg) } } waitIdle(t, id, profile, 2) replies := strings.Join(eventText(streamSnapshot(t, id), "message"), "\n") if !strings.Contains(replies, "echo: continue without compacting") { t.Fatalf("the reopened session did not answer: %q", replies) }}