scripts/release-desktop.sh 1.2.3

#!/usr/bin/env bash
# release-desktop.sh — build, tag, and publish a new MyApp desktop
# version in one shot. Run from the repo root.
#
# Usage:
#   scripts/release-desktop.sh                 # release current wails.json version
#   scripts/release-desktop.sh 1.2.3           # bump wails.json + release
#   scripts/release-desktop.sh 1.2.3 --notes "Custom notes"
 
set -euo pipefail
 
REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$REPO_ROOT"
 
WAILS_JSON="apps/desktop/wails.json"
BIN_DIR="apps/desktop/build/bin"
 
VERSION=""
NOTES=""
NO_INSTALLER=false
 
while [[ $# -gt 0 ]]; do
  case "$1" in
    --notes) NOTES="$2"; shift 2 ;;
    --no-installer) NO_INSTALLER=true; shift ;;
    *)
      if [[ -z "$VERSION" && "$1" =~ ^[0-9] ]]; then
        VERSION="$1"
      else
        echo "Unknown arg: $1" >&2
        exit 2
      fi
      shift
      ;;
  esac
done
 
CURRENT=$(grep '"productVersion"' "$WAILS_JSON" | head -1 | sed 's/.*"productVersion": *"\([^"]*\)".*/\1/')
if [[ -z "$VERSION" ]]; then
  VERSION="$CURRENT"
  echo "==> No version arg — releasing current wails.json version $VERSION"
fi
 
