redfetch 1.4.3__tar.gz → 1.5.0__tar.gz

{redfetch-1.4.3 → redfetch-1.5.0}/.gitignore

@@ -33,6 +33,7 @@ src/redfetch/__about__.py
 
 # Database files
 *.db
+.cache/
 
 # Environment file
 .env

{redfetch-1.4.3 → redfetch-1.5.0}/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.0] - 2026-07-21
+
+### Added
+- Background updates triggered on each launch of "Very Vanilla MQ", so you no longer have to see redfetch. Run MacroQuest directly. Credit: all the TUI haters
+
+### Changed
+- Navigation meshes now download by default instead of prompting. Opt out in settings. (`PROTECTED_FILES_BY_RESOURCE` still protects your custom meshes)
+
+### Fixed
+- pip/pipx in-app updates fixed on windows
+
+## [1.4.4] - 2026-07-18
+
+### Fixed
+- A rejected OAuth token will no longer assume you're level 1.
+
 ## [1.4.3] - 2026-07-06
 
 ### Added

{redfetch-1.4.3 → redfetch-1.5.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: redfetch
-Version: 1.4.3
+Version: 1.5.0
 Summary: Download and publish EverQuest scripts and software using the RedGuides API
 Project-URL: Homepage, https://www.redguides.com
 Project-URL: Documentation, https://www.redguides.com/community/resources/redfetch.3177/
 Project-URL: Repository, https://github.com/RedGuides/redfetch
 Project-URL: Issues, https://github.com/RedGuides/redfetch/issues
 Project-URL: Changelog, https://github.com/RedGuides/redfetch/blob/main/CHANGELOG.md
-Project-URL: Source_archive, https://github.com/RedGuides/redfetch/archive/9161a88b101d6df6ce9a697736e3fcc57b1c3122.zip
+Project-URL: Source_archive, https://github.com/RedGuides/redfetch/archive/9825ba1eaf7b60758f68420040e877f5bee93ddb.zip
 Author-email: Redbot <ask@redguides.com>
 License-Expression: GPL-3.0-or-later
 License-File: LICENSE

{redfetch-1.4.3 → redfetch-1.5.0}/src/redfetch/__about__.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.4.3'
-__version_tuple__ = version_tuple = (1, 4, 3)
+__version__ = version = '1.5.0'
+__version_tuple__ = version_tuple = (1, 5, 0)
 
 __commit_id__ = commit_id = None

redfetch-1.5.0/src/redfetch/__init__.py

@@ -0,0 +1,4 @@
+import sys
+
+# sys.path entries can get held open, and Windows can't update an open .exe.
+sys.path[:] = [p for p in sys.path if not p.lower().endswith('.exe')]

{redfetch-1.4.3 → redfetch-1.5.0}/src/redfetch/auth.py

@@ -55,7 +55,7 @@ def _get_setting(key: str, default=None):
 
 
 # ---------------------------------------------------------------------------
-# Disk cache for non-secret identity data (user_id, username, token_expiry)
+# Disk cache for non-secret identity data (username, token_expiry)
 # ---------------------------------------------------------------------------
 
 _disk_cache = None
@@ -76,21 +76,6 @@ def _ensure_cache():
     return _disk_cache
 
 
-def get_disk_cache():
-    """Return the shared disk cache (for non-identity caching by other modules)."""
-    return _ensure_cache()
-
-
-def set_user_id(user_id: str) -> None:
-    """Store user_id in disk cache (non-sensitive public identifier)."""
-    _ensure_cache().set('user_id', str(user_id))
-
-
-def get_user_id() -> Optional[str]:
-    """Retrieve user_id from disk cache."""
-    return _ensure_cache().get('user_id')
-
-
 def set_username(username: str) -> None:
     """Store username in disk cache (non-sensitive public display name)."""
     _ensure_cache().set('username', username)
@@ -241,7 +226,7 @@ def first_authorization(client_id: str, client_secret: str | None, *, scope: str
 
 
 def _cache_user_info(access_token: str | None) -> None:
-    """Fetch /api/me and cache username/user_id (best-effort)."""
+    """Fetch /api/me and cache username (best-effort)."""
     if not access_token:
         return
     headers = {"Authorization": f"Bearer {access_token}"}
@@ -251,8 +236,6 @@ def _cache_user_info(access_token: str | None) -> None:
     me = data.get("me") or {}
     if me.get("username"):
         set_username(str(me["username"]))
-    if me.get("user_id"):
-        set_user_id(str(me["user_id"]))
 
 
 def authorize():
@@ -381,7 +364,6 @@ def get_cached_tokens():
     data["access_token"] = keyring.get_password(KEYRING_SERVICE_NAME, "access_token")
     data["refresh_token"] = keyring.get_password(KEYRING_SERVICE_NAME, "refresh_token")
     data["username"] = get_username_from_cache()
-    data["user_id"] = get_user_id()
     return data
 
 
@@ -391,28 +373,19 @@ def logout():
 
     keyring_credentials = ["access_token", "refresh_token", "api_key"]
     legacy_credentials = ["user_id", "username", "expires_at"]
-    
-    credentials_deleted = False
 
     for credential in keyring_credentials + legacy_credentials:
         try:
             keyring.delete_password(KEYRING_SERVICE_NAME, credential)
-            credentials_deleted = True
         except keyring.errors.PasswordDeleteError:
             pass
 
-    try:
-        clear_disk_cache()
-        meta.clear_pypi_cache()
-        net.clear_manifest_cache()
-        credentials_deleted = True
-    except Exception:
-        pass
-
-    if credentials_deleted:
-        print("You have been logged out successfully.")
-    else:
-        print("No active session found. You were not logged in.")
+    # isolated so a locked cache can't block the remaining clears
+    for clear in (clear_disk_cache, meta.clear_pypi_cache, net.clear_manifest_cache):
+        try:
+            clear()
+        except Exception:
+            pass
 
 
 # ---------------------------------------------------------------------------
@@ -434,23 +407,21 @@ async def fetch_me(client: httpx.AsyncClient) -> Optional[dict]:
 
 
 async def fetch_user_id_from_api(api_key):
-    """Fetch user_id using the API key; caches it."""
+    """Fetch user_id using the API key."""
     async with httpx.AsyncClient(headers={'XF-Api-Key': api_key}, http2=True) as client:
         me = await fetch_me(client)
     if me:
-        set_user_id(me['user_id'])
         return me['user_id']
     return None
 
 
 async def fetch_username(api_key, cache=True):
-    """Fetch username via API key; caches username and user_id."""
+    """Fetch username via API key; caches username."""
     async with httpx.AsyncClient(headers={'XF-Api-Key': api_key}, http2=True) as client:
         me = await fetch_me(client)
     if me:
         if cache:
             set_username(me['username'])
-            set_user_id(me['user_id'])
         return me['username']
     return "Unknown"
 
@@ -499,7 +470,7 @@ async def get_api_headers():
                 if access_token:
                     return {"Authorization": f"Bearer {access_token}"}
 
-            raise RuntimeError("OAuth token refresh failed. Please run `redfetch logout` and authorize again.")
+            raise RuntimeError("OAuth token refresh failed. Restart redfetch to authorize again.")
 
         raise RuntimeError("OAuth access token is expired and no refresh token is available. Please authorize again.")
 
@@ -534,7 +505,6 @@ async def get_username():
             me = await fetch_me(client)
         if me and me.get("username"):
             set_username(me["username"])
-            set_user_id(me["user_id"])
             return me["username"]
         raise RuntimeError("Unable to retrieve username using the stored OAuth token.")
 

{redfetch-1.4.3 → redfetch-1.5.0}/src/redfetch/config.py

@@ -4,12 +4,14 @@ import os
 import platform
 import re
 import shutil
+import tomllib
 
 # third-party
 import tomlkit
 from dynaconf import Dynaconf, Validator, ValidationError
 from dynaconf.loaders import env_loader
 from platformdirs import user_config_dir, user_data_dir
+from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_fixed
 
 # Parent Category to folder
 CATEGORY_MAP = {
@@ -58,7 +60,6 @@ BREADCRUMB_FILENAME = "last_command.json"
 DEFAULT_CONFIG_DIR = user_config_dir("redfetch", "RedGuides")
 
 script_dir = os.path.dirname(os.path.abspath(__file__))
-os.environ['REDFETCH_SCRIPT_DIR'] = script_dir
 
 # Populated by initialize_config()
 config_dir = None
@@ -139,6 +140,9 @@ def initialize_config():
         atomic_write_text(env_file_path, 'REDFETCH_ENV=LIVE\n')
         print(f".env file created with default environment set to 'LIVE' at {env_file_path}")
 
+    # Migrate any settings.local.toml written by older versions
+    _migrate_local_settings(config_dir)
+
     # Initialize Dynaconf settings
     settings = Dynaconf(
         envvar_prefix="REDFETCH",
@@ -210,6 +214,17 @@ def _resolve_redfetch_executable():
     return None
 
 
+@retry(
+    retry=retry_if_exception_type(PermissionError),
+    stop=stop_after_attempt(5),
+    wait=wait_fixed(0.1),
+    reraise=True,
+)
+def _replace_with_retry(src: str, dst: str) -> None:
+    # MQ reads update_status.json
+    os.replace(src, dst)
+
+
 def atomic_write_text(path: str, text: str) -> None:
     """Write UTF-8 text to `path` via a temp file + os.replace() so readers never see a partial write."""
     directory = os.path.dirname(path)
@@ -218,7 +233,7 @@ def atomic_write_text(path: str, text: str) -> None:
     tmp_path = f"{path}.tmp"
     with open(tmp_path, "w", encoding="utf-8") as f:
         f.write(text)
-    os.replace(tmp_path, path)
+    _replace_with_retry(tmp_path, path)
 
 
 def atomic_write_json(path: str, data) -> None:
@@ -435,6 +450,26 @@ def save_config(file_path, config_data):
     atomic_write_text(file_path, toml_text)
 
 
+def _migrate_local_settings(config_dir):
+    """Carry renamed settings in an older settings.local.toml"""
+    config_file = os.path.join(config_dir, 'settings.local.toml')
+    if not os.path.exists(config_file):
+        return
+    try:
+        with open(config_file, "rb") as f:
+            data = tomllib.load(f)
+    except Exception:
+        return
+    # NAVMESH_OPT_IN became NAVMESH_DOWNLOADS
+    changed = False
+    for env_table in data.values():
+        if isinstance(env_table, dict) and "NAVMESH_OPT_IN" in env_table:
+            env_table.setdefault("NAVMESH_DOWNLOADS", env_table.pop("NAVMESH_OPT_IN"))
+            changed = True
+    if changed:
+        save_config(config_file, data)
+
+
 def update_setting(setting_path, setting_value, env=None):
     """Update a specific setting in the settings.local.toml file and in memory,
     optionally within a specific environment."""

{redfetch-1.4.3 → redfetch-1.5.0}/src/redfetch/config_firstrun.py

@@ -460,8 +460,7 @@ def first_run_setup():
         default_choice = bool(os.environ.get("PYAPP"))
 
         console.print(
-            "\n[bold cyan][italic]\"Wilt thou we set a signe upon thy Desktop, whereby redfetch may be call'd forth "
-            "when thou list?\"[/italic][/bold cyan]"
+            "\n[bold cyan][italic]\"Shall we set a signe upon thy fair anime walpaper?\"[/italic][/bold cyan]"
         )
         wants_shortcut = CustomConfirm.ask(
             "Create Desktop shortcut?",

{redfetch-1.4.3 → redfetch-1.5.0}/src/redfetch/detecteq.py

@@ -91,26 +91,6 @@ def find_everquest_uninstall_location():
     except OSError:
         pass
 
-    # 3) HKU: enumerate SIDs as final fallback
-    try:
-        with reg.ConnectRegistry(None, reg.HKEY_USERS) as hku:
-            i = 0
-            while True:
-                try:
-                    sid = reg.EnumKey(hku, i)
-                    i += 1
-                    subkey = rf"{sid}\{base_uninstall}"
-                    for valname in ("InstallLocation", "DisplayIcon", "UninstallString"):
-                        val = _read_reg_value(hku, subkey, valname)
-                        if val:
-                            candidate = _extract_dir_from_value(str(val))
-                            if _is_valid_eq_dir(candidate):
-                                return candidate
-                except OSError:
-                    break
-    except OSError:
-        pass
-
     return None
 
 

{redfetch-1.4.3 → redfetch-1.5.0}/src/redfetch/download.py

@@ -7,7 +7,7 @@ import sys
 import time
 import zlib
 from pathlib import Path
-from zipfile import ZipFile, is_zipfile
+from zipfile import BadZipFile, ZipFile, is_zipfile
 import asyncio
 
 # third-party
@@ -104,7 +104,17 @@ async def download_file_async(
         if tmp_path is None:
             return False
 
-        os.replace(tmp_path, file_path)
+        try:
+            displaced = _swap_into_place(tmp_path, file_path)
+        except PermissionError:
+            _report_locked_target(file_path)
+            return False
+        except OSError as e:
+            print(f"Could not update {os.path.basename(file_path)}: {e}")
+            _remove_if_exists(tmp_path)
+            return False
+        if displaced:
+            print(f"Staged update for {os.path.basename(file_path)}; applies on next launch.")
         print(f"Downloaded file {file_path}")
         return True
     finally:
@@ -181,15 +191,6 @@ def extract_and_discard_zip(zip_path, extract_to, resource_id, should_flatten=Fa
             return False
 
         with ZipFile(zip_path, 'r') as zip_ref:
-            try:
-                bad_member = zip_ref.testzip()
-                if bad_member is not None:
-                    print(f"ZIP integrity check failed at member: {bad_member}. Extraction aborted.")
-                    return False
-            except Exception as e:
-                print(f"ZIP integrity check failed: {e}. Extraction aborted.")
-                return False
-
             infos = zip_ref.infolist()
             if len(infos) > MAX_FILES_PER_ZIP:
                 print(f"ZIP has too many files ({len(infos)} > {MAX_FILES_PER_ZIP}). Extraction aborted.")
@@ -211,10 +212,14 @@ def extract_and_discard_zip(zip_path, extract_to, resource_id, should_flatten=Fa
             if protected_files is None:
                 protected_files = config.settings.from_env(config.settings.ENV).PROTECTED_FILES_BY_RESOURCE.get(resource_id, [])
             sweep_stale_swap_files(extract_to)
-            if should_flatten:
-                extract_flattened(zip_ref, extract_to, protected_files)
-            else:
-                extract_with_structure(zip_ref, extract_to, protected_files)
+            try:
+                if should_flatten:
+                    extract_flattened(zip_ref, extract_to, protected_files)
+                else:
+                    extract_with_structure(zip_ref, extract_to, protected_files)
+            except (BadZipFile, zlib.error) as e:  # bad CRC raises BadZipFile; truncated deflate raises zlib.error
+                print(f"ZIP integrity check failed: {e}. Extraction aborted.")
+                return False
             return True
     finally:
         delete_zip_file(zip_path)

{redfetch-1.4.3 → redfetch-1.5.0}/src/redfetch/listener.py

@@ -7,9 +7,9 @@ from typing import Any, Dict, Optional
 
 from aiohttp import web
 
+from redfetch import config
 from redfetch import store
 from redfetch import sync
-from redfetch.special import compute_special_status
 
 log = logging.getLogger(__name__)
 
@@ -169,9 +169,9 @@ async def handle_category_map(request: web.Request) -> web.Response:
 
 
 async def handle_special_resource_ids(request: web.Request) -> web.Response:
-    status = compute_special_status(None)
-    special_resource_ids = [int(rid) for rid, info in status.items() if info["is_special"]]
-    return web.json_response(special_resource_ids)
+    # from_env, not bare settings: --server swaps settings.ENV at runtime
+    special_resources = config.settings.from_env(config.settings.ENV).SPECIAL_RESOURCES
+    return web.json_response([int(rid) for rid, d in special_resources.items() if d.get('opt_in', False)])
 
 
 async def create_app(

{redfetch-1.4.3 → redfetch-1.5.0}/src/redfetch/main.py

@@ -1,13 +1,14 @@
 # standard imports
 import sys
 import os
+from contextlib import contextmanager
 from enum import Enum
 from pathlib import Path
 from typing import Optional
 import asyncio
 
 # third-party imports
-from rich.prompt import Confirm, Prompt
+from rich.prompt import Prompt
 from rich.console import Console
 import typer
 
@@ -25,6 +26,7 @@ from redfetch import sync
 from redfetch import store
 from redfetch import shortcuts
 from redfetch.runtime_errors import exit_with_fatal_error
+from redfetch.sync_types import SyncOutcome
 
 
 app = typer.Typer(
@@ -43,13 +45,10 @@ class Env(str, Enum):
 
 def parse_resource_id_or_fail(value: str) -> str:
     """Accept either an integer ID or a URL that includes a recognizable ID."""
-    value_stripped = value.strip()
-    if value_stripped.isdigit():
-        return value_stripped
-    parsed = utils.parse_resource_id(value_stripped)
-    if parsed is None:
-        raise typer.BadParameter("Provide a resource ID or a recognized RedGuides URL.")
-    return parsed
+    try:
+        return utils.parse_resource_id(value.strip())
+    except ValueError as exc:
+        raise typer.BadParameter(str(exc)) from exc
 
 
 def _apply_server_override(server: "Optional[Env]" = None) -> None:
@@ -78,41 +77,6 @@ def initialize_db_only(server: "Optional[Env]" = None):
 
 # ===== CLI prompt helpers =====
 
-def prompt_navmesh_opt_in() -> bool | None:
-    """Prompt user about navmesh downloads if not configured."""
-    from redfetch import navmesh
-
-    # Check if VVMQ path exists (navmesh requires it)
-    vvmq_path = utils.get_vvmq_path()
-    if not vvmq_path:
-        return None  # Can't do navmesh without VVMQ
-
-    opt_in = navmesh.get_navmesh_opt_in()
-
-    if opt_in is not None:
-        return None  # Already configured, use existing setting
-
-    # Prompt user
-    user_choice = Prompt.ask(
-        "🧭 Download navigation meshes? (will overwrite, protect your custom meshes in settings.local.toml)",
-        choices=["yes", "no", "always", "never"],
-        default="yes",
-    )
-
-    if user_choice == "yes":
-        return True  # One-time yes
-    elif user_choice == "always":
-        config.update_setting(["NAVMESH_OPT_IN"], True)
-        console.print("Updated settings to always download navmeshes.")
-        return None  # Config is now set, use it
-    elif user_choice == "never":
-        config.update_setting(["NAVMESH_OPT_IN"], False)
-        console.print("Updated settings to never download navmeshes.")
-        return None  # Config is now set, use it
-    else:  # "no"
-        return False  # One-time no
-
-
 class _CliPostUpdate:
     """CLI adapter for post_update.execute: rich prompts, console output."""
 
@@ -162,19 +126,8 @@ async def handle_download_watched_async(db_path: str, headers: dict) -> bool:
         console.print(
             "[bold yellow]Warning:[/bold yellow] [blink bold red]MQ appears to be down[/blink bold red] for a patch, so it's not likely to work."
         )
-        continue_download = Confirm.ask(
-            "Do you want to continue with the download?", default=False
-        )
-        if not continue_download:
-            console.print("Download cancelled by user.")
-            return False
 
-    navmesh_override = prompt_navmesh_opt_in()
-
-    outcome = await sync.run_sync(
-        db_path, headers,
-        navmesh_override=navmesh_override,
-    )
+    outcome = await sync.run_sync(db_path, headers)
     # offer regardless of overall success:
     await post_update.offer(outcome, _CliPostUpdate())
     return outcome.success
@@ -216,11 +169,113 @@ async def download_command_async(db_name: str, db_path: str, id_or_url: str, for
 def update_command(
     force: bool = typer.Option(False, "--force", "-f", help="Force re-download of all watched resources."),
     server: Optional[Env] = typer.Option(None, "--server", "-s", case_sensitive=False, help="Update this server for this run only, without changing your current server ([green]LIVE[/green], [yellow]TEST[/yellow], [cyan]EMU[/cyan])."),
+    headless: bool = typer.Option(False, "--headless", hidden=True, help="MQ silent update: no prompts, no browser, no dialogs. writes update_status.json."),
 ):
+    if headless:
+        _headless_update(server=server, force=force)
+        return
     db_name, db_path = initialize_db_only(server=server)
     asyncio.run(update_command_async(db_name=db_name, db_path=db_path, force=force))
 
 
+@contextmanager
+def _exit_silently_on_error():
+    """Anything unexpected for headless commands becomes a silent exit 1."""
+    try:
+        yield
+    except typer.Exit:
+        raise
+    except Exception:
+        raise typer.Exit(1)
+
+
+def _headless_update(server: "Optional[Env]", force: bool) -> None:
+    from redfetch.config_firstrun import is_configured
+    from redfetch import update_status
+
+    requested_env = server.value if server else None
+
+    with _exit_silently_on_error():
+        if not is_configured():
+            update_status.write_update_status(
+                env=requested_env or Env.LIVE.value,
+                auth_state="not_configured",
+            )
+            raise typer.Exit(0)
+
+        config.initialize_config()
+        if requested_env:
+            config.select_environment_in_memory(requested_env)
+        env = config.settings.ENV
+        auth.initialize_keyring()
+
+        auto_update = utils.is_auto_update_enabled()
+        if not auto_update:
+            raise typer.Exit(1)
+
+        managed_path = utils.get_vvmq_path()
+
+        if not _has_auth_credentials():
+            update_status.write_update_status(
+                env=env, auth_state="needs_login", managed_path=managed_path, auto_update=auto_update,
+            )
+            raise typer.Exit(0)
+
+        db_name = f"{env}_resources.db"
+        store.initialize_db(db_name)
+        db_path = store.get_db_path(db_name)
+
+        if force:
+            with store.get_db_connection(db_name) as conn:
+                store.reset_download_dates(conn.cursor())
+
+        outcome = asyncio.run(_headless_update_async(db_path))
+
+        if outcome is None:
+            # Mid-run silent-refresh failure handling
+            update_status.write_update_status(
+                env=env, auth_state="needs_login", managed_path=managed_path, auto_update=auto_update,
+            )
+            raise typer.Exit(0)
+
+        if outcome.execution_plan is None or outcome.execution_result is None:
+            raise typer.Exit(1)  # busy or cancelled: nothing ran, nothing fresh
+
+        installed, remaining = update_status.split_items_by_outcome(
+            outcome.execution_plan, outcome.execution_result
+        )
+        vvmq_version = None
+        if outcome.vvmq_updated:
+            vvmq_id = utils.get_current_vvmq_id(env)
+            vvmq_version = next(
+                (item["version"] for item in installed if item["resource_id"] == vvmq_id), None
+            )
+        update_status.write_update_status(
+            env=env,
+            auth_state="ok",
+            items=remaining,
+            managed_path=managed_path,
+            auto_update=auto_update,
+            installed=installed,
+            pending_restart=outcome.vvmq_updated,
+            pending_restart_version=vvmq_version,
+        )
+
+        # the swap starts only when this run has nothing left to do.
+        meta.spawn_silent_self_update()
+        raise typer.Exit(0)
+
+
+async def _headless_update_async(db_path: str) -> SyncOutcome | None:
+    """Returns the SyncOutcome or needs_login."""
+    await asyncio.to_thread(utils.sweep_stale_update_debris)
+    try:
+        headers = await auth.get_api_headers()
+    except RuntimeError:
+        return None
+    return await sync.run_sync(db_path, headers)
+
+
 @app.command(
     "download",
     help="Download a specific resource by ID or URL.",
@@ -265,15 +320,14 @@ def check_command(
 
     requested_env = server.value if server else None
 
-    # Pre-flight: not configured at all -> no init possible, but we can still record the verdict.
-    if not is_configured():
-        update_status.write_update_status(
-            env=requested_env or Env.LIVE.value,
-            auth_state="not_configured",
-        )
-        raise typer.Exit(0)
+    with _exit_silently_on_error():
+        if not is_configured():
+            update_status.write_update_status(
+                env=requested_env or Env.LIVE.value,
+                auth_state="not_configured",
+            )
+            raise typer.Exit(0)
 
-    try:
         config.initialize_config()
         # Honor --server for this run only; never persist (a "check" must not change the user's env).
         if requested_env:
@@ -284,8 +338,12 @@ def check_command(
         # MQ matches this against its own root to ignore stray copies.
         managed_path = utils.get_vvmq_path()
 
+        auto_update = utils.is_auto_update_enabled()
+
         if not _has_auth_credentials():
-            update_status.write_update_status(env=env, auth_state="needs_login", managed_path=managed_path)
+            update_status.write_update_status(
+                env=env, auth_state="needs_login", managed_path=managed_path, auto_update=auto_update,
+            )
             raise typer.Exit(0)
 
         db_name = f"{env}_resources.db"
@@ -293,15 +351,11 @@ def check_command(
         db_path = store.get_db_path(db_name)
 
         auth_state, items = asyncio.run(_check_command_async(db_path))
-        update_status.write_update_status(env=env, auth_state=auth_state, items=items, managed_path=managed_path)
+        update_status.write_update_status(
+            env=env, auth_state=auth_state, items=items, managed_path=managed_path, auto_update=auto_update,
+        )
         raise typer.Exit(0)
 
-    except typer.Exit:
-        raise
-    except Exception:
-        # Transient failure, no touch to update_status.json so we know checked_at didn't advance this cycle.
-        raise typer.Exit(1)
-
 
 async def _check_command_async(db_path: str) -> tuple[str, list[dict] | None]:
     from redfetch import update_status