package server import ( "context" "errors" "fmt" "time" "git.a-wan.net/alan/pipelines/internal/protocol" ) // chatShellDismissStore persists dismissals; *pipeline.Store implements it. type chatShellDismissStore interface { DismissChatShellRuns(ctx context.Context, sessionID string, ids []string, at int64) ([]string, error) RestoreChatShellRuns(ctx context.Context, sessionID string, ids []string, since int64) ([]protocol.ChatShellRunRecord, error) PurgeDismissedChatShellRuns(ctx context.Context, before int64) (int64, error) DismissedChatShellRuns(ctx context.Context, sessionID string) ([]string, error) } func validChatShellRunIDs(ids []string) error { if len(ids) == 0 { return errors.New("name at least one command") } if len(ids) > protocol.ChatShellDismissLimit { return fmt.Errorf("name at most %d commands", protocol.ChatShellDismissLimit) } return nil } // Dismiss removes the session's finished runs among ids for every watcher and // returns the ids it dismissed. Their output is purged once the undo window // has passed. func (r *chatShellRunner) Dismiss(ctx context.Context, sessionID string, ids []string) ([]string, error) { if err := validChatShellRunIDs(ids); err != nil { return nil, err } finished := make([]string, 0, len(ids)) for _, id := range ids { // The store refuses a run recorded as running; a process that just // exited may not have saved its final record yet, so ask it too. if r.activeProcess(sessionID, id) == nil { finished = append(finished, id) } } if len(finished) == 0 { return nil, errors.New("stop the command and wait for it to finish before dismissing it") } dismissed, err := r.store.DismissChatShellRuns(ctx, sessionID, finished, r.now().UnixMilli()) if err != nil { return nil, err } for _, id := range dismissed { r.publishFrame(protocol.ChatShellRunEventFrame{SessionID: sessionID, RunID: id, Dismissed: true}) } if len(dismissed) > 0 { r.schedulePurge() } return dismissed, nil } // Restore undoes the dismissal of the session's runs among ids that are still // inside the undo window and returns them with their list output tail. func (r *chatShellRunner) Restore(ctx context.Context, sessionID string, ids []string) ([]protocol.ChatShellRunRecord, error) { if err := validChatShellRunIDs(ids); err != nil { return nil, err } since := r.now().Add(-r.undo).UnixMilli() runs, err := r.store.RestoreChatShellRuns(ctx, sessionID, ids, since) if err != nil { return nil, err } if len(runs) == 0 { return nil, errors.New("these commands can no longer be restored") } for i, run := range runs { r.publishRun(run) runs[i] = chatShellRecordTail(run, protocol.ChatShellRunListOutput) runs[i].Text = "" } return runs, nil } // Dismissed is the session's dismissed run ids (their tombstones). func (r *chatShellRunner) Dismissed(ctx context.Context, sessionID string) ([]string, error) { return r.store.DismissedChatShellRuns(ctx, sessionID) } // purgeDismissed deletes the output of runs whose undo window has passed. func (r *chatShellRunner) purgeDismissed(ctx context.Context) { _, _ = r.store.PurgeDismissedChatShellRuns(ctx, r.now().Add(-r.undo).UnixMilli()) } // schedulePurge purges once the window of a dismissal made now has passed. // A server stopping before then purges on its next start (recover). func (r *chatShellRunner) schedulePurge() { time.AfterFunc(r.undo+time.Second, func() { if r.base.Err() == nil { r.purgeDismissed(r.base) } }) } func (r *chatShellRunner) publishFrame(frame protocol.ChatShellRunEventFrame) { if r.publish != nil { r.publish(frame.SessionID, frame) } }