if [[ ! "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[A-Za-z0-9.]+)?$ ]]; then
  echo "Bad version '$VERSION' — expected X.Y.Z[-suffix]" >&2
  exit 2
fi
 
TAG="v$VERSION"
EXE="MyApp-v$VERSION.exe"
INSTALLER="MyApp-Setup-v$VERSION.exe"
ZIP="MyApp-Setup-v$VERSION.zip"
 
# ---- guard rails ----
if gh release view "$TAG" >/dev/null 2>&1; then
  echo "GitHub release $TAG already exists. Aborting." >&2
  exit 1
fi
if git rev-parse "$TAG" >/dev/null 2>&1; then
  echo "Git tag $TAG already exists. Aborting." >&2
  exit 1
fi
 
# ---- bump wails.json if needed ----
if [[ "$VERSION" != "$CURRENT" ]]; then
  echo "==> Bumping wails.json: $CURRENT -> $VERSION"
  python -c "
import json
p = '$WAILS_JSON'
with open(p) as f: data = json.load(f)
data['outputfilename'] = 'MyApp-v$VERSION'
data['info']['productVersion'] = '$VERSION'
with open(p, 'w') as f: json.dump(data, f, indent=2)
"
  git add "$WAILS_JSON"
  git commit -m "chore(release): bump desktop to v$VERSION"
fi
 
# ---- build ----
echo "==> Building desktop v$VERSION"
if $NO_INSTALLER; then
  (cd apps/desktop && wails build -platform windows/amd64)
else
  # -nsis produces both MyApp-vX.Y.Z.exe AND MyApp-Setup-vX.Y.Z.exe
  (cd apps/desktop && wails build -nsis -platform windows/amd64)
fi
 
if [[ ! -f "$BIN_DIR/$EXE" ]]; then
  echo "Expected $BIN_DIR/$EXE — build did not produce it." >&2
  exit 1
fi
 
# ---- zip the installer ----
if ! $NO_INSTALLER && [[ -f "$BIN_DIR/$INSTALLER" ]]; then
  ZIP_SOURCE="$INSTALLER"
else
  ZIP_SOURCE="$EXE"
  ZIP="MyApp-v$VERSION.zip"
fi
echo "==> Packaging $ZIP"
(cd "$BIN_DIR" && powershell.exe -Command "Compress-Archive -Path '$ZIP_SOURCE' -DestinationPath '$ZIP' -Force")
 
# ---- release notes ----
if [[ -z "$NOTES" ]]; then
  NOTES="MyApp desktop v$VERSION"
fi
 
# ---- publish ----
echo "==> Tagging $TAG + pushing"
git tag -a "$TAG" -m "MyApp desktop $TAG"
git push origin "$(git rev-parse --abbrev-ref HEAD)"
git push origin "$TAG"
 
echo "==> Creating GitHub release"
# Asset ORDER matters — the first asset is what the Releases page
# shows most prominently. Installer first so humans grab the right
# one; raw .exe second (auto-updater picks it programmatically via
# the "no setup keyword" rule); zip last.
RELEASE_ASSETS=()
if ! $NO_INSTALLER && [[ -f "$BIN_DIR/$INSTALLER" ]]; then
  RELEASE_ASSETS+=("$BIN_DIR/$INSTALLER")
fi
RELEASE_ASSETS+=("$BIN_DIR/$EXE" "$BIN_DIR/$ZIP")
gh release create "$TAG" \
  "${RELEASE_ASSETS[@]}" \
  --title "MyApp desktop $TAG" \
  --notes "$NOTES"
 
echo "Released $TAG."

scripts/release-desktop.sh 0.0.1

; project.nsi — make it a per-user install
RequestExecutionLevel user
InstallDir "$LOCALAPPDATA\Programs\MyApp"

// desktop_handler.go
package handlers
 
import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "strings"
    "sync"
    "time"
 
    "github.com/gin-gonic/gin"
)
 
type DesktopHandler struct {
    mu     sync.Mutex
    cached *cachedRelease
}
 
type cachedRelease struct {
    payload   gin.H
    expiresAt time.Time
}
 
func NewDesktopHandler() *DesktopHandler { return &DesktopHandler{} }
 
// Fallback values — used only when GitHub is unreachable AND no env
// override is set. Lets the endpoint never return 500.
const (
    defaultOwner        = "you"
    defaultRepo         = "myapp"
    defaultAssetGlob    = ".exe"
    defaultVersion      = "1.0.0"
    defaultURL          = "https://github.com/you/myapp/releases/latest"
    defaultReleaseNotes = "See CHANGELOG"
    cacheTTL            = 10 * time.Minute
    githubTimeout       = 8 * time.Second
)
 
func envOr(key, fallback string) string {
    if v := strings.TrimSpace(os.Getenv(key)); v != "" {
        return v
    }
    return fallback
}
 
type githubRelease struct {
    TagName     string `json:"tag_name"`
    Body        string `json:"body"`
    PublishedAt string `json:"published_at"`
    Draft       bool   `json:"draft"`
    Prerelease  bool   `json:"prerelease"`
    Assets      []struct {
        ID                 int64  `json:"id"`
        Name               string `json:"name"`
        BrowserDownloadURL string `json:"browser_download_url"`
    } `json:"assets"`
}
 
func fetchLatest(owner, repo string) (*githubRelease, error) {
    url := fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", owner, repo)
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Accept", "application/vnd.github+json")
    if tok := strings.TrimSpace(os.Getenv("GITHUB_TOKEN")); tok != "" {
        req.Header.Set("Authorization", "Bearer "+tok)
    }
    client := &http.Client{Timeout: githubTimeout}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    if resp.StatusCode != 200 {
        body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
        return nil, fmt.Errorf("github %d: %s", resp.StatusCode, string(body))
    }
    var rel githubRelease
    if err := json.NewDecoder(resp.Body).Decode(&rel); err != nil {
        return nil, err
    }
    if rel.Draft || rel.Prerelease {
        return nil, fmt.Errorf("latest is draft/prerelease")
    }
    return &rel, nil
}
 
// pickAsset finds the raw .exe (preferred) or installer (fallback).
// Two-pass: prefer assets that DON'T contain "setup" so the
// auto-updater's binary-swap path gets the portable .exe, not the
// NSIS wizard.
func pickAsset(rel *githubRelease, glob string) (int64, string) {
    g := strings.ToLower(glob)
    var fallback struct {
        ID  int64
        URL string
    }
    for _, a := range rel.Assets {
        ln := strings.ToLower(a.Name)
        if !strings.Contains(ln, g) {
            continue
        }
        if fallback.URL == "" {
            fallback.ID, fallback.URL = a.ID, a.BrowserDownloadURL
        }
        if !strings.Contains(ln, "setup") && !strings.Contains(ln, "installer") {
            return a.ID, a.BrowserDownloadURL
        }
    }
    return fallback.ID, fallback.URL
}
 
func (h *DesktopHandler) getCached() gin.H {
    h.mu.Lock()
    defer h.mu.Unlock()
    if h.cached != nil && time.Now().Before(h.cached.expiresAt) {
        return h.cached.payload
    }
    return nil
}
 
func (h *DesktopHandler) setCache(payload gin.H) {
    h.mu.Lock()
    defer h.mu.Unlock()
    h.cached = &cachedRelease{payload: payload, expiresAt: time.Now().Add(cacheTTL)}
}
 
// GET /api/desktop/latest
// GET /api/desktop/latest?refresh=1 — bust the cache
func (h *DesktopHandler) GetLatest(c *gin.Context) {
    // Env override wins — emergency manual control without a redeploy
    if v := strings.TrimSpace(os.Getenv("DESKTOP_LATEST_VERSION")); v != "" {
        c.JSON(200, gin.H{"data": gin.H{
            "version":       v,
            "download_url":  envOr("DESKTOP_LATEST_URL", defaultURL),
            "release_notes": envOr("DESKTOP_LATEST_NOTES", defaultReleaseNotes),
            "source":        "env",
        }})
        return
    }
 
    if c.Query("refresh") != "1" {
        if cached := h.getCached(); cached != nil {
            c.JSON(200, gin.H{"data": cached})
            return
        }
    }
 
    owner := envOr("DESKTOP_GITHUB_OWNER", defaultOwner)
    repo := envOr("DESKTOP_GITHUB_REPO", defaultRepo)
    glob := envOr("DESKTOP_ASSET_GLOB", defaultAssetGlob)
 
    rel, err := fetchLatest(owner, repo)
    if err != nil {
        // Last-resort fallback — keep the endpoint up
        c.JSON(200, gin.H{"data": gin.H{
            "version":       defaultVersion,
            "download_url":  defaultURL,
            "release_notes": defaultReleaseNotes,
            "source":        "fallback",
        }})
        return
    }
 
    assetID, githubURL := pickAsset(rel, glob)
    if githubURL == "" {
        c.JSON(200, gin.H{"data": gin.H{
            "version":      strings.TrimPrefix(rel.TagName, "v"),
            "download_url": defaultURL,
            "source":       "no-asset",
        }})
        return
    }
 
    // download_url points at OUR proxy, not GitHub directly. This is
    // how private-repo assets work without the desktop needing auth.
    base := requestBase(c)
    payload := gin.H{
        "version":       strings.TrimPrefix(rel.TagName, "v"),
        "download_url":  fmt.Sprintf("%s/api/desktop/download?tag=%s", base, rel.TagName),
        "github_url":    githubURL,
        "released_at":   rel.PublishedAt,
        "release_notes": rel.Body,
        "source":        "github",
    }
    _ = assetID
    h.setCache(payload)
    c.JSON(200, gin.H{"data": payload})
}
 
// requestBase honours X-Forwarded-Proto for Traefik / nginx setups
// so the download URL we hand back is https:// in prod and http://
// locally.
func requestBase(c *gin.Context) string {
    scheme := "http"
    if c.Request.TLS != nil {
        scheme = "https"
    }
    if p := c.Request.Header.Get("X-Forwarded-Proto"); p != "" {
        scheme = p
    }
    host := c.Request.Host
    if h := c.Request.Header.Get("X-Forwarded-Host"); h != "" {
        host = h
    }
    return scheme + "://" + host
}

// resolvePresignedAssetURL hits GitHub's asset endpoint with
// Accept: application/octet-stream. For both public and private
// repos this responds with a 302 to a short-lived presigned URL
// (no further auth required by the client). We read the Location
// header without following the redirect, then re-emit it to the
// client.
func resolvePresignedAssetURL(owner, repo string, assetID int64) (string, error) {
    url := fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/assets/%d", owner, repo, assetID)
    client := &http.Client{
        Timeout: githubTimeout,
        CheckRedirect: func(req *http.Request, via []*http.Request) error {
            return http.ErrUseLastResponse
        },
    }
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Accept", "application/octet-stream")
    if tok := strings.TrimSpace(os.Getenv("GITHUB_TOKEN")); tok != "" {
        req.Header.Set("Authorization", "Bearer "+tok)
    }
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    if resp.StatusCode != http.StatusFound && resp.StatusCode != http.StatusTemporaryRedirect {
        return "", fmt.Errorf("expected 302, got %d", resp.StatusCode)
    }
    loc := resp.Header.Get("Location")
    if loc == "" {
        return "", fmt.Errorf("missing Location header")
    }
    return loc, nil
}
 
// GET /api/desktop/download?tag=v1.2.3
func (h *DesktopHandler) GetDownload(c *gin.Context) {
    owner := envOr("DESKTOP_GITHUB_OWNER", defaultOwner)
    repo := envOr("DESKTOP_GITHUB_REPO", defaultRepo)
    tag := strings.TrimSpace(c.Query("tag"))
 
    var rel *githubRelease
    var err error
    if tag == "" {
        rel, err = fetchLatest(owner, repo)
    } else {
        rel, err = fetchReleaseByTag(owner, repo, tag)
    }
    if err != nil {
        c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
        return
    }
    assetID, _ := pickAsset(rel, envOr("DESKTOP_ASSET_GLOB", defaultAssetGlob))
    if assetID == 0 {
        c.JSON(http.StatusNotFound, gin.H{"error": "no matching asset"})
        return
    }
    presigned, err := resolvePresignedAssetURL(owner, repo, assetID)
    if err != nil {
        c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
        return
    }
    c.Redirect(http.StatusFound, presigned)
}

r := gin.Default()
desk := handlers.NewDesktopHandler()
r.GET("/api/desktop/latest", desk.GetLatest)
r.GET("/api/desktop/download", desk.GetDownload)

func (h *DesktopHandler) GetDiagnostics(c *gin.Context) {
    tok := os.Getenv("GITHUB_TOKEN")
    prefix := ""
    if n := len(tok); n >= 4 {
        prefix = tok[:4] + "..."
    }
    owner := envOr("DESKTOP_GITHUB_OWNER", defaultOwner)
    repo := envOr("DESKTOP_GITHUB_REPO", defaultRepo)
    test := gin.H{"owner": owner, "repo": repo}
    if rel, err := fetchLatest(owner, repo); err != nil {
        test["ok"] = false
        test["error"] = err.Error()
    } else {
        test["ok"] = true
        test["latest_tag"] = rel.TagName
        test["asset_count"] = len(rel.Assets)
    }
    c.JSON(200, gin.H{"data": gin.H{
        "token_set":    tok != "",
        "token_length": len(tok),
        "token_prefix": prefix,
        "github":       test,
    }})
}

package main
 
import (
    "context"
    "errors"
    "fmt"
    "io"
    "net/http"
    "os"
    "os/exec"
    "path/filepath"
    "sync"
    "sync/atomic"
    "time"
 
    "github.com/wailsapp/wails/v2/pkg/runtime"
)
 
type Updater struct {
    ctx context.Context
 
    mu      sync.RWMutex
    status  string // idle | downloading | downloaded | installing | error
    target  string // path to the downloaded .exe
    version string
    errMsg  string
 
    bytesDownloaded atomic.Int64
    bytesTotal      atomic.Int64
 
    cancel context.CancelFunc
}
 
type UpdaterState struct {
    Status          string `json:"status"`
    Version         string `json:"version"`
    BytesDownloaded int64  `json:"bytes_downloaded"`
    BytesTotal      int64  `json:"bytes_total"`
    Error           string `json:"error,omitempty"`
}
 
func NewUpdater() *Updater { return &Updater{status: "idle"} }
func (u *Updater) SetContext(ctx context.Context) { u.ctx = ctx }
 
// CleanupOldOnStartup removes the .exe.old left behind by the
// previous in-app update. Called from main.go in a goroutine so app
// startup isn't blocked. Best-effort: retries briefly in case the
// old process is still releasing the handle.
func (u *Updater) CleanupOldOnStartup() {
    exe, err := os.Executable()
    if err != nil {
        return
    }
    old := exe + ".old"
    if _, err := os.Stat(old); errors.Is(err, os.ErrNotExist) {
        return
    }
    for i := 0; i < 25; i++ {
        if err := os.Remove(old); err == nil || errors.Is(err, os.ErrNotExist) {
            return
        }
        time.Sleep(200 * time.Millisecond)
    }
}
 
func (u *Updater) GetProgress() UpdaterState {
    u.mu.RLock()
    defer u.mu.RUnlock()
    return UpdaterState{
        Status:          u.status,
        Version:         u.version,
        BytesDownloaded: u.bytesDownloaded.Load(),
        BytesTotal:      u.bytesTotal.Load(),
        Error:           u.errMsg,
    }
}
 
func (u *Updater) StartDownload(url, version string) error {
    if url == "" || version == "" {
        return errors.New("url and version required")
    }
    u.mu.Lock()
    if u.status == "downloading" {
        u.mu.Unlock()
        return errors.New("download already in progress")
    }
    ctx, cancel := context.WithCancel(context.Background())
    u.cancel = cancel
    u.status = "downloading"
    u.version = version
    u.errMsg = ""
    u.target = ""
    u.bytesDownloaded.Store(0)
    u.bytesTotal.Store(0)
    u.mu.Unlock()
    go u.downloadWorker(ctx, url, version)
    return nil
}
 
func (u *Updater) downloadWorker(ctx context.Context, url, version string) {
    fail := func(err error) {
        u.mu.Lock()
        u.status = "error"
        u.errMsg = err.Error()
        u.mu.Unlock()
    }
 
    partial := filepath.Join(os.TempDir(), fmt.Sprintf("MyApp-v%s.exe.partial", version))
    final := filepath.Join(os.TempDir(), fmt.Sprintf("MyApp-v%s.exe", version))
    _ = os.Remove(partial)
    _ = os.Remove(final)
 
    req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
    // No client-level timeout. The download can be 20+ MB on a flaky
    // link. Context-driven cancellation handles user-cancel.
    resp, err := (&http.Client{Timeout: 0}).Do(req)
    if err != nil {
        fail(err)
        return
    }
    defer resp.Body.Close()
    if resp.StatusCode < 200 || resp.StatusCode >= 300 {
        fail(fmt.Errorf("download HTTP %d", resp.StatusCode))
        return
    }
 
    u.bytesTotal.Store(resp.ContentLength)
 
    out, err := os.Create(partial)
    if err != nil {
        fail(err)
        return
    }
    prog := &progressWriter{u: u}
    if _, err := io.Copy(out, io.TeeReader(resp.Body, prog)); err != nil {
        out.Close()
        _ = os.Remove(partial)
        if ctx.Err() != nil {
            u.mu.Lock()
            u.status = "idle"
            u.mu.Unlock()
            return
        }
        fail(err)
        return
    }
    out.Close()
 
    if err := os.Rename(partial, final); err != nil {
        fail(err)
        return
    }
    u.mu.Lock()
    u.status = "downloaded"
    u.target = final
    u.mu.Unlock()
}
 
type progressWriter struct{ u *Updater }
 
func (p *progressWriter) Write(b []byte) (int, error) {
    p.u.bytesDownloaded.Add(int64(len(b)))
    return len(b), nil
}
 
func (u *Updater) CancelDownload() {
    u.mu.Lock()
    if u.cancel != nil {
        u.cancel()
    }
    u.mu.Unlock()
}
 
// InstallAndRestart is THE trick. On Windows, you can't overwrite a
// running .exe. But you CAN rename it — Windows keeps the kernel
// object alive while the directory entry moves. So we:
//
//   1. Rename live.exe → live.exe.old
//   2. Copy new.exe (from %TEMP%) → live.exe path
//   3. Spawn live.exe (the new version) as a detached child
//   4. Quit our current process
//
// On next launch, CleanupOldOnStartup() removes the .old.
func (u *Updater) InstallAndRestart() error {
    u.mu.Lock()
    src := u.target
    curStatus := u.status
    u.mu.Unlock()
 
    if curStatus != "downloaded" || src == "" {
        return fmt.Errorf("no completed download (status=%s)", curStatus)
    }
    u.mu.Lock()
    u.status = "installing"
    u.mu.Unlock()
 
    currentExe, err := os.Executable()
    if err != nil {
        return fmt.Errorf("resolving current exe: %w", err)
    }
 
    oldPath := currentExe + ".old"
    _ = os.Remove(oldPath) // clear stale .old from a previous attempt
 
    if err := os.Rename(currentExe, oldPath); err != nil {
        return fmt.Errorf("renaming current exe: %w", err)
    }
 
    // Copy, not rename — %TEMP% is usually on a different volume than
    // %LOCALAPPDATA% and os.Rename across volumes fails with EXDEV.
    if err := copyFile(src, currentExe); err != nil {
        _ = os.Rename(oldPath, currentExe) // roll back
        return fmt.Errorf("copying new exe: %w", err)
    }
    _ = os.Remove(src)
 
    cmd := exec.Command(currentExe)
    if err := cmd.Start(); err != nil {
        return fmt.Errorf("starting new version: %w", err)
    }
 
    // Small delay so the modal's "Installing…" state has time to
    // paint before the window closes. Feels less abrupt.
    go func() {
        time.Sleep(250 * time.Millisecond)
        if u.ctx != nil {
            runtime.Quit(u.ctx)
        } else {
            os.Exit(0)
        }
    }()
    return nil
}
 
func copyFile(src, dst string) error {
    in, err := os.Open(src)
    if err != nil {
        return err
    }
    defer in.Close()
    out, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o755)
    if err != nil {
        return err
    }
    defer out.Close()
    if _, err := io.Copy(out, in); err != nil {
        return err
    }
    return out.Close()
}

