Periodically write state file for external integration

README.md

@@ -170,6 +170,18 @@ Example `pomo.yaml`:
 # options: "ask" | "start" | "quit"
 onSessionEnd: "ask"
 
+# if enabled pomo will write current state to /tmp/pomo.json every second with format:
+# {
+#   "state": "running",
+#   "type": "work",
+#   "elapsed_seconds": 312,
+#   "duration_seconds": 1500,
+#   "remaining_seconds": 1188,
+#   "sessions_done": 1,
+#   "cycle_position": 2
+# }
+writeStateFile: false
+
 asciiArt:
   # use ASCII art for timer display
   enabled: true

config/config.go

@@ -51,11 +51,12 @@ type ASCIIArt struct {
 }
 
 type Config struct {
-	OnSessionEnd string
-	ASCIIArt     ASCIIArt
-	Work         Task
-	Break        Task
-	LongBreak    LongBreak
+	OnSessionEnd   string
+	WriteStateFile bool
+	ASCIIArt       ASCIIArt
+	Work           Task
+	Break          Task
+	LongBreak      LongBreak
 }
 
 var (
@@ -64,7 +65,8 @@ var (
 	C    Config
 
 	DefaultConfig = map[string]any{
-		"onSessionEnd": "ask",
+		"onSessionEnd":   "ask",
+		"writeStateFile": false,
 		"asciiArt": map[string]any{
 			"enabled": true,
 			"font":    ascii.DefaultFont,

config/config_test.go

@@ -84,6 +84,13 @@ longBreak:
 	assert.Equal(t, defaults.ASCIIArt.Font, C.ASCIIArt.Font)
 }
 
+func TestLoadConfigWriteStateFile(t *testing.T) {
+	setupViper()
+	writeAndLoadConfig(t, "writeStateFile: true")
+
+	assert.True(t, C.WriteStateFile)
+}
+
 func TestLoadConfigThenCommands(t *testing.T) {
 	configYAML := `
 work:
@@ -292,6 +299,7 @@ func getDefaultConfig() Config {
 func assertConfigMatches(t *testing.T, expected Config, actual Config) {
 	// main config assertion
 	assert.Equal(t, expected.OnSessionEnd, actual.OnSessionEnd)
+	assert.Equal(t, expected.WriteStateFile, actual.WriteStateFile)
 
 	// ASCII Art assertions
 	assert.Equal(t, expected.ASCIIArt.Enabled, actual.ASCIIArt.Enabled)

pomo.yaml

@@ -3,6 +3,7 @@
 # https://github.com/Bahaaio/pomo
 
 onSessionEnd: ask
+writeStateFile: false
 
 asciiArt:
   enabled: true

ui/handlers.go

@@ -48,6 +48,8 @@ func (m *Model) handleKeys(msg tea.KeyMsg) tea.Cmd {
 			m.sessionState = Paused
 		}
 
+		m.writeState()
+
 		if m.sessionState == Running {
 			return m.timer.Start()
 		}
@@ -118,6 +120,8 @@ func (m *Model) handleTimerTick(msg timer.TickMsg) tea.Cmd {
 	percent := m.getPercent()
 	cmds = append(cmds, m.progressBar.SetPercent(percent))
 
+	m.writeState()
+
 	return tea.Batch(cmds...)
 }
 
@@ -182,6 +186,7 @@ func (m *Model) handleCompletion() tea.Cmd {
 	case "ask":
 		m.sessionState = ShowingConfirm
 		m.confirmStartTime = time.Now()
+		m.writeState()
 
 		// send first confirm tick
 		return func() tea.Msg {
@@ -262,6 +267,7 @@ func (m *Model) startSession(taskType config.TaskType, task config.Task, isShort
 	m.timer = timer.New(m.currentTask.Duration)
 
 	m.sessionState = Running
+	m.writeState()
 	return tea.Batch(
 		m.progressBar.SetPercent(0.0),
 		m.timer.Start(),
@@ -299,6 +305,7 @@ func (m *Model) recordSession() {
 
 // handles the completion of post actions and quits the application
 func (m *Model) handleCommandsDone() tea.Cmd {
+	m.removeStateFile()
 	m.sessionState = Quitting
 	return tea.Quit
 }
@@ -345,6 +352,7 @@ func (m *Model) Quit() tea.Cmd {
 		return m.waitForCommands()
 	}
 
+	m.removeStateFile()
 	m.sessionState = Quitting
 	return tea.Quit
 }

ui/model.go

@@ -48,6 +48,9 @@ type Model struct {
 	timerFont       ascii.Font
 	asciiTimerStyle lipgloss.Style
 
+	// state file
+	writeStateFile bool
+
 	// databse
 	repo *db.SessionRepo
 }
@@ -97,6 +100,7 @@ func NewModel(taskType config.TaskType, cfg config.Config) Model {
 		longBreak:       cfg.LongBreak,
 		cyclePosition:   1,
 
+		writeStateFile:  cfg.WriteStateFile,
 		useTimerArt:     cfg.ASCIIArt.Enabled,
 		timerFont:       timerFont,
 		asciiTimerStyle: timerStyle,

ui/statefile.go

@@ -0,0 +1,77 @@
+package ui
+
+import (
+	"encoding/json"
+	"log"
+	"os"
+
+	"github.com/Bahaaio/pomo/config"
+)
+
+const stateFilePath = "/tmp/pomo.json"
+
+type sessionStateFile struct {
+	State            string  `json:"state"`
+	Type             string  `json:"type"`
+	ElapsedSeconds   int     `json:"elapsed_seconds"`
+	DurationSeconds  int     `json:"duration_seconds"`
+	RemainingSeconds int     `json:"remaining_seconds"`
+	Percent          float64 `json:"percent"`
+	SessionsDone     int     `json:"sessions_done"`
+	CyclePosition    int     `json:"cycle_position"`
+}
+
+func (m Model) writeState() {
+	if !m.writeStateFile {
+		return
+	}
+
+	s := sessionStateFile{
+		State:            m.stateString(),
+		Type:             m.typeString(),
+		ElapsedSeconds:   int(m.elapsed.Seconds()),
+		DurationSeconds:  int(m.duration.Seconds()),
+		RemainingSeconds: int((m.duration - m.elapsed).Seconds()),
+		Percent:          m.getPercent(),
+		SessionsDone:     m.sessionSummary.WorkSessions(),
+		CyclePosition:    m.cyclePosition,
+	}
+
+	data, err := json.Marshal(s)
+	if err != nil {
+		log.Printf("failed to marshal state file: %v", err)
+		return
+	}
+
+	if err := os.WriteFile(stateFilePath, data, 0644); err != nil {
+		log.Printf("failed to write state file: %v", err)
+	}
+}
+
+func (m Model) removeStateFile() {
+	if !m.writeStateFile {
+		return
+	}
+
+	if err := os.Remove(stateFilePath); err != nil && !os.IsNotExist(err) {
+		log.Printf("failed to remove state file: %v", err)
+	}
+}
+
+func (m Model) stateString() string {
+	switch m.sessionState {
+	case Paused:
+		return "paused"
+	case ShowingConfirm:
+		return "completed"
+	default:
+		return "running"
+	}
+}
+
+func (m Model) typeString() string {
+	if m.currentTaskType == config.WorkTask {
+		return "work"
+	}
+	return "break"
+}

ui/statefile_test.go

@@ -0,0 +1,120 @@
+package ui
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/Bahaaio/pomo/config"
+	"github.com/Bahaaio/pomo/ui/summary"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func newTestModel(writeStateFile bool) Model {
+	return Model{
+		writeStateFile:  writeStateFile,
+		sessionState:    Running,
+		currentTaskType: config.WorkTask,
+		elapsed:         5 * time.Minute,
+		duration:        25 * time.Minute,
+		sessionSummary:  summary.SessionSummary{},
+		cyclePosition:   2,
+	}
+}
+
+func readStateFile(t *testing.T) sessionStateFile {
+	t.Helper()
+	data, err := os.ReadFile(stateFilePath)
+	require.NoError(t, err)
+
+	var s sessionStateFile
+	require.NoError(t, json.Unmarshal(data, &s))
+	return s
+}
+
+func TestWriteState(t *testing.T) {
+	t.Cleanup(func() { os.Remove(stateFilePath) })
+
+	m := newTestModel(true)
+	m.writeState()
+
+	s := readStateFile(t)
+	assert.Equal(t, "running", s.State)
+	assert.Equal(t, "work", s.Type)
+	assert.Equal(t, 300, s.ElapsedSeconds)
+	assert.Equal(t, 1500, s.DurationSeconds)
+	assert.Equal(t, 1200, s.RemainingSeconds)
+	assert.Equal(t, 0.2, s.Percent)
+	assert.Equal(t, 0, s.SessionsDone)
+	assert.Equal(t, 2, s.CyclePosition)
+}
+
+func TestWriteStateDisabled(t *testing.T) {
+	os.Remove(stateFilePath)
+
+	m := newTestModel(false)
+	m.writeState()
+
+	_, err := os.Stat(stateFilePath)
+	assert.True(t, os.IsNotExist(err), "state file should not be created when disabled")
+}
+
+func TestWriteStatePaused(t *testing.T) {
+	t.Cleanup(func() { os.Remove(stateFilePath) })
+
+	m := newTestModel(true)
+	m.sessionState = Paused
+	m.writeState()
+
+	s := readStateFile(t)
+	assert.Equal(t, "paused", s.State)
+}
+
+func TestWriteStateBreak(t *testing.T) {
+	t.Cleanup(func() { os.Remove(stateFilePath) })
+
+	m := newTestModel(true)
+	m.currentTaskType = config.BreakTask
+	m.writeState()
+
+	s := readStateFile(t)
+	assert.Equal(t, "break", s.Type)
+}
+
+func TestWriteStateCompleted(t *testing.T) {
+	t.Cleanup(func() { os.Remove(stateFilePath) })
+
+	m := newTestModel(true)
+	m.sessionState = ShowingConfirm
+	m.writeState()
+
+	s := readStateFile(t)
+	assert.Equal(t, "completed", s.State)
+}
+
+func TestRemoveStateFile(t *testing.T) {
+	m := newTestModel(true)
+	m.writeState()
+
+	_, err := os.Stat(stateFilePath)
+	require.NoError(t, err, "state file should exist before removal")
+
+	m.removeStateFile()
+
+	_, err = os.Stat(stateFilePath)
+	assert.True(t, os.IsNotExist(err), "state file should be removed")
+}
+
+func TestRemoveStateFileDisabled(t *testing.T) {
+	// create the file manually to ensure removeStateFile respects the flag
+	require.NoError(t, os.WriteFile(stateFilePath, []byte("{}"), 0644))
+	t.Cleanup(func() { os.Remove(stateFilePath) })
+
+	m := newTestModel(false)
+	m.removeStateFile()
+
+	_, err := os.Stat(stateFilePath)
+	assert.NoError(t, err, "state file should not be removed when disabled")
+}

ui/summary/session_summary.go

@@ -46,6 +46,10 @@ func (t *SessionSummary) AddDuration(taskType config.TaskType, duration time.Dur
 	}
 }
 
+func (t SessionSummary) WorkSessions() int {
+	return t.totalWorkSessions
+}
+
 // SetDatabaseUnavailable marks the database as unavailable.
 // prints a warning in the summary.
 func (t *SessionSummary) SetDatabaseUnavailable() {