package store import ( "context" "database/sql" "encoding/json" "errors" "time" "github.com/google/uuid" ) const TaskFocusEventType = "task.focus.complete" type TaskFocus struct { UUID string `json:"uuid"` TaskUUID string `json:"task_uuid"` Phase string `json:"phase"` State string `json:"state"` DurationMS int64 `json:"duration_ms"` RemainingMS int64 `json:"remaining_ms"` DeadlineMS int64 `json:"deadline_ms"` CreatedMS int64 `json:"created_at_ms"` UpdatedMS int64 `json:"updated_at_ms"` Version int64 `json:"version"` } func (s *Store) ensureTaskFocusSchema() error { _, err := s.DB.Exec(`CREATE TABLE IF NOT EXISTS organizer_focus(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,uuid TEXT PRIMARY KEY,task_uuid TEXT NOT NULL,phase TEXT NOT NULL,state TEXT NOT NULL,duration_ms INTEGER NOT NULL,remaining_ms INTEGER NOT NULL,deadline_ms INTEGER NOT NULL,created_at_ms INTEGER NOT NULL,updated_at_ms INTEGER NOT NULL,version INTEGER NOT NULL); CREATE UNIQUE INDEX IF NOT EXISTS organizer_focus_active ON organizer_focus(owner_uuid) WHERE state IN ('running','paused'); CREATE INDEX IF NOT EXISTS organizer_focus_due ON organizer_focus(state,deadline_ms,uuid); CREATE INDEX IF NOT EXISTS organizer_focus_owner ON organizer_focus(domain_uuid,owner_uuid,created_at_ms DESC,uuid DESC); CREATE TABLE IF NOT EXISTS organizer_focus_changes(session_uuid TEXT NOT NULL,version INTEGER NOT NULL,action TEXT NOT NULL,created_at_ms INTEGER NOT NULL,data TEXT NOT NULL,PRIMARY KEY(session_uuid,version))`) if err != nil { return err } return s.ensureTaskFocusSpans() } const focusColumns = `uuid,task_uuid,phase,state,duration_ms,remaining_ms,deadline_ms,created_at_ms,updated_at_ms,version` func scanFocus(row interface{ Scan(...any) error }) (TaskFocus, error) { var f TaskFocus err := row.Scan(&f.UUID, &f.TaskUUID, &f.Phase, &f.State, &f.DurationMS, &f.RemainingMS, &f.DeadlineMS, &f.CreatedMS, &f.UpdatedMS, &f.Version) return f, err } func (s *Store) LatestTaskFocus(ctx context.Context, domain, actor string) (*TaskFocus, error) { if err := taskActor(ctx, s.DB, domain, actor, false); err != nil { return nil, err } f, err := scanFocus(s.DB.QueryRowContext(ctx, `SELECT `+focusColumns+` FROM organizer_focus WHERE domain_uuid=? AND owner_uuid=? AND state IN ('running','paused')`, domain, actor)) if errors.Is(err, sql.ErrNoRows) { f, err = scanFocus(s.DB.QueryRowContext(ctx, `SELECT `+focusColumns+` FROM organizer_focus WHERE domain_uuid=? AND owner_uuid=? ORDER BY created_at_ms DESC,uuid DESC LIMIT 1`, domain, actor)) } if errors.Is(err, sql.ErrNoRows) { return nil, nil } if err != nil { return nil, err } return &f, nil } func recordFocusTx(ctx context.Context, tx *sql.Tx, f TaskFocus, action string) error { if err := recordFocusSpanTx(ctx, tx, f); err != nil { return err } data, err := json.Marshal(f) if err != nil { return err } _, err = tx.ExecContext(ctx, `INSERT INTO organizer_focus_changes(session_uuid,version,action,created_at_ms,data) VALUES(?,?,?,?,?)`, f.UUID, f.Version, action, f.UpdatedMS, string(data)) return err } // ChangeTaskFocus serializes transitions, including cross-Domain starts, under // SQLite's writer lock. The partial unique index is a second line of defense. // The supplied time is server-controlled (also allows deterministic tests). func (s *Store) ChangeTaskFocus(ctx context.Context, domain, actor, action string, f TaskFocus, expected int64, now time.Time) (TaskFocus, error) { if _, err := uuid.Parse(f.UUID); err != nil { return f, ErrTaskInvalid } tx, err := s.DB.BeginTx(ctx, nil) if err != nil { return f, err } defer tx.Rollback() if _, err = tx.ExecContext(ctx, `UPDATE domain_memberships SET state=state WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil { return f, err } if err = taskActor(ctx, tx, domain, actor, true); err != nil { return f, err } enabled, err := taskReminderExtensionEnabled(ctx, tx, domain) if err != nil { return f, err } if !enabled { return f, ErrAccessDenied } old, err := scanFocus(tx.QueryRowContext(ctx, `SELECT `+focusColumns+` FROM organizer_focus WHERE domain_uuid=? AND owner_uuid=? AND uuid=?`, domain, actor, f.UUID)) if err != nil && !errors.Is(err, sql.ErrNoRows) { return f, err } ms := now.UnixMilli() if action == "start" { if f.Phase != "focus" && f.Phase != "break" || f.DurationMS < 60000 || f.DurationMS > 180*60000 || f.DurationMS%60000 != 0 || expected != 0 { return f, ErrTaskInvalid } if err == nil { if old.TaskUUID != f.TaskUUID || old.Phase != f.Phase || old.DurationMS != f.DurationMS { return f, ErrTaskConflict } return old, tx.Commit() } if f.TaskUUID != "" { var exists bool if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_items WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND kind='task' AND archived=0 AND status NOT IN ('done','cancelled'))`, domain, actor, f.TaskUUID).Scan(&exists); err != nil { return f, err } if !exists { return f, sql.ErrNoRows } } var otherDomain, otherID string err = tx.QueryRowContext(ctx, `SELECT domain_uuid,uuid FROM organizer_focus WHERE owner_uuid=? AND state IN ('running','paused')`, actor).Scan(&otherDomain, &otherID) if err != nil && !errors.Is(err, sql.ErrNoRows) { return f, err } if err == nil { allowed := taskActor(ctx, tx, otherDomain, actor, false) if allowed != nil && !errors.Is(allowed, ErrAccessDenied) { return f, allowed } on, e := taskReminderExtensionEnabled(ctx, tx, otherDomain) if e != nil { return f, e } if allowed == nil && on { return f, ErrTaskConflict } // A timer stranded in a revoked/disabled Domain must not lock the // user out forever. Release only their timer, never another task. stale, e := scanFocus(tx.QueryRowContext(ctx, `SELECT `+focusColumns+` FROM organizer_focus WHERE uuid=?`, otherID)) if e != nil { return f, e } if stale.State == "running" { stale.RemainingMS = max(0, min(stale.RemainingMS, stale.DeadlineMS-ms)) } stale.State = "cancelled" stale.DeadlineMS = 0 stale.UpdatedMS = ms stale.Version++ if _, e = tx.ExecContext(ctx, `UPDATE organizer_focus SET state='cancelled',deadline_ms=0,remaining_ms=?,updated_at_ms=?,version=? WHERE uuid=?`, stale.RemainingMS, ms, stale.Version, stale.UUID); e != nil { return f, e } if e = recordFocusTx(ctx, tx, stale, "revoked"); e != nil { return f, e } } f.State = "running" f.RemainingMS = f.DurationMS f.DeadlineMS = ms + f.DurationMS f.CreatedMS = ms f.UpdatedMS = ms f.Version = 1 res, e := tx.ExecContext(ctx, `INSERT OR IGNORE INTO organizer_focus(domain_uuid,owner_uuid,uuid,task_uuid,phase,state,duration_ms,remaining_ms,deadline_ms,created_at_ms,updated_at_ms,version) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`, domain, actor, f.UUID, f.TaskUUID, f.Phase, f.State, f.DurationMS, f.RemainingMS, f.DeadlineMS, f.CreatedMS, f.UpdatedMS, f.Version) if e != nil { return f, e } if n, _ := res.RowsAffected(); n != 1 { return f, ErrTaskConflict } } else { if err != nil { return f, err } f = old if f.Version != expected { return f, ErrTaskConflict } if f.State != "running" && f.State != "paused" { return f, ErrTaskConflict } if f.State == "running" { f.RemainingMS = max(0, min(f.RemainingMS, f.DeadlineMS-ms)) } switch action { case "pause": if f.State != "running" || f.RemainingMS == 0 { return f, ErrTaskConflict } f.State = "paused" f.DeadlineMS = 0 case "resume": if f.State != "paused" { return f, ErrTaskConflict } f.State = "running" f.DeadlineMS = ms + f.RemainingMS case "complete": f.State = "completed" f.DeadlineMS = 0 case "cancel": f.State = "cancelled" f.DeadlineMS = 0 default: return f, ErrTaskInvalid } f.Version++ f.UpdatedMS = ms if _, err = tx.ExecContext(ctx, `UPDATE organizer_focus SET state=?,remaining_ms=?,deadline_ms=?,updated_at_ms=?,version=? WHERE uuid=?`, f.State, f.RemainingMS, f.DeadlineMS, f.UpdatedMS, f.Version, f.UUID); err != nil { return f, err } } if err = recordFocusTx(ctx, tx, f, action); err != nil { return f, err } return f, tx.Commit() } // A bounded, indexed sweep completes timers even while all browsers are closed. // Completing a timer never changes a task's status, due date or planned date. func (s *Store) CompleteTaskFocus(ctx context.Context, now time.Time, limit int) (int, error) { if limit < 1 || limit > 100 { limit = 100 } ctx, cancel := context.WithTimeout(ctx, 3*time.Second) defer cancel() tx, err := s.DB.BeginTx(ctx, nil) if err != nil { return 0, err } defer tx.Rollback() if _, err = tx.ExecContext(ctx, `UPDATE organizer_focus SET state=state WHERE rowid=-1`); err != nil { return 0, err } rows, err := tx.QueryContext(ctx, `SELECT domain_uuid,owner_uuid,uuid FROM organizer_focus WHERE state='running' AND deadline_ms<=? ORDER BY deadline_ms,uuid LIMIT ?`, now.UnixMilli(), limit) if err != nil { return 0, err } type entry struct{ domain, owner, id string } items := []entry{} for rows.Next() { var e entry if err = rows.Scan(&e.domain, &e.owner, &e.id); err != nil { rows.Close() return 0, err } items = append(items, e) } err = rows.Err() rows.Close() if err != nil { return 0, err } for _, e := range items { f, err := scanFocus(tx.QueryRowContext(ctx, `SELECT `+focusColumns+` FROM organizer_focus WHERE uuid=?`, e.id)) if err != nil { return 0, err } enabled, err := taskReminderExtensionEnabled(ctx, tx, e.domain) if err != nil { return 0, err } auth := taskActor(ctx, tx, e.domain, e.owner, false) if auth != nil && !errors.Is(auth, ErrAccessDenied) { return 0, auth } // Stop unauthorized/disabled sessions without notification. Do not queue // them indefinitely ahead of valid timers belonging to other users. f.State = "completed" action := "elapsed" if !enabled || auth != nil { f.State = "cancelled" action = "revoked" } if enabled && auth == nil && now.UnixMilli()-f.DeadlineMS < 24*time.Hour.Milliseconds() { _, _, err = s.CreateNotificationTx(tx, Notification{DomainUUID: e.domain, RecipientUUID: e.owner, EventUUID: f.UUID, Kind: TaskFocusEventType, RequestUUID: f.TaskUUID, Href: "/v/plan/today", Message: "Timer completed", CreatedAtMS: now.UnixMilli()}) if err != nil { return 0, err } } f.RemainingMS = 0 f.DeadlineMS = 0 f.UpdatedMS = now.UnixMilli() f.Version++ if _, err = tx.ExecContext(ctx, `UPDATE organizer_focus SET state=?,remaining_ms=0,deadline_ms=0,updated_at_ms=?,version=? WHERE uuid=?`, f.State, f.UpdatedMS, f.Version, f.UUID); err != nil { return 0, err } if err = recordFocusTx(ctx, tx, f, action); err != nil { return 0, err } } if err = tx.Commit(); err != nil { return 0, err } return len(items), nil } func (s *Store) EnsureTaskFocusEvent() error { now := time.Now().UnixMilli() _, err := s.DB.Exec(`INSERT OR IGNORE INTO event_definitions(uuid,name,event_type,event_key,payload,schedule_kind,interval_seconds,next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms) VALUES('builtin.task.focus','Focus timer completion',?,'local','{}','interval',60,?,1,-2,3,?,?)`, TaskFocusEventType, now, now, now) return err }