diff --git a/internal/gateway/compress_identity_test.go b/internal/gateway/compress_identity_test.go index e3042bdd3..aeeb6f8bf 100644 --- a/internal/gateway/compress_identity_test.go +++ b/internal/gateway/compress_identity_test.go @@ -12,14 +12,8 @@ import ( // compressBackends provides the persistent store used by compression tests. func compressBackends() map[string]func(t *testing.T) SessionStore { return map[string]func(t *testing.T) SessionStore{ - "sqlite": func(t *testing.T) SessionStore { - s, err := NewSQLiteSessionStoreMemory() - if err != nil { - t.Fatalf("NewSQLiteSessionStoreMemory: %v", err) - } - t.Cleanup(func() { _ = s.Close() }) - return s - }, + "memory": func(*testing.T) SessionStore { return NewSessionStoreMemory() }, + "postgres": func(t *testing.T) SessionStore { return newPostgresStore(t) }, } } diff --git a/internal/gateway/compress_trigger_test.go b/internal/gateway/compress_trigger_test.go index 7617ef74b..a87729a55 100644 --- a/internal/gateway/compress_trigger_test.go +++ b/internal/gateway/compress_trigger_test.go @@ -38,10 +38,7 @@ func (s *countingReplaceStore) ReplaceMessages(ctx context.Context, sessionID st // written to it. func newTriggerStore(t *testing.T) *countingReplaceStore { t.Helper() - inner, err := NewSQLiteSessionStoreMemory() - if err != nil { - t.Fatalf("NewSQLiteSessionStoreMemory: %v", err) - } + inner := NewSessionStoreMemory() t.Cleanup(func() { _ = inner.Close() }) ledger, ok := inner.(TurnLedger) if !ok { diff --git a/internal/gateway/session_store.go b/internal/gateway/session_store.go index 96e690ac2..e0f874455 100644 --- a/internal/gateway/session_store.go +++ b/internal/gateway/session_store.go @@ -10,15 +10,6 @@ import ( "github.com/samcharles93/archie-core/internal/domain/messaging" ) -// NewSessionStoreMemory returns an in-memory SQLite SessionStore for tests. -func NewSessionStoreMemory() SessionStore { - store, err := NewSQLiteSessionStoreMemory() - if err != nil { - panic(err) - } - return store -} - // sessionRecency is the later of a session's creation and activity times. func sessionRecency(sc SessionContext) time.Time { if sc.LastActiveAt.After(sc.CreatedAt) { diff --git a/internal/gateway/session_store_memory.go b/internal/gateway/session_store_memory.go new file mode 100644 index 000000000..cfa407f06 --- /dev/null +++ b/internal/gateway/session_store_memory.go @@ -0,0 +1,482 @@ +package gateway + +import ( + "context" + "fmt" + "slices" + "strings" + "sync" + "time" + "unicode" + + "github.com/samcharles93/archie-core/internal/domain/messaging" +) + +// memorySessionStore is the in-process SessionStore for tests and embedders +// that need no durability. It follows the PostgreSQL store's contract +// (sessionstore_conformance_test.go) including the optional TurnLedger, +// TurnHistory and TurnReplayStore capabilities: millisecond timestamps, the +// strictly-increasing append clamp, redelivery dedup on canonical IDs, and a +// search that ANDs lowercase word terms over sender and text. +type memorySessionStore struct { + mu sync.Mutex + sessions map[string]SessionContext + messages map[string][]memoryMessage + turns map[string]TurnRecord + seq int64 +} + +type memoryMessage struct { + seq int64 + ts int64 + msg messaging.Message +} + +// NewSessionStoreMemory returns an empty in-memory SessionStore. +func NewSessionStoreMemory() SessionStore { + return &memorySessionStore{ + sessions: map[string]SessionContext{}, + messages: map[string][]memoryMessage{}, + turns: map[string]TurnRecord{}, + } +} + +func (s *memorySessionStore) Close() error { return nil } + +func truncateMilli(t time.Time) time.Time { return time.UnixMilli(t.UnixMilli()).UTC() } + +// ── Sessions ──────────────────────────────────────────────────────────────── + +func (s *memorySessionStore) Save(_ context.Context, sc SessionContext) error { + s.mu.Lock() + defer s.mu.Unlock() + sc.CreatedAt = truncateMilli(sc.CreatedAt) + sc.LastActiveAt = truncateMilli(sc.LastActiveAt) + s.sessions[sc.SessionID] = sc + return nil +} + +func (s *memorySessionStore) Get(_ context.Context, sessionID string) (*SessionContext, error) { + s.mu.Lock() + defer s.mu.Unlock() + sc, ok := s.sessions[sessionID] + if !ok { + return nil, nil + } + return &sc, nil +} + +func (s *memorySessionStore) GetByChannel(_ context.Context, platform, channelID string) ([]SessionContext, error) { + s.mu.Lock() + defer s.mu.Unlock() + return s.sortedSessions(func(sc SessionContext) bool { + return sc.Source.Platform == platform && sc.Source.ChannelID == channelID + }), nil +} + +func (s *memorySessionStore) List(_ context.Context) ([]SessionContext, error) { + s.mu.Lock() + defer s.mu.Unlock() + return s.sortedSessions(func(SessionContext) bool { return true }), nil +} + +func (s *memorySessionStore) sortedSessions(keep func(SessionContext) bool) []SessionContext { + out := make([]SessionContext, 0, len(s.sessions)) + for _, sc := range s.sessions { + if keep(sc) { + out = append(out, sc) + } + } + slices.SortFunc(out, func(a, b SessionContext) int { + if c := sessionRecency(b).Compare(sessionRecency(a)); c != 0 { + return c + } + return strings.Compare(a.SessionID, b.SessionID) + }) + return out +} + +func (s *memorySessionStore) Delete(_ context.Context, sessionID string) error { + s.mu.Lock() + defer s.mu.Unlock() + delete(s.sessions, sessionID) + delete(s.messages, sessionID) + for id, turn := range s.turns { + if turn.SessionID == sessionID { + delete(s.turns, id) + } + } + return nil +} + +func (s *memorySessionStore) Touch(_ context.Context, sessionID string) error { + s.mu.Lock() + defer s.mu.Unlock() + if sc, ok := s.sessions[sessionID]; ok { + sc.LastActiveAt = truncateMilli(time.Now().UTC()) + s.sessions[sessionID] = sc + } + return nil +} + +// ── Messages ──────────────────────────────────────────────────────────────── + +func (s *memorySessionStore) SaveMessage(_ context.Context, sessionID string, msg messaging.Message) error { + s.mu.Lock() + defer s.mu.Unlock() + s.saveMessage(sessionID, msg, true) + return nil +} + +func (s *memorySessionStore) SaveMessages(_ context.Context, sessionID string, msgs []messaging.Message) error { + s.mu.Lock() + defer s.mu.Unlock() + for _, msg := range msgs { + s.saveMessage(sessionID, msg, true) + } + return nil +} + +func (s *memorySessionStore) indexOf(sessionID, id string) int { + return slices.IndexFunc(s.messages[sessionID], func(m memoryMessage) bool { return string(m.msg.ID) == id }) +} + +// saveMessage stores msg and returns the canonical ID it lives under. clamp +// selects the append path, whose timestamp must exceed the session's newest. +func (s *memorySessionStore) saveMessage(sessionID string, msg messaging.Message, clamp bool) string { + id := string(msg.ID) + legacyID := "" + if msg.SourceID == "" { + if id == "" { + id = newMessageID(sessionID, "") + } + } else { + currentID, compatibleLegacyID := canonicalMessageIDs(sessionID, msg.SourceID) + if id == "" { + id = currentID + } + if id == currentID { + legacyID = compatibleLegacyID + } + } + if legacyID != "" && s.indexOf(sessionID, legacyID) >= 0 { + return legacyID + } + if s.indexOf(sessionID, id) >= 0 { + return id + } + role := msg.Role + if role == "" { + role = messaging.RoleUser + } + ts := stamp(msg).UnixMilli() + history := s.messages[sessionID] + if clamp { + for _, m := range history { + if m.ts >= ts { + ts = m.ts + 1 + } + } + } + s.seq++ + stored := messaging.Message{ + ID: messaging.MessageID(id), SourceID: msg.SourceID, Sender: msg.Sender, + SenderID: msg.SenderID, Role: role, Text: msg.Text, + } + history = append(history, memoryMessage{seq: s.seq, ts: ts, msg: stored}) + slices.SortStableFunc(history, func(a, b memoryMessage) int { + if a.ts != b.ts { + return int(a.ts - b.ts) + } + return int(a.seq - b.seq) + }) + s.messages[sessionID] = history + return id +} + +func (s *memorySessionStore) ReplaceMessages(_ context.Context, sessionID string, msgs []messaging.Message, superseded []string) error { + s.mu.Lock() + defer s.mu.Unlock() + survivors := make(map[string]struct{}, len(msgs)) + for _, msg := range msgs { + survivors[s.saveMessage(sessionID, msg, false)] = struct{}{} + } + doomed := make(map[string]struct{}, len(superseded)) + for _, id := range superseded { + if _, kept := survivors[id]; !kept { + doomed[id] = struct{}{} + } + } + s.messages[sessionID] = slices.DeleteFunc(s.messages[sessionID], func(m memoryMessage) bool { + _, drop := doomed[string(m.msg.ID)] + return drop + }) + return nil +} + +// read returns the stored message with its session's conversation address. +func (s *memorySessionStore) read(sessionID string, m memoryMessage) messaging.Message { + out := m.msg + out.At = time.UnixMilli(m.ts).UTC() + if sc, ok := s.sessions[sessionID]; ok { + out.ConversationID = messaging.ConversationID{ChannelID: sc.Source.ChannelID, ThreadID: sc.Source.ThreadID} + } + return out +} + +func (s *memorySessionStore) RecentMessages(_ context.Context, sessionID string, n int) ([]messaging.Message, error) { + if n <= 0 { + return nil, nil + } + s.mu.Lock() + defer s.mu.Unlock() + history := s.messages[sessionID] + history = history[max(len(history)-n, 0):] + out := make([]messaging.Message, 0, len(history)) + for _, m := range history { + out = append(out, s.read(sessionID, m)) + } + return out, nil +} + +func (s *memorySessionStore) DeleteRecentMessages(_ context.Context, sessionID string, n int) (int, error) { + if n <= 0 { + return 0, nil + } + s.mu.Lock() + defer s.mu.Unlock() + history := s.messages[sessionID] + deleted := min(n, len(history)) + s.messages[sessionID] = history[:len(history)-deleted] + return deleted, nil +} + +func (s *memorySessionStore) MessageCount(_ context.Context, sessionID string) (int, error) { + s.mu.Lock() + defer s.mu.Unlock() + return len(s.messages[sessionID]), nil +} + +func (s *memorySessionStore) FindPriorReply(_ context.Context, sessionID, sourceID, identity string) (string, error) { + if sourceID == "" { + return "", nil + } + s.mu.Lock() + defer s.mu.Unlock() + currentID, legacyID := canonicalMessageIDs(sessionID, sourceID) + i := -1 + if legacyID != "" { + i = s.indexOf(sessionID, legacyID) + } + if i < 0 { + i = s.indexOf(sessionID, currentID) + } + history := s.messages[sessionID] + if i < 0 || i+1 >= len(history) { + return "", nil + } + next := history[i+1].msg + if next.Sender != identity || isCompressionSummary(next.Text) { + return "", nil + } + return next.Text, nil +} + +// searchTerms splits text into lowercase letter-and-digit words. +func searchTerms(text string) []string { + return strings.FieldsFunc(strings.ToLower(text), func(r rune) bool { + return !unicode.IsLetter(r) && !unicode.IsDigit(r) + }) +} + +func (s *memorySessionStore) SearchMessages(_ context.Context, sessionID string, q MessageQuery) (MessagePage, error) { + query := strings.TrimSpace(q.Query) + if query == "" { + return MessagePage{}, nil + } + if len(query) > MaxMessageSearchQueryBytes { + return MessagePage{}, fmt.Errorf("sessionstore: search query exceeds %d bytes", MaxMessageSearchQueryBytes) + } + if terms := len(strings.Fields(query)); terms > MaxMessageSearchQueryTerms { + return MessagePage{}, fmt.Errorf("sessionstore: search query exceeds %d terms", MaxMessageSearchQueryTerms) + } + terms := searchTerms(query) + if len(terms) == 0 { + return MessagePage{}, nil + } + limit := q.Limit + if limit <= 0 { + limit = DefaultMessagePageSize + } + limit = min(limit, MaxMessagePageSize) + offset := max(q.Offset, 0) + + s.mu.Lock() + defer s.mu.Unlock() + var matches []messaging.Message + history := s.messages[sessionID] + for _, m := range slices.Backward(history) { + words := searchTerms(m.msg.Sender + " " + m.msg.Text) + if !allIn(terms, words) { + continue + } + matches = append(matches, s.read(sessionID, m)) + } + if offset >= len(matches) { + return MessagePage{}, nil + } + page := matches[offset:min(offset+limit, len(matches))] + next := offset + len(page) + return MessagePage{Messages: page, NextOffset: next, HasMore: next < len(matches)}, nil +} + +func allIn(terms, words []string) bool { + for _, term := range terms { + if !slices.Contains(words, term) { + return false + } + } + return true +} + +// ── Turns ─────────────────────────────────────────────────────────────────── + +// storedTurn normalises a turn the way a database round trip does. +func storedTurn(turn TurnRecord) (TurnRecord, error) { + raw, err := marshalToolCalls(turn.ToolCalls) + if err != nil { + return TurnRecord{}, err + } + if turn.ToolCalls, err = unmarshalToolCalls(raw); err != nil { + return TurnRecord{}, err + } + turn.CreatedAt = truncateMilli(turn.CreatedAt) + turn.UpdatedAt = truncateMilli(turn.UpdatedAt) + return turn, nil +} + +func (s *memorySessionStore) ClaimTurn(_ context.Context, initial TurnRecord) (TurnRecord, TurnClaim, error) { + initial, _, err := prepareInitialTurn(initial, time.Now().UTC()) + if err != nil { + return TurnRecord{}, "", err + } + if initial, err = storedTurn(initial); err != nil { + return TurnRecord{}, "", err + } + s.mu.Lock() + defer s.mu.Unlock() + turn, exists := s.turns[initial.TurnID] + if !exists { + s.turns[initial.TurnID] = initial + return initial, TurnClaimOwned, nil + } + switch turn.Status { + case TurnStatusCompleted: + return turn, TurnClaimCompleted, nil + case TurnStatusFailed, TurnStatusCancelled: + if turn.AssistantMessageID != "" { + turn.Status = TurnStatusCompleted + turn.Error = "" + turn.UpdatedAt = truncateMilli(time.Now().UTC()) + s.turns[turn.TurnID] = turn + return turn, TurnClaimCompleted, nil + } + turn.Status = TurnStatusRunning + turn.Attempt++ + turn.OwnerID = initial.OwnerID + turn.Error = "" + turn.UpdatedAt = truncateMilli(time.Now().UTC()) + s.turns[turn.TurnID] = turn + return turn, TurnClaimOwned, nil + default: + return turn, TurnClaimInProgress, nil + } +} + +func recoverable(turn TurnRecord) bool { + switch turn.Status { + case TurnStatusAccepted, TurnStatusRunning, TurnStatusPartial: + return true + default: + return false + } +} + +func (s *memorySessionStore) RecoverTurns(_ context.Context, ownerID string) error { + if ownerID == "" { + return fmt.Errorf("sessionstore: recovery owner ID is required") + } + s.mu.Lock() + defer s.mu.Unlock() + now := truncateMilli(time.Now().UTC()) + for id, turn := range s.turns { + if recoverable(turn) && turn.OwnerID != ownerID { + turn.Status = TurnStatusFailed + turn.Error = "recovered after process restart" + turn.UpdatedAt = now + s.turns[id] = turn + } + } + return nil +} + +func (s *memorySessionStore) GetTurn(_ context.Context, turnID string) (TurnRecord, bool, error) { + s.mu.Lock() + defer s.mu.Unlock() + turn, ok := s.turns[turnID] + return turn, ok, nil +} + +func (s *memorySessionStore) RecentTurns(_ context.Context, sessionID string, n int) ([]TurnRecord, error) { + if n <= 0 { + return []TurnRecord{}, nil + } + n = min(n, 500) + s.mu.Lock() + defer s.mu.Unlock() + var out []TurnRecord + for _, turn := range s.turns { + if turn.SessionID == sessionID { + out = append(out, turn) + } + } + slices.SortFunc(out, func(a, b TurnRecord) int { return a.CreatedAt.Compare(b.CreatedAt) }) + return append([]TurnRecord{}, out[max(len(out)-n, 0):]...), nil +} + +func (s *memorySessionStore) SaveTurn(_ context.Context, turn TurnRecord) error { + if turn.TurnID == "" { + return fmt.Errorf("sessionstore: turn ID is required") + } + s.mu.Lock() + defer s.mu.Unlock() + current, ok := s.turns[turn.TurnID] + if !ok { + return fmt.Errorf("sessionstore: save turn: turn not found") + } + if current.Attempt != turn.Attempt || current.OwnerID != turn.OwnerID { + return fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID) + } + if turn.UpdatedAt.IsZero() { + turn.UpdatedAt = time.Now().UTC() + } + stored, err := storedTurn(turn) + if err != nil { + return err + } + s.turns[turn.TurnID] = stored + return nil +} + +func (s *memorySessionStore) ListRecoverableTurns(_ context.Context) ([]TurnRecord, error) { + s.mu.Lock() + defer s.mu.Unlock() + var out []TurnRecord + for _, turn := range s.turns { + if recoverable(turn) { + out = append(out, turn) + } + } + slices.SortFunc(out, func(a, b TurnRecord) int { return a.UpdatedAt.Compare(b.UpdatedAt) }) + return out, nil +} diff --git a/internal/gateway/session_store_postgres_test.go b/internal/gateway/session_store_postgres_test.go index bf8903e00..62661779c 100644 --- a/internal/gateway/session_store_postgres_test.go +++ b/internal/gateway/session_store_postgres_test.go @@ -23,7 +23,14 @@ func TestMain(m *testing.M) { // applied and registers pool cleanup. func newPostgresPool(t *testing.T) *pgxpool.Pool { t.Helper() - pool, err := postgres.Open(t.Context(), pgtest.URL(t)) + return openPostgresPoolAt(t, pgtest.URL(t)) +} + +// openPostgresPoolAt opens a migrated pool on url, so a test can reopen the +// same database through a second pool. +func openPostgresPoolAt(t *testing.T, url string) *pgxpool.Pool { + t.Helper() + pool, err := postgres.Open(t.Context(), url) if err != nil { t.Fatalf("postgres.Open: %v", err) } @@ -42,6 +49,18 @@ func newPostgresStore(t *testing.T) SessionStore { return NewPostgresSessionStore(newPostgresPool(t)) } +// openPostgresStoreAt returns a SessionStore over its own pool on url. +func openPostgresStoreAt(t *testing.T, url string) SessionStore { + t.Helper() + return NewPostgresSessionStore(openPostgresPoolAt(t, url)) +} + +// TestSessionStoreConformanceMemory runs the shared SessionStore contract +// against the in-memory implementation. +func TestSessionStoreConformanceMemory(t *testing.T) { + runSessionStoreSuite(t, func(*testing.T) SessionStore { return NewSessionStoreMemory() }) +} + // TestSessionStoreConformancePostgres runs the shared SessionStore contract // against the PostgreSQL implementation. func TestSessionStoreConformancePostgres(t *testing.T) { diff --git a/internal/gateway/session_store_sqlite.go b/internal/gateway/session_store_sqlite.go deleted file mode 100644 index 47e8f959c..000000000 --- a/internal/gateway/session_store_sqlite.go +++ /dev/null @@ -1,1112 +0,0 @@ -package gateway - -import ( - "context" - "database/sql" - "encoding/json" - "errors" - "fmt" - "os" - "path/filepath" - "strings" - "sync" - "time" - - _ "modernc.org/sqlite" - - "github.com/samcharles93/archie-core/internal/domain/messaging" -) - -// ── SQLite implementation ─────────────────────────────────────────────────── -// -// sqliteSessionStore is the durable, transactional SessionStore described by -// docs/architecture/messaging-and-work-intake.md. -// -// Schema: -// -// - sessions holds one row per SessionContext, round-tripping every field -// including ParentSessionID and BranchName. -// - messages holds one row per message, keyed by the application-generated -// canonical MessageID (session-scoped unique, not the table's rowid -- -// the integer rowid backs the FTS5 external-content index instead). -// - messages_fts is an external-content FTS5 index over (sender, text) -// only, kept in sync by AFTER INSERT/UPDATE/DELETE triggers on messages. -// Because the sync is driven by triggers on the table itself rather than -// application code, it cannot drift regardless of which Go method wrote -// the row. -type sqliteSessionStore struct { - db *sql.DB - // mu serializes every write (Save, Delete, message mutations) so the - // strictly-increasing per-session timestamp invariant holds under - // concurrent callers: assigning the next timestamp is a read-then-write - // over two statements, which needs an application-level lock even - // though SQLite itself serializes at the connection level. - mu sync.Mutex -} - -const sqliteSessionSchema = ` -CREATE TABLE IF NOT EXISTS sessions ( - session_id TEXT PRIMARY KEY, - platform TEXT NOT NULL DEFAULT '', - bot_user TEXT NOT NULL DEFAULT '', - channel_id TEXT NOT NULL DEFAULT '', - thread_id TEXT NOT NULL DEFAULT '', - title TEXT NOT NULL DEFAULT '', - parent_session_id TEXT NOT NULL DEFAULT '', - branch_name TEXT NOT NULL DEFAULT '', - created_at INTEGER NOT NULL DEFAULT 0, - last_active_at INTEGER NOT NULL DEFAULT 0 -); -CREATE INDEX IF NOT EXISTS idx_sessions_channel ON sessions(platform, channel_id); --- Ordering is by recency, which is last_active_at when set and created_at --- otherwise (see sessionRecencySQL). The index matches that expression so --- the newest-first listings do not sort at query time. -CREATE INDEX IF NOT EXISTS idx_sessions_recency - ON sessions(platform, channel_id, MAX(last_active_at, created_at) DESC); - -CREATE TABLE IF NOT EXISTS messages ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - message_id TEXT NOT NULL, - session_id TEXT NOT NULL, - source_id TEXT NOT NULL DEFAULT '', - sender TEXT NOT NULL DEFAULT '', - sender_id TEXT NOT NULL DEFAULT '', - role TEXT NOT NULL DEFAULT '', - text TEXT NOT NULL DEFAULT '', - ts INTEGER NOT NULL, - UNIQUE(session_id, message_id) -); -CREATE INDEX IF NOT EXISTS idx_messages_session_ts ON messages(session_id, ts); - -CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5( - sender, - text, - content='messages', - content_rowid='id' -); - -CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN - INSERT INTO messages_fts(rowid, sender, text) VALUES (new.id, new.sender, new.text); -END; -CREATE TRIGGER IF NOT EXISTS messages_ad AFTER DELETE ON messages BEGIN - INSERT INTO messages_fts(messages_fts, rowid, sender, text) VALUES('delete', old.id, old.sender, old.text); -END; -CREATE TRIGGER IF NOT EXISTS messages_au AFTER UPDATE ON messages BEGIN - INSERT INTO messages_fts(messages_fts, rowid, sender, text) VALUES('delete', old.id, old.sender, old.text); - INSERT INTO messages_fts(rowid, sender, text) VALUES (new.id, new.sender, new.text); -END; - -CREATE TABLE IF NOT EXISTS turns ( - turn_id TEXT PRIMARY KEY, - session_id TEXT NOT NULL, - source_id TEXT NOT NULL DEFAULT '', - status TEXT NOT NULL, - attempt INTEGER NOT NULL DEFAULT 0, - owner_id TEXT NOT NULL DEFAULT '', - input_message_id TEXT NOT NULL DEFAULT '', - assistant_message_id TEXT NOT NULL DEFAULT '', - partial_text TEXT NOT NULL DEFAULT '', - response_text TEXT NOT NULL DEFAULT '', - tool_calls TEXT NOT NULL DEFAULT '[]', - error TEXT NOT NULL DEFAULT '', - created_at INTEGER NOT NULL, - updated_at INTEGER NOT NULL -); -CREATE INDEX IF NOT EXISTS idx_turns_session_source ON turns(session_id, source_id); -CREATE INDEX IF NOT EXISTS idx_turns_status_updated ON turns(status, updated_at); -` - -// OpenSQLiteSessionStore opens (creating if needed) a SQLite-backed -// SessionStore. -func OpenSQLiteSessionStore(path string) (SessionStore, error) { - if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil { - return nil, fmt.Errorf("sessionstore: mkdir: %w", err) - } - return openSQLiteSessionStore(sqliteSessionDSN(path)) -} - -func sqliteSessionDSN(path string) string { - separator := "?" - if strings.HasSuffix(path, "?") || strings.HasSuffix(path, "&") { - separator = "" - } else if strings.Contains(path, "?") { - separator = "&" - } - return path + separator + "_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)" -} - -// NewSQLiteSessionStoreMemory returns an in-memory SQLite SessionStore for -// tests. -func NewSQLiteSessionStoreMemory() (SessionStore, error) { - return openSQLiteSessionStore(":memory:") -} - -func openSQLiteSessionStore(dsn string) (SessionStore, error) { - db, err := sql.Open("sqlite", dsn) - if err != nil { - return nil, fmt.Errorf("sessionstore: open: %w", err) - } - // A second connection to an in-memory database is a distinct, empty - // database under modernc.org/sqlite, and even for the file-backed case - // this store's own mutex already serializes every operation -- so a - // pool beyond one connection buys nothing and risks the memory-mode - // footgun. Pin it to one. - db.SetMaxOpenConns(1) - - ctx := context.Background() - if _, err := db.ExecContext(ctx, sqliteSessionSchema); err != nil { - return nil, errors.Join(fmt.Errorf("sessionstore: init schema: %w", err), db.Close()) - } - // A database created before tool_calls existed has a turns table without - // it; CREATE TABLE IF NOT EXISTS above leaves an existing table alone, so - // the column is added here. The duplicate-column error is the documented - // way to detect "already migrated" with this driver -- there is no - // IF NOT EXISTS clause for ADD COLUMN. - if _, err := db.ExecContext(ctx, `ALTER TABLE turns ADD COLUMN tool_calls TEXT NOT NULL DEFAULT '[]'`); err != nil && - !strings.Contains(err.Error(), "duplicate column name") { - return nil, errors.Join(fmt.Errorf("sessionstore: migrate turns table: %w", err), db.Close()) - } - // A database created before the messaging migration has a messages - // table without the role column; CREATE TABLE IF NOT EXISTS above - // leaves an existing table alone, so the column is added here, with - // the same duplicate-column detection as the turns migration. - if _, err := db.ExecContext(ctx, `ALTER TABLE messages ADD COLUMN role TEXT NOT NULL DEFAULT ''`); err != nil && - !strings.Contains(err.Error(), "duplicate column name") { - return nil, errors.Join(fmt.Errorf("sessionstore: migrate messages table: %w", err), db.Close()) - } - // A database created before sender ids were persisted has a messages - // table without the sender_id column; same duplicate-column detection. - if _, err := db.ExecContext(ctx, `ALTER TABLE messages ADD COLUMN sender_id TEXT NOT NULL DEFAULT ''`); err != nil && - !strings.Contains(err.Error(), "duplicate column name") { - return nil, errors.Join(fmt.Errorf("sessionstore: migrate messages sender_id: %w", err), db.Close()) - } - // Backfill the role for rows written before it was persisted, using - // the same sender-equality the store boundary applies to new writes: - // a message sent by its session's bot identity is the assistant's. - if _, err := db.ExecContext(ctx, ` - UPDATE messages SET role = CASE - WHEN sender = (SELECT bot_user FROM sessions WHERE sessions.session_id = messages.session_id) - THEN 'assistant' ELSE 'user' - END WHERE role = ''`); err != nil { - return nil, errors.Join(fmt.Errorf("sessionstore: backfill message roles: %w", err), db.Close()) - } - if err := repairFutureMessageTimestamps(ctx, db, time.Now().UTC()); err != nil { - return nil, errors.Join(err, db.Close()) - } - return &sqliteSessionStore{db: db}, nil -} - -// repairFutureMessageTimestamps heals sessions poisoned by older versions -// that accepted a platform timestamp arbitrarily far ahead of the daemon's -// clock. Future rows retain their order and are rebased immediately after the -// session's last non-future row. With no earlier row, they end at now. A dense -// history can finish a few milliseconds beyond now, but never preserves the -// original hours- or days-long skew. -func repairFutureMessageTimestamps(ctx context.Context, db *sql.DB, now time.Time) error { - cutoff := now.UnixMilli() - _, err := db.ExecContext(ctx, ` - WITH future AS MATERIALIZED ( - SELECT m.id, - COALESCE( - (SELECT MAX(p.ts) FROM messages p - WHERE p.session_id = m.session_id AND p.ts <= ?), - ? - COUNT(*) OVER (PARTITION BY m.session_id) - ) + ROW_NUMBER() OVER ( - PARTITION BY m.session_id ORDER BY m.ts, m.id - ) AS repaired_ts - FROM messages m - WHERE m.ts > ? - ) - UPDATE messages - SET ts = (SELECT repaired_ts FROM future WHERE future.id = messages.id) - WHERE id IN (SELECT id FROM future) AND ts > ?`, - cutoff, cutoff, cutoff, cutoff) - if err != nil { - return fmt.Errorf("sessionstore: repair future message timestamps: %w", err) - } - return nil -} - -func (s *sqliteSessionStore) Close() error { - return s.db.Close() -} - -func (s *sqliteSessionStore) ClaimTurn(ctx context.Context, initial TurnRecord) (TurnRecord, TurnClaim, error) { - initial, initialToolCalls, err := prepareInitialTurn(initial, time.Now().UTC()) - if err != nil { - return TurnRecord{}, "", err - } - s.mu.Lock() - defer s.mu.Unlock() - - tx, err := s.db.BeginTx(ctx, nil) - if err != nil { - return TurnRecord{}, "", fmt.Errorf("sessionstore: claim turn: begin: %w", err) - } - defer func() { _ = tx.Rollback() }() - - // Claim by writing first. Under WAL, a transaction that reads and then - // upgrades to a writer can fail immediately with SQLITE_BUSY_SNAPSHOT; - // busy_timeout only waits for ordinary writer contention. INSERT ... ON - // CONFLICT acquires writer intent before any snapshot read, so concurrent - // claimers wait normally and the loser can inspect the committed turn. - inserted, err := insertInitialTurn(ctx, tx, initial, initialToolCalls) - if err != nil { - return TurnRecord{}, "", err - } - if inserted { - if err := tx.Commit(); err != nil { - return TurnRecord{}, "", fmt.Errorf("sessionstore: claim turn: commit: %w", err) - } - return initial, TurnClaimOwned, nil - } - - var turn TurnRecord - var createdMS, updatedMS int64 - var toolCallsRaw string - err = tx.QueryRowContext(ctx, ` - SELECT turn_id, session_id, source_id, status, attempt, owner_id, - input_message_id, assistant_message_id, partial_text, - response_text, tool_calls, error, created_at, updated_at - FROM turns WHERE turn_id = ?`, initial.TurnID).Scan( - &turn.TurnID, &turn.SessionID, &turn.SourceID, &turn.Status, &turn.Attempt, &turn.OwnerID, - &turn.InputMessageID, &turn.AssistantMessageID, &turn.PartialText, - &turn.ResponseText, &toolCallsRaw, &turn.Error, &createdMS, &updatedMS, - ) - if err != nil { - return TurnRecord{}, "", fmt.Errorf("sessionstore: read turn: %w", err) - } - turn.CreatedAt = time.UnixMilli(createdMS).UTC() - turn.UpdatedAt = time.UnixMilli(updatedMS).UTC() - if turn.ToolCalls, err = unmarshalToolCalls(toolCallsRaw); err != nil { - return TurnRecord{}, "", err - } - return claimExistingTurn(ctx, tx, turn, initial) -} - -func claimExistingTurn(ctx context.Context, tx *sql.Tx, turn, initial TurnRecord) (TurnRecord, TurnClaim, error) { - switch turn.Status { - case TurnStatusCompleted: - return turn, TurnClaimCompleted, nil - case TurnStatusAccepted, TurnStatusRunning, TurnStatusPartial: - return turn, TurnClaimInProgress, nil - case TurnStatusFailed, TurnStatusCancelled: - if turn.AssistantMessageID != "" { - result, err := tx.ExecContext(ctx, ` - UPDATE turns SET status = ?, error = ?, updated_at = ? - WHERE turn_id = ? AND attempt = ? AND owner_id = ?`, string(TurnStatusCompleted), "", - time.Now().UTC().UnixMilli(), turn.TurnID, turn.Attempt, turn.OwnerID) - if err != nil { - return TurnRecord{}, "", fmt.Errorf("sessionstore: finalize turn: %w", err) - } - if affected, err := result.RowsAffected(); err != nil || affected != 1 { - return TurnRecord{}, "", fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID) - } - if err := tx.Commit(); err != nil { - return TurnRecord{}, "", fmt.Errorf("sessionstore: finalize turn: commit: %w", err) - } - turn.Status = TurnStatusCompleted - turn.Error = "" - return turn, TurnClaimCompleted, nil - } - oldOwner, oldAttempt := turn.OwnerID, turn.Attempt - turn.Status = TurnStatusRunning - turn.Attempt++ - turn.OwnerID = initial.OwnerID - turn.Error = "" - turn.UpdatedAt = time.Now().UTC() - result, err := tx.ExecContext(ctx, ` - UPDATE turns SET status = ?, attempt = ?, owner_id = ?, error = ?, updated_at = ? - WHERE turn_id = ? AND attempt = ? AND owner_id = ?`, string(turn.Status), turn.Attempt, turn.OwnerID, turn.Error, - turn.UpdatedAt.UnixMilli(), turn.TurnID, oldAttempt, oldOwner) - if err != nil { - return TurnRecord{}, "", fmt.Errorf("sessionstore: retry turn: %w", err) - } - if affected, err := result.RowsAffected(); err != nil || affected != 1 { - return TurnRecord{}, "", fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID) - } - if err := tx.Commit(); err != nil { - return TurnRecord{}, "", fmt.Errorf("sessionstore: retry turn: commit: %w", err) - } - return turn, TurnClaimOwned, nil - default: - return turn, TurnClaimInProgress, nil - } -} - -func insertInitialTurn(ctx context.Context, tx *sql.Tx, initial TurnRecord, toolCalls string) (bool, error) { - result, err := tx.ExecContext(ctx, ` - INSERT INTO turns ( - turn_id, session_id, source_id, status, attempt, owner_id, - input_message_id, assistant_message_id, partial_text, - response_text, tool_calls, error, created_at, updated_at - ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) - ON CONFLICT(turn_id) DO NOTHING`, turnValues(initial, toolCalls)...) - if err != nil { - return false, fmt.Errorf("sessionstore: claim turn: insert: %w", err) - } - affected, err := result.RowsAffected() - if err != nil { - return false, fmt.Errorf("sessionstore: claim turn: rows affected: %w", err) - } - return affected == 1, nil -} - -func prepareInitialTurn(initial TurnRecord, now time.Time) (TurnRecord, string, error) { - if initial.TurnID == "" { - return TurnRecord{}, "", fmt.Errorf("sessionstore: turn ID is required") - } - initial.Status = TurnStatusRunning - initial.Attempt = 1 - if initial.CreatedAt.IsZero() { - initial.CreatedAt = now - } - initial.UpdatedAt = now - toolCalls, err := marshalToolCalls(initial.ToolCalls) - return initial, toolCalls, err -} - -func (s *sqliteSessionStore) RecoverTurns(ctx context.Context, ownerID string) error { - if ownerID == "" { - return fmt.Errorf("sessionstore: recovery owner ID is required") - } - s.mu.Lock() - defer s.mu.Unlock() - _, err := s.db.ExecContext(ctx, ` - UPDATE turns - SET status = ?, error = ?, updated_at = ? - WHERE status IN (?, ?, ?) AND owner_id <> ?`, - string(TurnStatusFailed), "recovered after process restart", time.Now().UTC().UnixMilli(), - string(TurnStatusAccepted), string(TurnStatusRunning), string(TurnStatusPartial), ownerID) - if err != nil { - return fmt.Errorf("sessionstore: recover turns: %w", err) - } - return nil -} - -func (s *sqliteSessionStore) GetTurn(ctx context.Context, turnID string) (TurnRecord, bool, error) { - if turnID == "" { - return TurnRecord{}, false, nil - } - s.mu.Lock() - defer s.mu.Unlock() - var turn TurnRecord - var createdMS, updatedMS int64 - var toolCallsRaw string - err := s.db.QueryRowContext(ctx, ` - SELECT turn_id, session_id, source_id, status, attempt, owner_id, - input_message_id, assistant_message_id, partial_text, - response_text, tool_calls, error, created_at, updated_at - FROM turns WHERE turn_id = ?`, turnID).Scan( - &turn.TurnID, &turn.SessionID, &turn.SourceID, &turn.Status, &turn.Attempt, &turn.OwnerID, - &turn.InputMessageID, &turn.AssistantMessageID, &turn.PartialText, - &turn.ResponseText, &toolCallsRaw, &turn.Error, &createdMS, &updatedMS, - ) - if errors.Is(err, sql.ErrNoRows) { - return TurnRecord{}, false, nil - } - if err != nil { - return TurnRecord{}, false, fmt.Errorf("sessionstore: get turn: %w", err) - } - turn.CreatedAt = time.UnixMilli(createdMS).UTC() - turn.UpdatedAt = time.UnixMilli(updatedMS).UTC() - if turn.ToolCalls, err = unmarshalToolCalls(toolCallsRaw); err != nil { - return TurnRecord{}, false, err - } - return turn, true, nil -} - -func (s *sqliteSessionStore) RecentTurns(ctx context.Context, sessionID string, n int) ([]TurnRecord, error) { - if n <= 0 { - return []TurnRecord{}, nil - } - if n > 500 { - n = 500 - } - s.mu.Lock() - defer s.mu.Unlock() - rows, err := s.db.QueryContext(ctx, ` - SELECT turn_id, session_id, source_id, status, attempt, owner_id, - input_message_id, assistant_message_id, partial_text, - response_text, tool_calls, error, created_at, updated_at - FROM turns WHERE session_id = ? ORDER BY created_at DESC LIMIT ?`, sessionID, n) - if err != nil { - return nil, fmt.Errorf("sessionstore: recent turns: %w", err) - } - defer func() { _ = rows.Close() }() - turns := make([]TurnRecord, 0) - for rows.Next() { - var turn TurnRecord - var createdMS, updatedMS int64 - var raw string - if err := rows.Scan(&turn.TurnID, &turn.SessionID, &turn.SourceID, &turn.Status, &turn.Attempt, &turn.OwnerID, - &turn.InputMessageID, &turn.AssistantMessageID, &turn.PartialText, &turn.ResponseText, &raw, &turn.Error, - &createdMS, &updatedMS); err != nil { - return nil, fmt.Errorf("sessionstore: scan recent turn: %w", err) - } - turn.CreatedAt = time.UnixMilli(createdMS).UTC() - turn.UpdatedAt = time.UnixMilli(updatedMS).UTC() - if turn.ToolCalls, err = unmarshalToolCalls(raw); err != nil { - return nil, err - } - turns = append(turns, turn) - } - if err := rows.Err(); err != nil { - return nil, fmt.Errorf("sessionstore: recent turns: %w", err) - } - for left, right := 0, len(turns)-1; left < right; left, right = left+1, right-1 { - turns[left], turns[right] = turns[right], turns[left] - } - return turns, nil -} - -func (s *sqliteSessionStore) SaveTurn(ctx context.Context, turn TurnRecord) error { - if turn.TurnID == "" { - return fmt.Errorf("sessionstore: turn ID is required") - } - s.mu.Lock() - defer s.mu.Unlock() - var currentAttempt int - var currentOwner string - if err := s.db.QueryRowContext(ctx, - `SELECT attempt, owner_id FROM turns WHERE turn_id = ?`, turn.TurnID). - Scan(¤tAttempt, ¤tOwner); errors.Is(err, sql.ErrNoRows) { - return fmt.Errorf("sessionstore: save turn: turn not found") - } else if err != nil { - return fmt.Errorf("sessionstore: save turn: read: %w", err) - } - if currentAttempt != turn.Attempt || currentOwner != turn.OwnerID { - return fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID) - } - if turn.UpdatedAt.IsZero() { - turn.UpdatedAt = time.Now().UTC() - } - toolCallsJSON, err := marshalToolCalls(turn.ToolCalls) - if err != nil { - return err - } - result, err := s.db.ExecContext(ctx, ` - UPDATE turns SET - session_id = ?, source_id = ?, status = ?, attempt = ?, owner_id = ?, - input_message_id = ?, assistant_message_id = ?, partial_text = ?, - response_text = ?, tool_calls = ?, error = ?, created_at = ?, updated_at = ? - WHERE turn_id = ? AND attempt = ? AND owner_id = ?`, - turn.SessionID, turn.SourceID, string(turn.Status), turn.Attempt, turn.OwnerID, - turn.InputMessageID, turn.AssistantMessageID, turn.PartialText, - turn.ResponseText, toolCallsJSON, turn.Error, turn.CreatedAt.UnixMilli(), turn.UpdatedAt.UnixMilli(), - turn.TurnID, turn.Attempt, turn.OwnerID) - if err != nil { - return fmt.Errorf("sessionstore: save turn: %w", err) - } - if affected, err := result.RowsAffected(); err != nil { - return fmt.Errorf("sessionstore: save turn: rows affected: %w", err) - } else if affected != 1 { - return fmt.Errorf("%w: %s", ErrTurnOwnershipLost, turn.TurnID) - } - return nil -} - -func (s *sqliteSessionStore) ListRecoverableTurns(ctx context.Context) ([]TurnRecord, error) { - s.mu.Lock() - defer s.mu.Unlock() - rows, err := s.db.QueryContext(ctx, ` - SELECT turn_id, session_id, source_id, status, attempt, owner_id, - input_message_id, assistant_message_id, partial_text, - response_text, tool_calls, error, created_at, updated_at - FROM turns WHERE status IN (?, ?, ?) ORDER BY updated_at ASC`, - string(TurnStatusAccepted), string(TurnStatusRunning), string(TurnStatusPartial)) - if err != nil { - return nil, fmt.Errorf("sessionstore: list recoverable turns: %w", err) - } - defer func() { _ = rows.Close() }() - var out []TurnRecord - for rows.Next() { - var turn TurnRecord - var createdMS, updatedMS int64 - var toolCallsRaw string - if err := rows.Scan( - &turn.TurnID, &turn.SessionID, &turn.SourceID, &turn.Status, &turn.Attempt, &turn.OwnerID, - &turn.InputMessageID, &turn.AssistantMessageID, &turn.PartialText, - &turn.ResponseText, &toolCallsRaw, &turn.Error, &createdMS, &updatedMS, - ); err != nil { - return nil, fmt.Errorf("sessionstore: scan recoverable turn: %w", err) - } - turn.CreatedAt = time.UnixMilli(createdMS).UTC() - turn.UpdatedAt = time.UnixMilli(updatedMS).UTC() - if turn.ToolCalls, err = unmarshalToolCalls(toolCallsRaw); err != nil { - return nil, err - } - out = append(out, turn) - } - if err := rows.Err(); err != nil { - return nil, fmt.Errorf("sessionstore: list recoverable turns: %w", err) - } - return out, nil -} - -func turnValues(turn TurnRecord, toolCallsJSON string) []any { - return []any{ - turn.TurnID, turn.SessionID, turn.SourceID, string(turn.Status), turn.Attempt, turn.OwnerID, - turn.InputMessageID, turn.AssistantMessageID, turn.PartialText, - turn.ResponseText, toolCallsJSON, turn.Error, turn.CreatedAt.UnixMilli(), turn.UpdatedAt.UnixMilli(), - } -} - -// marshalToolCalls encodes a turn's recorded tool activity for storage. An -// empty slice becomes "[]" rather than SQL NULL or the JSON "null" so an -// unmigrated-looking row (the column's own DEFAULT) and a turn that recorded -// no tool calls are indistinguishable in the database, and both round-trip -// through unmarshalToolCalls to a nil slice. -func marshalToolCalls(events []ToolCallEvent) (string, error) { - if len(events) == 0 { - return "[]", nil - } - encoded, err := json.Marshal(events) - if err != nil { - return "", fmt.Errorf("sessionstore: marshal tool calls: %w", err) - } - return string(encoded), nil -} - -// unmarshalToolCalls decodes tool activity persisted by marshalToolCalls. -func unmarshalToolCalls(raw string) ([]ToolCallEvent, error) { - if raw == "" || raw == "[]" { - return nil, nil - } - var events []ToolCallEvent - if err := json.Unmarshal([]byte(raw), &events); err != nil { - return nil, fmt.Errorf("sessionstore: unmarshal tool calls: %w", err) - } - return events, nil -} - -// ── Sessions ──────────────────────────────────────────────────────────────── - -func (s *sqliteSessionStore) Save(ctx context.Context, sc SessionContext) error { - s.mu.Lock() - defer s.mu.Unlock() - - _, err := s.db.ExecContext(ctx, ` - INSERT INTO sessions (session_id, platform, bot_user, channel_id, thread_id, - title, parent_session_id, branch_name, created_at, last_active_at) - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) - ON CONFLICT(session_id) DO UPDATE SET - platform = excluded.platform, - bot_user = excluded.bot_user, - channel_id = excluded.channel_id, - thread_id = excluded.thread_id, - title = excluded.title, - parent_session_id = excluded.parent_session_id, - branch_name = excluded.branch_name, - created_at = excluded.created_at, - last_active_at = excluded.last_active_at`, - sc.SessionID, sc.Source.Platform, sc.Source.BotUser, sc.Source.ChannelID, sc.Source.ThreadID, - sc.Title, sc.ParentSessionID, sc.BranchName, sc.CreatedAt.UnixMilli(), sc.LastActiveAt.UnixMilli()) - if err != nil { - return fmt.Errorf("sessionstore: save: %w", err) - } - return nil -} - -func (s *sqliteSessionStore) Get(ctx context.Context, sessionID string) (*SessionContext, error) { - row := s.db.QueryRowContext(ctx, sessionSelect+` WHERE session_id = ?`, sessionID) - sc, err := scanSession(row) - if errors.Is(err, sql.ErrNoRows) { - return nil, nil - } - if err != nil { - return nil, fmt.Errorf("sessionstore: get: %w", err) - } - return sc, nil -} - -func (s *sqliteSessionStore) GetByChannel(ctx context.Context, platform, channelID string) ([]SessionContext, error) { - rows, err := s.db.QueryContext(ctx, - sessionSelect+` WHERE platform = ? AND channel_id = ? ORDER BY `+sessionRecencySQL+` DESC`, - platform, channelID) - if err != nil { - return nil, fmt.Errorf("sessionstore: get by channel: %w", err) - } - return scanSessions(rows) -} - -func (s *sqliteSessionStore) Delete(ctx context.Context, sessionID string) error { - s.mu.Lock() - defer s.mu.Unlock() - - tx, err := s.db.BeginTx(ctx, nil) - if err != nil { - return fmt.Errorf("sessionstore: delete: begin: %w", err) - } - defer func() { _ = tx.Rollback() }() - - if _, err := tx.ExecContext(ctx, `DELETE FROM messages WHERE session_id = ?`, sessionID); err != nil { - return fmt.Errorf("sessionstore: delete messages: %w", err) - } - if _, err := tx.ExecContext(ctx, `DELETE FROM turns WHERE session_id = ?`, sessionID); err != nil { - return fmt.Errorf("sessionstore: delete turns: %w", err) - } - if _, err := tx.ExecContext(ctx, `DELETE FROM sessions WHERE session_id = ?`, sessionID); err != nil { - return fmt.Errorf("sessionstore: delete session: %w", err) - } - if err := tx.Commit(); err != nil { - return fmt.Errorf("sessionstore: delete: commit: %w", err) - } - return nil -} - -func (s *sqliteSessionStore) Touch(ctx context.Context, sessionID string) error { - s.mu.Lock() - defer s.mu.Unlock() - - _, err := s.db.ExecContext(ctx, - `UPDATE sessions SET last_active_at = ? WHERE session_id = ?`, - time.Now().UTC().UnixMilli(), sessionID) - if err != nil { - return fmt.Errorf("sessionstore: touch: %w", err) - } - return nil -} - -func (s *sqliteSessionStore) List(ctx context.Context) ([]SessionContext, error) { - rows, err := s.db.QueryContext(ctx, sessionSelect+` ORDER BY `+sessionRecencySQL+` DESC`) - if err != nil { - return nil, fmt.Errorf("sessionstore: list: %w", err) - } - return scanSessions(rows) -} - -// sessionRecencySQL is a session's recency: LastActiveAt when it has been -// set, CreatedAt otherwise. -const sessionRecencySQL = `MAX(last_active_at, created_at)` - -const sessionSelect = ` - SELECT session_id, platform, bot_user, channel_id, thread_id, - title, parent_session_id, branch_name, created_at, last_active_at - FROM sessions` - -// rowScanner is satisfied by both *sql.Row and *sql.Rows, letting scanSession -// serve single-row and multi-row queries alike. -type rowScanner interface { - Scan(dest ...any) error -} - -func scanSession(row rowScanner) (*SessionContext, error) { - var ( - sc SessionContext - createdAt, lastActive int64 - ) - err := row.Scan(&sc.SessionID, &sc.Source.Platform, &sc.Source.BotUser, &sc.Source.ChannelID, - &sc.Source.ThreadID, &sc.Title, &sc.ParentSessionID, &sc.BranchName, &createdAt, &lastActive) - if err != nil { - return nil, err - } - sc.CreatedAt = time.UnixMilli(createdAt).UTC() - sc.LastActiveAt = time.UnixMilli(lastActive).UTC() - return &sc, nil -} - -func scanSessions(rows *sql.Rows) ([]SessionContext, error) { - defer func() { _ = rows.Close() }() - var out []SessionContext - for rows.Next() { - sc, err := scanSession(rows) - if err != nil { - return nil, fmt.Errorf("sessionstore: scan session: %w", err) - } - out = append(out, *sc) - } - if err := rows.Err(); err != nil { - return nil, fmt.Errorf("sessionstore: scan sessions: %w", err) - } - return out, nil -} - -// ── Messages ───────────────────────────────────────────────────────────────── - -// execer is satisfied by both *sql.DB and *sql.Tx, so message-writing -// helpers work identically for a single-statement call (SaveMessage) and a -// multi-statement transaction (SaveMessages, ReplaceMessages). -type execer interface { - ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) - QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row -} - -func (s *sqliteSessionStore) SaveMessage(ctx context.Context, sessionID string, msg messaging.Message) error { - s.mu.Lock() - defer s.mu.Unlock() - _, err := saveMessage(ctx, s.db, sessionID, msg) - return err -} - -// saveMessage persists one message and reports the canonical ID it was -// stored under (or was already stored under, for a redelivered message). -// -// A message carrying a canonical ID keeps it -- re-saving history read back -// must not mint a new identity. An existing record with that ID is left -// untouched: stored messages are immutable, so a redelivered edit is a -// no-op rather than an overwrite. -func saveMessage(ctx context.Context, ex execer, sessionID string, msg messaging.Message) (string, error) { - return saveMessageAt(ctx, ex, sessionID, msg, true) -} - -// saveMessageAt writes a message, optionally without the monotonic clamp. -// The clamp belongs to the append path, not to a caller rewriting history and -// placing records deliberately. -func saveMessageAt(ctx context.Context, ex execer, sessionID string, msg messaging.Message, clamp bool) (string, error) { - id := string(msg.ID) - legacyID := "" - if msg.SourceID == "" { - if id == "" { - id = newMessageID(sessionID, "") - } - } else { - currentID, compatibleLegacyID := canonicalMessageIDs(sessionID, msg.SourceID) - if id == "" { - id = currentID - } - // TurnRunner supplies the current canonical ID before calling the - // store. Still check the compatible legacy identity: a crash can - // leave the old message durable before its turn record names it. - if id == currentID { - legacyID = compatibleLegacyID - } - } - // An empty Role means "user": producers set RoleAssistant explicitly - // (see TurnRunner.generateAndComplete), and pre-migration rows are - // backfilled at open, so only a hand-built record arrives without one. - role := string(msg.Role) - if role == "" { - role = string(messaging.RoleUser) - } - if legacyID != "" { - var existingID string - err := ex.QueryRowContext(ctx, - `SELECT message_id FROM messages WHERE session_id = ? AND message_id = ?`, - sessionID, legacyID).Scan(&existingID) - switch { - case err == nil: - return existingID, nil - case !errors.Is(err, sql.ErrNoRows): - return "", fmt.Errorf("sessionstore: read legacy message identity: %w", err) - } - } - at := stamp(msg) - if clamp { - _, err := ex.ExecContext(ctx, ` - INSERT INTO messages (message_id, session_id, source_id, sender, sender_id, role, text, ts) - VALUES (?, ?, ?, ?, ?, ?, ?, ( - SELECT CASE - WHEN MAX(ts) IS NOT NULL AND MAX(ts) >= ? THEN MAX(ts) + 1 - ELSE ? - END - FROM messages WHERE session_id = ? - )) - ON CONFLICT(session_id, message_id) DO NOTHING`, - id, sessionID, msg.SourceID, msg.Sender, msg.SenderID, role, msg.Text, - at.UnixMilli(), at.UnixMilli(), sessionID) - if err != nil { - return "", fmt.Errorf("sessionstore: save message: %w", err) - } - return id, nil - } - - var exists int - err := ex.QueryRowContext(ctx, - `SELECT 1 FROM messages WHERE session_id = ? AND message_id = ?`, sessionID, id).Scan(&exists) - switch { - case err == nil: - return id, nil - case !errors.Is(err, sql.ErrNoRows): - return "", fmt.Errorf("sessionstore: read existing message: %w", err) - } - - _, err = ex.ExecContext(ctx, ` - INSERT INTO messages (message_id, session_id, source_id, sender, sender_id, role, text, ts) - VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, - id, sessionID, msg.SourceID, msg.Sender, msg.SenderID, role, msg.Text, at.UnixMilli()) - if err != nil { - return "", fmt.Errorf("sessionstore: save message: %w", err) - } - return id, nil -} - -func (s *sqliteSessionStore) SaveMessages(ctx context.Context, sessionID string, msgs []messaging.Message) error { - s.mu.Lock() - defer s.mu.Unlock() - - tx, err := s.db.BeginTx(ctx, nil) - if err != nil { - return fmt.Errorf("sessionstore: save messages: begin: %w", err) - } - defer func() { _ = tx.Rollback() }() - - // Each message gets its own time-ordered ID, so a bulk save appends to - // whatever the session already holds instead of overwriting from zero. - for _, msg := range msgs { - if _, err := saveMessage(ctx, tx, sessionID, msg); err != nil { - return fmt.Errorf("sessionstore: save messages: %w", err) - } - } - if err := tx.Commit(); err != nil { - return fmt.Errorf("sessionstore: save messages: commit: %w", err) - } - return nil -} - -// ReplaceMessages writes msgs and removes exactly the messages named by -// superseded, atomically: both happen inside one transaction, so a caller -// either sees the old history or the new one, never an in-between state. -// -// Only the named messages are removed. Deleting the complement of msgs swept -// up anything saved since the caller read the history -- a chat turn arriving -// mid-compression was destroyed without ever being read. -// -// A replacement message that carries a canonical ID lands on the same row it -// already occupied (saveMessage's immutability no-op), so an ID in both lists -// is kept. -func (s *sqliteSessionStore) ReplaceMessages( - ctx context.Context, - sessionID string, - msgs []messaging.Message, - superseded []string, -) error { - s.mu.Lock() - defer s.mu.Unlock() - - tx, err := s.db.BeginTx(ctx, nil) - if err != nil { - return fmt.Errorf("sessionstore: replace messages: begin: %w", err) - } - defer func() { _ = tx.Rollback() }() - - survivors := make(map[string]struct{}, len(msgs)) - for _, msg := range msgs { - // No clamp: the caller has already decided where each record belongs. - id, err := saveMessageAt(ctx, tx, sessionID, msg, false) - if err != nil { - return fmt.Errorf("sessionstore: replace messages: %w", err) - } - survivors[id] = struct{}{} - } - - doomed := make([]any, 0, len(superseded)) - for _, id := range superseded { - if _, kept := survivors[id]; kept { - continue - } - doomed = append(doomed, id) - } - if len(doomed) > 0 { - placeholders := strings.TrimSuffix(strings.Repeat("?,", len(doomed)), ",") - query := `DELETE FROM messages WHERE session_id = ? AND message_id IN (` + placeholders + `)` - args := append([]any{sessionID}, doomed...) - if _, err := tx.ExecContext(ctx, query, args...); err != nil { - return fmt.Errorf("sessionstore: replace messages: delete old: %w", err) - } - } - - if err := tx.Commit(); err != nil { - return fmt.Errorf("sessionstore: replace messages: commit: %w", err) - } - return nil -} - -func (s *sqliteSessionStore) FindPriorReply(ctx context.Context, sessionID, sourceID, identity string) (string, error) { - if sourceID == "" { - return "", nil - } - s.mu.Lock() - defer s.mu.Unlock() - - currentID, legacyID := canonicalMessageIDs(sessionID, sourceID) - var ts int64 - err := s.db.QueryRowContext(ctx, ` - SELECT ts FROM messages - WHERE session_id = ? AND message_id IN (?, ?) - ORDER BY CASE WHEN message_id = ? THEN 0 ELSE 1 END - LIMIT 1`, sessionID, currentID, legacyID, legacyID).Scan(&ts) - if errors.Is(err, sql.ErrNoRows) { - return "", nil - } - if err != nil { - return "", fmt.Errorf("sessionstore: find source message: %w", err) - } - var sender, text string - err = s.db.QueryRowContext(ctx, ` - SELECT sender, text FROM messages - WHERE session_id = ? AND ts > ? ORDER BY ts ASC LIMIT 1`, sessionID, ts). - Scan(&sender, &text) - if errors.Is(err, sql.ErrNoRows) { - return "", nil - } - if err != nil { - return "", fmt.Errorf("sessionstore: find prior reply: %w", err) - } - if sender != identity || isCompressionSummary(text) { - return "", nil - } - return text, nil -} - -func (s *sqliteSessionStore) RecentMessages(ctx context.Context, sessionID string, n int) ([]messaging.Message, error) { - if n <= 0 { - return nil, nil - } - // The conversation address is resolved from the owning session, not - // stored per message: a LEFT JOIN keeps orphaned rows readable exactly - // as before, with an empty address. - rows, err := s.db.QueryContext(ctx, ` - SELECT m.message_id, m.source_id, m.sender, m.sender_id, m.role, m.text, m.ts, - COALESCE(s.channel_id, ''), COALESCE(s.thread_id, '') - FROM ( - SELECT message_id, source_id, sender, sender_id, role, text, ts, session_id FROM messages - WHERE session_id = ? ORDER BY ts DESC LIMIT ? - ) m LEFT JOIN sessions s ON s.session_id = m.session_id - ORDER BY m.ts ASC`, sessionID, n) - if err != nil { - return nil, fmt.Errorf("sessionstore: recent messages: %w", err) - } - return scanMessages(rows) -} - -func (s *sqliteSessionStore) DeleteRecentMessages(ctx context.Context, sessionID string, n int) (int, error) { - s.mu.Lock() - defer s.mu.Unlock() - if n <= 0 { - return 0, nil - } - - res, err := s.db.ExecContext(ctx, ` - DELETE FROM messages WHERE id IN ( - SELECT id FROM messages WHERE session_id = ? ORDER BY ts DESC LIMIT ? - )`, sessionID, n) - if err != nil { - return 0, fmt.Errorf("sessionstore: delete recent messages: %w", err) - } - deleted, err := res.RowsAffected() - if err != nil { - return 0, fmt.Errorf("sessionstore: delete recent messages: rows affected: %w", err) - } - return int(deleted), nil -} - -func (s *sqliteSessionStore) MessageCount(ctx context.Context, sessionID string) (int, error) { - var n int - err := s.db.QueryRowContext(ctx, - `SELECT COUNT(*) FROM messages WHERE session_id = ?`, sessionID).Scan(&n) - if err != nil { - return 0, fmt.Errorf("sessionstore: message count: %w", err) - } - return n, nil -} - -// scanMessages scans rows shaped (message_id, source_id, sender, sender_id, -// role, text, ts, channel_id, thread_id). Both the history reads and -// SearchMessages select that column order, so they share one scanner. -func scanMessages(rows *sql.Rows) ([]messaging.Message, error) { - defer func() { _ = rows.Close() }() - var out []messaging.Message - for rows.Next() { - var ( - msg messaging.Message - id string - role string - ts int64 - ) - if err := rows.Scan(&id, &msg.SourceID, &msg.Sender, &msg.SenderID, &role, &msg.Text, &ts, - &msg.ConversationID.ChannelID, &msg.ConversationID.ThreadID); err != nil { - return nil, fmt.Errorf("sessionstore: scan message: %w", err) - } - msg.ID = messaging.MessageID(id) - msg.Role = messaging.Role(role) - msg.At = time.UnixMilli(ts).UTC() - out = append(out, msg) - } - if err := rows.Err(); err != nil { - return nil, fmt.Errorf("sessionstore: scan messages: %w", err) - } - return out, nil -} - -// SearchMessages runs an FTS5 search over the session's entire message -// history, matching message text and sender only -- ts and other metadata -// are not part of the indexed content, so a query like "2026" cannot match -// every message via its timestamp. An empty or whitespace-only query -// returns an empty page without touching the database. -// -// SQLite gives an exact total match count, so MessagePage.Truncated is always -// false. -func (s *sqliteSessionStore) SearchMessages(ctx context.Context, sessionID string, q MessageQuery) (MessagePage, error) { - query := strings.TrimSpace(q.Query) - if query == "" { - return MessagePage{}, nil - } - if len(query) > MaxMessageSearchQueryBytes { - return MessagePage{}, fmt.Errorf("sessionstore: search query exceeds %d bytes", MaxMessageSearchQueryBytes) - } - if terms := len(strings.Fields(query)); terms > MaxMessageSearchQueryTerms { - return MessagePage{}, fmt.Errorf("sessionstore: search query exceeds %d terms", MaxMessageSearchQueryTerms) - } - limit := q.Limit - if limit <= 0 { - limit = DefaultMessagePageSize - } - limit = min(limit, MaxMessagePageSize) - offset := max(q.Offset, 0) - - match := ftsMatchQuery(query) - - var total int - err := s.db.QueryRowContext(ctx, ` - SELECT COUNT(*) FROM messages_fts - JOIN messages m ON m.id = messages_fts.rowid - WHERE messages_fts MATCH ? AND m.session_id = ?`, match, sessionID).Scan(&total) - if err != nil { - return MessagePage{}, fmt.Errorf("sessionstore: search messages: count: %w", err) - } - if offset >= total { - return MessagePage{}, nil - } - - rows, err := s.db.QueryContext(ctx, ` - SELECT m.message_id, m.source_id, m.sender, m.sender_id, m.role, m.text, m.ts, - COALESCE(s.channel_id, ''), COALESCE(s.thread_id, '') - FROM messages_fts - JOIN messages m ON m.id = messages_fts.rowid - LEFT JOIN sessions s ON s.session_id = m.session_id - WHERE messages_fts MATCH ? AND m.session_id = ? - ORDER BY bm25(messages_fts) ASC - LIMIT ? OFFSET ?`, match, sessionID, limit, offset) - if err != nil { - return MessagePage{}, fmt.Errorf("sessionstore: search messages: %w", err) - } - msgs, err := scanMessages(rows) - if err != nil { - return MessagePage{}, err - } - - next := offset + len(msgs) - return MessagePage{ - Messages: msgs, - NextOffset: next, - HasMore: next < total, - Truncated: false, - }, nil -} - -// ftsMatchQuery turns free text into an FTS5 MATCH expression requiring -// every term to be present. Each term is wrapped as a quoted phrase -- -// doubling any embedded quote to escape it -- so user input can never be -// interpreted as FTS5 query syntax (column filters, NEAR, boolean -// operators); every token is a literal string to match, joined with an -// explicit AND. -func ftsMatchQuery(query string) string { - fields := strings.Fields(query) - terms := make([]string, 0, len(fields)) - for _, f := range fields { - escaped := strings.ReplaceAll(f, `"`, `""`) - terms = append(terms, `"`+escaped+`"`) - } - return strings.Join(terms, " AND ") -} diff --git a/internal/gateway/session_store_sqlite_claimturn_race_test.go b/internal/gateway/session_store_sqlite_claimturn_race_test.go deleted file mode 100644 index c26cdccd1..000000000 --- a/internal/gateway/session_store_sqlite_claimturn_race_test.go +++ /dev/null @@ -1,102 +0,0 @@ -package gateway - -import ( - "context" - "fmt" - "path/filepath" - "sync" - "testing" - "time" -) - -// TestClaimTurnConcurrentInsertRaceResolvesToOneOwner verifies that ordinary -// contention between processes sharing the session database is resolved by -// ClaimTurn itself. Callers must not need to recognize and retry SQLite's -// SQLITE_BUSY or SQLITE_BUSY_SNAPSHOT implementation details. -// -// Two invariants must hold under contention: every ClaimTurn call returns -// without error, and EXACTLY ONE of the racers ends up TurnClaimOwned while -// the other observes the committed row and returns a non-owning claim. -// The second invariant matters more than the first: a bug that returns -// TurnClaimOwned to both racers means two archied processes drive the same -// turn to completion, and the assistant reply gets emitted twice to the -// chat. The first invariant alone would not catch that. -// -// A single sqliteSessionStore instance cannot exhibit any of this: its own -// mutex serializes every ClaimTurn call against that instance's connection, -// so this uses two separate store instances (two connections, two mutexes) -// against the same file-backed database -- the real-world shape of the -// scenario (two archied/worker processes or connections sharing one session -// DB). -func TestClaimTurnConcurrentInsertRaceResolvesToOneOwner(t *testing.T) { - path := filepath.Join(t.TempDir(), "sessions.db") - - const stores = 2 - const trials = 100 - - openers := make([]TurnLedger, stores) - for i := range openers { - store, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("OpenSQLiteSessionStore[%d]: %v", i, err) - } - closer, ok := store.(interface{ Close() error }) - if !ok { - t.Fatalf("store[%d] is %T, want a Close() error", i, store) - } - t.Cleanup(func() { _ = closer.Close() }) - ledger, ok := store.(TurnLedger) - if !ok { - t.Fatalf("store[%d] is %T, want TurnLedger", i, store) - } - openers[i] = ledger - } - - ctx := context.Background() - now := time.UnixMilli(1000).UTC() - - // Each trial races the two independent stores over one turn ID, then waits - // before starting the next trial. This isolates the same-turn claim race - // from unrelated 100-way global writer contention. - for trial := range trials { - turnID := fmt.Sprintf("race-turn-%d", trial) - initial := TurnRecord{ - TurnID: turnID, - SessionID: "race-session", - SourceID: turnID, - Status: TurnStatusAccepted, - CreatedAt: now, - UpdatedAt: now, - } - errs := make([]error, stores) - claims := make([]TurnClaim, stores) - var wg sync.WaitGroup - var start sync.WaitGroup - start.Add(1) - for i := range stores { - wg.Add(1) - go func(i int) { - defer wg.Done() - start.Wait() - _, claims[i], errs[i] = openers[i].ClaimTurn(ctx, initial) - }(i) - } - start.Done() - wg.Wait() - - for i, err := range errs { - if err != nil { - t.Fatalf("trial %d, store %d: ClaimTurn() unexpected error = %v", trial, i, err) - } - } - owners := 0 - for _, c := range claims { - if c == TurnClaimOwned { - owners++ - } - } - if owners != 1 { - t.Fatalf("trial %d: expected exactly one TurnClaimOwned across %d racers, got %d (claims=%v)", trial, stores, owners, claims) - } - } -} diff --git a/internal/gateway/session_store_sqlite_conformance_test.go b/internal/gateway/session_store_sqlite_conformance_test.go deleted file mode 100644 index e0cfa8ad2..000000000 --- a/internal/gateway/session_store_sqlite_conformance_test.go +++ /dev/null @@ -1,15 +0,0 @@ -package gateway - -import "testing" - -// TestSessionStoreConformanceSQLite runs the shared SessionStore contract -// against the SQLite implementation. -func TestSessionStoreConformanceSQLite(t *testing.T) { - runSessionStoreSuite(t, func(t *testing.T) SessionStore { - s, err := NewSQLiteSessionStoreMemory() - if err != nil { - t.Fatalf("NewSQLiteSessionStoreMemory: %v", err) - } - return s - }) -} diff --git a/internal/gateway/session_store_sqlite_test.go b/internal/gateway/session_store_sqlite_test.go deleted file mode 100644 index ad8500a7c..000000000 --- a/internal/gateway/session_store_sqlite_test.go +++ /dev/null @@ -1,1365 +0,0 @@ -package gateway - -import ( - "context" - "database/sql" - "fmt" - "path/filepath" - "strings" - "sync" - "testing" - "time" - - "github.com/google/uuid" - - "github.com/samcharles93/archie-core/internal/domain/messaging" -) - -func newTestSQLiteStore(t *testing.T) SessionStore { - t.Helper() - st, err := NewSQLiteSessionStoreMemory() - if err != nil { - t.Fatalf("NewSQLiteSessionStoreMemory: %v", err) - } - t.Cleanup(func() { _ = st.Close() }) - return st -} - -func sqliteBase() time.Time { return time.Date(2026, 8, 3, 12, 0, 0, 0, time.UTC) } - -func TestSQLiteSessionStoreRecentTurnsReturnsReplayableToolHistory(t *testing.T) { - st := newTestSQLiteStore(t) - ledger, ok := st.(TurnLedger) - if !ok { - t.Fatalf("store is %T, want TurnLedger", st) - } - turn, claim, err := ledger.ClaimTurn(t.Context(), TurnRecord{ - TurnID: "turn-history", SessionID: "session-history", SourceID: "source-history", OwnerID: "owner", - ToolCalls: []ToolCallEvent{{Name: "shell", Output: "exit 0"}}, - }) - if err != nil || claim != TurnClaimOwned { - t.Fatalf("ClaimTurn() = %#v, %v, %v", turn, claim, err) - } - turn.Status = TurnStatusCompleted - turn.ResponseText = "answer" - turn.UpdatedAt = time.Now().UTC() - if err := ledger.SaveTurn(t.Context(), turn); err != nil { - t.Fatalf("SaveTurn() error = %v", err) - } - history, ok := st.(TurnHistory) - if !ok { - t.Fatalf("store is %T, want TurnHistory", st) - } - got, err := history.RecentTurns(t.Context(), "session-history", 10) - if err != nil || len(got) != 1 || len(got[0].ToolCalls) != 1 || got[0].ResponseText != "answer" { - t.Fatalf("RecentTurns() = %#v, %v; want one replayable turn", got, err) - } -} - -// TestOpenSQLiteSessionStoreMigratesPreExistingTurnsTable simulates a -// database created before the tool_calls column existed: CREATE TABLE IF NOT -// EXISTS leaves such a table alone, so opening it must add the column rather -// than fail or silently keep the old shape. -func TestOpenSQLiteSessionStoreMigratesPreExistingTurnsTable(t *testing.T) { - path := filepath.Join(t.TempDir(), "legacy.db") - raw, err := sql.Open("sqlite", sqliteSessionDSN(path)) - if err != nil { - t.Fatalf("sql.Open() error = %v", err) - } - if _, err := raw.ExecContext(t.Context(), `CREATE TABLE turns ( - turn_id TEXT PRIMARY KEY, - session_id TEXT NOT NULL, - source_id TEXT NOT NULL DEFAULT '', - status TEXT NOT NULL, - attempt INTEGER NOT NULL DEFAULT 0, - owner_id TEXT NOT NULL DEFAULT '', - input_message_id TEXT NOT NULL DEFAULT '', - assistant_message_id TEXT NOT NULL DEFAULT '', - partial_text TEXT NOT NULL DEFAULT '', - response_text TEXT NOT NULL DEFAULT '', - error TEXT NOT NULL DEFAULT '', - created_at INTEGER NOT NULL, - updated_at INTEGER NOT NULL - )`); err != nil { - t.Fatalf("create legacy turns table: %v", err) - } - if _, err := raw.ExecContext(t.Context(), `INSERT INTO turns ( - turn_id, session_id, source_id, status, attempt, owner_id, - input_message_id, assistant_message_id, partial_text, response_text, - error, created_at, updated_at - ) VALUES ('legacy-turn', 'legacy-session', 'legacy-source', 'completed', 1, 'owner', - '', 'assistant-1', '', 'legacy answer', '', 0, 0)`); err != nil { - t.Fatalf("insert legacy turn row: %v", err) - } - if err := raw.Close(); err != nil { - t.Fatalf("close legacy handle: %v", err) - } - - store, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("OpenSQLiteSessionStore() on legacy schema error = %v", err) - } - defer func() { _ = store.Close() }() - ledger, ok := store.(TurnLedger) - if !ok { - t.Fatalf("store is %T, want TurnLedger", store) - } - turn, ok, err := ledger.GetTurn(t.Context(), "legacy-turn") - if err != nil || !ok { - t.Fatalf("GetTurn() after migration = %#v, %v, %v; want the legacy row", turn, ok, err) - } - if turn.ResponseText != "legacy answer" || len(turn.ToolCalls) != 0 { - t.Fatalf("migrated turn = %#v, want legacy text with no tool calls", turn) - } - - // Reopening a second time must not fail on the "duplicate column name" - // the migration produces once the column already exists. - if err := store.Close(); err != nil { - t.Fatalf("Close() error = %v", err) - } - reopened, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("second OpenSQLiteSessionStore() error = %v", err) - } - _ = reopened.Close() -} - -func TestSQLiteSessionStoreRejectsExcessiveSearchQueries(t *testing.T) { - st := newTestSQLiteStore(t) - tests := []struct { - name string - query string - }{ - {name: "bytes", query: strings.Repeat("a", 4097)}, - {name: "terms", query: strings.Repeat("word ", 65)}, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - if _, err := st.SearchMessages(t.Context(), "sess", MessageQuery{Query: tt.query}); err == nil { - t.Fatal("SearchMessages accepted an excessive query") - } - }) - } -} - -func TestOpenSQLiteSessionStoreAppliesPragmasWithTrailingQueryDelimiter(t *testing.T) { - st, err := OpenSQLiteSessionStore(filepath.Join(t.TempDir(), "messages.db") + "?") - if err != nil { - t.Fatal(err) - } - t.Cleanup(func() { _ = st.Close() }) - sqliteStore, ok := st.(*sqliteSessionStore) - if !ok { - t.Fatalf("store type = %T, want *sqliteSessionStore", st) - } - var mode string - if err := sqliteStore.db.QueryRowContext(t.Context(), `PRAGMA journal_mode`).Scan(&mode); err != nil { - t.Fatal(err) - } - if mode != "wal" { - t.Fatalf("journal_mode = %q, want wal", mode) - } -} - -func TestSQLiteSessionStoreThreadIDRoundTrip(t *testing.T) { - st := newTestSQLiteStore(t) - want := SessionContext{ - SessionID: "sess-thread", - Source: SessionSource{ - Platform: "telegram", BotUser: "archie", ChannelID: "-100123", ThreadID: "5", - }, - CreatedAt: sqliteBase(), LastActiveAt: sqliteBase(), - } - if err := st.Save(t.Context(), want); err != nil { - t.Fatal(err) - } - got, err := st.Get(t.Context(), want.SessionID) - if err != nil { - t.Fatal(err) - } - if got == nil || got.Source.ThreadID != want.Source.ThreadID || got.Source.ChannelID != want.Source.ChannelID { - t.Fatalf("Get = %+v, want thread %q channel %q", got, want.Source.ThreadID, want.Source.ChannelID) - } -} - -func TestMessageIDsAreUnique(t *testing.T) { - const count = 10_000 - seen := make(map[string]struct{}, count) - for range count { - id := newMessageID("sess", "") - if _, exists := seen[id]; exists { - t.Fatalf("duplicate message ID %q", id) - } - seen[id] = struct{}{} - } -} - -func TestCanonicalMessageIDComponentsAreInjectivelyEncoded(t *testing.T) { - t.Parallel() - - tests := []struct { - name string - firstSession string - firstSource string - secondSession string - secondSource string - }{ - { - name: "separator can occur in session", - firstSession: "a\x00b", - firstSource: "c", - secondSession: "a", - secondSource: "b\x00c", - }, - { - name: "empty session does not alias prefixed source", - firstSession: "", - firstSource: "a\x00b", - secondSession: "\x00a", - secondSource: "b", - }, - } - - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - first := CanonicalMessageID(tc.firstSession, tc.firstSource) - second := CanonicalMessageID(tc.secondSession, tc.secondSource) - if first == second { - t.Fatalf("CanonicalMessageID(%q, %q) = CanonicalMessageID(%q, %q) = %q", - tc.firstSession, tc.firstSource, tc.secondSession, tc.secondSource, first) - } - }) - } -} - -func TestSQLiteSessionStoreRecognisesLegacyCanonicalIDOnRedelivery(t *testing.T) { - t.Parallel() - - store := newTestSQLiteStore(t) - ctx := t.Context() - const ( - sessionID = "a\x00b" - sourceID = "source" - ) - legacyID := uuid.NewSHA1(messageIDNamespace, []byte(sessionID+"\x00"+sourceID)).String() - if _, err := sqliteStoreDB(t, store).ExecContext(ctx, ` - INSERT INTO messages (message_id, session_id, source_id, sender, text, ts) - VALUES (?, ?, ?, 'alice', 'original', ?)`, - legacyID, sessionID, sourceID, time.Now().Add(-time.Minute).UnixMilli()); err != nil { - t.Fatalf("seed legacy message: %v", err) - } - - if err := store.SaveMessage(ctx, sessionID, messaging.Message{ - ID: messaging.MessageID(CanonicalMessageID(sessionID, sourceID)), - SourceID: sourceID, Sender: "alice", Role: messaging.RoleUser, Text: "redelivered", - }); err != nil { - t.Fatalf("SaveMessage(redelivery): %v", err) - } - messages, err := store.RecentMessages(ctx, sessionID, 10) - if err != nil { - t.Fatalf("RecentMessages: %v", err) - } - if len(messages) != 1 { - t.Fatalf("redelivery produced %d messages, want 1", len(messages)) - } - if string(messages[0].ID) != legacyID || messages[0].Text != "original" { - t.Fatalf("legacy message changed on redelivery: %#v", messages[0]) - } -} - -func TestSQLiteSessionStoreFindPriorReplyRecognisesLegacyCanonicalID(t *testing.T) { - t.Parallel() - - store := newTestSQLiteStore(t) - ctx := t.Context() - const ( - sessionID = "a\x00b" - sourceID = "source" - identity = "archie" - ) - legacyID := uuid.NewSHA1(messageIDNamespace, []byte(sessionID+"\x00"+sourceID)).String() - inputAt := time.Now().Add(-time.Minute).UnixMilli() - statements := []struct { - id string - source string - sender string - text string - at int64 - }{ - {id: legacyID, source: sourceID, sender: "alice", text: "question", at: inputAt}, - {id: "reply", sender: identity, text: "answer", at: inputAt + 1}, - } - for _, row := range statements { - if _, err := sqliteStoreDB(t, store).ExecContext(ctx, ` - INSERT INTO messages (message_id, session_id, source_id, sender, text, ts) - VALUES (?, ?, ?, ?, ?, ?)`, - row.id, sessionID, row.source, row.sender, row.text, row.at); err != nil { - t.Fatalf("seed %s: %v", row.id, err) - } - } - - replayStore, ok := store.(TurnReplayStore) - if !ok { - t.Fatalf("store is %T, want TurnReplayStore", store) - } - got, err := replayStore.FindPriorReply(ctx, sessionID, sourceID, identity) - if err != nil { - t.Fatalf("FindPriorReply: %v", err) - } - if got != "answer" { - t.Fatalf("FindPriorReply = %q, want legacy reply", got) - } -} - -func TestSQLiteSessionStoreCapsFutureMessageTimestamp(t *testing.T) { - t.Parallel() - - store := newTestSQLiteStore(t) - ctx := t.Context() - now := time.Now().UTC() - if err := store.SaveMessage(ctx, "sess", messaging.Message{ - Sender: "alice", Role: messaging.RoleUser, Text: "future", At: now.Add(24 * time.Hour), - }); err != nil { - t.Fatalf("SaveMessage(future): %v", err) - } - if err := store.SaveMessage(ctx, "sess", messaging.Message{ - Sender: "alice", Role: messaging.RoleUser, Text: "current", At: now, - }); err != nil { - t.Fatalf("SaveMessage(current): %v", err) - } - - messages, err := store.RecentMessages(ctx, "sess", 10) - if err != nil { - t.Fatalf("RecentMessages: %v", err) - } - if len(messages) != 2 { - t.Fatalf("RecentMessages returned %d messages, want 2", len(messages)) - } - if messages[0].At.After(time.Now().UTC().Add(time.Minute)) { - t.Fatalf("future timestamp was persisted as %s", messages[0].At) - } - if !messages[1].At.After(messages[0].At) { - t.Fatalf("current message timestamp %s does not follow capped future timestamp %s", - messages[1].At, messages[0].At) - } -} - -func TestSQLiteSessionStoreRepairsPersistedFutureTimestampsOnReopen(t *testing.T) { - t.Parallel() - - ctx := t.Context() - path := filepath.Join(t.TempDir(), "future.db") - store, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("OpenSQLiteSessionStore: %v", err) - } - now := time.Now().UTC() - rows := []struct { - id string - text string - at time.Time - }{ - {id: "past", text: "past", at: now.Add(-time.Minute)}, - {id: "future-1", text: "future-1", at: now.Add(24 * time.Hour)}, - {id: "future-2", text: "future-2", at: now.Add(25 * time.Hour)}, - } - for _, row := range rows { - if _, err := sqliteStoreDB(t, store).ExecContext(ctx, ` - INSERT INTO messages (message_id, session_id, sender, text, ts) - VALUES (?, 'sess', 'alice', ?, ?)`, row.id, row.text, row.at.UnixMilli()); err != nil { - t.Fatalf("seed %s: %v", row.id, err) - } - } - if err := store.Close(); err != nil { - t.Fatalf("Close seeded store: %v", err) - } - - reopened, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("reopen store: %v", err) - } - t.Cleanup(func() { _ = reopened.Close() }) - if err := reopened.SaveMessage(ctx, "sess", messaging.Message{ - Sender: "alice", Role: messaging.RoleUser, Text: "current", At: time.Now().UTC(), - }); err != nil { - t.Fatalf("SaveMessage(current): %v", err) - } - - messages, err := reopened.RecentMessages(ctx, "sess", 10) - if err != nil { - t.Fatalf("RecentMessages: %v", err) - } - want := []string{"past", "future-1", "future-2", "current"} - if got := texts(messages); !equal(got, want) { - t.Fatalf("history = %v, want %v", got, want) - } - for i := 1; i < len(messages); i++ { - if !messages[i].At.After(messages[i-1].At) { - t.Fatalf("timestamp %d (%s) does not follow %d (%s)", - i, messages[i].At, i-1, messages[i-1].At) - } - } - if messages[len(messages)-1].At.After(time.Now().UTC().Add(time.Second)) { - t.Fatalf("repaired history remains pinned in the future: last timestamp %s", - messages[len(messages)-1].At) - } -} - -func TestSQLiteMessageTimestampRoundTrips(t *testing.T) { - st := newTestSQLiteStore(t) - want := sqliteBase().Add(90*time.Minute + 123*time.Millisecond) - if err := st.SaveMessage(t.Context(), "sess", messaging.Message{Sender: "user", Role: messaging.RoleUser, Text: "hello", At: want}); err != nil { - t.Fatal(err) - } - got, err := st.RecentMessages(t.Context(), "sess", 1) - if err != nil { - t.Fatal(err) - } - if len(got) != 1 || !got[0].At.Equal(want) { - t.Fatalf("RecentMessages = %+v, want timestamp %s", got, want) - } -} - -// TestSQLiteSessionStore_SenderIDRoundTrips proves the channel-native -// participant identifier survives both history reads -- the ordered -// RecentMessages and the ranked SearchMessages -- and that a record with no -// sender id round-trips as empty rather than erroring. -func TestSQLiteSessionStore_SenderIDRoundTrips(t *testing.T) { - st := newTestSQLiteStore(t) - ctx := context.Background() - if err := st.SaveMessage(ctx, "sess", messaging.Message{ - SourceID: "tg-1", Sender: "alice", SenderID: "u-42", - Role: messaging.RoleUser, Text: "hello there", At: sqliteBase(), - }); err != nil { - t.Fatalf("SaveMessage: %v", err) - } - if err := st.SaveMessage(ctx, "sess", messaging.Message{ - Sender: "archie", Role: messaging.RoleAssistant, Text: "hi", At: sqliteBase().Add(time.Second), - }); err != nil { - t.Fatalf("SaveMessage(no sender id): %v", err) - } - - hist, err := st.RecentMessages(ctx, "sess", 10) - if err != nil { - t.Fatalf("RecentMessages: %v", err) - } - if len(hist) != 2 { - t.Fatalf("RecentMessages = %d messages, want 2", len(hist)) - } - if hist[0].SenderID != "u-42" { - t.Errorf("RecentMessages()[0].SenderID = %q, want %q", hist[0].SenderID, "u-42") - } - if hist[1].SenderID != "" { - t.Errorf("RecentMessages()[1].SenderID = %q, want empty", hist[1].SenderID) - } - - page, err := st.SearchMessages(ctx, "sess", MessageQuery{Query: "hello", Limit: 10}) - if err != nil { - t.Fatalf("SearchMessages: %v", err) - } - if len(page.Messages) != 1 || page.Messages[0].SenderID != "u-42" { - t.Errorf("SearchMessages() = %+v, want one match with SenderID u-42", page.Messages) - } -} - -func TestSQLiteMessageTimestampsIncreaseAcrossStoreHandles(t *testing.T) { - path := filepath.Join(t.TempDir(), "messages.db") - stores := make([]SessionStore, 2) - for i := range stores { - var err error - stores[i], err = OpenSQLiteSessionStore(path) - if err != nil { - t.Fatal(err) - } - defer func(store SessionStore) { _ = store.Close() }(stores[i]) - } - - const perStore = 100 - wantTime := sqliteBase() - var wg sync.WaitGroup - for storeIndex, st := range stores { - for messageIndex := range perStore { - wg.Go(func() { - err := st.SaveMessage(t.Context(), "sess", messaging.Message{ - ID: messaging.MessageID(fmt.Sprintf("%d-%d", storeIndex, messageIndex)), - Sender: "user", Role: messaging.RoleUser, - Text: "concurrent", - At: wantTime, - }) - if err != nil { - t.Errorf("SaveMessage: %v", err) - } - }) - } - } - wg.Wait() - - messages, err := stores[0].RecentMessages(t.Context(), "sess", perStore*len(stores)) - if err != nil { - t.Fatal(err) - } - if len(messages) != perStore*len(stores) { - t.Fatalf("messages = %d, want %d", len(messages), perStore*len(stores)) - } - for i := 1; i < len(messages); i++ { - if !messages[i].At.After(messages[i-1].At) { - t.Fatalf("timestamp %d (%s) is not after timestamp %d (%s)", i, messages[i].At, i-1, messages[i-1].At) - } - } -} - -// TestSQLiteSessionStore_DeleteIsAtomic pins invariant 4: Delete removes the -// session and its messages together. -func TestSQLiteSessionStore_DeleteIsAtomic(t *testing.T) { - ctx := context.Background() - st := newTestSQLiteStore(t) - - sc := SessionContext{ - SessionID: "sess-del", Source: SessionSource{Platform: "web", ChannelID: "c"}, - CreatedAt: sqliteBase(), LastActiveAt: sqliteBase(), - } - if err := st.Save(ctx, sc); err != nil { - t.Fatalf("Save: %v", err) - } - if err := st.SaveMessage(ctx, "sess-del", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "hi", At: sqliteBase()}); err != nil { - t.Fatalf("SaveMessage: %v", err) - } - - if err := st.Delete(ctx, "sess-del"); err != nil { - t.Fatalf("Delete: %v", err) - } - - got, err := st.Get(ctx, "sess-del") - if err != nil { - t.Fatalf("Get: %v", err) - } - if got != nil { - t.Error("expected session to be gone") - } - count, err := st.MessageCount(ctx, "sess-del") - if err != nil { - t.Fatalf("MessageCount: %v", err) - } - if count != 0 { - t.Errorf("expected messages to be gone, got count %d", count) - } - - // Deleting a non-existent session is a no-op. - if err := st.Delete(ctx, "nonexistent"); err != nil { - t.Errorf("Delete nonexistent: %v", err) - } -} - -// TestSQLiteSessionStore_SearchPagingAndTruncated pins invariant 6: Limit is -// a page size (not a cap), paging is honoured via Offset/NextOffset/HasMore, -// and Truncated is always false (SQLite has a real total count). -func TestSQLiteSessionStore_SearchPagingAndTruncated(t *testing.T) { - ctx := context.Background() - st := newTestSQLiteStore(t) - - const total = 30 - for i := range total { - m := messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "needle common", At: sqliteBase().Add(time.Duration(i) * time.Second)} - if err := st.SaveMessage(ctx, "sess", m); err != nil { - t.Fatalf("SaveMessage %d: %v", i, err) - } - } - - seen := map[string]bool{} - offset := 0 - pages := 0 - for { - page, err := st.SearchMessages(ctx, "sess", MessageQuery{Query: "needle", Limit: 7, Offset: offset}) - if err != nil { - t.Fatalf("SearchMessages offset=%d: %v", offset, err) - } - if page.Truncated { - t.Errorf("expected Truncated=false for SQLite backend") - } - for _, m := range page.Messages { - if seen[string(m.ID)] { - t.Errorf("duplicate message across pages: %s", string(m.ID)) - } - seen[string(m.ID)] = true - } - pages++ - if !page.HasMore { - break - } - offset = page.NextOffset - if pages > total { - t.Fatal("paging did not terminate") - } - } - if len(seen) != total { - t.Errorf("expected to see all %d matches across pages, got %d", total, len(seen)) - } -} - -func TestSQLiteSessionStore_ErrorPaths(t *testing.T) { - ctx := context.Background() - st := newTestSQLiteStore(t) - if err := st.Close(); err != nil { - t.Fatalf("Close: %v", err) - } - - t.Run("Save after close", func(t *testing.T) { - if err := st.Save(ctx, SessionContext{SessionID: "x"}); err == nil { - t.Error("expected error saving to a closed store") - } - }) - t.Run("Get after close", func(t *testing.T) { - if _, err := st.Get(ctx, "x"); err == nil { - t.Error("expected error getting from a closed store") - } - }) - t.Run("SaveMessage after close", func(t *testing.T) { - if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: "hi"}); err == nil { - t.Error("expected error saving message to a closed store") - } - }) - t.Run("SearchMessages after close", func(t *testing.T) { - if _, err := st.SearchMessages(ctx, "sess", MessageQuery{Query: "hi"}); err == nil { - t.Error("expected error searching a closed store") - } - }) - t.Run("Delete after close", func(t *testing.T) { - if err := st.Delete(ctx, "sess"); err == nil { - t.Error("expected error deleting from a closed store") - } - }) - t.Run("ReplaceMessages after close", func(t *testing.T) { - if err := st.ReplaceMessages(ctx, "sess", nil, nil); err == nil { - t.Error("expected error replacing messages on a closed store") - } - }) -} - -func TestOpenSQLiteSessionStore_CreatesFile(t *testing.T) { - dir := t.TempDir() - path := dir + "/sub/dir/sessions.db" - - st, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("OpenSQLiteSessionStore: %v", err) - } - defer func() { _ = st.Close() }() - - ctx := context.Background() - sc := SessionContext{SessionID: "s1", Source: SessionSource{Platform: "web", ChannelID: "c"}, CreatedAt: sqliteBase(), LastActiveAt: sqliteBase()} - if err := st.Save(ctx, sc); err != nil { - t.Fatalf("Save: %v", err) - } - got, err := st.Get(ctx, "s1") - if err != nil { - t.Fatalf("Get: %v", err) - } - if got == nil { - t.Fatal("expected session to persist to the created file") - } -} - -// ── Adversarial file-backed coverage (bead 8u8.1) ─────────────────────────── -// -// These tests are deliberately SQLite-only. They prove two properties the -// shared 19-group conformance suite cannot: file-backed durability across -// close+reopen (with the trigger-maintained FTS index intact and a clean -// PRAGMA quick_check), and transaction rollback under injected -// mid-operation failures. They reach into sqliteSessionStore internals -- the -// raw *sql.DB -- to install deterministic abort triggers and run PRAGMA -// checks, which the SessionStore interface does not expose. - -// sqliteStoreDB exposes the raw handle behind a store for SQLite-specific -// tests. The store pins its pool to one connection and serializes writes -// with its own mutex, so a test touching this handle between operations is -// safe and deterministic. -// TestSQLiteSessionStore_MigratesPreRoleDatabase pins the upgrade path for -// databases written before the messaging migration added the role column: -// opening backfills roles from the sender-vs-bot identity the boundary -// applies to new writes, so old histories keep their assistant/user -// distinction and sender search keeps working. -func TestSQLiteSessionStore_MigratesPreRoleDatabase(t *testing.T) { - path := filepath.Join(t.TempDir(), "old.db") - db, err := sql.Open("sqlite", sqliteSessionDSN(path)) - if err != nil { - t.Fatalf("open raw db: %v", err) - } - oldMessages := strings.Replace(sqliteSessionSchema, - "\tsender TEXT NOT NULL DEFAULT '',\n\tsender_id TEXT NOT NULL DEFAULT '',\n\trole TEXT NOT NULL DEFAULT '',\n", - "\tsender TEXT NOT NULL DEFAULT '',\n", 1) - if _, err := db.ExecContext(t.Context(), oldMessages); err != nil { - t.Fatalf("create old schema: %v", err) - } - millis := sqliteBase().UnixMilli() - if _, err := db.ExecContext(t.Context(), `INSERT INTO sessions (session_id, platform, bot_user, channel_id, created_at, last_active_at) - VALUES ('sess-old', 'telegram', 'archie', 'chat-1', ?, ?)`, millis, millis); err != nil { - t.Fatalf("seed old session: %v", err) - } - if _, err := db.ExecContext(t.Context(), `INSERT INTO messages (message_id, session_id, source_id, sender, text, ts) VALUES - ('m-user', 'sess-old', 'tg-1', 'alice', 'hello', ?), - ('m-assistant', 'sess-old', '', 'archie', 'hi', ?)`, millis, millis+1); err != nil { - t.Fatalf("seed old messages: %v", err) - } - if err := db.Close(); err != nil { - t.Fatalf("close raw db: %v", err) - } - - st, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("reopen old database: %v", err) - } - t.Cleanup(func() { _ = st.Close() }) - - hist, err := st.RecentMessages(context.Background(), "sess-old", 10) - if err != nil { - t.Fatalf("RecentMessages: %v", err) - } - if len(hist) != 2 { - t.Fatalf("history = %d messages, want 2", len(hist)) - } - if hist[0].Role != messaging.RoleUser || hist[0].Sender != "alice" { - t.Errorf("user message = %+v, want role user from alice", hist[0]) - } - if hist[1].Role != messaging.RoleAssistant || hist[1].Sender != "archie" { - t.Errorf("assistant message = %+v, want role assistant from archie", hist[1]) - } - page, err := st.SearchMessages(context.Background(), "sess-old", MessageQuery{Query: "alice", Limit: 10}) - if err != nil { - t.Fatalf("SearchMessages: %v", err) - } - if len(page.Messages) != 1 { - t.Errorf("sender search = %d matches, want 1", len(page.Messages)) - } -} - -// TestSQLiteSessionStore_MigratesPreSenderIDDatabase simulates a database -// created before sender_id existed: a role-era schema with no sender_id -// column. Opening it must add the column with an empty default, leave the -// existing rows readable, and stay clean across a second open. -func TestSQLiteSessionStore_MigratesPreSenderIDDatabase(t *testing.T) { - path := filepath.Join(t.TempDir(), "old-sender.db") - db, err := sql.Open("sqlite", sqliteSessionDSN(path)) - if err != nil { - t.Fatalf("open raw db: %v", err) - } - oldMessages := strings.Replace(sqliteSessionSchema, - "\tsender_id TEXT NOT NULL DEFAULT '',\n", "", 1) - if _, err := db.ExecContext(t.Context(), oldMessages); err != nil { - t.Fatalf("create old schema: %v", err) - } - millis := sqliteBase().UnixMilli() - if _, err := db.ExecContext(t.Context(), `INSERT INTO sessions (session_id, platform, bot_user, channel_id, created_at, last_active_at) - VALUES ('sess-old', 'telegram', 'archie', 'chat-1', ?, ?)`, millis, millis); err != nil { - t.Fatalf("seed old session: %v", err) - } - if _, err := db.ExecContext(t.Context(), `INSERT INTO messages (message_id, session_id, source_id, sender, role, text, ts) VALUES - ('m-user', 'sess-old', 'tg-1', 'alice', 'user', 'hello', ?)`, millis); err != nil { - t.Fatalf("seed old message: %v", err) - } - if err := db.Close(); err != nil { - t.Fatalf("close raw db: %v", err) - } - - st, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("reopen old database: %v", err) - } - t.Cleanup(func() { _ = st.Close() }) - - hist, err := st.RecentMessages(context.Background(), "sess-old", 10) - if err != nil { - t.Fatalf("RecentMessages: %v", err) - } - if len(hist) != 1 { - t.Fatalf("history = %d messages, want 1", len(hist)) - } - if hist[0].Sender != "alice" || hist[0].SenderID != "" { - t.Errorf("migrated message = %+v, want sender alice with empty SenderID", hist[0]) - } - - // The second open takes the duplicate-column path; it must not fail. - again, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("second reopen: %v", err) - } - t.Cleanup(func() { _ = again.Close() }) - if _, err := again.RecentMessages(context.Background(), "sess-old", 10); err != nil { - t.Fatalf("RecentMessages after second reopen: %v", err) - } -} - -func sqliteStoreDB(t *testing.T, st SessionStore) *sql.DB { - t.Helper() - s, ok := st.(*sqliteSessionStore) - if !ok { - t.Fatalf("store is %T, want *sqliteSessionStore", st) - } - return s.db -} - -// installAbortTrigger deterministically fails the statement that matches -// clause by raising ABORT from a BEFORE trigger. Because the trigger fires -// mid-transaction (after earlier statements in the same transaction have -// already run), a correct store must roll the whole transaction back for the -// abort to be invisible to later reads. -func installAbortTrigger(t *testing.T, st SessionStore, clause string) { - t.Helper() - _, err := sqliteStoreDB(t, st).ExecContext(context.Background(), - `CREATE TRIGGER test_forced_abort `+clause+` BEGIN - SELECT RAISE(ABORT, 'forced test abort'); - END`) - if err != nil { - t.Fatalf("install abort trigger: %v", err) - } -} - -// TestSQLiteSessionStore_CloseReopenDurability proves that a file-backed -// store persists SessionContext fields and canonical message identity -// (MessageID, SourceID, sender, text, timestamp) across a close+reopen -// cycle, that the trigger-maintained FTS index survives with it, and that -// PRAGMA quick_check reports the file intact. -func TestSQLiteSessionStore_CloseReopenDurability(t *testing.T) { - ctx := context.Background() - path := filepath.Join(t.TempDir(), "sessions.db") - - st, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("OpenSQLiteSessionStore: %v", err) - } - - wantSC := SessionContext{ - SessionID: "sess-durable", - Source: SessionSource{ - Platform: "telegram", BotUser: "archie", ChannelID: "chat-42", ThreadID: "topic-7", - }, - Title: "durable title", - ParentSessionID: "sess-parent", - BranchName: "feature/x", - CreatedAt: sqliteBase(), - LastActiveAt: sqliteBase().Add(time.Minute), - } - if err := st.Save(ctx, wantSC); err != nil { - t.Fatalf("Save: %v", err) - } - - wantMsgs := []messaging.Message{ - {ID: "canonical-1", SourceID: "tg-1001", Sender: "alice", Role: messaging.RoleUser, Text: "first durable message", At: sqliteBase().Add(time.Second)}, - {ID: "canonical-2", SourceID: "tg-1002", Sender: "bob", Role: messaging.RoleUser, Text: "second durable message", At: sqliteBase().Add(2 * time.Second)}, - } - for _, m := range wantMsgs { - if err := st.SaveMessage(ctx, "sess-durable", m); err != nil { - t.Fatalf("SaveMessage %q: %v", string(m.ID), err) - } - } - if err := st.Close(); err != nil { - t.Fatalf("Close: %v", err) - } - - st2, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("reopen OpenSQLiteSessionStore: %v", err) - } - defer func() { _ = st2.Close() }() - - got, err := st2.Get(ctx, "sess-durable") - if err != nil { - t.Fatalf("Get after reopen: %v", err) - } - if got == nil { - t.Fatal("expected session to survive close+reopen") - } - if *got != wantSC { - t.Errorf("session after reopen:\n got %+v\nwant %+v", *got, wantSC) - } - - hist, err := st2.RecentMessages(ctx, "sess-durable", 10) - if err != nil { - t.Fatalf("RecentMessages after reopen: %v", err) - } - if len(hist) != len(wantMsgs) { - t.Fatalf("history after reopen: got %d messages, want %d", len(hist), len(wantMsgs)) - } - for i, m := range hist { - want := wantMsgs[i] - if m.ID != want.ID || m.SourceID != want.SourceID || - m.Sender != want.Sender || m.Role != want.Role || m.Text != want.Text || !m.At.Equal(want.At) { - t.Errorf("message %d after reopen:\n got %+v\nwant %+v", i, m, want) - } - } - - // The FTS index is trigger-maintained, so it must survive reopen too. - page, err := st2.SearchMessages(ctx, "sess-durable", MessageQuery{Query: "durable"}) - if err != nil { - t.Fatalf("SearchMessages after reopen: %v", err) - } - if len(page.Messages) != len(wantMsgs) { - t.Errorf("search after reopen: got %d matches, want %d", len(page.Messages), len(wantMsgs)) - } - - var check string - if err := sqliteStoreDB(t, st2).QueryRowContext(ctx, "PRAGMA quick_check").Scan(&check); err != nil { - t.Fatalf("PRAGMA quick_check: %v", err) - } - if check != "ok" { - t.Errorf("PRAGMA quick_check = %q, want ok", check) - } -} - -// TestSQLiteSessionStore_DeleteAbortRollsBack pins that Delete rolls its -// transaction back when a statement fails mid-operation: the messages DELETE -// has already run inside the transaction when the sessions DELETE trips the -// abort trigger, so the rollback must restore the session, its history, its -// count, and its search results. -func TestSQLiteSessionStore_DeleteAbortRollsBack(t *testing.T) { - ctx := context.Background() - st := newTestSQLiteStore(t) - - sc := SessionContext{ - SessionID: "sess-del-abort", - Source: SessionSource{Platform: "web", ChannelID: "c"}, - Title: "keep me", - CreatedAt: sqliteBase(), LastActiveAt: sqliteBase(), - } - if err := st.Save(ctx, sc); err != nil { - t.Fatalf("Save: %v", err) - } - seed := []messaging.Message{ - {Sender: "alice", Role: messaging.RoleUser, Text: "alpha", At: sqliteBase()}, - {Sender: "bob", Role: messaging.RoleUser, Text: "beta", At: sqliteBase().Add(time.Second)}, - {Sender: "carol", Role: messaging.RoleUser, Text: "gamma", At: sqliteBase().Add(2 * time.Second)}, - } - for _, m := range seed { - if err := st.SaveMessage(ctx, "sess-del-abort", m); err != nil { - t.Fatalf("SaveMessage: %v", err) - } - } - - installAbortTrigger(t, st, `BEFORE DELETE ON sessions WHEN old.session_id = 'sess-del-abort'`) - - if err := st.Delete(ctx, "sess-del-abort"); err == nil { - t.Fatal("expected Delete to fail from the forced abort trigger") - } - - got, err := st.Get(ctx, "sess-del-abort") - if err != nil { - t.Fatalf("Get after failed Delete: %v", err) - } - if got == nil || *got != sc { - t.Errorf("session after failed Delete: got %+v, want %+v", got, sc) - } - - hist, err := st.RecentMessages(ctx, "sess-del-abort", 10) - if err != nil { - t.Fatalf("RecentMessages after failed Delete: %v", err) - } - if len(hist) != len(seed) { - t.Fatalf("history after failed Delete: got %d messages, want %d", len(hist), len(seed)) - } - for i, m := range hist { - if m.Text != seed[i].Text || m.Sender != seed[i].Sender { - t.Errorf("message %d after failed Delete: got %+v, want text %q from %q", i, m, seed[i].Text, seed[i].Sender) - } - } - - count, err := st.MessageCount(ctx, "sess-del-abort") - if err != nil { - t.Fatalf("MessageCount after failed Delete: %v", err) - } - if count != len(seed) { - t.Errorf("count after failed Delete: got %d, want %d", count, len(seed)) - } - - // The FTS index must match the rolled-back history. - page, err := st.SearchMessages(ctx, "sess-del-abort", MessageQuery{Query: "beta"}) - if err != nil { - t.Fatalf("SearchMessages after failed Delete: %v", err) - } - if len(page.Messages) != 1 { - t.Errorf("search after failed Delete: got %d matches, want 1", len(page.Messages)) - } -} - -// TestSQLiteSessionStore_ReplaceMessagesAbortRollsBack pins that -// ReplaceMessages rolls its transaction back when the delete-old step fails -// mid-operation: the replacement inserts have already landed in the -// transaction when the abort fires, so the rollback must remove the -// replacement and restore the original history, count, and search results. -func TestSQLiteSessionStore_ReplaceMessagesAbortRollsBack(t *testing.T) { - ctx := context.Background() - st := newTestSQLiteStore(t) - - seed := []messaging.Message{ - {ID: "m-0", SourceID: "s-0", Sender: "alice", Role: messaging.RoleUser, Text: "alpha", At: sqliteBase()}, - {ID: "m-1", SourceID: "s-1", Sender: "bob", Role: messaging.RoleUser, Text: "beta", At: sqliteBase().Add(time.Second)}, - {ID: "m-2", SourceID: "s-2", Sender: "carol", Role: messaging.RoleUser, Text: "gamma", At: sqliteBase().Add(2 * time.Second)}, - } - if err := st.SaveMessages(ctx, "sess-replace-abort", seed); err != nil { - t.Fatalf("SaveMessages: %v", err) - } - - // Guard an original row so the abort fires only after the replacement - // inserts have landed inside the transaction. - installAbortTrigger(t, st, `BEFORE DELETE ON messages WHEN old.message_id = 'm-1'`) - - replacement := []messaging.Message{{Sender: "summarizer", Role: messaging.RoleUser, Text: "merged summary", At: sqliteBase().Add(time.Hour)}} - if err := st.ReplaceMessages(ctx, "sess-replace-abort", replacement, supersededIDs(ctx, t, st, "sess-replace-abort")); err == nil { - t.Fatal("expected ReplaceMessages to fail from the forced abort trigger") - } - - hist, err := st.RecentMessages(ctx, "sess-replace-abort", 10) - if err != nil { - t.Fatalf("RecentMessages after failed ReplaceMessages: %v", err) - } - if len(hist) != len(seed) { - t.Fatalf("history after failed ReplaceMessages: got %d messages, want %d", len(hist), len(seed)) - } - for i, m := range hist { - if string(m.ID) != string(seed[i].ID) || m.Text != seed[i].Text || m.Sender != seed[i].Sender { - t.Errorf("message %d after failed ReplaceMessages: got %+v, want %+v", i, m, seed[i]) - } - } - - count, err := st.MessageCount(ctx, "sess-replace-abort") - if err != nil { - t.Fatalf("MessageCount after failed ReplaceMessages: %v", err) - } - if count != len(seed) { - t.Errorf("count after failed ReplaceMessages: got %d, want %d", count, len(seed)) - } - - page, err := st.SearchMessages(ctx, "sess-replace-abort", MessageQuery{Query: "beta"}) - if err != nil { - t.Fatalf("SearchMessages after failed ReplaceMessages: %v", err) - } - if len(page.Messages) != 1 { - t.Errorf("search 'beta' after failed ReplaceMessages: got %d matches, want 1", len(page.Messages)) - } - page, err = st.SearchMessages(ctx, "sess-replace-abort", MessageQuery{Query: "summary"}) - if err != nil { - t.Fatalf("SearchMessages after failed ReplaceMessages: %v", err) - } - if len(page.Messages) != 0 { - t.Errorf("search 'summary' after failed ReplaceMessages: got %d matches, want 0 (replacement must be rolled back)", len(page.Messages)) - } -} - -// ── FTS lifecycle and literal-query semantics (bead 8u8.4) ────────────────── -// -// The shared 19-group conformance suite (sessionstore_conformance_test.go) -// proves behaviour through the SessionStore interface, but two properties are -// SQLite-specific and cannot be expressed there: the trigger-maintained FTS5 -// index must stay consistent as history mutates, and free-text queries must -// survive hostile input. These tests are SQLite-only and assert exact -// results -- not merely the absence of panics. - -// sameTexts compares two text slices as sets: same length, same members, -// order-insensitive. FTS pages are ranked by bm25, so order is a ranking -// detail rather than part of the match contract. -func sameTexts(a, b []string) bool { - if len(a) != len(b) { - return false - } - seen := make(map[string]int, len(a)) - for _, s := range a { - seen[s]++ - } - for _, s := range b { - seen[s]-- - if seen[s] < 0 { - return false - } - } - return true -} - -// ftsIntegrityErr runs the documented FTS5 external-content integrity -// check (`INSERT INTO ...(table, rank) VALUES('integrity-check', 1)`) against -// the store's raw handle and returns any error it reports. A consistent -// index reports no error; a stale entry -- a content row deleted without the -// AFTER DELETE trigger firing -- reports "database disk image is malformed". -// Search/count joins can never surface such an entry because they only see -// index rows whose content row still exists, so this is the one check that -// detects an orphaned index. -func ftsIntegrityErr(t *testing.T, st SessionStore) error { - t.Helper() - _, err := sqliteStoreDB(t, st).ExecContext(context.Background(), - `INSERT INTO messages_fts(messages_fts, rank) VALUES('integrity-check', 1)`) - return err -} - -// TestSQLiteSessionStore_FTSStaysCorrectThroughMutations pins that the FTS5 -// index follows every message mutation: DeleteRecentMessages removes the -// newest documents, ReplaceMessages swaps the whole document set, and Delete -// clears the session -- with search results and counts tracking the surviving -// history and never leaking across sessions. -func TestSQLiteSessionStore_FTSStaysCorrectThroughMutations(t *testing.T) { - // Sessions "a" and "b" share the term "needle", so any cross-session - // leak in search or count is caught; "marker" lives only in "b". - seedA := []string{"needle alpha", "filler one", "needle beta", "filler two"} - seedB := []string{"needle gamma", "distinct marker"} - - tests := []struct { - name string - mutate func(ctx context.Context, t *testing.T, st SessionStore) error - wantA []string // session a history after the mutation - wantANeedle []string // session a search "needle" - wantACount int - wantAMarker []string // session a search "marker" (only in b) - wantBNeedle []string // session b search "needle" (must stay intact) - wantBCount int - }{ - { - name: "DeleteRecentMessages prunes the index newest-first", - mutate: func(ctx context.Context, t *testing.T, st SessionStore) error { - deleted, err := st.DeleteRecentMessages(ctx, "a", 2) - if err == nil && deleted != 2 { - t.Errorf("deleted %d messages, want 2", deleted) - } - return err - }, - wantA: []string{"needle alpha", "filler one"}, - wantANeedle: []string{"needle alpha"}, - wantACount: 2, - wantAMarker: nil, - wantBNeedle: []string{"needle gamma"}, - wantBCount: 2, - }, - { - name: "ReplaceMessages swaps the document set", - mutate: func(ctx context.Context, t *testing.T, st SessionStore) error { - return st.ReplaceMessages(ctx, "a", []messaging.Message{{ - Sender: "summarizer", Role: messaging.RoleUser, Text: "merged needle summary", At: sqliteBase().Add(time.Hour), - }}, supersededIDs(ctx, t, st, "a")) - }, - wantA: []string{"merged needle summary"}, - wantANeedle: []string{"merged needle summary"}, - wantACount: 1, - wantAMarker: nil, - wantBNeedle: []string{"needle gamma"}, - wantBCount: 2, - }, - { - name: "Delete clears the session's index", - mutate: func(ctx context.Context, t *testing.T, st SessionStore) error { - return st.Delete(ctx, "a") - }, - wantA: nil, - wantANeedle: nil, - wantACount: 0, - wantAMarker: nil, - wantBNeedle: []string{"needle gamma"}, - wantBCount: 2, - }, - } - - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - // Subtest-local context: mutation closures receive it as a - // parameter instead of capturing the outer function's. - ctx := context.Background() - st := newTestSQLiteStore(t) - - for i, text := range seedA { - if err := st.SaveMessage(ctx, "a", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { - t.Fatalf("SaveMessage a %q: %v", text, err) - } - } - for i, text := range seedB { - if err := st.SaveMessage(ctx, "b", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { - t.Fatalf("SaveMessage b %q: %v", text, err) - } - } - - if err := tc.mutate(ctx, t, st); err != nil { - t.Fatalf("mutate: %v", err) - } - - // The index must be internally consistent with the surviving - // history, not merely join-visible: an orphaned entry would be - // invisible to the search/count joins below, so check the index - // itself after every mutation. - if err := ftsIntegrityErr(t, st); err != nil { - t.Fatalf("FTS5 integrity check after %q: %v", tc.name, err) - } - - hist, err := st.RecentMessages(ctx, "a", 100) - if err != nil { - t.Fatalf("RecentMessages a: %v", err) - } - if !equal(texts(hist), tc.wantA) { - t.Errorf("session a history = %v, want %v", texts(hist), tc.wantA) - } - - assertSearch := func(session, term string, want []string) { - t.Helper() - page, err := st.SearchMessages(ctx, session, MessageQuery{Query: term, Limit: 100}) - if err != nil { - t.Fatalf("SearchMessages(%s, %q): %v", session, term, err) - } - if !sameTexts(texts(page.Messages), want) { - t.Errorf("search %s %q = %v, want %v", session, term, texts(page.Messages), want) - } - if page.Truncated || page.HasMore { - t.Errorf("search %s %q: Truncated=%v HasMore=%v, want false/false", session, term, page.Truncated, page.HasMore) - } - } - - assertSearch("a", "needle", tc.wantANeedle) - assertSearch("a", "marker", tc.wantAMarker) - assertSearch("b", "needle", tc.wantBNeedle) - - for _, sc := range []struct { - session string - want int - }{ - {"a", tc.wantACount}, {"b", tc.wantBCount}, - } { - count, err := st.MessageCount(ctx, sc.session) - if err != nil { - t.Fatalf("MessageCount %s: %v", sc.session, err) - } - if count != sc.want { - t.Errorf("MessageCount %s = %d, want %d", sc.session, count, sc.want) - } - } - - histB, err := st.RecentMessages(ctx, "b", 100) - if err != nil { - t.Fatalf("RecentMessages b: %v", err) - } - if !equal(texts(histB), seedB) { - t.Errorf("session b history = %v, want untouched %v", texts(histB), seedB) - } - }) - } -} - -// TestSQLiteSessionStore_FTSIntegrityCheckDetectsOrphanedIndex proves the -// integrity check used by the lifecycle test is load-bearing: with the AFTER -// DELETE trigger temporarily dropped, a store mutation leaves a stale -// messages_fts entry that the check must report, while the same mutation with -// the trigger intact leaves a consistent index. -func TestSQLiteSessionStore_FTSIntegrityCheckDetectsOrphanedIndex(t *testing.T) { - t.Run("stale index entry fails the check", func(t *testing.T) { - ctx := context.Background() - st := newTestSQLiteStore(t) - - for i, text := range []string{"needle one", "needle two"} { - if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { - t.Fatalf("SaveMessage: %v", err) - } - } - - // Bypass the AFTER DELETE trigger so the index keeps a row for the - // deleted message. - if _, err := sqliteStoreDB(t, st).ExecContext(ctx, `DROP TRIGGER messages_ad`); err != nil { - t.Fatalf("drop delete trigger: %v", err) - } - if _, err := st.DeleteRecentMessages(ctx, "sess", 1); err != nil { - t.Fatalf("DeleteRecentMessages: %v", err) - } - - if err := ftsIntegrityErr(t, st); err == nil { - t.Fatal("FTS5 integrity check passed despite a stale index entry (delete trigger bypassed)") - } - }) - - t.Run("trigger-maintained delete keeps the index consistent", func(t *testing.T) { - ctx := context.Background() - st := newTestSQLiteStore(t) - - for i, text := range []string{"needle one", "needle two"} { - if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { - t.Fatalf("SaveMessage: %v", err) - } - } - if _, err := st.DeleteRecentMessages(ctx, "sess", 1); err != nil { - t.Fatalf("DeleteRecentMessages: %v", err) - } - - if err := ftsIntegrityErr(t, st); err != nil { - t.Fatalf("FTS5 integrity check failed after trigger-maintained delete: %v", err) - } - }) -} - -// TestSQLiteSessionStore_HostileQueriesAreLiteral pins that free-text input -// is never executed as FTS5 query syntax: column filters, the NEAR operator, -// prefix wildcards, and boolean operators must all be treated as literal -// terms (or, for a bare "*", an empty phrase) without syntax errors. Each -// row asserts the exact match set, not merely the absence of a panic. -func TestSQLiteSessionStore_HostileQueriesAreLiteral(t *testing.T) { - ctx := context.Background() - st := newTestSQLiteStore(t) - - seed := []string{ - "text:hello here", // phrase (text, hello) - "hello there", // would match a raw "text:hello" column filter - "hello world", - `hello "world quote`, // unmatched-quote input must still find this - "near a b", // phrase (near, a) AND token b - "a far b", // would match a raw NEAR(a b) operator - "star * symbol", // "*" is a separator: never a token, never matches - "needle or elsewhere", - "needle elsewhere", // would match a raw OR query - "needle", - "alpha beta gamma", // both AND terms present - "alpha alone", - "beta alone", - } - for i, text := range seed { - if err := st.SaveMessage(ctx, "sess", messaging.Message{Sender: "u", Role: messaging.RoleUser, Text: text, At: sqliteBase().Add(time.Duration(i) * time.Second)}); err != nil { - t.Fatalf("SaveMessage %q: %v", text, err) - } - } - - tests := []struct { - name string - query string - want []string - }{ - {"column syntax is a literal phrase, not a column filter", "text:hello", []string{"text:hello here"}}, - {"unmatched quote is literal, not a syntax error", `hello "world`, []string{"hello world", `hello "world quote`}}, - {"NEAR syntax is literal, not the NEAR operator", "NEAR(a b)", []string{"near a b"}}, - {"bare wildcard is an empty phrase, not a prefix operator", "*", nil}, - {"OR is a literal term, not the boolean operator", "needle OR elsewhere", []string{"needle or elsewhere"}}, - {"multi-term query pins AND semantics", "alpha beta", []string{"alpha beta gamma"}}, - } - - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - page, err := st.SearchMessages(ctx, "sess", MessageQuery{Query: tc.query, Limit: 100}) - if err != nil { - t.Fatalf("SearchMessages(%q): %v", tc.query, err) - } - if !sameTexts(texts(page.Messages), tc.want) { - t.Errorf("query %q matched %v, want %v", tc.query, texts(page.Messages), tc.want) - } - if page.Truncated || page.HasMore { - t.Errorf("query %q: Truncated=%v HasMore=%v, want false/false", tc.query, page.Truncated, page.HasMore) - } - }) - } -} - -// TestFTSMatchQueryEscapesHostileInput pins the exact MATCH expression the -// store generates: every whitespace-separated term becomes a quoted phrase -// (embedded quotes doubled), joined by explicit AND, so user input can never -// reach the FTS5 parser as query syntax. -func TestFTSMatchQueryEscapesHostileInput(t *testing.T) { - tests := []struct{ in, want string }{ - {"", ""}, - {" ", ""}, - {"alpha beta", `"alpha" AND "beta"`}, - {"needle OR elsewhere", `"needle" AND "OR" AND "elsewhere"`}, - {"text:hello", `"text:hello"`}, - {`hello "world`, `"hello" AND """world"`}, - {"NEAR(a b)", `"NEAR(a" AND "b)"`}, - {"*", `"*"`}, - } - for _, tc := range tests { - if got := ftsMatchQuery(tc.in); got != tc.want { - t.Errorf("ftsMatchQuery(%q) = %q, want %q", tc.in, got, tc.want) - } - } -} diff --git a/internal/gateway/turn_ledger.go b/internal/gateway/turn_ledger.go index ba4fad5f0..e9c4f43e7 100644 --- a/internal/gateway/turn_ledger.go +++ b/internal/gateway/turn_ledger.go @@ -2,8 +2,11 @@ package gateway import ( "context" + "encoding/json" "errors" + "fmt" "strings" + "time" "github.com/google/uuid" ) @@ -72,3 +75,42 @@ func CanonicalTurnID(sessionID, sourceID string) string { func legacyCanonicalTurnID(sessionID, sourceID string) string { return uuid.NewSHA1(uuid.NameSpaceURL, []byte("archie-turn:\x00"+sessionID+"\x00"+sourceID)).String() } + +func prepareInitialTurn(initial TurnRecord, now time.Time) (TurnRecord, string, error) { + if initial.TurnID == "" { + return TurnRecord{}, "", fmt.Errorf("sessionstore: turn ID is required") + } + initial.Status = TurnStatusRunning + initial.Attempt = 1 + if initial.CreatedAt.IsZero() { + initial.CreatedAt = now + } + initial.UpdatedAt = now + toolCalls, err := marshalToolCalls(initial.ToolCalls) + return initial, toolCalls, err +} + +// marshalToolCalls encodes tool activity for storage; an empty slice becomes +// "[]" so it round-trips through unmarshalToolCalls to nil. +func marshalToolCalls(events []ToolCallEvent) (string, error) { + if len(events) == 0 { + return "[]", nil + } + encoded, err := json.Marshal(events) + if err != nil { + return "", fmt.Errorf("sessionstore: marshal tool calls: %w", err) + } + return string(encoded), nil +} + +// unmarshalToolCalls decodes tool activity persisted by marshalToolCalls. +func unmarshalToolCalls(raw string) ([]ToolCallEvent, error) { + if raw == "" || raw == "[]" { + return nil, nil + } + var events []ToolCallEvent + if err := json.Unmarshal([]byte(raw), &events); err != nil { + return nil, fmt.Errorf("sessionstore: unmarshal tool calls: %w", err) + } + return events, nil +} diff --git a/internal/gateway/turn_ledger_test.go b/internal/gateway/turn_ledger_test.go index 7b0d8e3e2..c3021acb2 100644 --- a/internal/gateway/turn_ledger_test.go +++ b/internal/gateway/turn_ledger_test.go @@ -3,9 +3,10 @@ package gateway import ( "context" "errors" - "path/filepath" "testing" "time" + + "github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgtest" ) func TestTurnLedgerClaimLifecycleIsIdempotent(t *testing.T) { @@ -14,17 +15,17 @@ func TestTurnLedgerClaimLifecycleIsIdempotent(t *testing.T) { open func(t *testing.T) (TurnLedger, func()) }{ { - name: "sqlite memory", + name: "memory", open: func(t *testing.T) (TurnLedger, func()) { - store, err := NewSQLiteSessionStoreMemory() - if err != nil { - t.Fatal(err) - } - ledger, ok := store.(TurnLedger) - if !ok { - t.Fatalf("store is %T, want TurnLedger", store) - } - return ledger, func() { _ = store.Close() } + store := NewSessionStoreMemory() + return store.(TurnLedger), func() { _ = store.Close() } + }, + }, + { + name: "postgres", + open: func(t *testing.T) (TurnLedger, func()) { + store := newPostgresStore(t) + return store.(TurnLedger), func() { _ = store.Close() } }, }, } @@ -109,17 +110,17 @@ func TestTurnLedgerReclaimsAcrossProcessOwnersAndRejectsStaleWrites(t *testing.T open func(t *testing.T) (TurnLedger, func()) }{ { - name: "sqlite memory", + name: "memory", open: func(t *testing.T) (TurnLedger, func()) { - store, err := NewSQLiteSessionStoreMemory() - if err != nil { - t.Fatal(err) - } - ledger, ok := store.(TurnLedger) - if !ok { - t.Fatalf("store is %T, want TurnLedger", store) - } - return ledger, func() { _ = store.Close() } + store := NewSessionStoreMemory() + return store.(TurnLedger), func() { _ = store.Close() } + }, + }, + { + name: "postgres", + open: func(t *testing.T) (TurnLedger, func()) { + store := newPostgresStore(t) + return store.(TurnLedger), func() { _ = store.Close() } }, }, } @@ -171,15 +172,10 @@ func TestSessionDeleteRemovesTurns(t *testing.T) { open func(t *testing.T) SessionStore }{ { - name: "sqlite memory", - open: func(t *testing.T) SessionStore { - store, err := NewSQLiteSessionStoreMemory() - if err != nil { - t.Fatal(err) - } - return store - }, + name: "memory", + open: func(*testing.T) SessionStore { return NewSessionStoreMemory() }, }, + {name: "postgres", open: newPostgresStore}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -208,12 +204,9 @@ func TestSessionDeleteRemovesTurns(t *testing.T) { } func TestTurnLedgerPersistsToolCallsAcrossClaimAndReopen(t *testing.T) { - path := filepath.Join(t.TempDir(), "sessions.db") + url := pgtest.URL(t) ctx := context.Background() - store, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("OpenSQLiteSessionStore() error = %v", err) - } + store := openPostgresStoreAt(t, url) ledger, ok := store.(TurnLedger) if !ok { t.Fatalf("store is %T, want TurnLedger", store) @@ -251,10 +244,7 @@ func TestTurnLedgerPersistsToolCallsAcrossClaimAndReopen(t *testing.T) { if err := store.Close(); err != nil { t.Fatalf("Close() error = %v", err) } - reopened, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("reopen error = %v", err) - } + reopened := openPostgresStoreAt(t, url) defer func() { _ = reopened.Close() }() reopenedLedger, ok := reopened.(TurnLedger) if !ok { @@ -269,13 +259,10 @@ func TestTurnLedgerPersistsToolCallsAcrossClaimAndReopen(t *testing.T) { } } -func TestSQLiteTurnLedgerSurvivesReopen(t *testing.T) { - path := filepath.Join(t.TempDir(), "sessions.db") +func TestPostgresTurnLedgerSurvivesReopen(t *testing.T) { + url := pgtest.URL(t) ctx := context.Background() - store, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("OpenSQLiteSessionStore() error = %v", err) - } + store := openPostgresStoreAt(t, url) ledger, ok := store.(TurnLedger) if !ok { t.Fatalf("store is %T, want TurnLedger", store) @@ -300,10 +287,7 @@ func TestSQLiteTurnLedgerSurvivesReopen(t *testing.T) { t.Fatalf("Close() error = %v", err) } - reopened, err := OpenSQLiteSessionStore(path) - if err != nil { - t.Fatalf("reopen error = %v", err) - } + reopened := openPostgresStoreAt(t, url) defer func() { _ = reopened.Close() }() reopenedLedger, ok := reopened.(TurnLedger) if !ok { @@ -347,7 +331,7 @@ func TestCanonicalTurnIDComponentsAreInjectivelyEncoded(t *testing.T) { func TestTurnRunnerCanonicalTurnIDPreservesMatchingLegacyRecord(t *testing.T) { t.Parallel() - store := newTestSQLiteStore(t) + store := NewSessionStoreMemory() ledger, ok := store.(TurnLedger) if !ok { t.Fatalf("store is %T, want TurnLedger", store) @@ -378,7 +362,7 @@ func TestTurnRunnerCanonicalTurnIDPreservesMatchingLegacyRecord(t *testing.T) { func TestTurnRunnerCanonicalTurnIDRejectsCollidingLegacyRecord(t *testing.T) { t.Parallel() - store := newTestSQLiteStore(t) + store := NewSessionStoreMemory() ledger, ok := store.(TurnLedger) if !ok { t.Fatalf("store is %T, want TurnLedger", store)