xonecas.io
62159
Sy

symb / commit 6c943d9

fix: loosing messages on db busy

xonecas2026-02-16 6c943d93733c6f91a94577716592e2302f81c348 parent 0071d95

7 files changed

cmd/symb/main.go+4−1
@@ -235,7 +235,10 @@ func openWebCache(cfg *config.Config) *store.Cache {
235235
236236 func newSessionID() string {
237237 b := make([]byte, 16)
238- rand.Read(b) //nolint:errcheck
238+ if _, err := rand.Read(b); err != nil {
239+ log.Warn().Err(err).Msg("failed to read random bytes for session id")
240+ return fmt.Sprintf("%x", time.Now().UnixNano())
241+ }
239242 return hex.EncodeToString(b)
240243 }
241244
internal/store/session.go+123−19
@@ -3,12 +3,19 @@ package store
33 import (
44 "encoding/json"
55 "fmt"
6+ "strings"
67 "time"
78
89 "github.com/rs/zerolog/log"
910 "github.com/xonecas/symb/internal/provider"
1011 )
1112
13+const (
14+ SQLiteBusyMaxRetries = 10
15+ SQLiteBusyBackoffStepMs = 50
16+ SQLiteBusyMaxBackoff = time.Second
17+)
18+
1219 // Session represents a conversation session.
1320 type Session struct {
1421 ID string
@@ -50,28 +57,33 @@ func (c *Cache) CreateSession(id string) error {
5057
5158 // SaveMessage persists a message synchronously.
5259 func (c *Cache) SaveMessage(sessionID string, msg SessionMessage) {
53- if c == nil {
54- return
60+ if err := c.SaveMessages(sessionID, []SessionMessage{msg}); err != nil {
61+ log.Warn().Err(err).Str("session", sessionID).Msg("failed to save message")
5562 }
56- c.mu.Lock()
57- defer c.mu.Unlock()
63+}
5864
59- tc := msg.ToolCalls
60- if tc == nil {
61- tc = json.RawMessage("[]")
65+// SaveMessages persists a batch of messages atomically.
66+func (c *Cache) SaveMessages(sessionID string, msgs []SessionMessage) error {
67+ if c == nil || len(msgs) == 0 {
68+ return nil
6269 }
6370
64- _, err := c.db.Exec(
65- `INSERT INTO messages (session_id, role, content, reasoning, tool_calls, tool_call_id, created, input_tokens, output_tokens)
66- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
67- sessionID, msg.Role, msg.Content, msg.Reasoning, string(tc), msg.ToolCallID, msg.CreatedAt.Unix(),
68- msg.InputTokens, msg.OutputTokens,
69- )
70- if err != nil {
71- log.Warn().Err(err).Str("session", sessionID).Msg("failed to save message")
71+ var err error
72+ for attempt := 0; attempt <= SQLiteBusyMaxRetries; attempt++ {
73+ err = c.saveMessagesOnce(sessionID, msgs)
74+ if err == nil {
75+ return nil
76+ }
77+ if !IsSQLiteBusy(err) || attempt == SQLiteBusyMaxRetries {
78+ return err
79+ }
80+ backoff := time.Duration((attempt+1)*SQLiteBusyBackoffStepMs) * time.Millisecond
81+ if backoff > SQLiteBusyMaxBackoff {
82+ backoff = SQLiteBusyMaxBackoff
83+ }
84+ time.Sleep(backoff)
7285 }
73-
74- c.db.Exec("UPDATE sessions SET updated = ? WHERE id = ?", time.Now().Unix(), sessionID) //nolint:errcheck
86+ return err
7587 }
7688
7789 // SaveMessageSync persists a message synchronously and returns its DB row ID.
@@ -80,29 +92,121 @@ func (c *Cache) SaveMessageSync(sessionID string, msg SessionMessage) (int64, er
8092 if c == nil {
8193 return 0, nil
8294 }
95+
96+ var err error
97+ for attempt := 0; attempt <= SQLiteBusyMaxRetries; attempt++ {
98+ id, attemptErr := c.saveMessageSyncOnce(sessionID, msg)
99+ if attemptErr == nil {
100+ return id, nil
101+ }
102+ err = attemptErr
103+ if !IsSQLiteBusy(err) || attempt == SQLiteBusyMaxRetries {
104+ return 0, err
105+ }
106+ backoff := time.Duration((attempt+1)*SQLiteBusyBackoffStepMs) * time.Millisecond
107+ if backoff > SQLiteBusyMaxBackoff {
108+ backoff = SQLiteBusyMaxBackoff
109+ }
110+ time.Sleep(backoff)
111+ }
112+ return 0, err
113+}
114+
115+func (c *Cache) saveMessagesOnce(sessionID string, msgs []SessionMessage) error {
116+ c.mu.Lock()
117+ defer c.mu.Unlock()
118+
119+ tx, err := c.db.Begin()
120+ if err != nil {
121+ return err
122+ }
123+
124+ for _, msg := range msgs {
125+ tc := msg.ToolCalls
126+ if tc == nil {
127+ tc = json.RawMessage("[]")
128+ }
129+ if _, err := tx.Exec(
130+ `INSERT INTO messages (session_id, role, content, reasoning, tool_calls, tool_call_id, created, input_tokens, output_tokens)
131+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
132+ sessionID, msg.Role, msg.Content, msg.Reasoning, string(tc), msg.ToolCallID, msg.CreatedAt.Unix(),
133+ msg.InputTokens, msg.OutputTokens,
134+ ); err != nil {
135+ if rbErr := tx.Rollback(); rbErr != nil {
136+ log.Warn().Err(rbErr).Msg("failed to rollback message save")
137+ }
138+ return err
139+ }
140+ }
141+
142+ if _, err := tx.Exec("UPDATE sessions SET updated = ? WHERE id = ?", time.Now().Unix(), sessionID); err != nil {
143+ if rbErr := tx.Rollback(); rbErr != nil {
144+ log.Warn().Err(rbErr).Msg("failed to rollback message save")
145+ }
146+ return err
147+ }
148+
149+ if err := tx.Commit(); err != nil {
150+ if rbErr := tx.Rollback(); rbErr != nil {
151+ log.Warn().Err(rbErr).Msg("failed to rollback message save")
152+ }
153+ return err
154+ }
155+ return nil
156+}
157+
158+func (c *Cache) saveMessageSyncOnce(sessionID string, msg SessionMessage) (int64, error) {
83159 c.mu.Lock()
84160 defer c.mu.Unlock()
85161
162+ tx, err := c.db.Begin()
163+ if err != nil {
164+ return 0, err
165+ }
166+
86167 tc := msg.ToolCalls
87168 if tc == nil {
88169 tc = json.RawMessage("[]")
89170 }
90171
91- res, err := c.db.Exec(
172+ res, err := tx.Exec(
92173 `INSERT INTO messages (session_id, role, content, reasoning, tool_calls, tool_call_id, created, input_tokens, output_tokens)
93174 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
94175 sessionID, msg.Role, msg.Content, msg.Reasoning, string(tc), msg.ToolCallID, msg.CreatedAt.Unix(),
95176 msg.InputTokens, msg.OutputTokens,
96177 )
97178 if err != nil {
179+ if rbErr := tx.Rollback(); rbErr != nil {
180+ log.Warn().Err(rbErr).Msg("failed to rollback message save")
181+ }
182+ return 0, err
183+ }
184+
185+ if _, err := tx.Exec("UPDATE sessions SET updated = ? WHERE id = ?", time.Now().Unix(), sessionID); err != nil {
186+ if rbErr := tx.Rollback(); rbErr != nil {
187+ log.Warn().Err(rbErr).Msg("failed to rollback message save")
188+ }
98189 return 0, err
99190 }
100191
101- c.db.Exec("UPDATE sessions SET updated = ? WHERE id = ?", time.Now().Unix(), sessionID) //nolint:errcheck
192+ if err := tx.Commit(); err != nil {
193+ if rbErr := tx.Rollback(); rbErr != nil {
194+ log.Warn().Err(rbErr).Msg("failed to rollback message save")
195+ }
196+ return 0, err
197+ }
102198
103199 return res.LastInsertId()
104200 }
105201
202+func IsSQLiteBusy(err error) bool {
203+ if err == nil {
204+ return false
205+ }
206+ msg := err.Error()
207+ return strings.Contains(msg, "SQLITE_BUSY") || strings.Contains(msg, "database is locked")
208+}
209+
106210 // DeleteMessagesFrom removes all messages with id >= minID for a session.
107211 func (c *Cache) DeleteMessagesFrom(sessionID string, minID int64) error {
108212 if c == nil {
internal/store/store.go+11−3
@@ -92,7 +92,9 @@ func Open(dbPath string, ttl time.Duration) (*Cache, error) {
9292 // Migrate: drop old search_cache with keywords column and recreate.
9393 // This is a cache, so losing data is acceptable.
9494 if hasColumn(db, "search_cache", "keywords") {
95- db.Exec("DROP TABLE search_cache") //nolint:errcheck // best-effort migration
95+ if _, err := db.Exec("DROP TABLE search_cache"); err != nil {
96+ log.Warn().Err(err).Msg("failed to drop search_cache for migration")
97+ }
9698 }
9799
98100 if _, err := db.Exec(schema); err != nil {
@@ -102,8 +104,14 @@ func Open(dbPath string, ttl time.Duration) (*Cache, error) {
102104
103105 // Migrate: add token count columns to messages table.
104106 if !hasColumn(db, "messages", "input_tokens") {
105- db.Exec("ALTER TABLE messages ADD COLUMN input_tokens INTEGER NOT NULL DEFAULT 0") //nolint:errcheck
106- db.Exec("ALTER TABLE messages ADD COLUMN output_tokens INTEGER NOT NULL DEFAULT 0") //nolint:errcheck
107+ if _, err := db.Exec("ALTER TABLE messages ADD COLUMN input_tokens INTEGER NOT NULL DEFAULT 0"); err != nil {
108+ db.Close()
109+ return nil, fmt.Errorf("add messages.input_tokens: %w", err)
110+ }
111+ if _, err := db.Exec("ALTER TABLE messages ADD COLUMN output_tokens INTEGER NOT NULL DEFAULT 0"); err != nil {
112+ db.Close()
113+ return nil, fmt.Errorf("add messages.output_tokens: %w", err)
114+ }
107115 }
108116
109117 c := &Cache{
internal/tui/gitdiff_test.go+5−1
@@ -51,7 +51,11 @@ func setupGitRepo(t *testing.T) (string, func()) {
5151 }
5252 }
5353
54- return dir, func() { os.Chdir(origDir) } //nolint:errcheck
54+ return dir, func() {
55+ if err := os.Chdir(origDir); err != nil {
56+ t.Errorf("restore chdir: %v", err)
57+ }
58+ }
5559 }
5660
5761 // ---------------------------------------------------------------------------
internal/tui/messages.go+72−2
@@ -9,6 +9,7 @@ import (
99 "time"
1010
1111 tea "charm.land/bubbletea/v2"
12+ "github.com/rs/zerolog/log"
1213 "github.com/xonecas/symb/internal/delta"
1314 "github.com/xonecas/symb/internal/llm"
1415 "github.com/xonecas/symb/internal/mcp"
@@ -46,6 +47,11 @@ type llmUsageMsg struct {
4647 outputTokens int
4748 }
4849
50+type storeBatch struct {
51+ sessionID string
52+ msgs []store.SessionMessage
53+}
54+
4955 type llmHistoryMsg struct{ msg provider.Message }
5056 type llmErrorMsg struct{ err error }
5157
@@ -246,7 +252,12 @@ func (m Model) processLLM() tea.Cmd {
246252 func messageToStore(msg provider.Message) store.SessionMessage {
247253 var tc json.RawMessage
248254 if len(msg.ToolCalls) > 0 {
249- tc, _ = json.Marshal(msg.ToolCalls) //nolint:errcheck
255+ encoded, err := json.Marshal(msg.ToolCalls)
256+ if err != nil {
257+ log.Warn().Err(err).Msg("failed to marshal tool calls")
258+ } else {
259+ tc = encoded
260+ }
250261 }
251262 return store.SessionMessage{
252263 Role: msg.Role,
@@ -265,5 +276,64 @@ func (m *Model) saveMessage(msg provider.Message) {
265276 if m.store == nil {
266277 return
267278 }
268- m.store.SaveMessage(m.sessionID, messageToStore(msg))
279+ stored := []store.SessionMessage{messageToStore(msg)}
280+ if m.storeQueue != nil {
281+ select {
282+ case m.storeQueue <- storeBatch{sessionID: m.sessionID, msgs: stored}:
283+ return
284+ default:
285+ log.Warn().Msg("store queue full; falling back to sync save")
286+ }
287+ }
288+ if err := m.store.SaveMessages(m.sessionID, stored); err != nil {
289+ log.Warn().Err(err).Msg("failed to save message batch")
290+ }
291+}
292+
293+func (m *Model) saveMessages(msgs []provider.Message) {
294+ if m.store == nil || len(msgs) == 0 {
295+ return
296+ }
297+ stored := make([]store.SessionMessage, 0, len(msgs))
298+ for _, msg := range msgs {
299+ stored = append(stored, messageToStore(msg))
300+ }
301+ if m.storeQueue != nil {
302+ select {
303+ case m.storeQueue <- storeBatch{sessionID: m.sessionID, msgs: stored}:
304+ return
305+ default:
306+ log.Warn().Msg("store queue full; dropping message batch")
307+ return
308+ }
309+ }
310+ if err := m.store.SaveMessages(m.sessionID, stored); err != nil {
311+ log.Warn().Err(err).Msg("failed to save message batch")
312+ }
313+}
314+
315+func startStoreWorker(db *store.Cache, queue <-chan storeBatch) <-chan struct{} {
316+ done := make(chan struct{})
317+ go func() {
318+ defer close(done)
319+ for batch := range queue {
320+ for attempt := 0; attempt <= store.SQLiteBusyMaxRetries; attempt++ {
321+ err := db.SaveMessages(batch.sessionID, batch.msgs)
322+ if err == nil {
323+ break
324+ }
325+ if !store.IsSQLiteBusy(err) || attempt == store.SQLiteBusyMaxRetries {
326+ log.Warn().Err(err).Msg("failed to save message batch")
327+ break
328+ }
329+ log.Warn().Err(err).Msg("retrying message save after busy")
330+ backoff := time.Duration((attempt+1)*store.SQLiteBusyBackoffStepMs) * time.Millisecond
331+ if backoff > store.SQLiteBusyMaxBackoff {
332+ backoff = store.SQLiteBusyMaxBackoff
333+ }
334+ time.Sleep(backoff)
335+ }
336+ }
337+ }()
338+ return done
269339 }
internal/tui/tui.go+22−5
@@ -8,6 +8,7 @@ import (
88
99 tea "charm.land/bubbletea/v2"
1010 "charm.land/lipgloss/v2"
11+ "github.com/rs/zerolog/log"
1112 "github.com/xonecas/symb/internal/constants"
1213 "github.com/xonecas/symb/internal/delta"
1314 "github.com/xonecas/symb/internal/filesearch"
@@ -206,8 +207,10 @@ type Model struct {
206207 turnCancel context.CancelFunc // cancels current LLM turn only (nil when idle)
207208
208209 // Session persistence
209- store *store.Cache
210- sessionID string
210+ store *store.Cache
211+ storeQueue chan storeBatch
212+ storeQueueDone <-chan struct{}
213+ sessionID string
211214
212215 // Conversation
213216 convEntries []convEntry // Conversation entries (not wrapped)
@@ -306,6 +309,12 @@ func New(prov provider.Provider, proxy *mcp.Proxy, tools []mcp.Tool, modelID str
306309 ai.Focus()
307310
308311 ch := make(chan tea.Msg, 500)
312+ var storeQueue chan storeBatch
313+ var storeQueueDone <-chan struct{}
314+ if db != nil {
315+ storeQueue = make(chan storeBatch, 256)
316+ storeQueueDone = startStoreWorker(db, storeQueue)
317+ }
309318 ctx, cancel := context.WithCancel(context.Background())
310319
311320 var entries []convEntry
@@ -315,7 +324,13 @@ func New(prov provider.Provider, proxy *mcp.Proxy, tools []mcp.Tool, modelID str
315324 systemPrompt := llm.BuildSystemPrompt(modelID, idx)
316325 systemMsg := provider.Message{Role: "system", Content: systemPrompt, CreatedAt: time.Now()}
317326 if db != nil {
318- db.SaveMessage(sessionID, messageToStore(systemMsg))
327+ if storeQueue != nil {
328+ storeQueue <- storeBatch{sessionID: sessionID, msgs: []store.SessionMessage{messageToStore(systemMsg)}}
329+ } else {
330+ if err := db.SaveMessages(sessionID, []store.SessionMessage{messageToStore(systemMsg)}); err != nil {
331+ log.Warn().Err(err).Msg("failed to save system message")
332+ }
333+ }
319334 }
320335 }
321336
@@ -333,8 +348,10 @@ func New(prov provider.Provider, proxy *mcp.Proxy, tools []mcp.Tool, modelID str
333348 ctx: ctx,
334349 cancel: cancel,
335350
336- store: db,
337- sessionID: sessionID,
351+ store: db,
352+ storeQueue: storeQueue,
353+ storeQueueDone: storeQueueDone,
354+ sessionID: sessionID,
338355
339356 scratchpad: pad,
340357 deltaTracker: dt,
internal/tui/update.go+37−4
@@ -173,12 +173,27 @@ func (m *Model) insertPaste(text string) {
173173 }
174174 }
175175
176+func (m *Model) flushAndQuit() tea.Cmd {
177+ queue := m.storeQueue
178+ done := m.storeQueueDone
179+ return func() tea.Msg {
180+ if queue != nil {
181+ close(queue)
182+ queue = nil
183+ }
184+ if done != nil {
185+ <-done
186+ }
187+ return tea.Quit()
188+ }
189+}
190+
176191 // handleKeyPress processes key events. Returns (model, cmd, true) if handled.
177192 func (m *Model) handleKeyPress(msg tea.KeyPressMsg) (Model, tea.Cmd, bool) {
178193 switch msg.Keystroke() {
179194 case "ctrl+c":
180195 m.cancel()
181- return *m, tea.Quit, true
196+ return *m, m.flushAndQuit(), true
182197 case "ctrl+shift+c":
183198 if cmd := m.copySelection(); cmd != nil {
184199 return *m, cmd, true
@@ -264,6 +279,15 @@ func (m Model) handleLLMBatch(batch llmBatchMsg) (tea.Model, tea.Cmd) {
264279 if !m.llmInFlight {
265280 return m.drainCancelled(batch)
266281 }
282+ var history []provider.Message
283+ for _, raw := range batch {
284+ if msg, ok := raw.(llmHistoryMsg); ok {
285+ history = append(history, msg.msg)
286+ }
287+ }
288+ if len(history) > 0 {
289+ m.saveMessages(history)
290+ }
267291 for _, raw := range batch {
268292 switch msg := raw.(type) {
269293 case llmReasoningDeltaMsg:
@@ -277,7 +301,7 @@ func (m Model) handleLLMBatch(batch llmBatchMsg) (tea.Model, tea.Cmd) {
277301 m.streamDirty = true
278302
279303 case llmHistoryMsg:
280- m.saveMessage(msg.msg)
304+ // Saved in a single transaction above.
281305
282306 case llmAssistantMsg:
283307 m.applyAssistantMsg(msg)
@@ -319,10 +343,19 @@ func (m Model) handleLLMBatch(batch llmBatchMsg) (tea.Model, tea.Cmd) {
319343 // drainCancelled handles a batch after the turn was cancelled.
320344 // It persists history messages and patches invalid API state on termination.
321345 func (m Model) drainCancelled(batch llmBatchMsg) (tea.Model, tea.Cmd) {
346+ var history []provider.Message
322347 for _, raw := range batch {
323- switch msg := raw.(type) {
348+ if msg, ok := raw.(llmHistoryMsg); ok {
349+ history = append(history, msg.msg)
350+ }
351+ }
352+ if len(history) > 0 {
353+ m.saveMessages(history)
354+ }
355+ for _, raw := range batch {
356+ switch raw.(type) {
324357 case llmHistoryMsg:
325- m.saveMessage(msg.msg)
358+ // Saved in a single transaction above.
326359 case llmDoneMsg, llmErrorMsg:
327360 m.patchInterruptedHistory()
328361 m.turnCancel = nil