Say when an update check fails, and keep the web server current

A launch check that failed looked exactly like being up to date: its
error was printed only under YOLOCODER_DEBUG, and its two-second limit
could run out on GitHub's redirect. A web server left running also never
looked again, so it showed the build it started with long after main
moved on. Launch now prints a failed check and waits five seconds, and
the web server checks hourly, installs a newer build over the binary on
disk, and says in the page and terminal to restart.

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

Author: torrmal

cmd/yolocoder/main.go

@@ -44,9 +44,13 @@ func main() {
 	}
 
 	var updated bool
+	var updateErr error
 	ui.WithRobot(os.Stdout, "Starting YoloCoder...", func(status ui.RobotStatus) {
-		updated = update.CheckOnLaunch(version.Commit, status)
+		updated, updateErr = update.CheckOnLaunch(version.Commit, status)
 	})
+	if updateErr != nil {
+		fmt.Fprintf(os.Stderr, "\x1b[2m[^_^] Could not check for updates, starting %s: %v\x1b[0m\n", version.Display(), updateErr)
+	}
 	if updated {
 		// Relaunch replaces the file on disk; without re-executing it,
 		// this process would keep running the old code it already

internal/update/update.go

@@ -39,12 +39,13 @@ type Checker struct {
 // reporting whether a new build was installed. The caller should follow a
 // true result with Relaunch so this invocation continues on the new build
 // instead of finishing out on the one it started with.
-func CheckOnLaunch(currentCommit string, status ui.RobotStatus) bool {
+//
+// A failed check is returned rather than swallowed. It used to be printed
+// only under YOLOCODER_DEBUG, so a check that timed out looked exactly like
+// being current, and a build three commits behind went unnoticed.
+func CheckOnLaunch(currentCommit string, status ui.RobotStatus) (bool, error) {
 	_, updated, err := check(currentCommit, false, status)
-	if err != nil {
-		debugf("%v", err)
-	}
-	return updated
+	return updated, err
 }
 
 // Relaunch re-executes the just-updated binary at its own path with the
@@ -104,7 +105,9 @@ func check(currentCommit string, force bool, status ui.RobotStatus) (string, boo
 	if !force && !checker.Due(now) {
 		return "", false, nil
 	}
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	// Two seconds was too tight for GitHub's redirect to the asset host on
+	// a slow connection, and a timeout meant no update at all.
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	status("Checking for updates...")
 	latest, err := checker.LatestCommit(ctx)
 	cancel()

internal/web/server.go

@@ -22,6 +22,8 @@ import (
 	"github.com/mindsdb/yolocoder/internal/app"
 	"github.com/mindsdb/yolocoder/internal/config"
 	"github.com/mindsdb/yolocoder/internal/session"
+	"github.com/mindsdb/yolocoder/internal/update"
+	"github.com/mindsdb/yolocoder/internal/version"
 )
 
 //go:embed static
@@ -140,6 +142,9 @@ type Server struct {
 	stateMutex sync.Mutex
 	busy       bool
 	phase      string
+	// updated is the notice that a newer build was installed while this
+	// server ran, empty until one is.
+	updated string
 	// settleUntil is when errors start being believed again after a turn
 	// changed files. Guarded by stateMutex with busy, because it is the
 	// same question asked about a slightly later moment.
@@ -227,6 +232,7 @@ func Serve(ctx context.Context, provider config.LLM, port int, initialTask strin
 	if task := strings.TrimSpace(initialTask); task != "" {
 		go server.runTask(context.Background(), task, nil, "user")
 	}
+	go server.watchForUpdates(ctx)
 
 	select {
 	case <-ctx.Done():
@@ -417,17 +423,60 @@ func (server *Server) handleConfig(response http.ResponseWriter, request *http.R
 // this whenever its SSE connection (re)opens.
 func (server *Server) handleState(response http.ResponseWriter, request *http.Request) {
 	server.stateMutex.Lock()
-	busy, phase := server.busy, server.phase
+	busy, phase, updated := server.busy, server.phase, server.updated
 	server.stateMutex.Unlock()
 	writeJSON(response, map[string]any{
 		"busy":    busy,
 		"phase":   phase,
 		"process": server.proc.State(),
 		"port":    server.proc.Port(),
 		"offers":  server.pendingOfferInfos(),
+		"update":  updated,
 	})
 }
 
+// updateInterval is how often a running web server looks for a newer build.
+const updateInterval = time.Hour
+
+// watchForUpdates keeps a long-running web server from sitting on an old
+// build. Updates were only ever checked at launch, and the web server is
+// the process people leave open for days, so it showed the build it
+// started with long after main had moved on.
+//
+// A newer build is downloaded over the binary on disk, exactly as at
+// launch, and the page says so. It is not restarted into: that would drop
+// the chat and the app's ports mid-session, so restarting stays the
+// person's call, and it is instant because the new build is already there.
+func (server *Server) watchForUpdates(ctx context.Context) {
+	if version.Commit == "" {
+		return
+	}
+	ticker := time.NewTicker(updateInterval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+		}
+		latest, updated, err := update.CheckNow(version.Commit, func(string) {})
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "\x1b[2m[^_^] Could not check for updates: %v\x1b[0m\n", err)
+			continue
+		}
+		if !updated {
+			continue
+		}
+		text := "YoloCoder " + latest + " is installed. Restart yolocoder to use it."
+		fmt.Println("[^_^] " + text)
+		server.stateMutex.Lock()
+		server.updated = text
+		server.stateMutex.Unlock()
+		server.hub.publish("update", map[string]string{"text": text})
+		return
+	}
+}
+
 // pendingOfferInfo is an unanswered error card's wire shape, so a tab
 // that (re)connects after the offer was staged can still render it
 // instead of never learning it existed.

internal/web/static/app.js

@@ -541,6 +541,15 @@ modelSelect.addEventListener("change", () => {
 // a reconnect during a long build, a tab opened mid-task — would
 // otherwise leave the UI stuck showing whatever it last knew, forever;
 // this is what lets it catch up instead.
+// A newer build installed while this server was running. It stays until
+// yolocoder is restarted, since that is the only thing that clears it.
+const updateNotice = document.getElementById("update-notice");
+function showUpdate(text) {
+  if (!text) return;
+  updateNotice.textContent = text;
+  updateNotice.hidden = false;
+}
+
 function resyncState() {
   fetch("/state")
     .then((response) => response.json())
@@ -551,6 +560,7 @@ function resyncState() {
       // A tab that (re)connects after an offer was staged still renders it:
       // the offer event is one-shot, but /state carries the unanswered ones.
       for (const offer of state.offers || []) addErrorOffer(offer.id, offer.source, offer.text);
+      showUpdate(state.update);
     })
     .catch(() => {});
 }
@@ -611,6 +621,7 @@ events.addEventListener("error-offer", (event) => {
   const data = JSON.parse(event.data);
   addErrorOffer(data.id, data.source, data.text || "");
 });
+events.addEventListener("update", (event) => showUpdate(JSON.parse(event.data).text));
 events.addEventListener("error-offer-dismissed", (event) => {
   removeErrorOffer(JSON.parse(event.data).id);
 });

internal/web/static/index.html

@@ -13,6 +13,7 @@
       <div id="brand-block">
         <span id="brand"><span class="brand-face">[^_^]</span> YoloCoder</span>
         <div id="folder-indicator"></div>
+        <div id="update-notice" hidden></div>
       </div>
       <button id="btn-recover" type="button" hidden>Restart</button>
       <button id="btn-collapse" type="button" title="Collapse chat">&laquo;</button>

internal/web/static/style.css

@@ -91,6 +91,14 @@ main {
   overflow: hidden;
   text-overflow: ellipsis;
 }
+#update-notice {
+  font: 11px var(--mono);
+  color: #1d5a2f;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+#update-notice[hidden] { display: none; }
 #btn-recover {
   border: 1px solid #f3c6c6;
   background: #fff5f5;