refactor(updater): drop in-process state machine; UI polls /version

The systemd restart kills this process before any "restarting/done"
state can be polled, so the 5-state machine produced UIs stuck on
"Downloading" while the update actually succeeded. Drop the state
tracking entirely:

- updater.Apply no longer takes onState; runs to completion or returns
  error.
- /api/v1/update/apply is fire-and-forget (HTTP 202); /update/status is
  removed along with JobStatus and updateJob.
- Dashboard polls /api/v1/version every 2s after click; success when
  git_revision changes; 60s timeout surfaces "check journalctl" hint.
- Failure path stays in s.l logger -> journalctl, same as before.

Net -193 lines.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Ehco1996

internal/cli/update.go

@@ -24,6 +24,6 @@ var UpdateCMD = &cli.Command{
 			Channel: c.String("channel"),
 			Force:   c.Bool("force"),
 			Restart: !c.Bool("no-restart"),
-		}, constant.Version, constant.GitRevision, cliLogger, nil)
+		}, constant.Version, constant.GitRevision, cliLogger)
 	},
 }

internal/updater/updater.go

@@ -29,18 +29,6 @@ const (
 	systemdServiceName = "ehco"
 )
 
-// State is the phase of an Apply run; consumed by the web UI.
-type State string
-
-const (
-	StateChecking    State = "checking"
-	StateDownloading State = "downloading"
-	StateInstalling  State = "installing"
-	StateRestarting  State = "restarting"
-	StateDone        State = "done"
-	StateFailed      State = "failed"
-)
-
 // CheckResult describes a release relative to the running binary.
 type CheckResult struct {
 	Channel         string    `json:"channel"`
@@ -110,16 +98,12 @@ func Check(ctx context.Context, channel, currentVersion, currentRevision string)
 	return res, nil
 }
 