func main() {
    app := NewApp()
    updater := NewUpdater()
 
    err := wails.Run(&options.App{
        Title:  "MyApp",
        Width:  1280,
        Height: 800,
        OnStartup: func(ctx context.Context) {
            app.startup(ctx)
            updater.SetContext(ctx)
            go updater.CleanupOldOnStartup()
        },
        Bind: []interface{}{
            app,
            updater, // ← exposes Updater methods to React
        },
    })
    if err != nil {
        println(err.Error())
    }
}

import { defineConfig } from "vite";
import fs from "node:fs";
import path from "node:path";
 
const wailsJson = JSON.parse(
  fs.readFileSync(path.resolve(__dirname, "../wails.json"), "utf-8")
);
 
export default defineConfig({
  define: {
    __APP_VERSION__: JSON.stringify(wailsJson.info.productVersion),
  },
  // ...rest of your config
});

export const APP_VERSION: string =
  (typeof __APP_VERSION__ !== "undefined" && __APP_VERSION__) || "1.0.0";
 
declare const __APP_VERSION__: string;
 
// Semver-light comparison. Strips suffixes after "-".
export function isNewerVersion(current: string, latest: string): boolean {
  const parse = (v: string) =>
    v
      .split("-")[0]
      .split(".")
      .map((n) => parseInt(n, 10))
      .map((n) => (Number.isFinite(n) ? n : 0));
  const a = parse(current);
  const b = parse(latest);
  const len = Math.max(a.length, b.length);
  for (let i = 0; i < len; i++) {
    const ai = a[i] ?? 0;
    const bi = b[i] ?? 0;
    if (bi > ai) return true;
    if (bi < ai) return false;
  }
  return false;
}

