fix(update): revalidate stale startup cache

Author: elkaix

.github/workflows/promote-release.yml

@@ -3,9 +3,10 @@ name: Promote release
 # Platform build workflows (windows-installer, linux-installer,
 # release-pythinker-cli) create the GitHub Release as a PRERELEASE so it stays
 # out of the date-based /releases/latest endpoint (which ignores make_latest)
-# until every asset has uploaded. This workflow waits for all expected assets,
-# then clears `prerelease` and marks the release latest — the single point
-# where a version becomes resolvable by the install scripts and in-app updater.
+# until every install channel is ready. This workflow waits for exact release
+# assets, PyPI, and the Homebrew formula, then clears `prerelease` and marks the
+# release latest — the single point where a version becomes resolvable by the
+# install scripts and in-app updater.
 #
 # It runs on the tag push (not `release: published`, which a GITHUB_TOKEN-created
 # release never fires) so promotion always happens. workflow_dispatch allows a
@@ -55,24 +56,44 @@ jobs:
           fi
           echo "tag=$tag" >> "$GITHUB_OUTPUT"
 
-      - name: Wait for all release assets
+      - name: Wait for install-channel readiness
         env:
           GH_TOKEN: ${{ github.token }}
           TAG: ${{ steps.tag.outputs.tag }}
           REPO: ${{ github.repository }}
         run: |
           set -euo pipefail
