tis24dev
diff --git a/‎.gitignore‎
Lines changed: 3 additions & 0 deletions b/‎.gitignore‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎cmd/proxsave/daemon.go‎
Lines changed: 28 additions & 0 deletions b/‎cmd/proxsave/daemon.go‎
Lines changed: 28 additions & 0 deletions
diff --git a/‎cmd/proxsave/daemon_diagnostics.go‎
Lines changed: 228 additions & 0 deletions b/‎cmd/proxsave/daemon_diagnostics.go‎
Lines changed: 228 additions & 0 deletions
diff --git a/‎cmd/proxsave/daemon_diagnostics_test.go‎
Lines changed: 84 additions & 0 deletions b/‎cmd/proxsave/daemon_diagnostics_test.go‎
Lines changed: 84 additions & 0 deletions
diff --git a/‎cmd/proxsave/daemon_lock.go‎
Lines changed: 32 additions & 0 deletions b/‎cmd/proxsave/daemon_lock.go‎
Lines changed: 32 additions & 0 deletions
@@ -7,6 +7,9 @@
 # GSD workspace — local-only planning projects, never version-controlled
 /gsd/
 
+# Superpowers design and planning artifacts — local-only, never version-controlled
+/docs/superpowers/
+
 # Build artifacts — compiled binary (root build) and Makefile output dir
 /proxsave
 /build/
 
