v1.17.1: harden relay, viewer, and release plumbing

Tightens relay startup and cached stream behavior, adds checksum-verified self-update, and ships the health, logging, and completion fixes from the v1.17 hardening pass.

Author: pfarnsworth

Dockerfile

@@ -11,4 +11,5 @@ COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
 COPY --from=builder /tltv /tltv
 EXPOSE 8000
 WORKDIR /data
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 CMD ["/tltv", "version"]
 ENTRYPOINT ["/tltv"]

README.md

@@ -126,7 +126,7 @@ tltv viewer demo.timelooptv.org
 | `loadtest <target>` | Multi-receiver load simulator |
 | `version` | Version, protocol version, platform info |
 | `update` | Self-update to latest GitHub release |
-| `completion` | Shell completions (`--install` for auto-install) |
+| `completion` | Shell completions and flag metadata (`--install`, `--flags`) |
 
 ## Global Flags
 

bridge.go

@@ -27,7 +27,7 @@ func cmdBridge(args []string) {
 	nameArg := fs.String("name", os.Getenv("NAME"), "channel name (single-stream mode only)")
 	fs.StringVar(nameArg, "n", os.Getenv("NAME"), "alias for --name")
 	descriptionArg := fs.String("description", os.Getenv("DESCRIPTION"), "channel description")
-	fs.StringVar(descriptionArg, "D", os.Getenv("DESCRIPTION"), "alias for --description")
+	fs.StringVar(descriptionArg, "U", os.Getenv("DESCRIPTION"), "alias for --description")
 	tagsArg := fs.String("tags", os.Getenv("TAGS"), "comma-separated tags (max 5)")
 	fs.StringVar(tagsArg, "T", os.Getenv("TAGS"), "alias for --tags")
 	languageArg := fs.String("language", os.Getenv("LANGUAGE"), "ISO 639-1 language code (e.g. en, ja)")
@@ -72,7 +72,7 @@ func cmdBridge(args []string) {
 	proxyStr := addProxyFlag(fs)
 
 	// --- Config ---
-	configPathBridge, dumpConfigBridge := addConfigFlags(fs)
+	configPathBridge, dumpConfigBridge := addConfigFlags(fs, configFlagOpts{ConfigShort: "f", DumpShort: "D"})
 
 	// --- Cache ---
 	cacheEnabled, cacheMaxEntries, cacheStatsInterval := addCacheFlags(fs)
@@ -97,7 +97,7 @@ func cmdBridge(args []string) {
 		fmt.Fprintf(os.Stderr, "  -G, --guide URL/PATH     guide source: XMLTV or JSON (optional)\n\n")
 		fmt.Fprintf(os.Stderr, "Channel defaults:\n")
 		fmt.Fprintf(os.Stderr, "  -n, --name STRING        channel name (single-stream mode only)\n")
-		fmt.Fprintf(os.Stderr, "  -D, --description TEXT   channel description\n")
+		fmt.Fprintf(os.Stderr, "  -U, --description TEXT   channel description\n")
 		fmt.Fprintf(os.Stderr, "  -T, --tags LIST          comma-separated tags (max 5)\n")
 		fmt.Fprintf(os.Stderr, "  -a, --language CODE      ISO 639-1 language code (e.g. en, ja)\n")
 		fmt.Fprintf(os.Stderr, "  -z, --timezone TZ        IANA timezone name for metadata\n")
@@ -113,8 +113,8 @@ func cmdBridge(args []string) {
 		fmt.Fprintf(os.Stderr, "  -P, --peers LIST         tltv:// URIs to advertise in peer exchange\n")
 		fmt.Fprintf(os.Stderr, "  -g, --gossip             re-advertise validated gossip-discovered channels\n\n")
 		fmt.Fprintf(os.Stderr, "Config:\n")
-		fmt.Fprintf(os.Stderr, "      --config PATH        config file (JSON)\n")
-		fmt.Fprintf(os.Stderr, "      --dump-config        print resolved config as JSON and exit\n\n")
+		fmt.Fprintf(os.Stderr, "  -f, --config PATH        config file (JSON)\n")
+		fmt.Fprintf(os.Stderr, "  -D, --dump-config        print resolved config as JSON and exit\n\n")
 		fmt.Fprintf(os.Stderr, "TLS:\n")
 		fmt.Fprintf(os.Stderr, "      --tls                enable TLS (autocert via Let's Encrypt if no cert/key)\n")
 		fmt.Fprintf(os.Stderr, "      --tls-cert FILE      TLS certificate file (PEM)\n")
@@ -159,6 +159,8 @@ func cmdBridge(args []string) {
 		fmt.Fprintf(os.Stderr, "error: %v\n", err)
 		os.Exit(1)
 	}
+	stopLogReopen := startLogReopenWatcher()
+	defer stopLogReopen()
 
 	// Load config file (if specified). Config values fill in unset flags.
 	var bridgeGuideEntries []guideEntry // from config inline guide
@@ -472,6 +474,9 @@ func cmdBridge(args []string) {
 					return map[string]interface{}{}
 				}
 				info := viewerBuildInfo(current.ChannelID, current.Name, current.metadata, current.guideDoc)
+				if icon := viewerIconDataURI(iconData, iconCT); icon != "" {
+					info["icon_data"] = icon
+				}
 				info["stream_src"] = "/tltv/v1/channels/" + current.ChannelID + "/stream.m3u8"
 				info["xmltv_url"] = "/tltv/v1/channels/" + current.ChannelID + "/guide.xml"
 				if registry.hostname != "" {
@@ -495,6 +500,7 @@ func cmdBridge(args []string) {
 					}
 					if ch.IconFileName != "" {
 						ref.IconPath = "/tltv/v1/channels/" + ch.ChannelID + "/" + ch.IconFileName
+						ref.IconData = viewerIconDataURI(iconData, iconCT)
 					}
 					refs = append(refs, ref)
 				}

bridge_server.go

@@ -14,12 +14,12 @@ import (
 // bridgeServer implements the TLTV protocol HTTP endpoints for bridged channels.
 type bridgeServer struct {
 	registry  *bridgeRegistry
-	cache     *hlsCache        // optional response cache (nil = disabled)
-	peerReg   *peerRegistry    // optional external peers (nil = no --peers)
-	gossipReg *peerRegistry    // optional gossip-discovered peers (nil = no --gossip)
+	cache     *hlsCache     // optional response cache (nil = disabled)
+	peerReg   *peerRegistry // optional external peers (nil = no --peers)
+	gossipReg *peerRegistry // optional gossip-discovered peers (nil = no --gossip)
 	mux       *http.ServeMux
-	iconData  []byte           // default icon data (nil = no default icon)
-	iconCT    string           // icon content type
+	iconData  []byte // default icon data (nil = no default icon)
+	iconCT    string // icon content type
 }
 
 // newBridgeServer creates a bridge HTTP server with all protocol endpoints registered.
@@ -181,6 +181,7 @@ func (s *bridgeServer) handleChannelPath(w http.ResponseWriter, r *http.Request)
 func (s *bridgeServer) handleHealth(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, map[string]interface{}{
 		"status":   "ok",
+		"version":  version,
 		"channels": s.registry.PublicChannelCount(),
 	}, http.StatusOK)
 }
@@ -255,7 +256,7 @@ func (s *bridgeServer) serveCachedStream(w http.ResponseWriter, r *http.Request,
 	}
 
 	cacheKey := r.URL.Path
-	data, _, hit, err := s.cache.getOrFetch(cacheKey, func() (*hlsCacheFetchResult, error) {
+	data, contentType, hit, err := s.cache.getOrFetch(cacheKey, func() (*hlsCacheFetchResult, error) {
 		fr, err := hlsCacheFetchUpstream(bridgeStreamClient, fetchURL, r)
 		if err != nil {
 			return nil, err
@@ -272,7 +273,7 @@ func (s *bridgeServer) serveCachedStream(w http.ResponseWriter, r *http.Request,
 		return
 	}
 
-	setStreamHeaders(w, subPath, ch.IsPrivate())
+	setStreamHeadersWithContentType(w, subPath, ch.IsPrivate(), contentType)
 	if hit {
 		w.Header().Set("Cache-Status", "HIT")
 	} else {

bridge_stream.go

@@ -154,7 +154,7 @@ func bridgeServeUpstreamStream(w http.ResponseWriter, r *http.Request, manifestU
 		return
 	}
 
-	setStreamHeaders(w, subPath, private)
+	setStreamHeadersWithContentType(w, subPath, private, resp.Header.Get("Content-Type"))
 
 	if strings.HasSuffix(subPath, ".m3u8") {
 		// Read and rewrite manifest
@@ -276,7 +276,17 @@ func bridgeAppendToken(uri, token string) string {
 
 // setStreamHeaders sets Content-Type and Cache-Control for stream responses.
 func setStreamHeaders(w http.ResponseWriter, subPath string, private bool) {
-	w.Header().Set("Content-Type", streamContentType(subPath))
+	setStreamHeadersWithContentType(w, subPath, private, "")
+}
+
+// setStreamHeadersWithContentType prefers the canonical content type for known
+// file extensions and falls back to the upstream content type for unknown ones.
+func setStreamHeadersWithContentType(w http.ResponseWriter, subPath string, private bool, contentType string) {
+	ct := streamContentType(subPath)
+	if ct == "application/octet-stream" && contentType != "" {
+		ct = contentType
+	}
+	w.Header().Set("Content-Type", ct)
 
 	if private {
 		w.Header().Set("Cache-Control", "private, no-store")
@@ -304,6 +314,12 @@ func streamContentType(name string) string {
 		return "audio/aac"
 	case strings.HasSuffix(name, ".vtt"):
 		return "text/vtt"
+	case strings.HasSuffix(name, ".svg"):
+		return "image/svg+xml"
+	case strings.HasSuffix(name, ".png"):
+		return "image/png"
+	case strings.HasSuffix(name, ".jpg"), strings.HasSuffix(name, ".jpeg"):
+		return "image/jpeg"
 	default:
 		return "application/octet-stream"
 	}

bridge_test.go

@@ -808,6 +808,9 @@ func TestBridgeHealth(t *testing.T) {
 	if resp["status"] != "ok" {
 		t.Errorf("status = %v, want ok", resp["status"])
 	}
+	if resp["version"] != version {
+		t.Errorf("version = %v, want %s", resp["version"], version)
+	}
 	if resp["channels"] != float64(1) {
 		t.Errorf("channels = %v, want 1", resp["channels"])
 	}

loadtest.go

@@ -95,6 +95,8 @@ func cmdLoadtest(args []string) {
 		fmt.Fprintf(os.Stderr, "error: %v\n", err)
 		os.Exit(1)
 	}
+	stopLogReopen := startLogReopenWatcher()
+	defer stopLogReopen()
 
 	// Parse durations
 	testDuration, err := time.ParseDuration(*durationStr)
@@ -420,17 +422,17 @@ func loadtestPrintJSON(agg *loadtestAggregator, target, directURL string, durati
 	}
 
 	result := map[string]interface{}{
-		"target":             displayTarget,
-		"receivers":          receivers,
-		"duration_ms":        elapsed.Milliseconds(),
-		"ramp_ms":            ramp.Milliseconds(),
-		"segments_total":     agg.totalSegments.Load() + agg.segmentErrors.Load(),
-		"segments_ok":        agg.totalSegments.Load(),
-		"segment_errors":     agg.segmentErrors.Load(),
-		"manifests_total":    agg.totalManifests.Load() + agg.manifestErrors.Load(),
-		"manifests_ok":       agg.totalManifests.Load(),
-		"manifest_errors":    agg.manifestErrors.Load(),
-		"bytes_received":     agg.bytesReceived.Load(),
+		"target":          displayTarget,
+		"receivers":       receivers,
+		"duration_ms":     elapsed.Milliseconds(),
+		"ramp_ms":         ramp.Milliseconds(),
+		"segments_total":  agg.totalSegments.Load() + agg.segmentErrors.Load(),
+		"segments_ok":     agg.totalSegments.Load(),
+		"segment_errors":  agg.segmentErrors.Load(),
+		"manifests_total": agg.totalManifests.Load() + agg.manifestErrors.Load(),
+		"manifests_ok":    agg.totalManifests.Load(),
+		"manifest_errors": agg.manifestErrors.Load(),
+		"bytes_received":  agg.bytesReceived.Load(),
 	}
 
 	if elapsed.Seconds() > 0 {

logging.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"os/signal"
 	"strings"
 	"sync"
 	"time"
@@ -28,6 +29,8 @@ var (
 	logMinLevel  logLevel  = levelInfo
 	logJSON      bool
 	logComponent string
+	logFilePath  string
+	logFile      *os.File
 )
 
 // addLogFlags registers --log-level, --log-format, --log-file on a flag set.
@@ -42,6 +45,15 @@ func addLogFlags(fs *flag.FlagSet) (level, format, file *string) {
 // setupLogging configures the package-level logger. Must be called before
 // any log output. The component name is included in every log line.
 func setupLogging(level, format, file, component string) error {
+	logMu.Lock()
+	defer logMu.Unlock()
+
+	if logFile != nil {
+		logFile.Close()
+		logFile = nil
+	}
+	logOut = os.Stderr
+	logFilePath = ""
 	logComponent = component
 
 	switch strings.ToLower(level) {
@@ -70,11 +82,68 @@ func setupLogging(level, format, file, component string) error {
 			return fmt.Errorf("open log file: %w", err)
 		}
 		logOut = f
+		logFile = f
+		logFilePath = file
+	}
+
+	return nil
+}
+
+func reopenLogFile() error {
+	logMu.Lock()
+	path := logFilePath
+	oldFile := logFile
+	logMu.Unlock()
+
+	if path == "" {
+		return nil
 	}
 
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+	if err != nil {
+		return fmt.Errorf("open log file: %w", err)
+	}
+
+	logMu.Lock()
+	logOut = f
+	logFile = f
+	logMu.Unlock()
+
+	if oldFile != nil {
+		oldFile.Close()
+	}
 	return nil
 }
 
+func startLogReopenWatcher() func() {
+	logMu.Lock()
+	hasFile := logFilePath != ""
+	logMu.Unlock()
+	if !hasFile {
+		return func() {}
+	}
+
+	ch := make(chan os.Signal, 1)
+	sighupNotify(ch)
+	done := make(chan struct{})
+	go func() {
+		for {
+			select {
+			case <-done:
+				signal.Stop(ch)
+				return
+			case <-ch:
+				if err := reopenLogFile(); err != nil {
+					logErrorf("reopen log file: %v", err)
+				} else {
+					logInfof("reopened log file")
+				}
+			}
+		}
+	}()
+	return func() { close(done) }
+}
+
 // logf writes a structured log entry at the given level.
 func logf(level logLevel, format string, args ...interface{}) {
 	if level < logMinLevel {