// src/hooks/use-latest-version.ts
import { useQuery, useQueryClient } from "@tanstack/react-query";
import axios from "axios";
import { APP_VERSION, isNewerVersion } from "@/lib/version";
 
export interface LatestVersionPayload {
  version: string;
  download_url: string;
  released_at: string;
  release_notes: string;
}
 
const POLL_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
 
export function useLatestVersion() {
  const qc = useQueryClient();
  const q = useQuery<LatestVersionPayload, Error>({
    queryKey: ["desktop-latest-version"],
    queryFn: async () => {
      const { data } = await axios.get(
        "https://api.myapp.com/api/desktop/latest"
      );
      return data.data as LatestVersionPayload;
    },
    refetchInterval: POLL_INTERVAL_MS,
    staleTime: POLL_INTERVAL_MS / 2,
    retry: 1, // old API that doesn't have this endpoint: fail once and back off
  });
 
  // Bypass the API's 10-min cache for the "Check for updates" click —
  // otherwise the operator clicking the button immediately after a
  // release ships sees stale data.
  async function checkNow() {
    const { data } = await axios.get(
      "https://api.myapp.com/api/desktop/latest?refresh=1"
    );
    const payload = data.data as LatestVersionPayload;
    qc.setQueryData(["desktop-latest-version"], payload);
    return payload;
  }
 
  const latestVersion = q.data?.version ?? null;
  const isUpdateAvailable =
    !!latestVersion && isNewerVersion(APP_VERSION, latestVersion);
 
  return {
    ...q,
    checkNow,
    isUpdateAvailable,
    currentVersion: APP_VERSION,
    latestVersion,
  };
}

