package pipeline import ( "context" "database/sql" "sort" "strconv" "strings" "time" "git.a-wan.net/alan/pipelines/internal/protocol" ) // AttentionAckRetention bounds how long an acknowledgement is kept. The // Needs-you list shows only today's work and a chat watermark is refreshed // whenever the chat is opened, so a month-old acknowledgement protects nothing. const AttentionAckRetention = 30 * 24 * time.Hour // initAttentionAcks creates the two additive acknowledgement tables. They are // tables of their own so no run or session schema changes; run_id is kept as a // column so pruning against pipeline_runs uses an integer comparison. func (s *Store) initAttentionAcks() error { _, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS attention_dismissals ( key TEXT PRIMARY KEY, run_id INTEGER NOT NULL, dismissed_at INTEGER NOT NULL); CREATE TABLE IF NOT EXISTS chat_seen_watermarks ( session_id TEXT PRIMARY KEY, seen_at INTEGER NOT NULL, acked_at INTEGER NOT NULL);`) return err } type attentionQuerier interface { QueryContext(context.Context, string, ...any) (*sql.Rows, error) } func readAttentionAcks(ctx context.Context, q attentionQuerier) (protocol.AttentionAcks, error) { acks := protocol.AttentionAcks{Dismissed: []string{}, ChatSeen: map[string]int64{}} rows, err := q.QueryContext(ctx, `SELECT key FROM attention_dismissals ORDER BY key`) if err != nil { return acks, err } for rows.Next() { var key string if err := rows.Scan(&key); err != nil { rows.Close() return acks, err } acks.Dismissed = append(acks.Dismissed, key) } rows.Close() if err := rows.Err(); err != nil { return acks, err } rows, err = q.QueryContext(ctx, `SELECT session_id, seen_at FROM chat_seen_watermarks`) if err != nil { return acks, err } defer rows.Close() for rows.Next() { var id string var at int64 if err := rows.Scan(&id, &at); err != nil { return acks, err } acks.ChatSeen[id] = at } return acks, rows.Err() } // AttentionAcks returns every stored acknowledgement. func (s *Store) AttentionAcks(ctx context.Context) (protocol.AttentionAcks, error) { return readAttentionAcks(ctx, s.db) } // AckAttention validates and records one acknowledgement, prunes stale rows, // and returns the delta that actually changed the stored set together with the // whole set afterwards. // // A dismissal of a run that does not exist is skipped, and so is a watermark // for a session that is not in the operator registry, so a client cannot grow // the tables with invented ids. A watermark only advances: the stored value is // the maximum of the old value, the client's value and the session's own // registry recency, so a device that opened the chat from a stale list row // still acknowledges everything the server listed at that moment. func (s *Store) AckAttention(ctx context.Context, ack *protocol.AttentionAcks, now time.Time) (delta, all protocol.AttentionAcks, err error) { valid, err := protocol.ValidateAttentionAck(ack) if err != nil { return delta, all, err } tx, err := s.db.BeginTx(ctx, nil) if err != nil { return delta, all, err } defer tx.Rollback() nowMillis := now.UnixMilli() delta = protocol.AttentionAcks{Dismissed: []string{}, ChatSeen: map[string]int64{}} for _, key := range valid.Dismissed { runID, _ := strconv.ParseInt(key[:strings.IndexByte(key, ':')], 10, 64) result, err := tx.ExecContext(ctx, `INSERT INTO attention_dismissals(key, run_id, dismissed_at) SELECT ?, id, ? FROM pipeline_runs WHERE id=? ON CONFLICT(key) DO NOTHING`, key, nowMillis, runID) if err != nil { return delta, all, err } if n, _ := result.RowsAffected(); n > 0 { delta.Dismissed = append(delta.Dismissed, key) } } ids := make([]string, 0, len(valid.ChatSeen)) for id := range valid.ChatSeen { ids = append(ids, id) } sort.Strings(ids) for _, id := range ids { var recency, stored int64 var hasStored bool err := tx.QueryRowContext(ctx, `SELECT last_used_at FROM operator_sessions WHERE session_id=?`, id).Scan(&recency) if err == sql.ErrNoRows { continue } if err != nil { return delta, all, err } switch err := tx.QueryRowContext(ctx, `SELECT seen_at FROM chat_seen_watermarks WHERE session_id=?`, id).Scan(&stored); err { case nil: hasStored = true case sql.ErrNoRows: default: return delta, all, err } next := max(valid.ChatSeen[id], recency, stored) if _, err := tx.ExecContext(ctx, `INSERT INTO chat_seen_watermarks(session_id, seen_at, acked_at) VALUES(?,?,?) ON CONFLICT(session_id) DO UPDATE SET seen_at=excluded.seen_at, acked_at=excluded.acked_at`, id, next, nowMillis); err != nil { return delta, all, err } if !hasStored || next > stored { delta.ChatSeen[id] = next } } if err := pruneAttentionAcks(ctx, tx, now); err != nil { return delta, all, err } all, err = readAttentionAcks(ctx, tx) if err != nil { return delta, all, err } return delta, all, tx.Commit() } // PruneAttentionAcks drops acknowledgements for runs and sessions that no // longer exist and any older than AttentionAckRetention. func (s *Store) PruneAttentionAcks(ctx context.Context, now time.Time) error { tx, err := s.db.BeginTx(ctx, nil) if err != nil { return err } defer tx.Rollback() if err := pruneAttentionAcks(ctx, tx, now); err != nil { return err } return tx.Commit() } func pruneAttentionAcks(ctx context.Context, tx *sql.Tx, now time.Time) error { cutoff := now.Add(-AttentionAckRetention).UnixMilli() for _, statement := range []string{ `DELETE FROM attention_dismissals WHERE dismissed_at < ? OR run_id NOT IN (SELECT id FROM pipeline_runs)`, `DELETE FROM chat_seen_watermarks WHERE acked_at < ? OR session_id NOT IN (SELECT session_id FROM operator_sessions)`, } { if _, err := tx.ExecContext(ctx, statement, cutoff); err != nil { return err } } return nil }