refactor(ipc): remove /status endpoint, add lastSyncAt to /list

Per review feedback on PR #1015, this removes the /status endpoint
and socket mode from the status command to avoid the confusing
behavior where only one command requires the -socket flag.

Instead of /status, the /list endpoint now includes lastSyncAt
for each database, providing the sync timing information without
needing a separate endpoint.

Changes:
- Remove GET /status endpoint from server
- Remove -socket flag and runWithSocket from status command
- Add LastSyncAt field to DatabaseSummary in /list response
- Update tests accordingly

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: corylanou

cmd/litestream/status.go

@@ -2,16 +2,10 @@ package main
 
 import (
 	"context"
-	"encoding/json"
 	"flag"
 	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/url"
 	"os"
 	"text/tabwriter"
-	"time"
 
 	"github.com/dustin/go-humanize"
 
@@ -25,77 +19,14 @@ type StatusCommand struct{}
 func (c *StatusCommand) Run(ctx context.Context, args []string) (err error) {
 	fs := flag.NewFlagSet("litestream-status", flag.ContinueOnError)
 	configPath, noExpandEnv := registerConfigFlag(fs)
-	socketPath := fs.String("socket", "", "control socket path for querying running daemon")
-	timeout := fs.Int("timeout", 10, "timeout in seconds for socket connection")
 	fs.Usage = c.Usage
 	if err := fs.Parse(args); err != nil {
 		return err
 	}
 
-	// If socket path is provided, query the running daemon.
-	if *socketPath != "" {
-		return c.runWithSocket(ctx, *socketPath, *timeout, fs.Args())
-	}
-
-	// Otherwise, use config file to get static status.
 	return c.runWithConfig(ctx, *configPath, *noExpandEnv, fs.Args())
 }
 
-// runWithSocket queries the running daemon via Unix socket.
-func (c *StatusCommand) runWithSocket(_ context.Context, socketPath string, timeout int, args []string) error {
-	if len(args) == 0 {
-		return fmt.Errorf("database path required when using -socket")
-	}
-	if len(args) > 1 {
-		return fmt.Errorf("too many arguments")
-	}
-
-	dbPath := args[0]
-
-	clientTimeout := time.Duration(timeout) * time.Second
-	client := &http.Client{
-		Timeout: clientTimeout,
-		Transport: &http.Transport{
-			DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {
-				return net.DialTimeout("unix", socketPath, clientTimeout)
-			},
-		},
-	}
-
-	reqURL := fmt.Sprintf("http://localhost/status?path=%s", url.QueryEscape(dbPath))
-	resp, err := client.Get(reqURL)
-	if err != nil {
-		return fmt.Errorf("failed to connect to control socket: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("failed to read response: %w", err)
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		var errResp litestream.ErrorResponse
-		if err := json.Unmarshal(body, &errResp); err == nil && errResp.Error != "" {
-			return fmt.Errorf("status failed: %s", errResp.Error)
-		}
-		return fmt.Errorf("status failed: %s", string(body))
-	}
-
-	var result litestream.StatusResponse
-	if err := json.Unmarshal(body, &result); err != nil {
-		return fmt.Errorf("failed to parse response: %w", err)
-	}
-
-	output, err := json.MarshalIndent(result, "", "  ")
-	if err != nil {
-		return fmt.Errorf("failed to format response: %w", err)
-	}
-	fmt.Println(string(output))
-
-	return nil
-}
-
 // runWithConfig reads the config file and displays static status.
 func (c *StatusCommand) runWithConfig(_ context.Context, configPath string, noExpandEnv bool, args []string) error {
 	// Load configuration.
@@ -195,33 +126,18 @@ Usage:
 
 	litestream status [arguments] [database path]
 
-	litestream status -socket PATH DB_PATH
-
 Arguments:
 
 	-config PATH
 	    Specifies the configuration file.
 	    Defaults to %s
 
-	-socket PATH
-	    Path to control socket for querying a running daemon.
-	    When specified, queries the daemon for live status.
-
-	-timeout SECONDS
-	    Timeout for socket connection (default: 10).
-
 	-no-expand-env
 	    Disables environment variable expansion in configuration file.
 
-Without -socket flag:
-  Reads the config file and displays static status from local files.
-  If a database path is provided, only that database's status is shown.
-  Otherwise, all configured databases are displayed.
-
-With -socket flag:
-  Queries the running daemon for live replication status.
-  A database path is required when using -socket.
-  Returns JSON output with current status, position, and replica info.
+Reads the config file and displays static status from local files.
+If a database path is provided, only that database's status is shown.
+Otherwise, all configured databases are displayed.
 
 `[1:],
 		DefaultConfigPath(),

cmd/litestream/status_test.go

@@ -6,9 +6,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/benbjohnson/litestream"
 	main "github.com/benbjohnson/litestream/cmd/litestream"
-	"github.com/benbjohnson/litestream/internal/testingutil"
 )
 
 func TestStatusCommand_Run(t *testing.T) {
@@ -20,36 +18,6 @@ func TestStatusCommand_Run(t *testing.T) {
 		}
 	})
 
-	t.Run("SocketModeRequiresPath", func(t *testing.T) {
-		cmd := &main.StatusCommand{}
-		err := cmd.Run(context.Background(), []string{"-socket", "/tmp/test.sock"})
-		if err == nil {
-			t.Error("expected error for missing database path")
-		}
-		if err.Error() != "database path required when using -socket" {
-			t.Errorf("unexpected error: %v", err)
-		}
-	})
-
-	t.Run("SocketModeTooManyArgs", func(t *testing.T) {
-		cmd := &main.StatusCommand{}
-		err := cmd.Run(context.Background(), []string{"-socket", "/tmp/test.sock", "/db1", "/db2"})
-		if err == nil {
-			t.Error("expected error for too many arguments")
-		}
-		if err.Error() != "too many arguments" {
-			t.Errorf("unexpected error: %v", err)
-		}
-	})
-
-	t.Run("SocketModeConnectionError", func(t *testing.T) {
-		cmd := &main.StatusCommand{}
-		err := cmd.Run(context.Background(), []string{"-socket", "/nonexistent/socket.sock", "/path/to/db"})
-		if err == nil {
-			t.Error("expected error for socket connection failure")
-		}
-	})
-
 	t.Run("WithConfig", func(t *testing.T) {
 		dir := t.TempDir()
 		dbPath := filepath.Join(dir, "test.db")
@@ -103,29 +71,4 @@ func TestStatusCommand_Run(t *testing.T) {
 			t.Errorf("unexpected error: %v", err)
 		}
 	})
-
-	t.Run("SocketModeSuccess", func(t *testing.T) {
-		db, sqldb := testingutil.MustOpenDBs(t)
-		defer testingutil.MustCloseDBs(t, db, sqldb)
-
-		store := litestream.NewStore([]*litestream.DB{db}, litestream.CompactionLevels{{Level: 0}})
-		store.CompactionMonitorEnabled = false
-		if err := store.Open(context.Background()); err != nil {
-			t.Fatal(err)
-		}
-		defer store.Close(context.Background())
-
-		server := litestream.NewServer(store)
-		server.SocketPath = testSocketPath(t)
-		if err := server.Start(); err != nil {
-			t.Fatal(err)
-		}
-		defer server.Close()
-
-		cmd := &main.StatusCommand{}
-		err := cmd.Run(context.Background(), []string{"-socket", server.SocketPath, db.Path()})
-		if err != nil {
-			t.Errorf("unexpected error: %v", err)
-		}
-	})
 }

server.go

@@ -72,7 +72,6 @@ func NewServer(store *Store) *Server {
 	mux := http.NewServeMux()
 	mux.HandleFunc("POST /start", s.handleStart)
 	mux.HandleFunc("POST /stop", s.handleStop)
-	mux.HandleFunc("GET /status", s.handleStatus)
 	mux.HandleFunc("GET /list", s.handleList)
 	mux.HandleFunc("GET /info", s.handleInfo)
 
@@ -267,70 +266,6 @@ type ErrorResponse struct {
 	Details interface{} `json:"details,omitempty"`
 }
 
-func (s *Server) handleStatus(w http.ResponseWriter, r *http.Request) {
-	path := r.URL.Query().Get("path")
-	if path == "" {
-		writeJSONError(w, http.StatusBadRequest, "path required", nil)
-		return
-	}
-
-	expandedPath, err := s.expandPath(path)
-	if err != nil {
-		writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("invalid path: %v", err), nil)
-		return
-	}
-
-	db := s.store.FindDB(expandedPath)
-	if db == nil {
-		writeJSONError(w, http.StatusNotFound, fmt.Sprintf("database not found: %s", expandedPath), nil)
-		return
-	}
-
-	resp := StatusResponse{
-		Path:     db.Path(),
-		PageSize: db.PageSize(),
-	}
-
-	// Determine replication status more accurately.
-	// "replicating" means DB is open AND has an active replica monitor.
-	// "open" means DB is open but replication is paused/disabled.
-	// "stopped" means DB is closed.
-	if db.IsOpen() {
-		if db.Replica != nil && db.Replica.MonitorEnabled {
-			resp.Status = "replicating"
-		} else {
-			resp.Status = "open"
-		}
-	} else {
-		resp.Status = "stopped"
-	}
-
-	// Get position from db.Pos() which reads the full position from disk,
-	// including both TXID and checksum. We don't use Replica.Pos() here
-	// because it only caches TXID, not the checksum.
-	if pos, err := db.Pos(); err != nil {
-		resp.Error = fmt.Sprintf("failed to read position: %v", err)
-	} else if pos.TXID > 0 {
-		resp.Position = &PositionInfo{
-			TXID:              pos.TXID.String(),
-			PostApplyChecksum: fmt.Sprintf("%016x", pos.PostApplyChecksum),
-		}
-	}
-
-	if t := db.LastSuccessfulSyncAt(); !t.IsZero() {
-		resp.LastSyncAt = &t
-	}
-
-	if db.Replica != nil && db.Replica.Client != nil {
-		resp.Replicas = append(resp.Replicas, ReplicaInfo{
-			Name: db.Replica.Client.Type(),
-			Type: db.Replica.Client.Type(),
-		})
-	}
-
-	writeJSON(w, http.StatusOK, resp)
-}
-
 func (s *Server) handleList(w http.ResponseWriter, _ *http.Request) {
 	dbs := s.store.DBs()
 	resp := ListResponse{
@@ -348,10 +283,17 @@ func (s *Server) handleList(w http.ResponseWriter, _ *http.Request) {
 		} else {
 			status = "stopped"
 		}
-		resp.Databases = append(resp.Databases, DatabaseSummary{
+
+		summary := DatabaseSummary{
 			Path:   db.Path(),
 			Status: status,
-		})
+		}
+
+		if t := db.LastSuccessfulSyncAt(); !t.IsZero() {
+			summary.LastSyncAt = &t
+		}
+
+		resp.Databases = append(resp.Databases, summary)
 	}
 
 	writeJSON(w, http.StatusOK, resp)
@@ -369,39 +311,16 @@ func (s *Server) handleInfo(w http.ResponseWriter, _ *http.Request) {
 	writeJSON(w, http.StatusOK, resp)
 }
 
-// StatusResponse is the response body for the /status endpoint.
-type StatusResponse struct {
-	Path       string        `json:"path"`
-	Status     string        `json:"status"`
-	Position   *PositionInfo `json:"position,omitempty"`
-	PageSize   int           `json:"page_size,omitempty"`
-	LastSyncAt *time.Time    `json:"last_sync_at,omitempty"`
-	Replicas   []ReplicaInfo `json:"replicas,omitempty"`
-	Error      string        `json:"error,omitempty"`
-}
-
-// PositionInfo contains replication position information.
-type PositionInfo struct {
-	TXID              string `json:"txid"`
-	PostApplyChecksum string `json:"post_apply_checksum"`
-}
-
-// ReplicaInfo contains information about a replica.
-type ReplicaInfo struct {
-	Name       string `json:"name"`
-	Type       string `json:"type"`
-	Generation string `json:"generation,omitempty"`
-}
-
 // ListResponse is the response body for the /list endpoint.
 type ListResponse struct {
 	Databases []DatabaseSummary `json:"databases"`
 }
 
 // DatabaseSummary contains summary information about a database.
 type DatabaseSummary struct {
-	Path   string `json:"path"`
-	Status string `json:"status"`
+	Path       string     `json:"path"`
+	Status     string     `json:"status"`
+	LastSyncAt *time.Time `json:"last_sync_at,omitempty"`
 }
 
 // InfoResponse is the response body for the /info endpoint.