// src/components/update-progress-modal.tsx
import { useEffect, useRef, useState } from "react";
 
// Wails injects window.go.main.Updater at runtime. We resolve through
// window so dev-server runs (no Wails) don't crash on the global.
interface UpdaterBinding {
  StartDownload: (url: string, version: string) => Promise<void>;
  GetProgress: () => Promise<UpdaterState>;
  CancelDownload: () => Promise<void>;
  InstallAndRestart: () => Promise<void>;
}
 
function getUpdater(): UpdaterBinding | null {
  const w = window as { go?: { main?: { Updater?: UpdaterBinding } } };
  return w.go?.main?.Updater ?? null;
}
 
export interface UpdaterState {
  status: "idle" | "downloading" | "downloaded" | "installing" | "error";
  version: string;
  bytes_downloaded: number;
  bytes_total: number;
  error?: string;
}
 
export function UpdateProgressModal({
  downloadURL,
  version,
  onClose,
}: {
  downloadURL: string;
  version: string;
  onClose: () => void;
}) {
  const [state, setState] = useState<UpdaterState>({
    status: "idle",
    version,
    bytes_downloaded: 0,
    bytes_total: 0,
  });
  const startedRef = useRef(false);
  const updater = getUpdater();
 
  // Kick off the download once on mount.
  useEffect(() => {
    if (startedRef.current || !updater) return;
    startedRef.current = true;
    updater
      .StartDownload(downloadURL, version)
      .catch((e: Error) =>
        setState((s) => ({ ...s, status: "error", error: e.message }))
      );
  }, [downloadURL, version, updater]);
 
  // Poll for progress 2x/sec until we hit a terminal state.
  useEffect(() => {
    if (!updater) return;
    if (["downloaded", "error", "installing"].includes(state.status)) return;
    const id = setInterval(async () => {
      try {
        const s = await updater.GetProgress();
        setState(s);
      } catch {
        // polling glitches are non-fatal
      }
    }, 500);
    return () => clearInterval(id);
  }, [state.status, updater]);
 
  const pct =
    state.bytes_total > 0
      ? Math.round((state.bytes_downloaded / state.bytes_total) * 100)
      : 0;
  const mb = (state.bytes_downloaded / 1024 / 1024).toFixed(1);
  const mbTotal =
    state.bytes_total > 0 ? (state.bytes_total / 1024 / 1024).toFixed(1) : "?";
 
  return (
    <div className="modal">
      <h2>
        {state.status === "downloading" && `Downloading v${version}`}
        {state.status === "downloaded" && `Ready to install v${version}`}
        {state.status === "installing" && "Installing…"}
        {state.status === "error" && "Update failed"}
      </h2>
 
      {(state.status === "downloading" || state.status === "downloaded") && (
        <>
          <progress value={pct} max={100} />
          <div>
            {mb} / {mbTotal} MB ({pct}%)
          </div>
        </>
      )}
 
      {state.status === "error" && <div className="error">{state.error}</div>}
 
      <div className="actions">
        {state.status === "downloading" && (
          <button
            onClick={() => {
              updater?.CancelDownload();
              onClose();
            }}
          >
            Cancel
          </button>
        )}
        {state.status === "downloaded" && (
          <button onClick={() => updater?.InstallAndRestart()}>
            Install &amp; restart
          </button>
        )}
        {state.status === "error" && <button onClick={onClose}>Close</button>}
      </div>
    </div>
  );
}