-          required=(
-            "PythinkerSetup-"
-            "_amd64.deb"
-            "_arm64.deb"
-            ".x86_64.rpm"
-            ".aarch64.rpm"
-            "x86_64-unknown-linux-gnu.tar.gz"
-            "aarch64-unknown-linux-gnu.tar.gz"
-            "aarch64-apple-darwin.tar.gz"
-            "x86_64-apple-darwin.tar.gz"
+          version="${TAG#v}"
+          required_assets=(
+            "PythinkerSetup-${version}.exe"
+            "PythinkerSetup-${version}.exe.sha256"
+            "pythinker-code_${version}_amd64.deb"
+            "pythinker-code_${version}_amd64.deb.sha256"
+            "pythinker-code_${version}_arm64.deb"
+            "pythinker-code_${version}_arm64.deb.sha256"
+            "pythinker-code-${version}.x86_64.rpm"
+            "pythinker-code-${version}.x86_64.rpm.sha256"
+            "pythinker-code-${version}.aarch64.rpm"
+            "pythinker-code-${version}.aarch64.rpm.sha256"
+            "pythinker-${version}-x86_64-unknown-linux-gnu.tar.gz"
+            "pythinker-${version}-x86_64-unknown-linux-gnu.tar.gz.sha256"
+            "pythinker-${version}-aarch64-unknown-linux-gnu.tar.gz"
+            "pythinker-${version}-aarch64-unknown-linux-gnu.tar.gz.sha256"
+            "pythinker-${version}-aarch64-apple-darwin.tar.gz"
+            "pythinker-${version}-aarch64-apple-darwin.tar.gz.sha256"
+            "pythinker-${version}-x86_64-apple-darwin.tar.gz"
+            "pythinker-${version}-x86_64-apple-darwin.tar.gz.sha256"
+            "pythinker-${version}-x86_64-unknown-linux-gnu-onedir.tar.gz"
+            "pythinker-${version}-x86_64-unknown-linux-gnu-onedir.tar.gz.sha256"
+            "pythinker-${version}-aarch64-unknown-linux-gnu-onedir.tar.gz"
+            "pythinker-${version}-aarch64-unknown-linux-gnu-onedir.tar.gz.sha256"
+            "pythinker-${version}-aarch64-apple-darwin-onedir.tar.gz"
+            "pythinker-${version}-aarch64-apple-darwin-onedir.tar.gz.sha256"
+            "pythinker-${version}-x86_64-apple-darwin-onedir.tar.gz"
+            "pythinker-${version}-x86_64-apple-darwin-onedir.tar.gz.sha256"
           )
+          pypi_url="https://pypi.org/pypi/pythinker-code/${version}/json"
+          homebrew_formula_url="https://raw.githubusercontent.com/TechMatrix-labs/homebrew-pythinker/main/Formula/pythinker-code.rb"
           # The budget must comfortably exceed the slowest platform build, since
           # this job runs on the tag push in parallel with them. The long pole is
           # linux-installer's emulated arm64 .deb/.rpm step: on the 0.26.0 release
@@ -83,26 +104,51 @@ jobs:
           max_attempts=80
           poll_interval=30
           budget_min=$(( max_attempts * poll_interval / 60 ))
-          echo "Polling for all release assets on $TAG (up to ${budget_min}m)..."
-          all_present=false
+          echo "Polling install-channel readiness for $TAG (up to ${budget_min}m)..."
+          all_ready=false
           for i in $(seq 1 "$max_attempts"); do
-            assets=$(gh api "repos/$REPO/releases/tags/$TAG" --jq '[.assets[].name] | join(" ")' 2>/dev/null || echo "")
-            all_present=true
-            for p in "${required[@]}"; do
-              if [[ "$assets" != *"$p"* ]]; then
-                all_present=false
-                break
+            assets_json=$(gh api "repos/$REPO/releases/tags/$TAG" --jq '[.assets[].name]' 2>/dev/null || printf '[]')
+            missing_assets=()
+            for asset in "${required_assets[@]}"; do
+              if ! jq -e --arg name "$asset" 'index($name)' <<<"$assets_json" >/dev/null; then
+                missing_assets+=("$asset")
               fi
             done
-            if [[ "$all_present" == "true" ]]; then
-              echo "All assets present (attempt $i)"
+
+            pypi_ready=false
+            if curl -fsSL --retry 2 --retry-delay 2 -o /dev/null "$pypi_url"; then
+              pypi_ready=true
+            fi
+
+            homebrew_ready=false
+            formula_text=$(curl -fsSL --retry 2 --retry-delay 2 "$homebrew_formula_url" 2>/dev/null || true)
+            if grep -qF "version \"${version}\"" <<<"$formula_text"; then
+              homebrew_ready=true
+            fi
+
+            if [[ "${#missing_assets[@]}" -eq 0 && "$pypi_ready" == "true" && "$homebrew_ready" == "true" ]]; then
+              all_ready=true
+              echo "All install channels ready (attempt $i)"
               break
             fi
-            echo "Attempt $i/$max_attempts: assets not ready, retrying in ${poll_interval}s..."
-            sleep "$poll_interval"
+
+            echo "Attempt $i/$max_attempts: install channels not ready."
+            if [[ "${#missing_assets[@]}" -gt 0 ]]; then
+              printf 'Missing release assets: %s\n' "${missing_assets[*]}"
+            fi
+            if [[ "$pypi_ready" != "true" ]]; then
+              echo "PyPI is not serving ${version} yet: $pypi_url"
+            fi
+            if [[ "$homebrew_ready" != "true" ]]; then
+              echo "Homebrew tap formula is not at ${version} yet: $homebrew_formula_url"
+            fi
+            if [[ "$i" -lt "$max_attempts" ]]; then
+              echo "Retrying in ${poll_interval}s..."
+              sleep "$poll_interval"
+            fi
           done
-          if [[ "$all_present" != "true" ]]; then
-            echo "::error::Release assets not fully uploaded after ${budget_min} minutes"
+          if [[ "$all_ready" != "true" ]]; then
+            echo "::error::Install channels were not fully ready after ${budget_min} minutes"
             exit 1
           fi
 

src/pythinker_code/ui/shell/update.py

@@ -52,6 +52,7 @@
 LAST_UPDATE_CHECK_FILE = get_share_dir() / "last_update_check.txt"
 DISMISSED_VERSION_FILE = get_share_dir() / "dismissed_update_version.txt"
 AUTO_UPDATE_CHECK_INTERVAL_SECONDS = 24 * 60 * 60
+PROMPT_UPDATE_REFRESH_TIMEOUT_SECONDS = 2.0
 
 _UPDATE_LOCK = asyncio.Lock()
 _skipped_version_this_session: str | None = None
@@ -404,17 +405,32 @@ async def _refresh_update_cache(*, force: bool) -> UpdateResult | None:
     return result
 
 
+async def _refresh_update_cache_for_prompt(*, force: bool) -> UpdateResult | None:
+    """Refresh the startup-prompt version cache without hanging shell startup."""
+    try:
+        return await asyncio.wait_for(
+            _refresh_update_cache(force=force),
+            timeout=PROMPT_UPDATE_REFRESH_TIMEOUT_SECONDS,
+        )
+    except TimeoutError:
+        logger.warning("Update prompt refresh timed out; using cached latest version")
+        return None
+
+
 async def _resolve_latest_version_for_prompt(*, force_refresh: bool = False) -> str | None:
-    """Return the latest known native release, refreshing when due or uncached.
+    """Return the latest known native release for the pre-start prompt.
 
-    Used by the blocking pre-start prompt and by the explicit ``/update`` flow.
-    A missing cache forces one network check so fresh installs can be prompted
-    before the agent starts instead of seeing only a later background notice.
-    ``/update`` passes ``force_refresh=True`` so explicit user checks hit the
-    release API even when the startup throttle is not due.
+    The background notifier uses a 24h throttle, but the blocking startup prompt
+    must not trust a cached "already current" answer forever: a release can land
+    minutes after the last successful check. Revalidate missing/stale caches with
+    a short timeout and GitHub's cached ETag; keep the throttle only when the
+    cached version is already newer than the running version.
     """
+    from pythinker_code.constant import VERSION as current_version
+
     cached = _read_latest_version_cache()
-    refresh_result = await _refresh_update_cache(force=force_refresh or not cached)
+    cached_is_stale = cached is None or semver_tuple(cached) <= semver_tuple(current_version)
+    refresh_result = await _refresh_update_cache_for_prompt(force=force_refresh or cached_is_stale)
     if refresh_result is not None:
         return _read_latest_version_cache() or cached
     return cached

tests/ui_and_conv/test_shell_update.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -319,6 +320,52 @@ async def fail_do_update(*, print: bool, check_only: bool) -> update.UpdateResul
     assert await update._resolve_latest_version_for_prompt() == "3.1.0"
 
 
+@pytest.mark.asyncio
+async def test_resolve_latest_version_revalidates_stale_cache_when_not_due(monkeypatch, tmp_path):
+    latest_file = tmp_path / "latest.txt"
+    latest_file.write_text("0.0.0", encoding="utf-8")
+    last_check_file = tmp_path / "last_update_check.txt"
+    calls: list[tuple[bool, bool]] = []
+
+    async def fake_do_update(*, print: bool, check_only: bool) -> update.UpdateResult:
+        calls.append((print, check_only))
+        latest_file.write_text("999.0.0", encoding="utf-8")
+        return update.UpdateResult.UPDATE_AVAILABLE
+
+    def fail_should_auto_check() -> bool:
+        raise AssertionError("stale prompt cache must bypass the 24h throttle")
+
+    monkeypatch.setattr(update, "LATEST_VERSION_FILE", latest_file)
+    monkeypatch.setattr(update, "LAST_UPDATE_CHECK_FILE", last_check_file)
+    monkeypatch.setattr(update, "_should_auto_check_for_updates", fail_should_auto_check)
+    monkeypatch.setattr(update, "do_update", fake_do_update)
+
+    assert await update._resolve_latest_version_for_prompt() == "999.0.0"
+    assert calls == [(False, True)]
+    assert last_check_file.exists()
+
+
+@pytest.mark.asyncio
+async def test_resolve_latest_version_keeps_cache_when_prompt_refresh_times_out(
+    monkeypatch, tmp_path
+):
+    latest_file = tmp_path / "latest.txt"
+    latest_file.write_text("0.0.0", encoding="utf-8")
+    calls: list[bool] = []
+
+    async def slow_refresh(*, force: bool) -> update.UpdateResult:
+        calls.append(force)
+        await asyncio.sleep(60)
+        return update.UpdateResult.UPDATE_AVAILABLE
+
+    monkeypatch.setattr(update, "LATEST_VERSION_FILE", latest_file)
+    monkeypatch.setattr(update, "PROMPT_UPDATE_REFRESH_TIMEOUT_SECONDS", 0.01)
+    monkeypatch.setattr(update, "_refresh_update_cache", slow_refresh)
+
+    assert await update._resolve_latest_version_for_prompt() == "0.0.0"
+    assert calls == [True]
+
+
 @pytest.mark.asyncio
 async def test_refresh_cache_does_not_throttle_on_failure(monkeypatch, tmp_path):
     """A failed check must not mark the throttle file.