-// Apply downloads + swaps + (optionally) restarts. Each phase is reported
-// to onState so the dashboard can render progress; CLI passes nil.
-func Apply(ctx context.Context, opts ApplyOptions, currentVersion, currentRevision string, log *zap.SugaredLogger, onState func(State)) error {
-	emit := func(s State) {
-		if onState != nil {
-			onState(s)
-		}
-	}
-
-	emit(StateChecking)
+// Apply downloads + swaps + (optionally) restarts. Errors are returned
+// for the caller to surface; phase tracking has been intentionally
+// dropped — the systemd restart kills this process before any
+// "restarting/done" state could be polled, making intermediate states
+// unreliable. The dashboard polls /version to detect completion.
+func Apply(ctx context.Context, opts ApplyOptions, currentVersion, currentRevision string, log *zap.SugaredLogger) error {
 	resolved, rel, err := pickRelease(ctx, opts.Channel, currentVersion)
 	if err != nil {
 		return err
@@ -134,7 +118,6 @@ func Apply(ctx context.Context, opts ApplyOptions, currentVersion, currentRevisi
 					rel.TagName, currentRevision)
 			} else {
 				log.Info("already up to date")
-				emit(StateDone)
 				return nil
 			}
 		} else if compareVersions(latest, currentVersion) < 0 {
@@ -156,14 +139,12 @@ func Apply(ctx context.Context, opts ApplyOptions, currentVersion, currentRevisi
 	}
 	tmpPath := binPath + ".new"
 
-	emit(StateDownloading)
 	log.Infof("downloading %s -> %s", asset.BrowserDownloadURL, tmpPath)
 	if err := download(ctx, asset.BrowserDownloadURL, tmpPath); err != nil {
 		_ = os.Remove(tmpPath)
 		return fmt.Errorf("download: %w", err)
 	}
 
-	emit(StateInstalling)
 	// rename(2) over a running ELF on linux is safe: the kernel keeps the
 	// old inode alive for the running process while new invocations
 	// resolve to the new file.
@@ -179,15 +160,9 @@ func Apply(ctx context.Context, opts ApplyOptions, currentVersion, currentRevisi
 
 	if !opts.Restart {
 		log.Info("skipping restart; restart manually to pick up the new binary")
-		emit(StateDone)
 		return nil
 	}
-	emit(StateRestarting)
-	if err := restartSystemd(log); err != nil {
-		return err
-	}
-	emit(StateDone)
-	return nil
+	return restartSystemd(log)
 }
 
 func pickRelease(ctx context.Context, channel, currentVersion string) (string, *ghRelease, error) {

internal/web/handler_update.go

@@ -23,18 +23,6 @@ type VersionInfo struct {
 	GoArch      string    `json:"go_arch"`
 }
 
-// JobStatus is the in-memory record of the most-recent update attempt.
-// Process-local on purpose: after a successful restart the new process
-// boots with no record, the SPA reloads /version and sees the new build.
-type JobStatus struct {
-	State     updater.State `json:"state"`
-	Channel   string        `json:"channel"`
-	From      string        `json:"from"`
-	To        string        `json:"to"`
-	StartedAt time.Time     `json:"started_at"`
-	Error     string        `json:"error,omitempty"`
-}
-
 func (s *Server) Version(c echo.Context) error {
 	return c.JSON(http.StatusOK, VersionInfo{
 		Version:     constant.Version,
@@ -61,6 +49,10 @@ func (s *Server) UpdateCheck(c echo.Context) error {
 	return c.JSON(http.StatusOK, res)
 }
 
+// UpdateApply kicks off the update in a detached goroutine and returns
+// immediately. The dashboard polls /version to detect completion (the
+// running process restarts mid-flow, so any in-process state machine is
+// inherently lossy). Failures are logged via s.l; check journalctl.
 func (s *Server) UpdateApply(c echo.Context) error {
 	if runtime.GOOS != "linux" {
 		return echo.NewHTTPError(http.StatusBadRequest,
@@ -73,58 +65,14 @@ func (s *Server) UpdateApply(c echo.Context) error {
 	if opts.Channel == "" {
 		opts.Channel = updater.ChannelAuto
 	}
-
-	prev := s.updateJob.Load()
-	if prev != nil && isInProgress(prev.State) {
-		return echo.NewHTTPError(http.StatusConflict, "another update is already running")
-	}
-
-	job := &JobStatus{
-		State:     updater.StateChecking,
-		Channel:   opts.Channel,
-		From:      constant.Version,
-		StartedAt: time.Now().UTC(),
-	}
-	s.updateJob.Store(job)
 	s.l.Infof("update apply requested channel=%s force=%v restart=%v", opts.Channel, opts.Force, opts.Restart)
 
-	// Detached context: closing the browser shouldn't abort an in-flight swap.
-	go s.runUpdate(opts, job)
-	return c.JSON(http.StatusAccepted, map[string]string{"state": string(updater.StateChecking)})
-}
-
-func (s *Server) runUpdate(opts updater.ApplyOptions, job *JobStatus) {
-	ctx, cancel := context.WithTimeout(context.Background(), updateApplyTimeout)
-	defer cancel()
-
-	onState := func(st updater.State) {
-		// Copy-on-write so /status readers always see a consistent snapshot.
-		next := *job
-		next.State = st
-		s.updateJob.Store(&next)
-		*job = next
-	}
-
-	if err := updater.Apply(ctx, opts, constant.Version, constant.GitRevision, s.l, onState); err != nil {
-		next := *job
-		next.State = updater.StateFailed
-		next.Error = err.Error()
-		s.updateJob.Store(&next)
-		s.l.Errorf("update failed: %v", err)
-	}
-}
-
-func (s *Server) UpdateStatus(c echo.Context) error {
-	if j := s.updateJob.Load(); j != nil {
-		return c.JSON(http.StatusOK, j)
-	}
-	return c.JSON(http.StatusOK, map[string]string{"state": "idle"})
-}
-
-func isInProgress(s updater.State) bool {
-	switch s {
-	case updater.StateChecking, updater.StateDownloading, updater.StateInstalling, updater.StateRestarting:
-		return true
-	}
-	return false
+	go func() {
+		ctx, cancel := context.WithTimeout(context.Background(), updateApplyTimeout)
+		defer cancel()
+		if err := updater.Apply(ctx, opts, constant.Version, constant.GitRevision, s.l); err != nil {
+			s.l.Errorf("update failed: %v", err)
+		}
+	}()
+	return c.NoContent(http.StatusAccepted)
 }

internal/web/server.go

@@ -32,8 +32,7 @@ type Server struct {
 	cfg  *config.Config
 	auth *authenticator
 
-	connMgr   cmgr.Cmgr
-	updateJob atomic.Pointer[JobStatus]
+	connMgr cmgr.Cmgr
 
 	// xrayStatus is wired post-construction by cli boot once the
 	// XrayServer exists. Always read via Load() — may be nil when
@@ -126,7 +125,6 @@ func setupRoutes(s *Server) {
 	api.GET("/version", s.Version)
 	api.GET("/update/check", s.UpdateCheck)
 	api.POST("/update/apply", s.UpdateApply)
-	api.GET("/update/status", s.UpdateStatus)
 
 	// Local SQLite store: read-side health snapshot + maintenance ops.
 	// All four mutations are auth-gated through the api group's

internal/web/webui/src/api/client.ts

@@ -35,7 +35,6 @@ import type {
   QueryNodeMetricsResp,
   VersionInfo,
   UpdateCheck,
-  UpdateStatus,
   UpdateApplyOptions,
   OverviewResp,
   DBHealth,
@@ -77,12 +76,11 @@ export const api = {
   updateCheck: (channel: string) =>
     request<UpdateCheck>(`/api/v1/update/check?channel=${encodeURIComponent(channel)}`),
   updateApply: (opts: UpdateApplyOptions) =>
-    request<{ state: string }>("/api/v1/update/apply", {
+    request<void>("/api/v1/update/apply", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(opts),
     }),
-  updateStatus: () => request<UpdateStatus>("/api/v1/update/status"),
   dbHealth: () => request<DBHealth>("/api/v1/db/health"),
   dbCleanup: (older_than_days: number) =>
     request<DBMaintenanceResult>("/api/v1/db/cleanup", {

internal/web/webui/src/api/types.ts

@@ -122,24 +122,6 @@ export interface UpdateCheck {
   asset_url: string;
 }
 
-export type UpdateState =
-  | "idle"
-  | "checking"
-  | "downloading"
-  | "installing"
-  | "restarting"
-  | "done"
-  | "failed";
-
-export interface UpdateStatus {
-  state: UpdateState;
-  channel?: string;
-  from?: string;
-  to?: string;
-  started_at?: string;
-  error?: string;
-}
-
 export interface UpdateApplyOptions {
   channel: string;
   force: boolean;