@@ -311,11 +311,39 @@ func runDaemon(rt *appRuntime) int {
 }
 
 func (d *daemon) run(ctx context.Context) int {
+	ownershipDone := logging.DebugStart(d.logger, "daemon ownership", "base_dir=%s", d.cfg.BaseDir)
+	releaseOwnership, err := acquireDaemonLock(d.cfg.BaseDir)
+	if err != nil {
+		if errors.Is(err, errDaemonLockHeld) {
+			if pid, pidErr := health.ReadDaemonPID(d.cfg.BaseDir); pidErr == nil && pid > 0 {
+				logging.Warning("daemon: another proxsave daemon is already running (pid=%d) - refusing a second instance so its pid file survives", pid)
+			} else {
+				logging.Warning("daemon: another proxsave daemon already owns %s - refusing a second instance", d.cfg.BaseDir)
+			}
+			ownershipDone(err)
+			return types.ExitBackupSkipped.Int()
+		}
+		logging.Error("daemon: cannot establish single-instance ownership: %v", err)
+		ownershipDone(err)
+		return types.ExitGenericError.Int()
+	}
+	ownershipDone(nil)
+	defer releaseOwnership()
+
 	// The trusted-path gate for the operator scripts, once, before any tick can start
 	// one: a refused path is blanked here with a loud reason (validatePersonalScripts),
 	// so the silent starters below never see it.
 	validatePersonalScripts(d.cfg)
 
+	// The flock above is authoritative between new daemons. Keep this PID probe while
+	// holding it for rolling compatibility with an older incumbent that publishes its
+	// identity but does not take the lock. The same liveness + /proc cmdline gate the
+	// standalone handoff trusts ensures a stale or recycled PID never blocks a restart.
+	if pid, err := health.ReadDaemonPID(d.cfg.BaseDir); err == nil && pid > 0 && pid != os.Getpid() && daemonAliveProbe(pid) {
+		logging.Warning("daemon: another proxsave daemon is already running (pid=%d) - refusing a second instance so its pid file survives", pid)
+		return types.ExitBackupSkipped.Int()
+	}
+
 	// CRITICAL: install the SIGUSR1 handler BEFORE publishing the pidfile below. Go's DEFAULT action
 	// for SIGUSR1 is to TERMINATE the process, and the pidfile is exactly what a standalone backup
 	// run uses to discover us and send SIGUSR1 to hand off its outcome. If the pid became
 
@@ -0,0 +1,228 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/tis24dev/proxsave/internal/config"
+	"github.com/tis24dev/proxsave/internal/health"
+	"github.com/tis24dev/proxsave/internal/logging"
+	"github.com/tis24dev/proxsave/internal/orchestrator"
+	"github.com/tis24dev/proxsave/internal/ui/components"
+)
+
+type daemonUIDDiagnostic struct {
+	Value          int
+	Source         string
+	FallbackReason string
+}
+
+// daemonDiagnostics is the single presentation-neutral snapshot consumed by
+// both the plain CLI and the dashboard daemon-status renderers.
+type daemonDiagnostics struct {
+	Mode        string
+	Unit        string
+	Active      string
+	State       health.DaemonState
+	Level       orchestrator.HealthcheckSetupLevel
+	Keyword     string
+	Explanation string
+	DaemonUID   daemonUIDDiagnostic
+	Scripts     personalScriptsDiagnostics
+}
+
+var (
+	daemonDiagnosticsCollector     = collectDaemonDiagnostics
+	daemonStatusUnitInstalledProbe = daemonUnitInstalled
+	daemonStatusActiveStateProbe   = daemonUnitActiveState
+	daemonStatusNow                = time.Now
+	daemonProcStatusReadFile       = os.ReadFile
+	daemonCurrentEUID              = os.Geteuid
+	daemonUIDResolver              = resolveDaemonEffectiveUID
+	personalScriptsInspector       = inspectPersonalScripts
+)
+
+// collectDaemonDiagnostics owns every probe and verdict used by the two
+// daemon-status frontends. Renderers receive facts; they never recompute them.
+func collectDaemonDiagnostics(ctx context.Context, cfg *config.Config, baseDir string) daemonDiagnostics {
+	mode := "unknown"
+	var interval time.Duration
+	if cfg != nil {
+		mode = cfg.SchedulerMode
+		interval = cfg.HealthcheckHeartbeatInterval
+		if configured := strings.TrimSpace(cfg.BaseDir); configured != "" {
+			baseDir = configured
+		}
+	}
+	if strings.TrimSpace(baseDir) == "" {
+		baseDir, _ = detectedBaseDirOrFallback()
+	}
+
+	unit := "not installed"
+	if daemonStatusUnitInstalledProbe() {
+		unit = "installed"
+	}
+	active := daemonStatusActiveStateProbe(ctx)
+	if active == "" {
+		active = "unknown"
+	}
+
+	state := health.CheckDaemonState(health.DaemonStateInput{
+		BaseDir:           baseDir,
+		SchedulerMode:     mode,
+		HeartbeatInterval: interval,
+		Now:               daemonStatusNow(),
+		Presence:          daemonPresenceProbe(ctx),
+		ProcAlive:         probeProxsaveDaemonAlive,
+		ProcStale:         procBinaryStaleProbe,
+	})
+	level, keyword, explanation := daemonStatusStyle(state)
+	daemonUID := daemonUIDResolver(state)
+	scripts := personalScriptsInspector(cfg, daemonUID.Value)
+	return daemonDiagnostics{
+		Mode:        mode,
+		Unit:        unit,
+		Active:      active,
+		State:       state,
+		Level:       level,
+		Keyword:     keyword,
+		Explanation: explanation,
+		DaemonUID:   daemonUID,
+		Scripts:     scripts,
+	}
+}
+
+// parseProcEffectiveUID reads the second numeric value from Linux's Uid line:
+// real, effective, saved-set, then filesystem UID.
+func parseProcEffectiveUID(data []byte) (int, error) {
+	for _, line := range strings.Split(string(data), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) == 0 || fields[0] != "Uid:" {
+			continue
+		}
+		if len(fields) < 3 {
+			return 0, fmt.Errorf("malformed Uid line: %q", line)
+		}
+		uid, err := strconv.Atoi(fields[2])
+		if err != nil {
+			return 0, fmt.Errorf("parse effective uid %q: %w", fields[2], err)
+		}
+		if uid < 0 {
+			return 0, fmt.Errorf("effective uid %q must not be negative", fields[2])
+		}
+		return uid, nil
+	}
+	return 0, fmt.Errorf("uid line not found")
+}
+
+func readProcessEffectiveUID(pid int) (int, error) {
+	if pid <= 0 {
+		return 0, fmt.Errorf("invalid daemon pid %d", pid)
+	}
+	path := fmt.Sprintf("/proc/%d/status", pid)
+	data, err := daemonProcStatusReadFile(path)
+	if err != nil {
+		return 0, fmt.Errorf("read %s: %w", path, err)
+	}
+	uid, err := parseProcEffectiveUID(data)
+	if err != nil {
+		return 0, fmt.Errorf("parse %s: %w", path, err)
+	}
+	return uid, nil
+}
+
+func resolveDaemonEffectiveUID(state health.DaemonState) daemonUIDDiagnostic {
+	if state.ProcessAlive && state.PID > 0 {
+		uid, err := readProcessEffectiveUID(state.PID)
+		if err == nil {
+			return daemonUIDDiagnostic{Value: uid, Source: "running daemon /proc"}
+		}
+		return daemonUIDDiagnostic{
+			Value:          daemonCurrentEUID(),
+			Source:         "current process",
+			FallbackReason: err.Error(),
+		}
+	}
+	return daemonUIDDiagnostic{
+		Value:          daemonCurrentEUID(),
+		Source:         "current process",
+		FallbackReason: "daemon process is not live or has no PID",
+	}
+}
+
+// logDaemonDiagnostics is the plain CLI renderer for the shared snapshot. The
+// entire visible block is bracketed by the standard debug start/end markers.
+func logDaemonDiagnostics(logger *logging.Logger, diagnostics daemonDiagnostics) {
+	if logger == nil {
+		logger = logging.GetDefaultLogger()
+	}
+	done := logging.DebugStart(logger, "daemon diagnostics", "daemon_uid=%d uid_source=%s",
+		diagnostics.DaemonUID.Value, daemonDiagnosticText(diagnostics.DaemonUID.Source))
+	defer done(nil)
+
+	logger.Info("Daemon status: %s", daemonDiagnosticText(diagnostics.Keyword))
+	logger.Info("Scheduler mode: %s", daemonDiagnosticText(diagnostics.Mode))
+	logger.Info("Daemon service (%s): %s", daemonUnitName, daemonDiagnosticText(diagnostics.Unit))
+	logger.Info("Service state (systemctl is-active): %s", daemonDiagnosticText(diagnostics.Active))
+	if diagnostics.State.HaveInfo {
+		logger.Info("Running version: %s (%s)", daemonDiagnosticText(diagnostics.State.Version), daemonDiagnosticText(diagnostics.State.Commit))
+	}
+	if diagnostics.State.HaveInfo || diagnostics.State.AlignChecked {
+		alignment := "unknown"
+		if diagnostics.State.AlignChecked {
+			if diagnostics.State.Aligned {
+				alignment = "aligned"
+			} else {
+				alignment = "BEHIND (restart needed)"
+			}
+		}
+		logger.Info("Binary alignment: %s", alignment)
+	}
+
+	logPersonalScriptDiagnostic(logger, "Personal pre-run script", diagnostics.Scripts.Pre)
+	logPersonalScriptDiagnostic(logger, "Personal post-run script", diagnostics.Scripts.Post)
+	logging.DebugStep(logger, "daemon diagnostics", "daemon uid: value=%d source=%q fallback_reason=%q",
+		diagnostics.DaemonUID.Value,
+		daemonDiagnosticText(diagnostics.DaemonUID.Source),
+		daemonDiagnosticText(diagnostics.DaemonUID.FallbackReason))
+	logPersonalScriptEvidence(logger, "pre-run", diagnostics.Scripts.Pre)
+	logPersonalScriptEvidence(logger, "post-run", diagnostics.Scripts.Post)
+}
+
+func logPersonalScriptDiagnostic(logger *logging.Logger, label string, diagnostic personalScriptDiagnostic) {
+	path := daemonDiagnosticText(diagnostic.Path)
+	reason := daemonDiagnosticText(diagnostic.Reason)
+	switch diagnostic.State {
+	case personalScriptReady:
+		logger.Info("%s: READY (%s)", label, path)
+	case personalScriptRefused:
+		if path == "" {
+			logger.Warning("%s: REFUSED: %s", label, reason)
+			return
+		}
+		logger.Warning("%s: REFUSED (%s): %s", label, path, reason)
+	default:
+		logger.Info("%s: NOT CONFIGURED", label)
+	}
+}
+
+func logPersonalScriptEvidence(logger *logging.Logger, label string, diagnostic personalScriptDiagnostic) {
+	logging.DebugStep(logger, "daemon diagnostics", "%s: key=%q state=%s path=%q daemon_uid=%d",
+		label,
+		daemonDiagnosticText(diagnostic.Key),
+		diagnostic.State,
+		daemonDiagnosticText(diagnostic.Path),
+		diagnostic.DaemonUID)
+	for _, component := range diagnostic.Components {
+		logging.DebugStep(logger, "daemon diagnostics", "%s component: path=%q uid=%d mode=%04o",
+			label, daemonDiagnosticText(component.Path), component.UID, component.Mode.Perm())
+	}
+}
+
+func daemonDiagnosticText(value string) string {
+	return strings.TrimSpace(components.SanitizeText(value))
+}
@@ -0,0 +1,84 @@
+package main
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/tis24dev/proxsave/internal/config"
+	"github.com/tis24dev/proxsave/internal/health"
+	"github.com/tis24dev/proxsave/internal/logging"
+	"github.com/tis24dev/proxsave/internal/types"
+)
+
+func TestCollectDaemonDiagnosticsBuildsOneSharedSnapshot(t *testing.T) {
+	origInstalled := daemonStatusUnitInstalledProbe
+	origActive := daemonStatusActiveStateProbe
+	origPresence := daemonPresenceProbe
+	origNow := daemonStatusNow
+	t.Cleanup(func() {
+		daemonStatusUnitInstalledProbe = origInstalled
+		daemonStatusActiveStateProbe = origActive
+		daemonPresenceProbe = origPresence
+		daemonStatusNow = origNow
+	})
+
+	daemonStatusUnitInstalledProbe = func() bool { return true }
+	daemonStatusActiveStateProbe = func(context.Context) string { return "active" }
+	daemonPresenceProbe = func(context.Context) health.DaemonPresence {
+		return health.DaemonPresence{Probed: true, Installed: true, Active: true}
+	}
+	daemonStatusNow = func() time.Time { return time.Unix(1_700_000_000, 0) }
+
+	cfg := &config.Config{
+		SchedulerMode:                "daemon",
+		BaseDir:                      t.TempDir(),
+		HealthcheckHeartbeatInterval: time.Minute,
+	}
+	got := collectDaemonDiagnostics(context.Background(), cfg, cfg.BaseDir)
+
+	if got.Mode != "daemon" || got.Unit != "installed" || got.Active != "active" {
+		t.Fatalf("incomplete shared snapshot: %+v", got)
+	}
+	if !got.State.Probed || !got.State.Installed || !got.State.Active {
+		t.Fatalf("health state did not use the shared presence probe: %+v", got.State)
+	}
+	if got.Keyword == "" || got.Explanation == "" {
+		t.Fatalf("shared snapshot is missing its verdict: %+v", got)
+	}
+}
+
+func TestRunDaemonStatusUsesSharedDiagnosticsCollector(t *testing.T) {
+	origCollector := daemonDiagnosticsCollector
+	t.Cleanup(func() { daemonDiagnosticsCollector = origCollector })
+
+	called := 0
+	daemonDiagnosticsCollector = func(context.Context, *config.Config, string) daemonDiagnostics {
+		called++
+		return daemonDiagnostics{
+			Mode:    "daemon",
+			Unit:    "installed",
+			Active:  "active",
+			State:   health.DaemonState{HaveInfo: true, Version: "1.2.3", Commit: "abc", AlignChecked: true, Aligned: true},
+			Level:   1,
+			Keyword: "running",
+		}
+	}
+
+	origLogger := logging.GetDefaultLogger()
+	logger := logging.New(types.LogLevelDebug, false)
+	logging.SetDefaultLogger(logger)
+	t.Cleanup(func() { logging.SetDefaultLogger(origLogger) })
+
+	rt := &appRuntime{
+		ctx:    context.Background(),
+		cfg:    &config.Config{SchedulerMode: "daemon", BaseDir: t.TempDir()},
+		logger: logger,
+	}
+	if code := runDaemonStatus(rt); code != 0 {
+		t.Fatalf("runDaemonStatus exit = %d, want 0", code)
+	}
+	if called != 1 {
+		t.Fatalf("shared collector calls = %d, want 1", called)
+	}
+}
@@ -0,0 +1,32 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/tis24dev/proxsave/internal/filelock"
+)
+
+const daemonLockFileName = ".daemon.lock"
+
+var errDaemonLockHeld = errors.New("daemon ownership lock is already held")
+
+func acquireDaemonLock(baseDir string) (release func(), err error) {
+	dir := filepath.Join(baseDir, "identity")
+	if err := os.MkdirAll(dir, 0o750); err != nil {
+		return nil, fmt.Errorf("create daemon lock directory %s: %w", dir, err)
+	}
+	path := filepath.Join(dir, daemonLockFileName)
+	releaseLock, err := filelock.TryAcquire(path)
+	if errors.Is(err, filelock.ErrHeld) {
+		return nil, fmt.Errorf("%w: %s", errDaemonLockHeld, path)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("acquire daemon lock %s: %w", path, err)
+	}
+	return func() {
+		_ = releaseLock()
+	}, nil
+}