// somewhere in your app shell
import { useState } from "react";
import { useLatestVersion } from "@/hooks/use-latest-version";
import { UpdateProgressModal } from "@/components/update-progress-modal";
 
function UpdateBanner() {
  const { isUpdateAvailable, latestVersion, data } = useLatestVersion();
  const [open, setOpen] = useState(false);
 
  if (!isUpdateAvailable) return null;
 
  return (
    <>
      <div className="banner">
        A new version (v{latestVersion}) is available.
        <button onClick={() => setOpen(true)}>Update now</button>
      </div>
      {open && data && (
        <UpdateProgressModal
          downloadURL={data.download_url}
          version={data.version}
          onClose={() => setOpen(false)}
        />
      )}
    </>
  );
}

const KEY = "myapp.auto_update_enabled";
 
export function getAutoUpdateEnabled(): boolean {
  const v = localStorage.getItem(KEY);
  return v === null || v === "true"; // default ON
}
 
export function setAutoUpdateEnabled(enabled: boolean) {
  localStorage.setItem(KEY, enabled ? "true" : "false");
}

# 1. Make your changes, run tests
git commit -am "feat: my new feature"
 
# 2. Ship it
scripts/release-desktop.sh 1.2.3
 
# 3. Wait ~90 seconds for the build
# 4. The release is live at https://github.com/you/myapp/releases/tag/v1.2.3